@proto-kit/protocol 0.1.1-develop.1086

package/dist/settlement/contracts/SettlementSmartContract.js

@@ -0,0 +1,241 @@
+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, 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;
+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 TokenContract {
+    constructor() {
+        super(...arguments);
+        this.sequencerKey = State();
+        this.lastSettlementL1BlockHeight = State();
+        this.stateRoot = State();
+        this.networkStateHash = State();
+        this.blockHashRoot = State();
+        this.dispatchContractAddressX = State();
+        this.outgoingMessageCursor = State();
+    }
+    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;
+        const contractInstance = new DispatchContract(dispatchContract);
+        await contractInstance.initialize(this.address);
+    }
+    async settle(blockProof, signature, dispatchContractAddress, publicKey, inputNetworkState, outputNetworkState, newPromisedMessagesHash) {
+        // Verify the blockproof
+        blockProof.verify();
+        // Get and assert on-chain values
+        const stateRoot = this.stateRoot.getAndRequireEquals();
+        const networkStateHash = this.networkStateHash.getAndRequireEquals();
+        const blockHashRoot = this.blockHashRoot.getAndRequireEquals();
+        const sequencerKey = this.sequencerKey.getAndRequireEquals();
+        const lastSettlementL1BlockHeight = this.lastSettlementL1BlockHeight.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
+        // 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 minBlockHeightIncluded = this.network.blockchainLength.get();
+        this.network.blockchainLength.requireBetween(minBlockHeightIncluded, 
+        // 5 because that is the length the newPromisedMessagesHash will be valid
+        minBlockHeightIncluded.add(4));
+        // Check signature/escape catch
+        publicKey.x.assertEquals(sequencerKey, "Sequencer public key witness not matching");
+        const signatureValid = signature.verify(publicKey, [
+            BATCH_SIGNATURE_PREFIX,
+            lastSettlementL1BlockHeight.value,
+        ]);
+        const escapeHatchActivated = lastSettlementL1BlockHeight
+            .add(UInt32.from(escapeHatchSlotsInterval))
+            .lessThan(minBlockHeightIncluded);
+        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,
+            lastSettlementL1BlockHeight,
+            sequencerKey: publicKey,
+        };
+        const inputs = {
+            blockProof,
+            contractState: stateRecord,
+            newPromisedMessagesHash,
+            fromNetworkState: inputNetworkState,
+            toNetworkState: outputNetworkState,
+            currentL1BlockHeight: minBlockHeightIncluded,
+        };
+        await mapSequential(hooks, async (hook) => {
+            await 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");
+        // 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
+        await dispatchContract.updateMessagesHash(promisedMessagesHash, newPromisedMessagesHash);
+        this.lastSettlementL1BlockHeight.set(minBlockHeightIncluded);
+    }
+    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);
+        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.internal.mint({ address, amount });
+            const isNewAccount = tokenAu.account.isNew.getAndRequireEquals();
+            tokenAu.body.balanceChange.magnitude =
+                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.Unsafe.fromField(accountCreationFeePaid));
+        this.outgoingMessageCursor.set(counter);
+    }
+    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.internal.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, "lastSettlementL1BlockHeight", 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", [AccountUpdateForest]),
+    __metadata("design:returntype", Promise)
+], SettlementSmartContract.prototype, "approveBase", null);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PublicKey, PublicKey]),
+    __metadata("design:returntype", Promise)
+], SettlementSmartContract.prototype, "initialize", null);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [LazyBlockProof,
+        Signature,
+        PublicKey,
+        PublicKey,
+        NetworkState,
+        NetworkState,
+        Field]),
+    __metadata("design:returntype", Promise)
+], SettlementSmartContract.prototype, "settle", null);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [OutgoingMessageArgumentBatch]),
+    __metadata("design:returntype", Promise)
+], SettlementSmartContract.prototype, "rollupOutgoingMessages", null);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [AccountUpdate]),
+    __metadata("design:returntype", Promise)
+], SettlementSmartContract.prototype, "redeem", null);
+/* eslint-enable @typescript-eslint/lines-between-class-members */

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

@@ -0,0 +1,64 @@
+import { PublicKey, UInt64 } from "o1js";
+declare const Deposit_base: (new (value: {
+    address: PublicKey;
+    amount: UInt64;
+}) => {
+    address: PublicKey;
+    amount: UInt64;
+}) & {
+    _isStruct: true;
+} & 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/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        address: PublicKey;
+        amount: UInt64;
+    }) => {
+        address: string;
+        amount: string;
+    };
+    fromJSON: (x: {
+        address: string;
+        amount: string;
+    }) => {
+        address: PublicKey;
+        amount: UInt64;
+    };
+    empty: () => {
+        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,189 @@
+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;
+} & 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/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/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;
+    };
+    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/provable/bool").Bool[];
+}) => {
+    arguments: OutgoingMessageArgument[];
+    isDummys: import("o1js/dist/node/lib/provable/bool").Bool[];
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    arguments: OutgoingMessageArgument[];
+    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/provable/bool").Bool[];
+    }) => {
+        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/provable/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/provable/bool").Bool[];
+    };
+    empty: () => {
+        arguments: OutgoingMessageArgument[];
+        isDummys: import("o1js/dist/node/lib/provable/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;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/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,65 @@
+import { PublicKey, UInt64 } from "o1js";
+declare const Withdrawal_base: (new (value: {
+    address: PublicKey;
+    amount: UInt64;
+}) => {
+    address: PublicKey;
+    amount: UInt64;
+}) & {
+    _isStruct: true;
+} & 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/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        address: PublicKey;
+        amount: UInt64;
+    }) => {
+        address: string;
+        amount: string;
+    };
+    fromJSON: (x: {
+        address: string;
+        amount: string;
+    }) => {
+        address: PublicKey;
+        amount: UInt64;
+    };
+    empty: () => {
+        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 { 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;
+    lastSettlementL1BlockHeight: UInt32;
+    stateRoot: Field;
+    networkStateHash: Field;
+    blockHashRoot: Field;
+};
+export type SettlementHookInputs = {
+    blockProof: BlockProof;
+    fromNetworkState: NetworkState;
+    toNetworkState: NetworkState;
+    newPromisedMessagesHash: Field;
+    contractState: SettlementStateRecord;
+    currentL1BlockHeight: UInt32;
+};
+export declare abstract class ProvableSettlementHook<Config> extends ProtocolModule<Config> {
+    abstract beforeSettlement(smartContract: SettlementSmartContract, inputs: SettlementHookInputs): Promise<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,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,2BAA2B,EAAE,MAAM,CAAC;IAEpC,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,oBAAoB,EAAE,MAAM,CAAC;CAC9B,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/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, currentL1BlockHeight, }: SettlementHookInputs): Promise<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;AAGF,qBAAa,4BAA6B,SAAQ,sBAAsB,CAAC,kCAAkC,CAAC;IAC7F,gBAAgB,CAC3B,aAAa,EAAE,uBAAuB,EACtC,EACE,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,oBAAoB,GACrB,EAAE,oBAAoB;CAiB1B"}