@proto-kit/protocol 0.1.1-develop.600 → 0.1.1-develop.833

package/dist/prover/block/acummulators/BlockHashMerkleTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockHashMerkleTree.d.ts","sourceRoot":"","sources":["../../../../src/prover/block/acummulators/BlockHashMerkleTree.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,EAA8B,MAAM,MAAM,CAAC;;AAE/D,qBAAa,mBAAoB,SAAQ,wBAAmB;CAAG;AAC/D,qBAAa,0BAA2B,SAAQ,mBAAmB,CAAC,OAAO;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9E,qBAAa,kBAAmB,SAAQ,uBAKtC;IACO,IAAI,IAAI,KAAK;CAGrB"}

package/dist/prover/block/acummulators/BlockHashMerkleTree.js

@@ -0,0 +1,16 @@
+import { createMerkleTree } from "@proto-kit/common";
+import { Bool, Field, Poseidon, Struct } from "o1js";
+export class BlockHashMerkleTree extends createMerkleTree(8) {
+}
+export class BlockHashMerkleTreeWitness extends BlockHashMerkleTree.WITNESS {
+}
+export class BlockHashTreeEntry extends Struct({
+    transactionsHash: Field,
+    closed: Bool,
+    // TODO We could add startingEternalTransactionsHash here to offer
+    // a more trivial connection to the sequence state
+}) {
+    hash() {
+        return Poseidon.hash([this.transactionsHash, ...this.closed.toFields()]);
+    }
+}

package/dist/prover/statetransition/StateTransitionProvable.d.ts

@@ -3,37 +3,60 @@ import { WithZkProgrammable } from "@proto-kit/common";
 import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
 import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
 declare const StateTransitionProverPublicInput_base: (new (value: {
-    stateTransitionsHash: import("o1js/dist/node/lib/field").Field;
-    protocolTransitionsHash: import("o1js/dist/node/lib/field").Field;
-    stateRoot: import("o1js/dist/node/lib/field").Field;
-    protocolStateRoot: import("o1js/dist/node/lib/field").Field;
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
 }) => {
-    stateTransitionsHash: import("o1js/dist/node/lib/field").Field;
-    protocolTransitionsHash: import("o1js/dist/node/lib/field").Field;
-    stateRoot: import("o1js/dist/node/lib/field").Field;
-    protocolStateRoot: import("o1js/dist/node/lib/field").Field;
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
 }) & {
     _isStruct: true;
-} & import("o1js/dist/node/snarky").ProvablePure<{
-    stateTransitionsHash: import("o1js/dist/node/lib/field").Field;
-    protocolTransitionsHash: import("o1js/dist/node/lib/field").Field;
-    stateRoot: import("o1js/dist/node/lib/field").Field;
-    protocolStateRoot: import("o1js/dist/node/lib/field").Field;
-}> & {
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    stateTransitionsHash: bigint;
+    protocolTransitionsHash: bigint;
+    stateRoot: bigint;
+    protocolStateRoot: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        stateTransitionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
     toInput: (x: {
-        stateTransitionsHash: import("o1js/dist/node/lib/field").Field;
-        protocolTransitionsHash: import("o1js/dist/node/lib/field").Field;
-        stateRoot: import("o1js/dist/node/lib/field").Field;
-        protocolStateRoot: import("o1js/dist/node/lib/field").Field;
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
     }) => {
-        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
-        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
     };
     toJSON: (x: {
-        stateTransitionsHash: import("o1js/dist/node/lib/field").Field;
-        protocolTransitionsHash: import("o1js/dist/node/lib/field").Field;
-        stateRoot: import("o1js/dist/node/lib/field").Field;
-        protocolStateRoot: import("o1js/dist/node/lib/field").Field;
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
     }) => {
         stateTransitionsHash: string;
         protocolTransitionsHash: string;
@@ -46,46 +69,75 @@ declare const StateTransitionProverPublicInput_base: (new (value: {
         stateRoot: string;
         protocolStateRoot: string;
     }) => {
-        stateTransitionsHash: import("o1js/dist/node/lib/field").Field;
-        protocolTransitionsHash: import("o1js/dist/node/lib/field").Field;
-        stateRoot: import("o1js/dist/node/lib/field").Field;
-        protocolStateRoot: import("o1js/dist/node/lib/field").Field;
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
     };
 };
 export declare class StateTransitionProverPublicInput extends StateTransitionProverPublicInput_base {
 }
 declare const StateTransitionProverPublicOutput_base: (new (value: {
-    stateTransitionsHash: import("o1js/dist/node/lib/field").Field;
-    protocolTransitionsHash: import("o1js/dist/node/lib/field").Field;
-    stateRoot: import("o1js/dist/node/lib/field").Field;
-    protocolStateRoot: import("o1js/dist/node/lib/field").Field;
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
 }) => {
-    stateTransitionsHash: import("o1js/dist/node/lib/field").Field;
-    protocolTransitionsHash: import("o1js/dist/node/lib/field").Field;
-    stateRoot: import("o1js/dist/node/lib/field").Field;
-    protocolStateRoot: import("o1js/dist/node/lib/field").Field;
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
 }) & {
     _isStruct: true;
-} & import("o1js/dist/node/snarky").ProvablePure<{
-    stateTransitionsHash: import("o1js/dist/node/lib/field").Field;
-    protocolTransitionsHash: import("o1js/dist/node/lib/field").Field;
-    stateRoot: import("o1js/dist/node/lib/field").Field;
-    protocolStateRoot: import("o1js/dist/node/lib/field").Field;
-}> & {
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    stateTransitionsHash: bigint;
+    protocolTransitionsHash: bigint;
+    stateRoot: bigint;
+    protocolStateRoot: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        stateTransitionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
     toInput: (x: {
-        stateTransitionsHash: import("o1js/dist/node/lib/field").Field;
-        protocolTransitionsHash: import("o1js/dist/node/lib/field").Field;
-        stateRoot: import("o1js/dist/node/lib/field").Field;
-        protocolStateRoot: import("o1js/dist/node/lib/field").Field;
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
     }) => {
-        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
-        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
     };
     toJSON: (x: {
-        stateTransitionsHash: import("o1js/dist/node/lib/field").Field;
-        protocolTransitionsHash: import("o1js/dist/node/lib/field").Field;
-        stateRoot: import("o1js/dist/node/lib/field").Field;
-        protocolStateRoot: import("o1js/dist/node/lib/field").Field;
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
     }) => {
         stateTransitionsHash: string;
         protocolTransitionsHash: string;
@@ -98,10 +150,16 @@ declare const StateTransitionProverPublicOutput_base: (new (value: {
         stateRoot: string;
         protocolStateRoot: string;
     }) => {
-        stateTransitionsHash: import("o1js/dist/node/lib/field").Field;
-        protocolTransitionsHash: import("o1js/dist/node/lib/field").Field;
-        stateRoot: import("o1js/dist/node/lib/field").Field;
-        protocolStateRoot: import("o1js/dist/node/lib/field").Field;
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
     };
 };
 export declare class StateTransitionProverPublicOutput extends StateTransitionProverPublicOutput_base {
@@ -109,8 +167,8 @@ export declare class StateTransitionProverPublicOutput extends StateTransitionPr
 export type StateTransitionProof = Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>;
 export interface StateTransitionProvable extends WithZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput> {
     witnessProviderReference: StateTransitionWitnessProviderReference;
-    runBatch: (publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch) => StateTransitionProverPublicOutput;
-    merge: (publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof) => StateTransitionProverPublicOutput;
+    runBatch: (publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch) => Promise<StateTransitionProverPublicOutput>;
+    merge: (publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof) => Promise<StateTransitionProverPublicOutput>;
 }
 export {};
 //# sourceMappingURL=StateTransitionProvable.d.ts.map

package/dist/prover/statetransition/StateTransitionProvable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StateTransitionProvable.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAU,MAAM,MAAM,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAkB,MAAM,mBAAmB,CAAC;AAEvE,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AAExF,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,gCAAiC,SAAQ,qCAKpD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,iCAAkC,SAAQ,sCAKrD;CAAG;AAEL,MAAM,MAAM,oBAAoB,GAAG,KAAK,CACtC,gCAAgC,EAChC,iCAAiC,CAClC,CAAC;AAEF,MAAM,WAAW,uBACf,SAAQ,kBAAkB,CACxB,gCAAgC,EAChC,iCAAiC,CAClC;IACD,wBAAwB,EAAE,uCAAuC,CAAC;IAElE,QAAQ,EAAE,CACR,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,KAChC,iCAAiC,CAAC;IAEvC,KAAK,EAAE,CACL,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,KACzB,iCAAiC,CAAC;CACxC"}
+{"version":3,"file":"StateTransitionProvable.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAU,MAAM,MAAM,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AAExF,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,gCAAiC,SAAQ,qCAKpD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,iCAAkC,SAAQ,sCAKrD;CAAG;AAEL,MAAM,MAAM,oBAAoB,GAAG,KAAK,CACtC,gCAAgC,EAChC,iCAAiC,CAClC,CAAC;AAEF,MAAM,WAAW,uBACf,SAAQ,kBAAkB,CACxB,gCAAgC,EAChC,iCAAiC,CAClC;IACD,wBAAwB,EAAE,uCAAuC,CAAC;IAElE,QAAQ,EAAE,CACR,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,KAChC,OAAO,CAAC,iCAAiC,CAAC,CAAC;IAEhD,KAAK,EAAE,CACL,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,KACzB,OAAO,CAAC,iCAAiC,CAAC,CAAC;CACjD"}

package/dist/prover/statetransition/StateTransitionProver.d.ts

@@ -1,10 +1,11 @@
-import { Field } from "o1js";
 import { AreProofsEnabled, PlainZkProgram, ZkProgrammable } from "@proto-kit/common";
-import { ProvableHashList } from "../../utils/ProvableHashList";
+import { Field } from "o1js";
 import { ProvableStateTransition } from "../../model/StateTransition";
 import { ProvableStateTransitionType, StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+import { StateTransitionProverType } from "../../protocol/Protocol";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
-import { StateTransitionProvable, StateTransitionProverPublicInput, StateTransitionProof, StateTransitionProverPublicOutput } from "./StateTransitionProvable";
+import { ProvableHashList } from "../../utils/ProvableHashList";
+import { StateTransitionProof, StateTransitionProvable, StateTransitionProverPublicInput, StateTransitionProverPublicOutput } from "./StateTransitionProvable";
 import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
 interface StateTransitionProverExecutionState {
     stateRoot: Field;
@@ -36,15 +37,15 @@ export declare class StateTransitionProverProgrammable extends ZkProgrammable<St
     /**
      * Applies a whole batch of StateTransitions at once
      */
-    runBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch): StateTransitionProverPublicOutput;
-    merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): StateTransitionProverPublicOutput;
+    runBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch): Promise<StateTransitionProverPublicOutput>;
+    merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): Promise<StateTransitionProverPublicOutput>;
 }
-export declare class StateTransitionProver extends ProtocolModule implements StateTransitionProvable {
+export declare class StateTransitionProver extends ProtocolModule implements StateTransitionProvable, StateTransitionProverType {
     readonly witnessProviderReference: StateTransitionWitnessProviderReference;
-    readonly zkProgrammable: StateTransitionProverProgrammable;
+    zkProgrammable: StateTransitionProverProgrammable;
     constructor(witnessProviderReference: StateTransitionWitnessProviderReference);
-    runBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch): StateTransitionProverPublicOutput;
-    merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): StateTransitionProverPublicOutput;
+    runBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch): Promise<StateTransitionProverPublicOutput>;
+    merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): Promise<StateTransitionProverPublicOutput>;
 }
 export {};
 //# sourceMappingURL=StateTransitionProver.d.ts.map

package/dist/prover/statetransition/StateTransitionProver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StateTransitionProver.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProver.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,EAAuB,MAAM,MAAM,CAAC;AAEtE,OAAO,EACL,gBAAgB,EAEhB,cAAc,EAGd,cAAc,EACf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,0CAA0C,CAAC;AAElD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAG/D,OAAO,EACL,uBAAuB,EACvB,gCAAgC,EAChC,oBAAoB,EACpB,iCAAiC,EAClC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;AAepG,UAAU,mCAAmC;IAC3C,SAAS,EAAE,KAAK,CAAC;IACjB,iBAAiB,EAAE,KAAK,CAAC;IACzB,mBAAmB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;IAC/D,sBAAsB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;CACnE;AAOD;;;GAGG;AACH,qBAAa,iCAAkC,SAAQ,cAAc,CACnE,gCAAgC,EAChC,iCAAiC,CAClC;IAGG,OAAO,CAAC,QAAQ,CAAC,qBAAqB;aACtB,wBAAwB,EAAE,uCAAuC;gBADhE,qBAAqB,EAAE,qBAAqB,EAC7C,wBAAwB,EAAE,uCAAuC;IAKnF,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAEM,gBAAgB,IAAI,cAAc,CACvC,gCAAgC,EAChC,iCAAiC,CAClC;IAqDD,OAAO,KAAK,eAAe,GAM1B;IAED;;;OAGG;IACI,gBAAgB,CACrB,SAAS,EAAE,KAAK,EAChB,iBAAiB,EAAE,KAAK,EACxB,6BAA6B,EAAE,KAAK,EACpC,gCAAgC,EAAE,KAAK,EACvC,eAAe,EAAE,4BAA4B,GAC5C,mCAAmC;IA6BtC;;;OAGG;IACI,eAAe,CACpB,KAAK,EAAE,mCAAmC,EAC1C,UAAU,EAAE,uBAAuB,EACnC,IAAI,EAAE,2BAA2B,EACjC,KAAK,SAAI;IAiDX;;OAEG;IAEI,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAkB7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CAqErC;AAED,qBACa,qBACX,SAAQ,cACR,YAAW,uBAAuB;aAMhB,wBAAwB,EAAE,uCAAuC;IAJnF,SAAgB,cAAc,EAAE,iCAAiC,CAAC;gBAIhD,wBAAwB,EAAE,uCAAuC;IAS5E,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAI7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CAGrC"}
+{"version":3,"file":"StateTransitionProver.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,cAAc,EAGd,cAAc,EACf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,EAAkC,MAAM,MAAM,CAAC;AAI7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;AAepG,UAAU,mCAAmC;IAC3C,SAAS,EAAE,KAAK,CAAC;IACjB,iBAAiB,EAAE,KAAK,CAAC;IACzB,mBAAmB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;IAC/D,sBAAsB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;CACnE;AAOD;;;GAGG;AACH,qBAAa,iCAAkC,SAAQ,cAAc,CACnE,gCAAgC,EAChC,iCAAiC,CAClC;IAEG,OAAO,CAAC,QAAQ,CAAC,qBAAqB;aACtB,wBAAwB,EAAE,uCAAuC;gBADhE,qBAAqB,EAAE,qBAAqB,EAC7C,wBAAwB,EAAE,uCAAuC;IAKnF,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAEM,gBAAgB,IAAI,cAAc,CACvC,gCAAgC,EAChC,iCAAiC,CAClC;IAqDD,OAAO,KAAK,eAAe,GAM1B;IAED;;;OAGG;IACI,gBAAgB,CACrB,SAAS,EAAE,KAAK,EAChB,iBAAiB,EAAE,KAAK,EACxB,6BAA6B,EAAE,KAAK,EACpC,gCAAgC,EAAE,KAAK,EACvC,eAAe,EAAE,4BAA4B,GAC5C,mCAAmC;IA6BtC;;;OAGG;IACI,eAAe,CACpB,KAAK,EAAE,mCAAmC,EAC1C,UAAU,EAAE,uBAAuB,EACnC,IAAI,EAAE,2BAA2B,EACjC,KAAK,SAAI;IAiDX;;OAEG;IAEU,QAAQ,CACnB,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,iCAAiC,CAAC;IAkBhC,KAAK,CAChB,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,iCAAiC,CAAC;CAqE9C;AAED,qBACa,qBACX,SAAQ,cACR,YAAW,uBAAuB,EAAE,yBAAyB;aAM3C,wBAAwB,EAAE,uCAAuC;IAJ5E,cAAc,EAAE,iCAAiC,CAAC;gBAIvC,wBAAwB,EAAE,uCAAuC;IAS5E,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,iCAAiC,CAAC;IAItC,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,iCAAiC,CAAC;CAG9C"}

package/dist/prover/statetransition/StateTransitionProver.js

@@ -7,15 +7,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-/* eslint-disable max-lines */
-import { Experimental, Field, Provable, SelfProof } from "o1js";
-import { injectable } from "tsyringe";
 import { provableMethod, RollupMerkleTreeWitness, ZkProgrammable, } from "@proto-kit/common";
-import { DefaultProvableHashList, } from "../../utils/ProvableHashList";
+import { Field, Provable, SelfProof, ZkProgram } from "o1js";
+import { injectable } from "tsyringe";
+import { constants } from "../../Constants";
 import { ProvableStateTransition } from "../../model/StateTransition";
 import { StateTransitionProvableBatch, } from "../../model/StateTransitionProvableBatch";
-import { constants } from "../../Constants";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
+import { DefaultProvableHashList, } from "../../utils/ProvableHashList";
 import { StateTransitionProverPublicInput, StateTransitionProverPublicOutput, } from "./StateTransitionProvable";
 import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
 const errors = {
@@ -29,9 +28,7 @@ const StateTransitionSelfProofClass = (SelfProof);
  * transitions and checks and updates their merkle-tree entries
  */
 export class StateTransitionProverProgrammable extends ZkProgrammable {
-    constructor(
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    stateTransitionProver, witnessProviderReference) {
+    constructor(stateTransitionProver, witnessProviderReference) {
         super();
         this.stateTransitionProver = stateTransitionProver;
         this.witnessProviderReference = witnessProviderReference;
@@ -40,17 +37,16 @@ export class StateTransitionProverProgrammable extends ZkProgrammable {
         return this.stateTransitionProver.appChain;
     }
     zkProgramFactory() {
-        // eslint-disable-next-line max-len
-        // eslint-disable-next-line @typescript-eslint/no-this-alias,consistent-this,unicorn/no-this-assignment
         const instance = this;
-        const program = Experimental.ZkProgram({
+        const program = ZkProgram({
+            name: "StateTransitionProver",
             publicInput: StateTransitionProverPublicInput,
             publicOutput: StateTransitionProverPublicOutput,
             methods: {
                 proveBatch: {
                     privateInputs: [StateTransitionProvableBatch],
-                    method(publicInput, batch) {
-                        return instance.runBatch(publicInput, batch);
+                    async method(publicInput, batch) {
+                        return await instance.runBatch(publicInput, batch);
                     },
                 },
                 merge: {
@@ -58,8 +54,8 @@ export class StateTransitionProverProgrammable extends ZkProgrammable {
                         StateTransitionSelfProofClass,
                         StateTransitionSelfProofClass,
                     ],
-                    method(publicInput, proof1, proof2) {
-                        return instance.merge(publicInput, proof1, proof2);
+                    async method(publicInput, proof1, proof2) {
+                        return await instance.merge(publicInput, proof1, proof2);
                     },
                 },
             },
@@ -68,10 +64,11 @@ export class StateTransitionProverProgrammable extends ZkProgrammable {
             proveBatch: program.proveBatch.bind(program),
             merge: program.merge.bind(program),
         };
-        const SelfProofClass = Experimental.ZkProgram.Proof(program);
+        const SelfProofClass = ZkProgram.Proof(program);
         return {
             compile: program.compile.bind(program),
             verify: program.verify.bind(program),
+            analyzeMethods: program.analyzeMethods.bind(program),
             Proof: SelfProofClass,
             methods,
         };
@@ -123,7 +120,7 @@ export class StateTransitionProverProgrammable extends ZkProgrammable {
     /**
      * Applies a whole batch of StateTransitions at once
      */
-    runBatch(publicInput, batch) {
+    async runBatch(publicInput, batch) {
         const result = this.applyTransitions(publicInput.stateRoot, publicInput.protocolStateRoot, publicInput.stateTransitionsHash, publicInput.protocolTransitionsHash, batch);
         return new StateTransitionProverPublicOutput({
             stateRoot: result.stateRoot,
@@ -132,7 +129,7 @@ export class StateTransitionProverProgrammable extends ZkProgrammable {
             protocolStateRoot: result.protocolStateRoot,
         });
     }
-    merge(publicInput, proof1, proof2) {
+    async merge(publicInput, proof1, proof2) {
         proof1.verify();
         proof2.verify();
         // Check state
@@ -160,15 +157,15 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [StateTransitionProverPublicInput,
         StateTransitionProvableBatch]),
-    __metadata("design:returntype", StateTransitionProverPublicOutput)
+    __metadata("design:returntype", Promise)
 ], StateTransitionProverProgrammable.prototype, "runBatch", null);
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [StateTransitionProverPublicInput, Object, Object]),
-    __metadata("design:returntype", StateTransitionProverPublicOutput)
+    __metadata("design:returntype", Promise)
 ], StateTransitionProverProgrammable.prototype, "merge", null);
-let StateTransitionProver = class StateTransitionProver extends ProtocolModule {
+export let StateTransitionProver = class StateTransitionProver extends ProtocolModule {
     constructor(
     // Injected
     witnessProviderReference) {
@@ -187,4 +184,3 @@ StateTransitionProver = __decorate([
     injectable(),
     __metadata("design:paramtypes", [StateTransitionWitnessProviderReference])
 ], StateTransitionProver);
-export { StateTransitionProver };

package/dist/prover/statetransition/StateTransitionWitnessProvider.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { injectable } from "tsyringe";
 import { RollupMerkleTreeWitness } from "@proto-kit/common";
-let NoOpStateTransitionWitnessProvider = class NoOpStateTransitionWitnessProvider {
+export let NoOpStateTransitionWitnessProvider = class NoOpStateTransitionWitnessProvider {
     getWitness() {
         return new RollupMerkleTreeWitness({ path: [], isLeft: [] });
     }
@@ -14,4 +14,3 @@ let NoOpStateTransitionWitnessProvider = class NoOpStateTransitionWitnessProvide
 NoOpStateTransitionWitnessProvider = __decorate([
     injectable()
 ], NoOpStateTransitionWitnessProvider);
-export { NoOpStateTransitionWitnessProvider };

package/dist/prover/statetransition/StateTransitionWitnessProviderReference.js

@@ -5,7 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { injectable, Lifecycle, scoped } from "tsyringe";
-let StateTransitionWitnessProviderReference = class StateTransitionWitnessProviderReference {
+export let StateTransitionWitnessProviderReference = class StateTransitionWitnessProviderReference {
     setWitnessProvider(provider) {
         this.witnessProvider = provider;
     }
@@ -17,4 +17,3 @@ StateTransitionWitnessProviderReference = __decorate([
     injectable(),
     scoped(Lifecycle.ContainerScoped)
 ], StateTransitionWitnessProviderReference);
-export { StateTransitionWitnessProviderReference };

package/dist/settlement/ContractModule.d.ts

@@ -0,0 +1,15 @@
+import { ConfigurableModule, NoConfig, TypedClass } from "@proto-kit/common";
+import { SmartContract } from "o1js";
+export type SmartContractClassFromInterface<Type> = typeof SmartContract & TypedClass<Type>;
+/**
+ * This module type is used to define a contract module that can be used to
+ * construct and inject smart contract instances.
+ * It defines a method contractFactory, whose arguments can be configured via
+ * the Argument generic. It returns a smart contract class that is a subclass
+ * of SmartContract and implements a certain interface as specified by the
+ * ContractType generic.
+ */
+export declare abstract class ContractModule<ContractType, Arguments = undefined, Config = NoConfig> extends ConfigurableModule<Config> {
+    abstract contractFactory(args: Arguments): SmartContractClassFromInterface<ContractType>;
+}
+//# sourceMappingURL=ContractModule.d.ts.map

package/dist/settlement/ContractModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractModule.d.ts","sourceRoot":"","sources":["../../src/settlement/ContractModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAErC,MAAM,MAAM,+BAA+B,CAAC,IAAI,IAAI,OAAO,aAAa,GACtE,UAAU,CAAC,IAAI,CAAC,CAAC;AAEnB;;;;;;;GAOG;AACH,8BAAsB,cAAc,CAClC,YAAY,EAEZ,SAAS,GAAG,SAAS,EACrB,MAAM,GAAG,QAAQ,CACjB,SAAQ,kBAAkB,CAAC,MAAM,CAAC;aAClB,eAAe,CAC7B,IAAI,EAAE,SAAS,GACd,+BAA+B,CAAC,YAAY,CAAC;CACjD"}

package/dist/settlement/ContractModule.js

@@ -0,0 +1,11 @@
+import { ConfigurableModule } from "@proto-kit/common";
+/**
+ * This module type is used to define a contract module that can be used to
+ * construct and inject smart contract instances.
+ * It defines a method contractFactory, whose arguments can be configured via
+ * the Argument generic. It returns a smart contract class that is a subclass
+ * of SmartContract and implements a certain interface as specified by the
+ * ContractType generic.
+ */
+export class ContractModule extends ConfigurableModule {
+}

package/dist/settlement/DispatchContract.d.ts

@@ -0,0 +1,20 @@
+import { Field, PublicKey, SmartContract, State, UInt64 } from "o1js";
+export declare const ACTIONS_EMPTY_HASH: import("o1js/dist/node/lib/field").Field;
+export interface DispatchContractType {
+    updateMessagesHash: (executedMessagesHash: Field, newPromisedMessagesHash: Field) => void;
+    initialize: (settlementContract: PublicKey) => void;
+    promisedMessagesHash: State<Field>;
+}
+export declare class DispatchContract extends SmartContract implements DispatchContractType {
+    private readonly methodIdMappings;
+    private readonly incomingMessagesPaths;
+    promisedMessagesHash: State<import("o1js/dist/node/lib/field").Field>;
+    honoredMessagesHash: State<import("o1js/dist/node/lib/field").Field>;
+    settlementContract: State<PublicKey>;
+    constructor(address: PublicKey, methodIdMappings: Record<string, bigint>, incomingMessagesPaths: Record<string, `${string}.${string}`>);
+    updateMessagesHash(executedMessagesHash: Field, newPromisedMessagesHash: Field): void;
+    initialize(settlementContract: PublicKey): void;
+    private dispatchMessage;
+    deposit(amount: UInt64): void;
+}
+//# sourceMappingURL=DispatchContract.d.ts.map

package/dist/settlement/DispatchContract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DispatchContract.d.ts","sourceRoot":"","sources":["../../src/settlement/DispatchContract.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,EAIL,SAAS,EAET,aAAa,EACb,KAAK,EAEL,MAAM,EACP,MAAM,MAAM,CAAC;AAOd,eAAO,MAAM,kBAAkB,0CAA6B,CAAC;AAE7D,MAAM,WAAW,oBAAoB;IACnC,kBAAkB,EAAE,CAClB,oBAAoB,EAAE,KAAK,EAC3B,uBAAuB,EAAE,KAAK,KAC3B,IAAI,CAAC;IACV,UAAU,EAAE,CAAC,kBAAkB,EAAE,SAAS,KAAK,IAAI,CAAC;IAEpD,oBAAoB,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;CACpC;AAED,qBAAa,gBACX,SAAQ,aACR,YAAW,oBAAoB;IAU7B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,qBAAqB;IATnB,oBAAoB,kDAAkB;IAEtC,mBAAmB,kDAAkB;IAEjC,kBAAkB,mBAAsB;gBAG/D,OAAO,EAAE,SAAS,EACD,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACxC,qBAAqB,EAAE,MAAM,CAC5C,MAAM,EACN,GAAG,MAAM,IAAI,MAAM,EAAE,CACtB;IAMI,kBAAkB,CACvB,oBAAoB,EAAE,KAAK,EAC3B,uBAAuB,EAAE,KAAK;IAiBzB,UAAU,CAAC,kBAAkB,EAAE,SAAS;IAY/C,OAAO,CAAC,eAAe;IA8BhB,OAAO,CAAC,MAAM,EAAE,MAAM;CAqB9B"}

package/dist/settlement/DispatchContract.js

@@ -0,0 +1,112 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { AccountUpdate, Field, method, Poseidon, PublicKey, Reducer, SmartContract, State, state, UInt64, } from "o1js";
+import { RuntimeTransaction } from "../model/transaction/RuntimeTransaction";
+import { MinaActions, MinaEvents } from "../utils/MinaPrefixedProvableHashList";
+import { Deposit } from "./messages/Deposit";
+export const ACTIONS_EMPTY_HASH = Reducer.initialActionState;
+export class DispatchContract extends SmartContract {
+    constructor(address, methodIdMappings, incomingMessagesPaths) {
+        super(address);
+        this.methodIdMappings = methodIdMappings;
+        this.incomingMessagesPaths = incomingMessagesPaths;
+        this.promisedMessagesHash = State();
+        this.honoredMessagesHash = State();
+        this.settlementContract = State();
+    }
+    updateMessagesHash(executedMessagesHash, newPromisedMessagesHash) {
+        const promisedMessagesHash = this.promisedMessagesHash.getAndAssertEquals();
+        this.honoredMessagesHash.getAndAssertEquals();
+        executedMessagesHash.assertEquals(promisedMessagesHash);
+        this.honoredMessagesHash.set(executedMessagesHash);
+        this.self.account.isNew;
+        // Assert and apply new promisedMessagesHash
+        this.self.account.actionState.assertEquals(newPromisedMessagesHash);
+        this.promisedMessagesHash.set(newPromisedMessagesHash);
+    }
+    initialize(settlementContract) {
+        this.promisedMessagesHash.getAndAssertEquals().assertEquals(Field(0));
+        this.honoredMessagesHash.getAndAssertEquals().assertEquals(Field(0));
+        this.settlementContract
+            .getAndAssertEquals()
+            .assertEquals(PublicKey.empty());
+        this.promisedMessagesHash.set(ACTIONS_EMPTY_HASH);
+        this.honoredMessagesHash.set(ACTIONS_EMPTY_HASH);
+        this.settlementContract.set(settlementContract);
+    }
+    dispatchMessage(methodId, value, valueType) {
+        const args = valueType.toFields(value);
+        // Should be the same as RuntimeTransaction.hash
+        const argsHash = Poseidon.hash(args);
+        const runtimeTransaction = RuntimeTransaction.fromMessage({
+            methodId,
+            argsHash,
+        });
+        // Append tx to incomingMessagesHash
+        const actionData = runtimeTransaction.hashData();
+        const actionHash = MinaActions.actionHash(actionData);
+        this.self.body.actions = {
+            hash: actionHash,
+            data: [actionData],
+        };
+        const eventHash = MinaEvents.eventHash(args);
+        this.self.body.events = {
+            hash: eventHash,
+            data: [args],
+        };
+    }
+    deposit(amount) {
+        // Save this, since otherwise it would be a second witness later,
+        // which could be a different values than the first
+        const { sender } = this;
+        const settlementContract = this.settlementContract.getAndAssertEquals();
+        // Credit the amount to the settlement contract
+        const balanceAU = AccountUpdate.create(settlementContract);
+        balanceAU.balance.addInPlace(amount);
+        this.self.approve(balanceAU);
+        const action = new Deposit({
+            address: sender,
+            amount,
+        });
+        const methodId = Field(this.methodIdMappings[this.incomingMessagesPaths.deposit]);
+        this.dispatchMessage(methodId.toConstant(), action, Deposit);
+    }
+}
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], DispatchContract.prototype, "promisedMessagesHash", void 0);
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], DispatchContract.prototype, "honoredMessagesHash", void 0);
+__decorate([
+    state(PublicKey),
+    __metadata("design:type", Object)
+], DispatchContract.prototype, "settlementContract", void 0);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Field,
+        Field]),
+    __metadata("design:returntype", void 0)
+], DispatchContract.prototype, "updateMessagesHash", null);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PublicKey]),
+    __metadata("design:returntype", void 0)
+], DispatchContract.prototype, "initialize", null);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UInt64]),
+    __metadata("design:returntype", void 0)
+], DispatchContract.prototype, "deposit", null);