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

package/dist/settlement/contracts/SettlementSmartContract.js

@@ -0,0 +1,235 @@
+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 { 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 { 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";
+export class LazyBlockProof extends Proof {
+}
+LazyBlockProof.publicInputType = BlockProverPublicInput;
+LazyBlockProof.publicOutputType = BlockProverPublicOutput;
+LazyBlockProof.tag = () => {
+    throw new Error("Tag not initialized yet");
+};
+// Some random prefix for the sequencer signature
+export const BATCH_SIGNATURE_PREFIX = prefixToField("pk-batchSignature");
+export class SettlementSmartContract extends SmartContract {
+    constructor() {
+        super(...arguments);
+        this.sequencerKey = State();
+        this.lastSettlementL1Block = State();
+        this.stateRoot = State();
+        this.networkStateHash = State();
+        this.blockHashRoot = State();
+        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));
+        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);
+    }
+    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();
+        onChainDispatchContractAddressX.assertEquals(dispatchContractAddress.x, "DispatchContract address not provided correctly");
+        const { DispatchContract, escapeHatchSlotsInterval, hooks } = SettlementSmartContract.args;
+        // Get dispatch contract values
+        // These values are witnesses but will be checked later on the AU
+        // call to the dispatch contract via .updateMessagesHash()
+        const dispatchContract = new DispatchContract(dispatchContractAddress);
+        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, 
+        // 5 because that is the length the newPromisedMessagesHash will be valid
+        minBlockIncluded.add(4));
+        // Check signature/escape catch
+        publicKey.x.assertEquals(sequencerKey, "Sequencer public key witness not matching");
+        const signatureValid = signature.verify(publicKey, [
+            BATCH_SIGNATURE_PREFIX,
+            lastSettlementL1Block.value,
+        ]);
+        const escapeHatchActivated = lastSettlementL1Block
+            .add(UInt32.from(escapeHatchSlotsInterval))
+            .lessThan(minBlockIncluded);
+        signatureValid
+            .or(escapeHatchActivated)
+            .assertTrue("Sequencer signature not valid and escape hatch not activated");
+        // Assert correctness of networkState witness
+        Provable.log("Network State Hash ", networkStateHash);
+        Provable.log("input Hash ", inputNetworkState.hash());
+        Provable.log("equals ", inputNetworkState.hash().equals(networkStateHash));
+        inputNetworkState
+            .hash()
+            .assertEquals(networkStateHash, "InputNetworkState witness not valid");
+        outputNetworkState
+            .hash()
+            .assertEquals(blockProof.publicOutput.networkStateHash, "OutputNetworkState witness not valid");
+        blockProof.publicOutput.closed.assertEquals(Bool(true), "Supplied proof is not a closed BlockProof");
+        // Execute onSettlementHooks for additional checks
+        const stateRecord = {
+            blockHashRoot,
+            stateRoot,
+            networkStateHash,
+            lastSettlementL1Block,
+            sequencerKey: publicKey,
+        };
+        const inputs = {
+            blockProof,
+            contractState: stateRecord,
+            newPromisedMessagesHash,
+            fromNetworkState: inputNetworkState,
+            toNetworkState: outputNetworkState,
+            currentL1Block: minBlockIncluded,
+        };
+        hooks.forEach((hook) => {
+            hook.beforeSettlement(this, inputs);
+        });
+        // Apply blockProof
+        stateRoot.assertEquals(blockProof.publicInput.stateRoot, "Input state root not matching");
+        Provable.log("Network State Hash ", networkStateHash);
+        Provable.log("input Hash ", inputNetworkState.hash());
+        Provable.log("Proof Hash ", blockProof.publicInput.networkStateHash);
+        networkStateHash.assertEquals(blockProof.publicInput.networkStateHash, "Input networkStateHash not matching");
+        blockHashRoot.assertEquals(blockProof.publicInput.blockHashRoot, "Input blockHashRoot not matching");
+        this.stateRoot.set(blockProof.publicOutput.stateRoot);
+        this.networkStateHash.set(blockProof.publicOutput.networkStateHash);
+        this.blockHashRoot.set(blockProof.publicOutput.blockHashRoot);
+        // Assert and apply deposit commitments
+        promisedMessagesHash.assertEquals(blockProof.publicOutput.incomingMessagesHash, "Promised messages not honored");
+        // Call DispatchContract
+        // This call checks that the promisedMessagesHash, which is already proven
+        // 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);
+        this.lastSettlementL1Block.set(minBlockIncluded);
+    }
+    rollupOutgoingMessages(batch) {
+        let counter = this.outgoingMessageCursor.getAndAssertEquals();
+        const stateRoot = this.stateRoot.getAndAssertEquals();
+        const [withdrawalModule, withdrawalStateName] = SettlementSmartContract.args.withdrawalStatePath;
+        const mapPath = Path.fromProperty(withdrawalModule, withdrawalStateName);
+        let accountCreationFeePaid = Field(0);
+        for (let i = 0; i < OUTGOING_MESSAGE_BATCH_SIZE; i++) {
+            const args = batch.arguments[i];
+            // Check witness
+            const path = Path.fromKey(mapPath, Field, counter);
+            args.witness
+                .checkMembership(stateRoot, path, Poseidon.hash(Withdrawal.toFields(args.value)))
+                .assertTrue("Provided Withdrawal witness not valid");
+            // 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();
+            tokenAu.body.balanceChange.magnitude =
+                tokenAu.body.balanceChange.magnitude.sub(Provable.if(isNewAccount, Mina.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.outgoingMessageCursor.set(counter);
+    }
+    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({
+            address: additionUpdate.publicKey,
+            amount,
+        });
+        // Send mina
+        this.approve(additionUpdate);
+        this.balance.subInPlace(amount);
+    }
+}
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], SettlementSmartContract.prototype, "sequencerKey", void 0);
+__decorate([
+    state(UInt32),
+    __metadata("design:type", Object)
+], SettlementSmartContract.prototype, "lastSettlementL1Block", void 0);
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], SettlementSmartContract.prototype, "stateRoot", void 0);
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], SettlementSmartContract.prototype, "networkStateHash", void 0);
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], SettlementSmartContract.prototype, "blockHashRoot", void 0);
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], SettlementSmartContract.prototype, "dispatchContractAddressX", void 0);
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], SettlementSmartContract.prototype, "outgoingMessageCursor", void 0);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PublicKey, PublicKey]),
+    __metadata("design:returntype", void 0)
+], SettlementSmartContract.prototype, "initialize", null);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [LazyBlockProof,
+        Signature,
+        PublicKey,
+        PublicKey,
+        NetworkState,
+        NetworkState,
+        Field]),
+    __metadata("design:returntype", void 0)
+], SettlementSmartContract.prototype, "settle", null);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [OutgoingMessageArgumentBatch]),
+    __metadata("design:returntype", void 0)
+], SettlementSmartContract.prototype, "rollupOutgoingMessages", null);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [AccountUpdate]),
+    __metadata("design:returntype", void 0)
+], SettlementSmartContract.prototype, "redeem", null);

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

@@ -0,0 +1,39 @@
+import { PublicKey, UInt64 } from "o1js";
+declare const Deposit_base: (new (value: {
+    address: PublicKey;
+    amount: UInt64;
+}) => {
+    address: PublicKey;
+    amount: UInt64;
+}) & {
+    _isStruct: true;
+} & import("o1js/dist/node/snarky").ProvablePure<{
+    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;
+    };
+    toJSON: (x: {
+        address: PublicKey;
+        amount: UInt64;
+    }) => {
+        address: string;
+        amount: string;
+    };
+    fromJSON: (x: {
+        address: string;
+        amount: string;
+    }) => {
+        address: PublicKey;
+        amount: UInt64;
+    };
+};
+export declare class Deposit extends Deposit_base {
+}
+export {};
+//# sourceMappingURL=Deposit.d.ts.map

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

@@ -0,0 +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"}

package/dist/settlement/messages/Deposit.js

@@ -0,0 +1,6 @@
+import { PublicKey, Struct, UInt64 } from "o1js";
+export class Deposit extends Struct({
+    address: PublicKey,
+    amount: UInt64,
+}) {
+}

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

@@ -0,0 +1,109 @@
+import { RollupMerkleTreeWitness } from "@proto-kit/common";
+import { Withdrawal } from "./Withdrawal";
+export declare const OUTGOING_MESSAGE_BATCH_SIZE = 1;
+declare const OutgoingMessageArgument_base: (new (value: {
+    witness: RollupMerkleTreeWitness;
+    value: Withdrawal;
+}) => {
+    witness: RollupMerkleTreeWitness;
+    value: Withdrawal;
+}) & {
+    _isStruct: true;
+} & import("o1js/dist/node/snarky").ProvablePure<{
+    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;
+    };
+    toJSON: (x: {
+        witness: RollupMerkleTreeWitness;
+        value: Withdrawal;
+    }) => {
+        witness: {
+            path: string[];
+            isLeft: boolean[];
+        };
+        value: {
+            address: string;
+            amount: string;
+        };
+    };
+    fromJSON: (x: {
+        witness: {
+            path: string[];
+            isLeft: boolean[];
+        };
+        value: {
+            address: string;
+            amount: string;
+        };
+    }) => {
+        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[];
+}) => {
+    arguments: OutgoingMessageArgument[];
+    isDummys: import("o1js/dist/node/lib/bool").Bool[];
+}) & {
+    _isStruct: true;
+} & import("o1js/dist/node/snarky").ProvablePure<{
+    arguments: OutgoingMessageArgument[];
+    isDummys: import("o1js/dist/node/lib/bool").Bool[];
+}> & {
+    toInput: (x: {
+        arguments: OutgoingMessageArgument[];
+        isDummys: import("o1js/dist/node/lib/bool").Bool[];
+    }) => {
+        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        arguments: OutgoingMessageArgument[];
+        isDummys: import("o1js/dist/node/lib/bool").Bool[];
+    }) => {
+        arguments: {
+            witness: {
+                path: string[];
+                isLeft: boolean[];
+            };
+            value: {
+                address: string;
+                amount: string;
+            };
+        }[];
+        isDummys: boolean[];
+    };
+    fromJSON: (x: {
+        arguments: {
+            witness: {
+                path: string[];
+                isLeft: boolean[];
+            };
+            value: {
+                address: string;
+                amount: string;
+            };
+        }[];
+        isDummys: boolean[];
+    }) => {
+        arguments: OutgoingMessageArgument[];
+        isDummys: import("o1js/dist/node/lib/bool").Bool[];
+    };
+};
+export declare class OutgoingMessageArgumentBatch extends OutgoingMessageArgumentBatch_base {
+    static fromMessages(providedArguments: OutgoingMessageArgument[]): OutgoingMessageArgumentBatch;
+}
+export {};
+//# sourceMappingURL=OutgoingMessageArgument.d.ts.map

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

@@ -0,0 +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"}

package/dist/settlement/messages/OutgoingMessageArgument.js

@@ -0,0 +1,32 @@
+import { Bool, Provable, Struct } from "o1js";
+import { RollupMerkleTreeWitness } from "@proto-kit/common";
+import { Withdrawal } from "./Withdrawal";
+export const OUTGOING_MESSAGE_BATCH_SIZE = 1;
+export class OutgoingMessageArgument extends Struct({
+    witness: RollupMerkleTreeWitness,
+    value: Withdrawal,
+}) {
+    static dummy() {
+        return new OutgoingMessageArgument({
+            witness: RollupMerkleTreeWitness.dummy(),
+            value: Withdrawal.dummy(),
+        });
+    }
+}
+export class OutgoingMessageArgumentBatch extends Struct({
+    arguments: Provable.Array(OutgoingMessageArgument, OUTGOING_MESSAGE_BATCH_SIZE),
+    isDummys: Provable.Array(Bool, OUTGOING_MESSAGE_BATCH_SIZE),
+}) {
+    static fromMessages(providedArguments) {
+        const batch = providedArguments.slice();
+        const isDummys = batch.map(() => Bool(false));
+        while (batch.length < OUTGOING_MESSAGE_BATCH_SIZE) {
+            batch.push(OutgoingMessageArgument.dummy());
+            isDummys.push(Bool(true));
+        }
+        return new OutgoingMessageArgumentBatch({
+            arguments: batch,
+            isDummys,
+        });
+    }
+}

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

@@ -0,0 +1,40 @@
+import { PublicKey, UInt64 } from "o1js";
+declare const Withdrawal_base: (new (value: {
+    address: PublicKey;
+    amount: UInt64;
+}) => {
+    address: PublicKey;
+    amount: UInt64;
+}) & {
+    _isStruct: true;
+} & import("o1js/dist/node/snarky").ProvablePure<{
+    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;
+    };
+    toJSON: (x: {
+        address: PublicKey;
+        amount: UInt64;
+    }) => {
+        address: string;
+        amount: string;
+    };
+    fromJSON: (x: {
+        address: string;
+        amount: string;
+    }) => {
+        address: PublicKey;
+        amount: UInt64;
+    };
+};
+export declare class Withdrawal extends Withdrawal_base {
+    static dummy(): Withdrawal;
+}
+export {};
+//# sourceMappingURL=Withdrawal.d.ts.map

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

@@ -0,0 +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"}

package/dist/settlement/messages/Withdrawal.js

@@ -0,0 +1,13 @@
+import { PublicKey, Struct, UInt64 } from "o1js";
+import { EMPTY_PUBLICKEY } from "@proto-kit/common";
+export class Withdrawal extends Struct({
+    address: PublicKey,
+    amount: UInt64,
+}) {
+    static dummy() {
+        return new Withdrawal({
+            address: EMPTY_PUBLICKEY,
+            amount: UInt64.from(0),
+        });
+    }
+}

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

@@ -0,0 +1,24 @@
+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 { SettlementSmartContract } from "../contracts/SettlementSmartContract";
+export type SettlementStateRecord = {
+    sequencerKey: PublicKey;
+    lastSettlementL1Block: UInt32;
+    stateRoot: Field;
+    networkStateHash: Field;
+    blockHashRoot: Field;
+};
+export type SettlementHookInputs = {
+    blockProof: BlockProof;
+    fromNetworkState: NetworkState;
+    toNetworkState: NetworkState;
+    newPromisedMessagesHash: Field;
+    contractState: SettlementStateRecord;
+    currentL1Block: UInt32;
+};
+export declare abstract class ProvableSettlementHook<Config> extends ProtocolModule<Config> {
+    abstract beforeSettlement(smartContract: SettlementSmartContract, inputs: SettlementHookInputs): void;
+}
+//# sourceMappingURL=ProvableSettlementHook.d.ts.map

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

@@ -0,0 +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"}

package/dist/settlement/modularity/ProvableSettlementHook.js

@@ -0,0 +1,3 @@
+import { ProtocolModule } from "../../protocol/ProtocolModule";
+export class ProvableSettlementHook extends ProtocolModule {
+}

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

@@ -0,0 +1,11 @@
+import { UInt64 } from "o1js";
+import { ProvableSettlementHook, SettlementHookInputs } from "../modularity/ProvableSettlementHook";
+import { SettlementSmartContract } from "../contracts/SettlementSmartContract";
+type NetworkStateSettlementModuleConfig = {
+    blocksPerL1Block: UInt64;
+};
+export declare class NetworkStateSettlementModule extends ProvableSettlementHook<NetworkStateSettlementModuleConfig> {
+    beforeSettlement(smartContract: SettlementSmartContract, { blockProof, fromNetworkState, toNetworkState, contractState, currentL1Block, }: SettlementHookInputs): void;
+}
+export {};
+//# sourceMappingURL=NetworkStateSettlementModule.d.ts.map

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

@@ -0,0 +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"}

package/dist/settlement/modules/NetworkStateSettlementModule.js

@@ -0,0 +1,12 @@
+import { ProvableSettlementHook, } from "../modularity/ProvableSettlementHook";
+export class NetworkStateSettlementModule extends ProvableSettlementHook {
+    beforeSettlement(smartContract, { blockProof, fromNetworkState, toNetworkState, contractState, currentL1Block, }) {
+        const { lastSettlementL1Block } = contractState;
+        const blocksPerL1Block = this.config.blocksPerL1Block.toConstant();
+        const numL1Blocks = currentL1Block.sub(lastSettlementL1Block);
+        const expectedHeightDiff = numL1Blocks.toUInt64().mul(blocksPerL1Block);
+        const actualHeightDiff = toNetworkState.block.height.sub(fromNetworkState.block.height);
+        const acceptableDerivation = numL1Blocks.mul(1).div(10);
+        // TODO Check within bounds efficiently
+    }
+}

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;IAuChB;;;;;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,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"}

package/dist/state/State.js

@@ -51,7 +51,8 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
             .resolve(RuntimeMethodExecutionContext)
             .current().result;
         // First try to find a match inside already created stateTransitions
-        const previousMutatingTransitions = stateTransitions.filter((transition) => transition.path.equals(path).and(transition.to.isSome).toBoolean());
+        let previousMutatingTransitions = [];
+        previousMutatingTransitions = stateTransitions.filter((transition) => transition.path.equals(path).and(transition.to.isSome).toBoolean());
         const pmtLength = previousMutatingTransitions.length;
         let value = pmtLength > 0
             ? // eslint-disable-next-line @typescript-eslint/consistent-type-assertions

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

@@ -1 +1 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/state/assert/assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAM5B;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,QAavD"}
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/state/assert/assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAY,MAAM,MAAM,CAAC;AAMtC;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,QAevD"}

package/dist/state/assert/assert.js

@@ -1,3 +1,4 @@
+import { Provable } from "o1js";
 import { container } from "tsyringe";
 import { log } from "@proto-kit/common";
 import { RuntimeMethodExecutionContext } from "../context/RuntimeMethodExecutionContext";
@@ -14,11 +15,13 @@ export function assert(condition, message) {
     const executionContext = container.resolve(RuntimeMethodExecutionContext);
     const previousStatus = executionContext.current().result.status;
     const status = condition.and(previousStatus);
-    if (!condition.toBoolean()) {
-        if (!executionContext.current().isSimulated) {
-            log.debug("Assertion failed: ", message);
+    Provable.asProver(() => {
+        if (!condition.toBoolean()) {
+            if (!executionContext.current().isSimulated) {
+                log.debug("Assertion failed: ", message);
+            }
+            executionContext.setStatusMessage(message);
         }
-        executionContext.setStatusMessage(message);
-    }
+    });
     executionContext.setStatus(status);
 }