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

package/dist/settlement/SettlementContract.d.ts

@@ -0,0 +1,230 @@
+import { AccountUpdate, Field, Proof, PublicKey, Signature, SmartContract, State, UInt32, UInt64 } from "o1js";
+import { RollupMerkleTreeWitness } from "@proto-kit/common";
+import { ProtocolModule } from "../protocol/ProtocolModule";
+import { BlockProvable, BlockProverPublicInput, BlockProverPublicOutput } from "../prover/block/BlockProvable";
+import { NetworkState } from "../model/network/NetworkState";
+import { ProvableSettlementHook } from "./ProvableSettlementHook";
+declare class LazyBlockProof extends Proof<BlockProverPublicInput, BlockProverPublicOutput> {
+    static publicInputType: typeof BlockProverPublicInput;
+    static publicOutputType: typeof BlockProverPublicOutput;
+    static tag: () => {
+        name: string;
+    };
+}
+export type SettlementMethodIdMapping = Record<`${string}.${string}`, bigint>;
+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 {
+}
+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 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 declare const BATCH_SIGNATURE_PREFIX: import("o1js/dist/node/lib/field").Field;
+export declare const ACTIONS_EMPTY_HASH: import("o1js/dist/node/lib/field").Field;
+export declare class SettlementContract extends SmartContract {
+    private readonly methodIdMappings;
+    private readonly hooks;
+    private readonly withdrawalStatePath;
+    private readonly incomingMessagesPaths;
+    private readonly escapeHatchSlotsInterval;
+    sequencerKey: State<import("o1js/dist/node/lib/field").Field>;
+    lastSettlementL1Block: State<UInt32>;
+    stateRoot: State<import("o1js/dist/node/lib/field").Field>;
+    networkStateHash: State<import("o1js/dist/node/lib/field").Field>;
+    blockHashRoot: State<import("o1js/dist/node/lib/field").Field>;
+    promisedMessagesHash: State<import("o1js/dist/node/lib/field").Field>;
+    honoredMessagesHash: State<import("o1js/dist/node/lib/field").Field>;
+    outgoingMessageCursor: State<import("o1js/dist/node/lib/field").Field>;
+    constructor(address: PublicKey, methodIdMappings: Record<string, bigint>, hooks: ProvableSettlementHook<unknown>[], withdrawalStatePath: [string, string], incomingMessagesPaths: Record<string, `${string}.${string}`>, escapeHatchSlotsInterval?: number);
+    initialize(sequencer: PublicKey): void;
+    settle(blockProof: LazyBlockProof, signature: Signature, publicKey: PublicKey, inputNetworkState: NetworkState, outputNetworkState: NetworkState, newPromisedMessagesHash: Field): void;
+    private dispatchMessage;
+    deposit(amount: UInt64): void;
+    rollupOutgoingMessages(batch: OutgoingMessageArgumentBatch): void;
+    redeem(additionUpdate: AccountUpdate): void;
+}
+export interface SettlementContractModuleConfig {
+    withdrawalStatePath: `${string}.${string}`;
+    withdrawalMethodPath: `${string}.${string}`;
+    incomingMessagesMethods: Record<string, `${string}.${string}`>;
+}
+export declare class SettlementContractModule extends ProtocolModule<SettlementContractModuleConfig> {
+    private readonly hooks;
+    private readonly blockProver;
+    constructor(hooks: ProvableSettlementHook<unknown>[], blockProver: BlockProvable);
+    getContractClass(): typeof SettlementContract;
+    createContract(address: PublicKey, methodIdMappings: SettlementMethodIdMapping): SettlementContract;
+}
+export {};
+//# sourceMappingURL=SettlementContract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SettlementContract.d.ts","sourceRoot":"","sources":["../../src/settlement/SettlementContract.ts"],"names":[],"mappings":"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"}

package/dist/settlement/SettlementContract.js

@@ -0,0 +1,346 @@
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { AccountUpdate, Bool, Field, method, Mina, Poseidon, Proof, Provable, PublicKey, Reducer, Signature, SmartContract, State, state, Struct, TokenId, UInt32, UInt64, } from "o1js";
+import { EMPTY_PUBLICKEY, prefixToField, RollupMerkleTree, RollupMerkleTreeWitness, } from "@proto-kit/common";
+import { inject, injectable, injectAll } from "tsyringe";
+import { ProtocolModule } from "../protocol/ProtocolModule";
+import { BlockProverPublicInput, BlockProverPublicOutput, } from "../prover/block/BlockProvable";
+import { NetworkState } from "../model/network/NetworkState";
+import { BlockHashMerkleTree } from "../prover/block/accummulators/BlockHashMerkleTree";
+import { RuntimeTransaction } from "../model/transaction/RuntimeTransaction";
+import { Path } from "../model/Path";
+import { MinaActions, MinaEvents } from "../utils/MinaPrefixedProvableHashList";
+class LazyBlockProof extends Proof {
+}
+LazyBlockProof.publicInputType = BlockProverPublicInput;
+LazyBlockProof.publicOutputType = BlockProverPublicOutput;
+LazyBlockProof.tag = () => {
+    throw new Error("Tag not initialized yet");
+};
+export class Deposit extends Struct({
+    address: PublicKey,
+    amount: UInt64,
+}) {
+}
+export class Withdrawal extends Struct({
+    address: PublicKey,
+    amount: UInt64,
+}) {
+    static dummy() {
+        return new Withdrawal({
+            address: EMPTY_PUBLICKEY,
+            amount: UInt64.from(0),
+        });
+    }
+}
+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,
+        });
+    }
+}
+// Some random prefix for the sequencer signature
+export const BATCH_SIGNATURE_PREFIX = prefixToField("pk-batchSignature");
+export const ACTIONS_EMPTY_HASH = Reducer.initialActionState;
+export class SettlementContract extends SmartContract {
+    constructor(address, methodIdMappings, hooks, withdrawalStatePath, incomingMessagesPaths, 
+    // 24 hours
+    escapeHatchSlotsInterval = (60 / 3) * 24) {
+        super(address);
+        this.methodIdMappings = methodIdMappings;
+        this.hooks = hooks;
+        this.withdrawalStatePath = withdrawalStatePath;
+        this.incomingMessagesPaths = incomingMessagesPaths;
+        this.escapeHatchSlotsInterval = escapeHatchSlotsInterval;
+        this.sequencerKey = State();
+        this.lastSettlementL1Block = State();
+        this.stateRoot = State();
+        this.networkStateHash = State();
+        this.blockHashRoot = State();
+        this.promisedMessagesHash = State();
+        this.honoredMessagesHash = State();
+        this.outgoingMessageCursor = State();
+    }
+    initialize(sequencer) {
+        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.promisedMessagesHash.getAndAssertEquals().assertEquals(Field(0));
+        this.honoredMessagesHash.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.promisedMessagesHash.set(ACTIONS_EMPTY_HASH);
+        this.honoredMessagesHash.set(ACTIONS_EMPTY_HASH);
+    }
+    settle(blockProof, signature, 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 promisedMessagesHash = this.promisedMessagesHash.getAndAssertEquals();
+        const honoredMessagesHash = this.honoredMessagesHash.getAndAssertEquals();
+        const lastSettlementL1Block = this.lastSettlementL1Block.getAndAssertEquals();
+        // Get block height and use the lower bound for all ops
+        const minBlockIncluded = this.network.globalSlotSinceGenesis.get();
+        this.network.globalSlotSinceGenesis.assertBetween(minBlockIncluded, minBlockIncluded.add(20));
+        // 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(this.escapeHatchSlotsInterval))
+            .lessThan(minBlockIncluded);
+        signatureValid
+            .or(escapeHatchActivated)
+            .assertTrue("Sequencer signature not valid and escape hatch not activated");
+        // Assert correctness of networkState witness
+        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,
+            honoredMessagesHash,
+            lastSettlementL1Block,
+            promisedMessagesHash,
+            sequencerKey,
+        };
+        const inputs = {
+            blockProof,
+            contractState: stateRecord,
+            newPromisedMessagesHash,
+            fromNetworkState: inputNetworkState,
+            toNetworkState: outputNetworkState,
+            currentL1Block: minBlockIncluded,
+        };
+        this.hooks.forEach((hook) => {
+            hook.beforeSettlement(this, inputs);
+        });
+        // Apply blockProof
+        stateRoot.assertEquals(blockProof.publicInput.stateRoot, "Input state root not matching");
+        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");
+        this.honoredMessagesHash.set(promisedMessagesHash);
+        // Assert and apply new promisedMessagesHash
+        this.self.account.actionState.assertEquals(newPromisedMessagesHash);
+        this.promisedMessagesHash.set(newPromisedMessagesHash);
+        this.lastSettlementL1Block.set(minBlockIncluded);
+    }
+    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.sender;
+        // Credit the amount to the bridge contract
+        this.self.balance.addInPlace(amount);
+        const action = new Deposit({
+            address: sender,
+            amount,
+        });
+        const methodId = Field(this.methodIdMappings[this.incomingMessagesPaths["deposit"]]);
+        this.dispatchMessage(methodId.toConstant(), action, Deposit);
+    }
+    rollupOutgoingMessages(batch) {
+        let counter = this.outgoingMessageCursor.getAndAssertEquals();
+        const stateRoot = this.stateRoot.getAndAssertEquals();
+        const [withdrawalModule, withdrawalStateName] = this.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)
+], SettlementContract.prototype, "sequencerKey", void 0);
+__decorate([
+    state(UInt32),
+    __metadata("design:type", Object)
+], SettlementContract.prototype, "lastSettlementL1Block", void 0);
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], SettlementContract.prototype, "stateRoot", void 0);
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], SettlementContract.prototype, "networkStateHash", void 0);
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], SettlementContract.prototype, "blockHashRoot", void 0);
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], SettlementContract.prototype, "promisedMessagesHash", void 0);
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], SettlementContract.prototype, "honoredMessagesHash", void 0);
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], SettlementContract.prototype, "outgoingMessageCursor", void 0);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PublicKey]),
+    __metadata("design:returntype", void 0)
+], SettlementContract.prototype, "initialize", null);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [LazyBlockProof,
+        Signature,
+        PublicKey,
+        NetworkState,
+        NetworkState,
+        Field]),
+    __metadata("design:returntype", void 0)
+], SettlementContract.prototype, "settle", null);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UInt64]),
+    __metadata("design:returntype", void 0)
+], SettlementContract.prototype, "deposit", null);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [OutgoingMessageArgumentBatch]),
+    __metadata("design:returntype", void 0)
+], SettlementContract.prototype, "rollupOutgoingMessages", null);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [AccountUpdate]),
+    __metadata("design:returntype", void 0)
+], SettlementContract.prototype, "redeem", null);
+let SettlementContractModule = class SettlementContractModule extends ProtocolModule {
+    constructor(hooks, blockProver) {
+        super();
+        this.hooks = hooks;
+        this.blockProver = blockProver;
+        LazyBlockProof.tag = blockProver.zkProgrammable.zkProgram.Proof.tag;
+    }
+    getContractClass() {
+        return SettlementContract;
+    }
+    createContract(address, methodIdMappings) {
+        // We know that this returns [string, string], but TS can't infer that
+        const withdrawalPath = this.config.withdrawalStatePath.split(".");
+        return new SettlementContract(address, methodIdMappings, this.hooks, [withdrawalPath[0], withdrawalPath[1]], this.config.incomingMessagesMethods);
+    }
+};
+SettlementContractModule = __decorate([
+    injectable(),
+    __param(0, injectAll("ProvableSettlementHook")),
+    __param(1, inject("BlockProver")),
+    __metadata("design:paramtypes", [Array, Object])
+], SettlementContractModule);
+export { SettlementContractModule };

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

@@ -0,0 +1,11 @@
+import { UInt64 } from "o1js";
+import { ProvableSettlementHook, SettlementHookInputs } from "../ProvableSettlementHook";
+import { SettlementContract } from "../SettlementContract";
+type NetworkStateSettlementModuleConfig = {
+    blocksPerL1Block: UInt64;
+};
+export declare class NetworkStateSettlementModule extends ProvableSettlementHook<NetworkStateSettlementModuleConfig> {
+    beforeSettlement(smartContract: SettlementContract, { 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,2BAA2B,CAAC;AACnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D,KAAK,kCAAkC,GAAG;IACxC,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,qBAAa,4BAA6B,SAAQ,sBAAsB,CAAC,kCAAkC,CAAC;IACnG,gBAAgB,CACrB,aAAa,EAAE,kBAAkB,EACjC,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 "../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
+    }
+}