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

package/dist/settlement/contracts/SettlementSmartContract.js

@@ -7,14 +7,15 @@ 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);
 };
-import { prefixToField, RollupMerkleTree } from "@proto-kit/common";
-import { AccountUpdate, Bool, Field, method, Mina, Poseidon, Proof, Provable, PublicKey, Signature, SmartContract, State, state, TokenId, UInt32, UInt64, } from "o1js";
+import { prefixToField, RollupMerkleTree, mapSequential, } from "@proto-kit/common";
+import { AccountUpdate, Bool, Field, method, Mina, Poseidon, Proof, Provable, PublicKey, Signature, State, state, TokenId, UInt32, UInt64, TokenContract, AccountUpdateForest, } from "o1js";
 import { NetworkState } from "../../model/network/NetworkState";
 import { Path } from "../../model/Path";
 import { BlockHashMerkleTree } from "../../prover/block/accummulators/BlockHashMerkleTree";
 import { BlockProverPublicInput, BlockProverPublicOutput, } from "../../prover/block/BlockProvable";
 import { OUTGOING_MESSAGE_BATCH_SIZE, OutgoingMessageArgumentBatch, } from "../messages/OutgoingMessageArgument";
 import { Withdrawal } from "../messages/Withdrawal";
+/* eslint-disable @typescript-eslint/lines-between-class-members */
 export class LazyBlockProof extends Proof {
 }
 LazyBlockProof.publicInputType = BlockProverPublicInput;
@@ -24,7 +25,7 @@ LazyBlockProof.tag = () => {
 };
 // Some random prefix for the sequencer signature
 export const BATCH_SIGNATURE_PREFIX = prefixToField("pk-batchSignature");
-export class SettlementSmartContract extends SmartContract {
+export class SettlementSmartContract extends TokenContract {
     constructor() {
         super(...arguments);
         this.sequencerKey = State();
@@ -35,30 +36,33 @@ export class SettlementSmartContract extends SmartContract {
         this.dispatchContractAddressX = State();
         this.outgoingMessageCursor = State();
     }
-    initialize(sequencer, dispatchContract) {
-        this.sequencerKey.getAndAssertEquals().assertEquals(Field(0));
-        this.stateRoot.getAndAssertEquals().assertEquals(Field(0));
-        this.blockHashRoot.getAndAssertEquals().assertEquals(Field(0));
-        this.networkStateHash.getAndAssertEquals().assertEquals(Field(0));
-        this.dispatchContractAddressX.getAndAssertEquals().assertEquals(Field(0));
+    async approveBase(forest) {
+        this.checkZeroBalanceChange(forest);
+    }
+    async initialize(sequencer, dispatchContract) {
+        this.sequencerKey.getAndRequireEquals().assertEquals(Field(0));
+        this.stateRoot.getAndRequireEquals().assertEquals(Field(0));
+        this.blockHashRoot.getAndRequireEquals().assertEquals(Field(0));
+        this.networkStateHash.getAndRequireEquals().assertEquals(Field(0));
+        this.dispatchContractAddressX.getAndRequireEquals().assertEquals(Field(0));
         this.sequencerKey.set(sequencer.x);
         this.stateRoot.set(Field(RollupMerkleTree.EMPTY_ROOT));
         this.blockHashRoot.set(Field(BlockHashMerkleTree.EMPTY_ROOT));
         this.networkStateHash.set(NetworkState.empty().hash());
         this.dispatchContractAddressX.set(dispatchContract.x);
-        const DispatchContract = SettlementSmartContract.args.DispatchContract;
-        new DispatchContract(dispatchContract).initialize(this.address);
+        const { DispatchContract } = SettlementSmartContract.args;
+        await new DispatchContract(dispatchContract).initialize(this.address);
     }
-    settle(blockProof, signature, dispatchContractAddress, publicKey, inputNetworkState, outputNetworkState, newPromisedMessagesHash) {
+    async settle(blockProof, signature, dispatchContractAddress, publicKey, inputNetworkState, outputNetworkState, newPromisedMessagesHash) {
         // Verify the blockproof
         blockProof.verify();
         // Get and assert on-chain values
-        const stateRoot = this.stateRoot.getAndAssertEquals();
-        const networkStateHash = this.networkStateHash.getAndAssertEquals();
-        const blockHashRoot = this.blockHashRoot.getAndAssertEquals();
-        const sequencerKey = this.sequencerKey.getAndAssertEquals();
-        const lastSettlementL1Block = this.lastSettlementL1Block.getAndAssertEquals();
-        const onChainDispatchContractAddressX = this.dispatchContractAddressX.getAndAssertEquals();
+        const stateRoot = this.stateRoot.getAndRequireEquals();
+        const networkStateHash = this.networkStateHash.getAndRequireEquals();
+        const blockHashRoot = this.blockHashRoot.getAndRequireEquals();
+        const sequencerKey = this.sequencerKey.getAndRequireEquals();
+        const lastSettlementL1Block = this.lastSettlementL1Block.getAndRequireEquals();
+        const onChainDispatchContractAddressX = this.dispatchContractAddressX.getAndRequireEquals();
         onChainDispatchContractAddressX.assertEquals(dispatchContractAddress.x, "DispatchContract address not provided correctly");
         const { DispatchContract, escapeHatchSlotsInterval, hooks } = SettlementSmartContract.args;
         // Get dispatch contract values
@@ -68,7 +72,7 @@ export class SettlementSmartContract extends SmartContract {
         const promisedMessagesHash = dispatchContract.promisedMessagesHash.get();
         // Get block height and use the lower bound for all ops
         const minBlockIncluded = this.network.globalSlotSinceGenesis.get();
-        this.network.globalSlotSinceGenesis.assertBetween(minBlockIncluded, 
+        this.network.globalSlotSinceGenesis.requireBetween(minBlockIncluded, 
         // 5 because that is the length the newPromisedMessagesHash will be valid
         minBlockIncluded.add(4));
         // Check signature/escape catch
@@ -110,8 +114,8 @@ export class SettlementSmartContract extends SmartContract {
             toNetworkState: outputNetworkState,
             currentL1Block: minBlockIncluded,
         };
-        hooks.forEach((hook) => {
-            hook.beforeSettlement(this, inputs);
+        await mapSequential(hooks, async (hook) => {
+            await hook.beforeSettlement(this, inputs);
         });
         // Apply blockProof
         stateRoot.assertEquals(blockProof.publicInput.stateRoot, "Input state root not matching");
@@ -130,12 +134,12 @@ export class SettlementSmartContract extends SmartContract {
         // to be the blockProofs publicoutput, is actually the current on-chain
         // promisedMessageHash. It also checks the newPromisedMessagesHash to be
         // a current sequencestate value
-        dispatchContract.updateMessagesHash(promisedMessagesHash, newPromisedMessagesHash);
+        await dispatchContract.updateMessagesHash(promisedMessagesHash, newPromisedMessagesHash);
         this.lastSettlementL1Block.set(minBlockIncluded);
     }
-    rollupOutgoingMessages(batch) {
-        let counter = this.outgoingMessageCursor.getAndAssertEquals();
-        const stateRoot = this.stateRoot.getAndAssertEquals();
+    async rollupOutgoingMessages(batch) {
+        let counter = this.outgoingMessageCursor.getAndRequireEquals();
+        const stateRoot = this.stateRoot.getAndRequireEquals();
         const [withdrawalModule, withdrawalStateName] = SettlementSmartContract.args.withdrawalStatePath;
         const mapPath = Path.fromProperty(withdrawalModule, withdrawalStateName);
         let accountCreationFeePaid = Field(0);
@@ -149,24 +153,24 @@ export class SettlementSmartContract extends SmartContract {
             // Process message
             const { address, amount } = args.value;
             const isDummy = address.equals(this.address);
-            const tokenAu = this.token.mint({ address, amount });
-            const isNewAccount = tokenAu.account.isNew.getAndAssertEquals();
+            const tokenAu = this.internal.mint({ address, amount });
+            const isNewAccount = tokenAu.account.isNew.getAndRequireEquals();
             tokenAu.body.balanceChange.magnitude =
-                tokenAu.body.balanceChange.magnitude.sub(Provable.if(isNewAccount, Mina.accountCreationFee().toConstant(), UInt64.zero));
+                tokenAu.body.balanceChange.magnitude.sub(Provable.if(isNewAccount, Mina.getNetworkConstants().accountCreationFee.toConstant(), UInt64.zero));
             accountCreationFeePaid = accountCreationFeePaid.add(Provable.if(isNewAccount, Field(1e9), Field(0)));
             counter = counter.add(Provable.if(isDummy, Field(0), Field(1)));
         }
-        this.balance.subInPlace(UInt64.from(accountCreationFeePaid));
+        this.balance.subInPlace(UInt64.Unsafe.fromField(accountCreationFeePaid));
         this.outgoingMessageCursor.set(counter);
     }
-    redeem(additionUpdate) {
+    async redeem(additionUpdate) {
         additionUpdate.body.tokenId.assertEquals(TokenId.default, "Tokenid not default token");
         additionUpdate.body.balanceChange.sgn
             .isPositive()
             .assertTrue("Sign not correct");
         const amount = additionUpdate.body.balanceChange.magnitude;
         // Burn tokens
-        this.token.burn({
+        this.internal.burn({
             address: additionUpdate.publicKey,
             amount,
         });
@@ -203,11 +207,17 @@ __decorate([
     state(Field),
     __metadata("design:type", Object)
 ], SettlementSmartContract.prototype, "outgoingMessageCursor", void 0);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [AccountUpdateForest]),
+    __metadata("design:returntype", Promise)
+], SettlementSmartContract.prototype, "approveBase", null);
 __decorate([
     method,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PublicKey, PublicKey]),
-    __metadata("design:returntype", void 0)
+    __metadata("design:returntype", Promise)
 ], SettlementSmartContract.prototype, "initialize", null);
 __decorate([
     method,
@@ -219,17 +229,18 @@ __decorate([
         NetworkState,
         NetworkState,
         Field]),
-    __metadata("design:returntype", void 0)
+    __metadata("design:returntype", Promise)
 ], SettlementSmartContract.prototype, "settle", null);
 __decorate([
     method,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [OutgoingMessageArgumentBatch]),
-    __metadata("design:returntype", void 0)
+    __metadata("design:returntype", Promise)
 ], SettlementSmartContract.prototype, "rollupOutgoingMessages", null);
 __decorate([
     method,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [AccountUpdate]),
-    __metadata("design:returntype", void 0)
+    __metadata("design:returntype", Promise)
 ], SettlementSmartContract.prototype, "redeem", null);
+/* eslint-enable @typescript-eslint/lines-between-class-members */

package/dist/settlement/messages/Deposit.d.ts

@@ -7,16 +7,37 @@ declare const Deposit_base: (new (value: {
     amount: UInt64;
 }) & {
     _isStruct: true;
-} & import("o1js/dist/node/snarky").ProvablePure<{
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
     address: PublicKey;
     amount: UInt64;
-}> & {
+}, {
+    address: {
+        x: bigint;
+        isOdd: boolean;
+    };
+    amount: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        address: PublicKey;
+        amount: UInt64;
+    };
+} & {
+    fromValue: (value: {
+        address: PublicKey | {
+            x: bigint | import("o1js/dist/node/lib/provable/field").Field;
+            isOdd: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+        };
+        amount: bigint | UInt64;
+    }) => {
+        address: PublicKey;
+        amount: UInt64;
+    };
     toInput: (x: {
         address: PublicKey;
         amount: UInt64;
     }) => {
-        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: {
         address: PublicKey;
@@ -32,6 +53,10 @@ declare const Deposit_base: (new (value: {
         address: PublicKey;
         amount: UInt64;
     };
+    empty: () => {
+        address: PublicKey;
+        amount: UInt64;
+    };
 };
 export declare class Deposit extends Deposit_base {
 }

package/dist/settlement/messages/Deposit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Deposit.d.ts","sourceRoot":"","sources":["../../../src/settlement/messages/Deposit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,MAAM,EAAE,MAAM,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjD,qBAAa,OAAQ,SAAQ,YAG3B;CAAG"}
+{"version":3,"file":"Deposit.d.ts","sourceRoot":"","sources":["../../../src/settlement/messages/Deposit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,MAAM,EAAE,MAAM,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjD,qBAAa,OAAQ,SAAQ,YAG3B;CAAG"}

package/dist/settlement/messages/OutgoingMessageArgument.d.ts

@@ -9,16 +9,49 @@ declare const OutgoingMessageArgument_base: (new (value: {
     value: Withdrawal;
 }) & {
     _isStruct: true;
-} & import("o1js/dist/node/snarky").ProvablePure<{
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
     witness: RollupMerkleTreeWitness;
     value: Withdrawal;
-}> & {
+}, {
+    witness: {
+        path: bigint[];
+        isLeft: boolean[];
+    };
+    value: {
+        address: {
+            x: bigint;
+            isOdd: boolean;
+        };
+        amount: bigint;
+    };
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        witness: RollupMerkleTreeWitness;
+        value: Withdrawal;
+    };
+} & {
+    fromValue: (value: {
+        witness: RollupMerkleTreeWitness | {
+            path: import("o1js/dist/node/lib/provable/field").Field[] | bigint[];
+            isLeft: import("o1js/dist/node/lib/provable/bool").Bool[] | boolean[];
+        };
+        value: Withdrawal | {
+            address: import("o1js/dist/node/lib/provable/crypto/signature").PublicKey | {
+                x: bigint | import("o1js/dist/node/lib/provable/field").Field;
+                isOdd: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+            };
+            amount: bigint | import("o1js/dist/node/lib/provable/int").UInt64;
+        };
+    }) => {
+        witness: RollupMerkleTreeWitness;
+        value: Withdrawal;
+    };
     toInput: (x: {
         witness: RollupMerkleTreeWitness;
         value: Withdrawal;
     }) => {
-        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: {
         witness: RollupMerkleTreeWitness;
@@ -46,32 +79,75 @@ declare const OutgoingMessageArgument_base: (new (value: {
         witness: RollupMerkleTreeWitness;
         value: Withdrawal;
     };
+    empty: () => {
+        witness: RollupMerkleTreeWitness;
+        value: Withdrawal;
+    };
 };
 export declare class OutgoingMessageArgument extends OutgoingMessageArgument_base {
     static dummy(): OutgoingMessageArgument;
 }
 declare const OutgoingMessageArgumentBatch_base: (new (value: {
     arguments: OutgoingMessageArgument[];
-    isDummys: import("o1js/dist/node/lib/bool").Bool[];
+    isDummys: import("o1js/dist/node/lib/provable/bool").Bool[];
 }) => {
     arguments: OutgoingMessageArgument[];
-    isDummys: import("o1js/dist/node/lib/bool").Bool[];
+    isDummys: import("o1js/dist/node/lib/provable/bool").Bool[];
 }) & {
     _isStruct: true;
-} & import("o1js/dist/node/snarky").ProvablePure<{
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
     arguments: OutgoingMessageArgument[];
-    isDummys: import("o1js/dist/node/lib/bool").Bool[];
-}> & {
+    isDummys: import("o1js/dist/node/lib/provable/bool").Bool[];
+}, {
+    arguments: {
+        witness: {
+            path: bigint[];
+            isLeft: boolean[];
+        };
+        value: {
+            address: {
+                x: bigint;
+                isOdd: boolean;
+            };
+            amount: bigint;
+        };
+    }[];
+    isDummys: boolean[];
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        arguments: OutgoingMessageArgument[];
+        isDummys: import("o1js/dist/node/lib/provable/bool").Bool[];
+    };
+} & {
+    fromValue: (value: {
+        arguments: OutgoingMessageArgument[] | {
+            witness: {
+                path: bigint[];
+                isLeft: boolean[];
+            };
+            value: {
+                address: {
+                    x: bigint;
+                    isOdd: boolean;
+                };
+                amount: bigint;
+            };
+        }[];
+        isDummys: import("o1js/dist/node/lib/provable/bool").Bool[] | boolean[];
+    }) => {
+        arguments: OutgoingMessageArgument[];
+        isDummys: import("o1js/dist/node/lib/provable/bool").Bool[];
+    };
     toInput: (x: {
         arguments: OutgoingMessageArgument[];
-        isDummys: import("o1js/dist/node/lib/bool").Bool[];
+        isDummys: import("o1js/dist/node/lib/provable/bool").Bool[];
     }) => {
-        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: {
         arguments: OutgoingMessageArgument[];
-        isDummys: import("o1js/dist/node/lib/bool").Bool[];
+        isDummys: import("o1js/dist/node/lib/provable/bool").Bool[];
     }) => {
         arguments: {
             witness: {
@@ -99,7 +175,11 @@ declare const OutgoingMessageArgumentBatch_base: (new (value: {
         isDummys: boolean[];
     }) => {
         arguments: OutgoingMessageArgument[];
-        isDummys: import("o1js/dist/node/lib/bool").Bool[];
+        isDummys: import("o1js/dist/node/lib/provable/bool").Bool[];
+    };
+    empty: () => {
+        arguments: OutgoingMessageArgument[];
+        isDummys: import("o1js/dist/node/lib/provable/bool").Bool[];
     };
 };
 export declare class OutgoingMessageArgumentBatch extends OutgoingMessageArgumentBatch_base {

package/dist/settlement/messages/OutgoingMessageArgument.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OutgoingMessageArgument.d.ts","sourceRoot":"","sources":["../../../src/settlement/messages/OutgoingMessageArgument.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,eAAO,MAAM,2BAA2B,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,uBAAwB,SAAQ,4BAG3C;WACc,KAAK,IAAI,uBAAuB;CAM/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,4BAA6B,SAAQ,iCAOhD;WACc,YAAY,CAAC,iBAAiB,EAAE,uBAAuB,EAAE;CAcxE"}
+{"version":3,"file":"OutgoingMessageArgument.d.ts","sourceRoot":"","sources":["../../../src/settlement/messages/OutgoingMessageArgument.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAE5D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,eAAO,MAAM,2BAA2B,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,uBAAwB,SAAQ,4BAG3C;WACc,KAAK,IAAI,uBAAuB;CAM/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,4BAA6B,SAAQ,iCAOhD;WACc,YAAY,CAAC,iBAAiB,EAAE,uBAAuB,EAAE;CAcxE"}

package/dist/settlement/messages/Withdrawal.d.ts

@@ -7,16 +7,37 @@ declare const Withdrawal_base: (new (value: {
     amount: UInt64;
 }) & {
     _isStruct: true;
-} & import("o1js/dist/node/snarky").ProvablePure<{
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
     address: PublicKey;
     amount: UInt64;
-}> & {
+}, {
+    address: {
+        x: bigint;
+        isOdd: boolean;
+    };
+    amount: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        address: PublicKey;
+        amount: UInt64;
+    };
+} & {
+    fromValue: (value: {
+        address: PublicKey | {
+            x: bigint | import("o1js/dist/node/lib/provable/field").Field;
+            isOdd: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+        };
+        amount: bigint | UInt64;
+    }) => {
+        address: PublicKey;
+        amount: UInt64;
+    };
     toInput: (x: {
         address: PublicKey;
         amount: UInt64;
     }) => {
-        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: {
         address: PublicKey;
@@ -32,6 +53,10 @@ declare const Withdrawal_base: (new (value: {
         address: PublicKey;
         amount: UInt64;
     };
+    empty: () => {
+        address: PublicKey;
+        amount: UInt64;
+    };
 };
 export declare class Withdrawal extends Withdrawal_base {
     static dummy(): Withdrawal;

package/dist/settlement/messages/Withdrawal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Withdrawal.d.ts","sourceRoot":"","sources":["../../../src/settlement/messages/Withdrawal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,MAAM,EAAE,MAAM,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGjD,qBAAa,UAAW,SAAQ,eAG9B;WACc,KAAK;CAMpB"}
+{"version":3,"file":"Withdrawal.d.ts","sourceRoot":"","sources":["../../../src/settlement/messages/Withdrawal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,MAAM,EAAE,MAAM,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGjD,qBAAa,UAAW,SAAQ,eAG9B;WACc,KAAK;CAMpB"}

package/dist/settlement/modularity/ProvableSettlementHook.d.ts

@@ -1,7 +1,7 @@
 import { Field, PublicKey, UInt32 } from "o1js";
-import type { BlockProof } from "../../prover/block/BlockProver";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { NetworkState } from "../../model/network/NetworkState";
+import type { BlockProof } from "../../prover/block/BlockProver";
 import type { SettlementSmartContract } from "../contracts/SettlementSmartContract";
 export type SettlementStateRecord = {
     sequencerKey: PublicKey;
@@ -19,6 +19,6 @@ export type SettlementHookInputs = {
     currentL1Block: UInt32;
 };
 export declare abstract class ProvableSettlementHook<Config> extends ProtocolModule<Config> {
-    abstract beforeSettlement(smartContract: SettlementSmartContract, inputs: SettlementHookInputs): void;
+    abstract beforeSettlement(smartContract: SettlementSmartContract, inputs: SettlementHookInputs): Promise<void>;
 }
 //# sourceMappingURL=ProvableSettlementHook.d.ts.map

package/dist/settlement/modularity/ProvableSettlementHook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProvableSettlementHook.d.ts","sourceRoot":"","sources":["../../../src/settlement/modularity/ProvableSettlementHook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEhD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAEhE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAEpF,MAAM,MAAM,qBAAqB,GAAG;IAClC,YAAY,EAAE,SAAS,CAAC;IACxB,qBAAqB,EAAE,MAAM,CAAC;IAE9B,SAAS,EAAE,KAAK,CAAC;IACjB,gBAAgB,EAAE,KAAK,CAAC;IACxB,aAAa,EAAE,KAAK,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,UAAU,CAAC;IACvB,gBAAgB,EAAE,YAAY,CAAC;IAC/B,cAAc,EAAE,YAAY,CAAC;IAC7B,uBAAuB,EAAE,KAAK,CAAC;IAC/B,aAAa,EAAE,qBAAqB,CAAC;IACrC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,8BAAsB,sBAAsB,CAC1C,MAAM,CACN,SAAQ,cAAc,CAAC,MAAM,CAAC;aACd,gBAAgB,CAC9B,aAAa,EAAE,uBAAuB,EACtC,MAAM,EAAE,oBAAoB,GAC3B,IAAI;CACR"}
+{"version":3,"file":"ProvableSettlementHook.d.ts","sourceRoot":"","sources":["../../../src/settlement/modularity/ProvableSettlementHook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEhD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAEpF,MAAM,MAAM,qBAAqB,GAAG;IAClC,YAAY,EAAE,SAAS,CAAC;IACxB,qBAAqB,EAAE,MAAM,CAAC;IAE9B,SAAS,EAAE,KAAK,CAAC;IACjB,gBAAgB,EAAE,KAAK,CAAC;IACxB,aAAa,EAAE,KAAK,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,UAAU,CAAC;IACvB,gBAAgB,EAAE,YAAY,CAAC;IAC/B,cAAc,EAAE,YAAY,CAAC;IAC7B,uBAAuB,EAAE,KAAK,CAAC;IAC/B,aAAa,EAAE,qBAAqB,CAAC;IACrC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,8BAAsB,sBAAsB,CAC1C,MAAM,CACN,SAAQ,cAAc,CAAC,MAAM,CAAC;aACd,gBAAgB,CAC9B,aAAa,EAAE,uBAAuB,EACtC,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,IAAI,CAAC;CACjB"}

package/dist/settlement/modules/NetworkStateSettlementModule.d.ts

@@ -5,7 +5,7 @@ type NetworkStateSettlementModuleConfig = {
     blocksPerL1Block: UInt64;
 };
 export declare class NetworkStateSettlementModule extends ProvableSettlementHook<NetworkStateSettlementModuleConfig> {
-    beforeSettlement(smartContract: SettlementSmartContract, { blockProof, fromNetworkState, toNetworkState, contractState, currentL1Block, }: SettlementHookInputs): void;
+    beforeSettlement(smartContract: SettlementSmartContract, { blockProof, fromNetworkState, toNetworkState, contractState, currentL1Block, }: SettlementHookInputs): Promise<void>;
 }
 export {};
 //# sourceMappingURL=NetworkStateSettlementModule.d.ts.map

package/dist/settlement/modules/NetworkStateSettlementModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkStateSettlementModule.d.ts","sourceRoot":"","sources":["../../../src/settlement/modules/NetworkStateSettlementModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAE9B,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACrB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAE/E,KAAK,kCAAkC,GAAG;IACxC,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,qBAAa,4BAA6B,SAAQ,sBAAsB,CAAC,kCAAkC,CAAC;IACnG,gBAAgB,CACrB,aAAa,EAAE,uBAAuB,EACtC,EACE,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,cAAc,GACf,EAAE,oBAAoB,GACtB,IAAI;CAgBR"}
+{"version":3,"file":"NetworkStateSettlementModule.d.ts","sourceRoot":"","sources":["../../../src/settlement/modules/NetworkStateSettlementModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAE9B,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACrB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAE/E,KAAK,kCAAkC,GAAG;IACxC,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAGF,qBAAa,4BAA6B,SAAQ,sBAAsB,CAAC,kCAAkC,CAAC;IAC7F,gBAAgB,CAC3B,aAAa,EAAE,uBAAuB,EACtC,EACE,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,cAAc,GACf,EAAE,oBAAoB;CAiB1B"}

package/dist/settlement/modules/NetworkStateSettlementModule.js

@@ -1,6 +1,7 @@
 import { ProvableSettlementHook, } from "../modularity/ProvableSettlementHook";
+/* eslint-disable @typescript-eslint/no-unused-vars */
 export class NetworkStateSettlementModule extends ProvableSettlementHook {
-    beforeSettlement(smartContract, { blockProof, fromNetworkState, toNetworkState, contractState, currentL1Block, }) {
+    async beforeSettlement(smartContract, { blockProof, fromNetworkState, toNetworkState, contractState, currentL1Block, }) {
         const { lastSettlementL1Block } = contractState;
         const blocksPerL1Block = this.config.blocksPerL1Block.toConstant();
         const numL1Blocks = currentL1Block.sub(lastSettlementL1Block);
@@ -10,3 +11,4 @@ export class NetworkStateSettlementModule extends ProvableSettlementHook {
         // TODO Check within bounds efficiently
     }
 }
+/* eslint-enable @typescript-eslint/no-unused-vars */

package/dist/state/State.d.ts

@@ -14,7 +14,7 @@ export declare class WithStateServiceProvider {
         stateServiceProvider: StateServiceProvider;
     };
 }
-declare const State_base: import("ts-mixer/dist/types/types").Class<any[], WithPath & WithStateServiceProvider, typeof WithPath & typeof WithStateServiceProvider, false>;
+declare const State_base: import("ts-mixer/dist/types/types").Class<any[], WithPath & WithStateServiceProvider, typeof WithPath & typeof WithStateServiceProvider>;
 /**
  * Utilities for runtime module state, such as get/set
  */
@@ -28,6 +28,7 @@ export declare class State<Value> extends State_base {
      */
     static from<Value>(valueType: FlexibleProvablePure<Value>): State<Value>;
     constructor(valueType: FlexibleProvablePure<Value>);
+    private stateType;
     /**
      * Returns the state that is currently the current state tree
      * value: The value-fields, or if not state was found, dummy values
@@ -49,7 +50,7 @@ export declare class State<Value> extends State_base {
      *
      * @returns Option representation of the current state.
      */
-    get(): Option<Value>;
+    get(): Promise<Option<Value>>;
     /**
      * Sets a new state value by creating a state transition from
      * the current value to the newly set value.
@@ -61,7 +62,7 @@ export declare class State<Value> extends State_base {
      *
      * @param value - Value to be set as the current state
      */
-    set(value: Value): void;
+    set(value: Value): Promise<void>;
 }
 export {};
 //# sourceMappingURL=State.d.ts.map

package/dist/state/State.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"State.d.ts","sourceRoot":"","sources":["../../src/state/State.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,EAAY,KAAK,oBAAoB,EAAE,MAAM,MAAM,CAAC;AAIxE,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAGzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAG9D,qBAAa,QAAQ;IACZ,IAAI,CAAC,EAAE,KAAK,CAAC;IAEb,aAAa,IAAI,OAAO,CAAC,IAAI,IAAI;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE;CAOvD;AAED,qBAAa,wBAAwB;IAC5B,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAE5C,qBAAqB,IAAI,OAAO,CAAC,IAAI,IAAI;QAC9C,oBAAoB,EAAE,oBAAoB,CAAC;KAC5C;CAOF;;AAED;;GAEG;AACH,qBAAa,KAAK,CAAC,KAAK,CAAE,SAAQ,UAAyC;IAW/C,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAVhE;;;;;OAKG;WACW,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;gBAItC,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAIhE;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;IAwChB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;;;;OAKG;IACI,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC;IAc3B;;;;;;;;;;OAUG;IACI,GAAG,CAAC,KAAK,EAAE,KAAK;CAiBxB"}
+{"version":3,"file":"State.d.ts","sourceRoot":"","sources":["../../src/state/State.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,EAAY,KAAK,oBAAoB,EAAU,MAAM,MAAM,CAAC;AAIhF,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAGzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAG9D,qBAAa,QAAQ;IACZ,IAAI,CAAC,EAAE,KAAK,CAAC;IAEb,aAAa,IAAI,OAAO,CAAC,IAAI,IAAI;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE;CAOvD;AAED,qBAAa,wBAAwB;IAC5B,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAE5C,qBAAqB,IAAI,OAAO,CAAC,IAAI,IAAI;QAC9C,oBAAoB,EAAE,oBAAoB,CAAC;KAC5C;CAOF;;AAED;;GAEG;AACH,qBAAa,KAAK,CAAC,KAAK,CAAE,SAAQ,UAAyC;IAW/C,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAVhE;;;;;OAKG;WACW,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;gBAItC,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAIhE,OAAO,CAAC,SAAS,CAGX;IAEN;;;;;;OAMG;YACW,QAAQ;IAyCtB;;;;;OAKG;YACW,gBAAgB;IAW9B;;;;;OAKG;IACU,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAc1C;;;;;;;;;;OAUG;IACU,GAAG,CAAC,KAAK,EAAE,KAAK;CAiB9B"}

package/dist/state/State.js

@@ -1,5 +1,5 @@
 import { Mixin } from "ts-mixer";
-import { Bool, Provable } from "o1js";
+import { Bool, Provable, Struct } from "o1js";
 import { container } from "tsyringe";
 import { dummyValue } from "@proto-kit/common";
 import { Option } from "../model/Option";
@@ -35,6 +35,11 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
     constructor(valueType) {
         super();
         this.valueType = valueType;
+        this.stateType = class StateType extends Struct({
+            value: this.valueType,
+            isSome: Bool,
+        }) {
+        };
     }
     /**
      * Returns the state that is currently the current state tree
@@ -43,13 +48,14 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
      * (Basically, whether the value-fields are dummy values or actual values
      * @private
      */
-    getState() {
+    async getState() {
         this.hasStateServiceOrFail();
         this.hasPathOrFail();
         const { path, stateServiceProvider, valueType } = this;
         const { stateTransitions } = container
             .resolve(RuntimeMethodExecutionContext)
             .current().result;
+        // TODO Use Stateservice for this
         // First try to find a match inside already created stateTransitions
         let previousMutatingTransitions = [];
         previousMutatingTransitions = stateTransitions.filter((transition) => transition.path.equals(path).and(transition.to.isSome).toBoolean());
@@ -62,7 +68,7 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
             return { value, isSome: Bool(true) };
         }
         // If the value is still undefined, look it up in the stateService
-        const fields = stateServiceProvider.stateService.get(path);
+        const fields = await stateServiceProvider.stateService.get(path);
         if (fields) {
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             value = valueType.fromFields(fields);
@@ -78,11 +84,10 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
      *
      * @returns Optional value of the current state
      */
-    witnessFromState() {
+    async witnessFromState() {
         // get the value from storage, or return a dummy value instead
-        const value = Provable.witness(this.valueType, () => this.getState().value);
-        // check if the value exists in the storage or not
-        const isSome = Provable.witness(Bool, () => this.getState().isSome);
+        // also check if the value exists in the storage or not
+        const { value, isSome } = await Provable.witnessAsync(this.stateType, async () => await this.getState());
         return Option.from(isSome, value, this.valueType);
     }
     /**
@@ -91,8 +96,8 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
      *
      * @returns Option representation of the current state.
      */
-    get() {
-        const option = this.witnessFromState();
+    async get() {
+        const option = await this.witnessFromState();
         this.hasPathOrFail();
         const stateTransition = StateTransition.from(this.path, option);
         container
@@ -111,9 +116,9 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
      *
      * @param value - Value to be set as the current state
      */
-    set(value) {
+    async set(value) {
         // link the transition to the current state
-        const fromOption = this.witnessFromState();
+        const fromOption = await this.witnessFromState();
         const toOption = Option.fromValue(value, this.valueType);
         this.hasPathOrFail();
         const stateTransition = StateTransition.fromTo(this.path, fromOption, toOption);