{-# OPTIONS --safe #-}

open import Ledger.Prelude
open import Ledger.Conway.Specification.Abstract
open import Ledger.Conway.Specification.Transaction using (TransactionStructure)

open import Data.Product using (_×_; _,_)
open import Relation.Binary.PropositionalEquality

open import Ledger.Conway.Conformance.Equivalence.Convert

module Ledger.Conway.Conformance.Equivalence.Certs
  (txs : _) (open TransactionStructure txs)
  (abs : AbstractFunctions txs) (open AbstractFunctions abs)
  where

private
  module L where
    open import Ledger.Conway.Specification.Certs govStructure public

  module C where
    open import Ledger.Conway.Conformance.Certs govStructure public

instance

  DStateToConf : L.Deposits ⊢ L.DState ⭆ C.DState
  DStateToConf .convⁱ deposits stᵈ =
    let open L.DState stᵈ in
    $\begin{pmatrix} \,\href{Ledger.Conway.Specification.Certs.html#4017}{\htmlId{815}{\htmlClass{Field}{\text{voteDelegs}}}}\, \\ \,\href{Ledger.Conway.Specification.Certs.html#4047}{\htmlId{828}{\htmlClass{Field}{\text{stakeDelegs}}}}\, \\ \,\href{Ledger.Conway.Specification.Certs.html#4078}{\htmlId{842}{\htmlClass{Field}{\text{rewards}}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#765}{\htmlId{852}{\htmlClass{Bound}{\text{deposits}}}}\, \end{pmatrix}$

  DStateFromConf : C.DState ⭆ L.DState
  DStateFromConf .convⁱ _ dState =
    let open C.DState dState in
    $\begin{pmatrix} \,\href{Ledger.Conway.Conformance.Certs.html#666}{\htmlId{976}{\htmlClass{Field}{\text{voteDelegs}}}}\, \\ \,\href{Ledger.Conway.Conformance.Certs.html#696}{\htmlId{989}{\htmlClass{Field}{\text{stakeDelegs}}}}\, \\ \,\href{Ledger.Conway.Conformance.Certs.html#736}{\htmlId{1003}{\htmlClass{Field}{\text{rewards}}}}\, \end{pmatrix}$

  GStateToConf : L.Deposits ⊢ L.GState ⭆ C.GState
  GStateToConf .convⁱ deposits stᵍ =
    let open L.GState stᵍ in
    $\begin{pmatrix} \,\href{Ledger.Conway.Specification.Certs.html#4278}{\htmlId{1136}{\htmlClass{Field}{\text{dreps}}}}\, \\ \,\href{Ledger.Conway.Specification.Certs.html#4301}{\htmlId{1144}{\htmlClass{Field}{\text{ccHotKeys}}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#1086}{\htmlId{1156}{\htmlClass{Bound}{\text{deposits}}}}\, \end{pmatrix}$

  GStateFromConf : C.GState ⭆ L.GState
  GStateFromConf .convⁱ deposits gState =
    let open C.GState gState in
    $\begin{pmatrix} \,\href{Ledger.Conway.Conformance.Certs.html#850}{\htmlId{1287}{\htmlClass{Field}{\text{dreps}}}}\, \\ \,\href{Ledger.Conway.Conformance.Certs.html#886}{\htmlId{1295}{\htmlClass{Field}{\text{ccHotKeys}}}}\, \end{pmatrix}$

data ValidDepsᵈ (pp : PParams) (deps : L.Deposits) : List L.DCert → Set where
  []         : ValidDepsᵈ pp deps []
  delegate   : ∀ {c del kh v certs}
             → ValidDepsᵈ pp (C.updateCertDeposit pp (L.delegate c del kh v) deps) certs
             → ValidDepsᵈ pp deps (L.delegate c del kh v ∷ certs)
  dereg      : ∀ {c md d certs}
             → (L.CredentialDeposit c , d) ∈ deps
             → md ≡ nothing ⊎ md ≡ just d
             → ValidDepsᵈ pp (C.updateCertDeposit pp (L.dereg c md) deps) certs
             → ValidDepsᵈ pp deps (L.dereg c md ∷ certs)
  regdrep    : ∀ {c v a certs}
             → ValidDepsᵈ pp deps certs
             → ValidDepsᵈ pp deps (L.regdrep c v a ∷ certs)
  deregdrep  : ∀ {c d certs}
             → ValidDepsᵈ pp deps certs
             → ValidDepsᵈ pp deps (L.deregdrep c d ∷ certs)
  regpool    : ∀ {kh p certs}
             → ValidDepsᵈ pp deps certs
             → ValidDepsᵈ pp deps (L.regpool kh p ∷ certs)
  retirepool : ∀ {kh e certs}
             → ValidDepsᵈ pp deps certs
             → ValidDepsᵈ pp deps (L.retirepool kh e  ∷ certs)
  ccreghot   : ∀ {c v certs}
             → ValidDepsᵈ pp deps certs
             → ValidDepsᵈ pp deps (L.ccreghot c v ∷ certs)
  reg        : ∀ {c d certs}
             → ValidDepsᵈ pp (C.updateCertDeposit pp (L.reg c d) deps) certs
             → ValidDepsᵈ pp deps (L.reg c d ∷ certs)

data ValidDepsᵍ (pp : PParams) (deps : L.Deposits) : List L.DCert → Set where
  []         : ValidDepsᵍ pp deps []
  regdrep    : ∀ {c v a certs}
             → ValidDepsᵍ pp (C.updateCertDeposit pp (L.regdrep c v a) deps) certs
             → ValidDepsᵍ pp deps (L.regdrep c v a ∷ certs)
  deregdrep  : ∀ {c d certs}
             → (L.DRepDeposit c , d) ∈ deps
             → ValidDepsᵍ pp (C.updateCertDeposit pp (L.deregdrep c d) deps) certs
             → ValidDepsᵍ pp deps (L.deregdrep c d ∷ certs)
  delegate   : ∀ {c del kh v certs}
             → ValidDepsᵍ pp deps certs
             → ValidDepsᵍ pp deps (L.delegate c del kh v ∷ certs)
  dereg      : ∀ {c d certs}
             → ValidDepsᵍ pp deps certs
             → ValidDepsᵍ pp deps (L.dereg c d ∷ certs)
  regpool    : ∀ {kh p certs}
             → ValidDepsᵍ pp deps certs
             → ValidDepsᵍ pp deps (L.regpool kh p ∷ certs)
  retirepool : ∀ {kh e certs}
             → ValidDepsᵍ pp deps certs
             → ValidDepsᵍ pp deps (L.retirepool kh e  ∷ certs)
  ccreghot   : ∀ {c v certs}
             → ValidDepsᵍ pp deps certs
             → ValidDepsᵍ pp deps (L.ccreghot c v ∷ certs)
  reg        : ∀ {c d certs}
             → ValidDepsᵍ pp deps certs
             → ValidDepsᵍ pp deps (L.reg c d ∷ certs)

record CertDeps* (pp : PParams) (dcerts : List L.DCert) : Set where
  constructor ⟦_,_,_,_⟧*
  field
    depsᵈ : L.Deposits
    depsᵍ : L.Deposits
    -- Invariants
    validᵈ : ValidDepsᵈ pp depsᵈ dcerts
    validᵍ : ValidDepsᵍ pp depsᵍ dcerts

pattern delegate*    ddeps gdeps = $\begin{pmatrix} \,\htmlId{4255}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4259}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4263}{\htmlClass{InductiveConstructor}{\text{delegate}}}\,   \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4274}{\htmlId{4274}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\htmlId{4282}{\htmlClass{InductiveConstructor}{\text{delegate}}}\,    \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4294}{\htmlId{4294}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$
pattern dereg*  v w  ddeps gdeps = $\begin{pmatrix} \,\htmlId{4340}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4344}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4348}{\htmlClass{InductiveConstructor}{\text{dereg}}}\, \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4354}{\htmlId{4354}{\htmlClass{Bound}{\text{v}}}}\, \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4356}{\htmlId{4356}{\htmlClass{Bound}{\text{w}}}}\,  \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4359}{\htmlId{4359}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\htmlId{4367}{\htmlClass{InductiveConstructor}{\text{dereg}}}\,       \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4379}{\htmlId{4379}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$
pattern regpool*     ddeps gdeps = $\begin{pmatrix} \,\htmlId{4425}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4429}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4433}{\htmlClass{InductiveConstructor}{\text{regpool}}}\,    \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4444}{\htmlId{4444}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\htmlId{4452}{\htmlClass{InductiveConstructor}{\text{regpool}}}\,     \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4464}{\htmlId{4464}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$
pattern retirepool*  ddeps gdeps = $\begin{pmatrix} \,\htmlId{4510}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4514}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4518}{\htmlClass{InductiveConstructor}{\text{retirepool}}}\, \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4529}{\htmlId{4529}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\htmlId{4537}{\htmlClass{InductiveConstructor}{\text{retirepool}}}\,  \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4549}{\htmlId{4549}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$
pattern regdrep*     ddeps gdeps = $\begin{pmatrix} \,\htmlId{4595}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4599}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4603}{\htmlClass{InductiveConstructor}{\text{regdrep}}}\,    \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4614}{\htmlId{4614}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\htmlId{4622}{\htmlClass{InductiveConstructor}{\text{regdrep}}}\,     \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4634}{\htmlId{4634}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$
pattern deregdrep* v ddeps gdeps = $\begin{pmatrix} \,\htmlId{4680}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4684}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4688}{\htmlClass{InductiveConstructor}{\text{deregdrep}}}\,  \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4699}{\htmlId{4699}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\htmlId{4707}{\htmlClass{InductiveConstructor}{\text{deregdrep}}}\, \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4717}{\htmlId{4717}{\htmlClass{Bound}{\text{v}}}}\, \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4719}{\htmlId{4719}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$
pattern ccreghot*    ddeps gdeps = $\begin{pmatrix} \,\htmlId{4765}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4769}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4773}{\htmlClass{InductiveConstructor}{\text{ccreghot}}}\,   \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4784}{\htmlId{4784}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\htmlId{4792}{\htmlClass{InductiveConstructor}{\text{ccreghot}}}\,    \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4804}{\htmlId{4804}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$
pattern reg*         ddeps gdeps = $\begin{pmatrix} \,\htmlId{4850}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4854}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{4858}{\htmlClass{InductiveConstructor}{\text{reg}}}\,        \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4869}{\htmlId{4869}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\htmlId{4877}{\htmlClass{InductiveConstructor}{\text{reg}}}\,         \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#4889}{\htmlId{4889}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$

open CertDeps*

getCertDeps* : ∀ {pp dcert} → CertDeps* pp dcert → L.Deposits × L.Deposits
getCertDeps* deps = deps .depsᵈ , deps .depsᵍ

updateCertDeps : ∀ {pp dcert dcerts} → CertDeps* pp (dcert ∷ dcerts) → CertDeps* pp dcerts
updateCertDeps (delegate*    ddeps gdeps) = $\begin{pmatrix} \,\htmlId{5174}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{5178}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5157}{\htmlId{5182}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5163}{\htmlId{5190}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$
updateCertDeps (dereg* _ _   ddeps gdeps) = $\begin{pmatrix} \,\htmlId{5245}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{5249}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5228}{\htmlId{5253}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5234}{\htmlId{5261}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$
updateCertDeps (regpool*     ddeps gdeps) = $\begin{pmatrix} \,\htmlId{5316}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{5320}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5299}{\htmlId{5324}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5305}{\htmlId{5332}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$
updateCertDeps (retirepool*  ddeps gdeps) = $\begin{pmatrix} \,\htmlId{5387}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{5391}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5370}{\htmlId{5395}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5376}{\htmlId{5403}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$
updateCertDeps (regdrep*     ddeps gdeps) = $\begin{pmatrix} \,\htmlId{5458}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{5462}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5441}{\htmlId{5466}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5447}{\htmlId{5474}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$
updateCertDeps (deregdrep* _ ddeps gdeps) = $\begin{pmatrix} \,\htmlId{5529}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{5533}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5512}{\htmlId{5537}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5518}{\htmlId{5545}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$
updateCertDeps (ccreghot*    ddeps gdeps) = $\begin{pmatrix} \,\htmlId{5600}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{5604}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5583}{\htmlId{5608}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5589}{\htmlId{5616}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$
updateCertDeps (reg*         ddeps gdeps) = $\begin{pmatrix} \,\htmlId{5671}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\htmlId{5675}{\htmlClass{Symbol}{\text{\_}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5654}{\htmlId{5679}{\htmlClass{Bound}{\text{ddeps}}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#5660}{\htmlId{5687}{\htmlClass{Bound}{\text{gdeps}}}}\, \end{pmatrix}$

updateCertDeps* : ∀ {pp} dcerts → CertDeps* pp dcerts → CertDeps* pp []
updateCertDeps* []               deps = deps
updateCertDeps* (dcert ∷ dcerts) deps = updateCertDeps* dcerts (updateCertDeps deps)

instance

  CertStToConf : L.Deposits × L.Deposits ⊢ L.CertState ⭆ C.CertState
  CertStToConf .convⁱ (ddeps , gdeps) certState =
    let open L.CertState certState in
    $\begin{pmatrix} \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#6002}{\htmlId{6073}{\htmlClass{Bound}{\text{ddeps}}}}\, \,\href{Ledger.Conway.Conformance.Equivalence.Convert.html#271}{\htmlId{6079}{\htmlClass{Function Operator}{\text{⊢conv}}}}\, \,\href{Ledger.Conway.Specification.Certs.html#4415}{\htmlId{6085}{\htmlClass{Field}{\text{dState}}}}\, \\ \,\href{Ledger.Conway.Specification.Certs.html#4435}{\htmlId{6094}{\htmlClass{Field}{\text{pState}}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Certs.html#6010}{\htmlId{6103}{\htmlClass{Bound}{\text{gdeps}}}}\, \,\href{Ledger.Conway.Conformance.Equivalence.Convert.html#271}{\htmlId{6109}{\htmlClass{Function Operator}{\text{⊢conv}}}}\, \,\href{Ledger.Conway.Specification.Certs.html#4455}{\htmlId{6115}{\htmlClass{Field}{\text{gState}}}}\, \end{pmatrix}$

  CertStFromConf : C.CertState ⭆ L.CertState
  CertStFromConf .convⁱ _ certState =
    let open C.CertState certState in
    $\begin{pmatrix} \,\href{Ledger.Conway.Conformance.Equivalence.Convert.html#453}{\htmlId{6252}{\htmlClass{Function}{\text{conv}}}}\, \,\href{Ledger.Conway.Conformance.Certs.html#1022}{\htmlId{6257}{\htmlClass{Field}{\text{dState}}}}\, \\ \,\href{Ledger.Conway.Conformance.Certs.html#1042}{\htmlId{6266}{\htmlClass{Field}{\text{pState}}}}\, \\ \,\href{Ledger.Conway.Conformance.Equivalence.Convert.html#453}{\htmlId{6275}{\htmlClass{Function}{\text{conv}}}}\, \,\href{Ledger.Conway.Conformance.Certs.html#1062}{\htmlId{6280}{\htmlClass{Field}{\text{gState}}}}\, \end{pmatrix}$

  PRE-CERTToConf : ∀ {Γ s s'}
                 → L.Deposits × L.Deposits
                   ⊢ Γ L.⊢ s ⇀⦇ _ ,PRE-CERT⦈ s' ⭆ⁱ λ deposits _ →
                     Γ C.⊢ (deposits ⊢conv s) ⇀⦇ _ ,PRE-CERT⦈ (deposits ⊢conv s')
  PRE-CERTToConf .convⁱ deposits (L.CERT-pre h) = C.CERT-pre h

  POST-CERTToConf : ∀ {Γ s s'}
                 → L.Deposits × L.Deposits
                   ⊢ Γ L.⊢ s ⇀⦇ _ ,POST-CERT⦈ s' ⭆ⁱ λ deposits _ →
                     Γ C.⊢ (deposits ⊢conv s) ⇀⦇ _ ,POST-CERT⦈ (deposits ⊢conv s')
  POST-CERTToConf .convⁱ deposits L.CERT-post = C.CERT-post

  DELEGToConf : ∀ {Γ s dcert dcerts s'}
                  (open L.DelegEnv Γ renaming (pparams to pp))
              → CertDeps* pp (dcert ∷ dcerts) ⊢
                 Γ L.⊢ s ⇀⦇ dcert ,DELEG⦈ s' ⭆ⁱ λ deposits _ →
                 Γ C.⊢ (deposits .depsᵈ ⊢conv s) ⇀⦇ dcert ,DELEG⦈ (updateCertDeps deposits .depsᵈ ⊢conv s')
  DELEGToConf .convⁱ (delegate* _ _) (L.DELEG-delegate h) = C.DELEG-delegate h
  DELEGToConf .convⁱ (dereg* v w _ _)  (L.DELEG-dereg h)    = C.DELEG-dereg (h , v , w)
  DELEGToConf .convⁱ (reg* _ _) (L.DELEG-reg h) = C.DELEG-reg h

  POOLToConf : ∀ {pp s dcert s'} → pp L.⊢ s ⇀⦇ dcert ,POOL⦈ s' ⭆ pp C.⊢ s ⇀⦇ dcert ,POOL⦈ s'
  POOLToConf .convⁱ _ L.POOL-regpool = C.POOL-regpool
  POOLToConf .convⁱ _ L.POOL-retirepool  = C.POOL-retirepool

  GOVCERTToConf : ∀ {Γ s dcert dcerts s'}
                  (open L.CertEnv Γ using (pp))
                → CertDeps* pp (dcert ∷ dcerts) ⊢
                   Γ L.⊢ s ⇀⦇ dcert ,GOVCERT⦈ s' ⭆ⁱ λ deposits _ →
                   Γ C.⊢ (deposits .depsᵍ ⊢conv s) ⇀⦇ dcert ,GOVCERT⦈ (updateCertDeps deposits .depsᵍ ⊢conv s')
  GOVCERTToConf .convⁱ (regdrep* _ _)     (L.GOVCERT-regdrep h) = C.GOVCERT-regdrep h
  GOVCERTToConf .convⁱ (deregdrep* v _ _) (L.GOVCERT-deregdrep h) = C.GOVCERT-deregdrep (h , v)
  GOVCERTToConf .convⁱ (ccreghot* _ _)    (L.GOVCERT-ccreghot h)  = C.GOVCERT-ccreghot h

  CERTToConf : ∀ {Γ s dcert dcerts s'} (open L.CertEnv Γ using (pp))
             → CertDeps* pp (dcert ∷ dcerts) ⊢
                Γ L.⊢ s ⇀⦇ dcert ,CERT⦈ s' ⭆ⁱ λ deposits _ →
                Γ C.⊢ (getCertDeps* deposits ⊢conv s) ⇀⦇ dcert ,CERT⦈ (getCertDeps* (updateCertDeps deposits) ⊢conv s')
  CERTToConf .convⁱ deposits@(delegate* _ _)    (L.CERT-deleg deleg)  = C.CERT-deleg (deposits ⊢conv deleg)
  CERTToConf .convⁱ deposits@(dereg* _ _ _ _)   (L.CERT-deleg deleg)  = C.CERT-deleg (deposits ⊢conv deleg)
  CERTToConf .convⁱ deposits@(regpool* _ _)     (L.CERT-pool pool)    = C.CERT-pool (conv pool)
  CERTToConf .convⁱ deposits@(retirepool* _ _)  (L.CERT-pool pool)    = C.CERT-pool (conv pool)
  CERTToConf .convⁱ deposits@(regdrep* _ _)     (L.CERT-vdel govcert) = C.CERT-vdel (deposits ⊢conv govcert)
  CERTToConf .convⁱ deposits@(deregdrep* _ _ _) (L.CERT-vdel govcert) = C.CERT-vdel (deposits ⊢conv govcert)
  CERTToConf .convⁱ deposits@(ccreghot* _ _)    (L.CERT-vdel govcert) = C.CERT-vdel (deposits ⊢conv govcert)
  CERTToConf .convⁱ deposits@(reg* _ _)         (L.CERT-deleg deleg)  = C.CERT-deleg (deposits ⊢conv deleg)

  CERT-POST-CERTToConf : ∀ {Γ s dcerts s'} (let open L.CertEnv Γ)
    → CertDeps* pp dcerts
      ⊢ RunTraceAndThen L._⊢_⇀⦇_,CERT⦈_ L._⊢_⇀⦇_,POST-CERT⦈_ Γ s dcerts s'
        ⭆ⁱ λ deposits _ → RunTraceAndThen C._⊢_⇀⦇_,CERT⦈_ C._⊢_⇀⦇_,POST-CERT⦈_
                            Γ (getCertDeps* deposits ⊢conv s) dcerts
                              (getCertDeps* (updateCertDeps* dcerts deposits) ⊢conv s')
  CERT-POST-CERTToConf .convⁱ deposits (run-[] x) = run-[] ((deposits .depsᵈ , deposits .depsᵍ) ⊢conv x)
  CERT-POST-CERTToConf .convⁱ deposits (run-∷ x x₁) = run-∷ (deposits ⊢conv x) (updateCertDeps deposits ⊢conv x₁)


  CERTSToConf : ∀ {Γ s dcerts s'} (let open L.CertEnv Γ)
    → CertDeps* pp dcerts
      ⊢ RunTraceAfterAndThen L._⊢_⇀⦇_,PRE-CERT⦈_ L._⊢_⇀⦇_,CERT⦈_ L._⊢_⇀⦇_,POST-CERT⦈_ Γ s dcerts s'
      ⭆ⁱ λ deposits _ → RunTraceAfterAndThen C._⊢_⇀⦇_,PRE-CERT⦈_ C._⊢_⇀⦇_,CERT⦈_ C._⊢_⇀⦇_,POST-CERT⦈_
                          Γ (getCertDeps* deposits ⊢conv s) dcerts
                            (getCertDeps* (updateCertDeps* dcerts deposits) ⊢conv s')
  CERTSToConf .convⁱ deposits (run (pre , cert-post)) = run (getCertDeps* deposits ⊢conv pre , deposits ⊢conv cert-post)

-- Converting form Conformance is easier since the deposit tracking disappears.
instance
  DELEGFromConf : ∀ {Γ s dcert s'}
                → Γ C.⊢ s ⇀⦇ dcert ,DELEG⦈ s' ⭆
                  Γ L.⊢ conv s ⇀⦇ dcert ,DELEG⦈ conv s'
  DELEGFromConf .convⁱ _ (C.DELEG-delegate h)    = L.DELEG-delegate h
  DELEGFromConf .convⁱ _ (C.DELEG-dereg (h , _)) = L.DELEG-dereg h
  DELEGFromConf .convⁱ _ (C.DELEG-reg h)         = L.DELEG-reg h

  GOVCERTFromConf : ∀ {Γ s dcert s'}
                  → Γ C.⊢ s ⇀⦇ dcert ,GOVCERT⦈ s' ⭆
                    Γ L.⊢ conv s ⇀⦇ dcert ,GOVCERT⦈ conv s'
  GOVCERTFromConf .convⁱ _ (C.GOVCERT-regdrep h)   = C.GOVCERT-regdrep h
  GOVCERTFromConf .convⁱ _ (C.GOVCERT-deregdrep (h , _)) = C.GOVCERT-deregdrep h
  GOVCERTFromConf .convⁱ _ (C.GOVCERT-ccreghot h)  = C.GOVCERT-ccreghot h

  CERTFromConf : ∀ {Γ s dcert s'} → Γ C.⊢ s ⇀⦇ dcert ,CERT⦈ s' ⭆ Γ L.⊢ conv s ⇀⦇ dcert ,CERT⦈ conv s'
  CERTFromConf .convⁱ _ (C.CERT-deleg deleg)  = L.CERT-deleg (conv deleg)
  CERTFromConf .convⁱ _ (C.CERT-pool pool)    = L.CERT-pool (conv pool)
  CERTFromConf .convⁱ _ (C.CERT-vdel govcert) = L.CERT-vdel (conv govcert)

  PRE-CERTFromConf : ∀ {Γ s s'}
                   → Γ C.⊢ s ⇀⦇ _ ,PRE-CERT⦈ s' ⭆
                     Γ L.⊢ (conv s) ⇀⦇ _ ,PRE-CERT⦈ (conv s')
  PRE-CERTFromConf .convⁱ _ (C.CERT-pre h) = L.CERT-pre h

  POST-CERTFromConf : ∀ {Γ s s'}
                   → Γ C.⊢ s ⇀⦇ _ ,POST-CERT⦈ s' ⭆
                     Γ L.⊢ (conv s) ⇀⦇ _ ,POST-CERT⦈ (conv s')
  POST-CERTFromConf .convⁱ _ C.CERT-post = L.CERT-post


  CERT-POST-CERTFromConf : ∀ {Γ s dcerts s'}
    → RunTraceAndThen C._⊢_⇀⦇_,CERT⦈_ C._⊢_⇀⦇_,POST-CERT⦈_ Γ s dcerts s'
      ⭆ RunTraceAndThen L._⊢_⇀⦇_,CERT⦈_ L._⊢_⇀⦇_,POST-CERT⦈_ Γ (conv s) dcerts (conv s')
  CERT-POST-CERTFromConf .convⁱ _ (run-[] x) = run-[] (conv x)
  CERT-POST-CERTFromConf .convⁱ _ (run-∷ x xs) = run-∷ (conv x) (conv xs)


  CERTSFromConf : ∀ {Γ s dcerts s'}
                 → RunTraceAfterAndThen C._⊢_⇀⦇_,PRE-CERT⦈_ C._⊢_⇀⦇_,CERT⦈_ C._⊢_⇀⦇_,POST-CERT⦈_ Γ s dcerts s' ⭆
                   RunTraceAfterAndThen L._⊢_⇀⦇_,PRE-CERT⦈_ L._⊢_⇀⦇_,CERT⦈_ L._⊢_⇀⦇_,POST-CERT⦈_ Γ (conv s) dcerts (conv s')
  CERTSFromConf .convⁱ _ (run (pre , cert-post)) = run ((conv pre) , conv cert-post)