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

package/dist/utils/merkletree/RollupMerkleTree.js

@@ -0,0 +1,255 @@
+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);
+};
+/* eslint-disable id-length */
+/* eslint-disable line-comment-position */
+/* eslint-disable no-inline-comments */
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+import { Bool, Field, Poseidon, Provable, Struct } from "o1js";
+import { range } from "@proto-kit/common";
+import { notInCircuit } from "../utils";
+import { InMemoryMerkleTreeStorage } from "./InMemoryMerkleTreeStorage";
+// external API
+// eslint-disable-next-line @typescript-eslint/no-use-before-define
+export { RollupMerkleTree, RollupMerkleWitness };
+// internal API
+// eslint-disable-next-line @typescript-eslint/no-use-before-define
+export { maybeSwap };
+/**
+ * The {@link BaseMerkleWitness} class defines a circuit-compatible base class
+ * for [Merkle Witness'](https://computersciencewiki.org/index.php/Merkle_proof).
+ */
+class RollupMerkleWitness extends Struct({
+    path: Provable.Array(Field, 256 - 1),
+    isLeft: Provable.Array(Bool, 256 - 1),
+}) {
+    height() {
+        return RollupMerkleWitness.height;
+    }
+    /**
+     * Calculates a root depending on the leaf value.
+     * @param leaf Value of the leaf node that belongs to this Witness.
+     * @returns The calculated root.
+     */
+    calculateRoot(hash) {
+        const n = this.height();
+        for (let index = 1; index < n; ++index) {
+            const isLeft = this.isLeft[index - 1];
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            const [left, right] = maybeSwap(isLeft, hash, this.path[index - 1]);
+            hash = Poseidon.hash([left, right]);
+        }
+        return hash;
+    }
+    /**
+     * Calculates the index of the leaf node that belongs to this Witness.
+     * @returns Index of the leaf.
+     */
+    calculateIndex() {
+        let powerOfTwo = Field(1);
+        let index = Field(0);
+        const n = this.height();
+        // eslint-disable-next-line no-underscore-dangle
+        for (let index_ = 1; index_ < n; ++index_) {
+            index = Provable.if(this.isLeft[index_ - 1], index, index.add(powerOfTwo));
+            powerOfTwo = powerOfTwo.mul(2);
+        }
+        return index;
+    }
+    toShortenedEntries() {
+        return range(0, 5)
+            .concat(range(251, 255))
+            .map((index) => [this.path[index].toString(), this.isLeft[index].toString()].toString());
+    }
+}
+RollupMerkleWitness.height = 256;
+/**
+ * A [Merkle Tree](https://en.wikipedia.org/wiki/Merkle_tree) is a binary tree in
+ * which every leaf is the cryptography hash of a piece of data,
+ * and every node is the hash of the concatenation of its two child nodes.
+ *
+ * A Merkle Tree allows developers to easily and securely verify
+ * the integrity of large amounts of data.
+ *
+ * Take a look at our [documentation](https://docs.minaprotocol.com/en/zkapps)
+ * on how to use Merkle Trees in combination with zkApps and
+ * zero knowledge programming!
+ *
+ * Levels are indexed from leaves (level 0) to root (level N - 1).
+ */
+class RollupMerkleTree {
+    static get leafCount() {
+        return 2n ** BigInt(RollupMerkleTree.height - 1);
+    }
+    constructor(store) {
+        this.store = store;
+        // eslint-disable-next-line @shopify/prefer-class-properties
+        this.zeroes = [0n];
+        for (let index = 1; index < RollupMerkleTree.height; index += 1) {
+            const previousLevel = Field(this.zeroes[index - 1]);
+            this.zeroes.push(Poseidon.hash([previousLevel, previousLevel]).toBigInt());
+        }
+    }
+    /**
+     * Returns a node which lives at a given index and level.
+     * @param level Level of the node.
+     * @param index Index of the node.
+     * @returns The data of the node.
+     */
+    getNode(level, index) {
+        return Field(this.store.getNode(index, level) ?? this.zeroes[level]);
+    }
+    /**
+     * Returns the root of the [Merkle Tree](https://en.wikipedia.org/wiki/Merkle_tree).
+     * @returns The root of the Merkle Tree.
+     */
+    getRoot() {
+        return this.getNode(RollupMerkleTree.height - 1, 0n);
+    }
+    // eslint-disable-next-line no-warning-comments
+    // TODO: this allows to set a node at an index larger than the size. OK?
+    setNode(level, index, value) {
+        this.store.setNode(index, level, value.toBigInt());
+    }
+    /**
+     * TODO: if this is passed an index bigger than the max, it will set a couple
+     * of out-of-bounds nodes but not affect the real Merkle root. OK?
+     */
+    /**
+     * Sets the value of a leaf node at a given index to a given value.
+     * @param index Position of the leaf node.
+     * @param leaf New value.
+     */
+    setLeaf(index, leaf) {
+        if (index >= this.leafCount) {
+            index %= this.leafCount;
+        }
+        this.setNode(0, index, leaf);
+        let currentIndex = index;
+        for (let level = 1; level < RollupMerkleTree.height; level += 1) {
+            currentIndex /= 2n;
+            const left = this.getNode(level - 1, currentIndex * 2n);
+            const right = this.getNode(level - 1, currentIndex * 2n + 1n);
+            this.setNode(level, currentIndex, Poseidon.hash([left, right]));
+        }
+    }
+    /**
+     * Returns the witness (also known as
+     * [Merkle Proof or Merkle Witness](https://computersciencewiki.org/index.php/Merkle_proof))
+     * for the leaf at the given index.
+     * @param index Position of the leaf node.
+     * @returns The witness that belongs to the leaf.
+     */
+    getWitness(index) {
+        if (index >= this.leafCount) {
+            throw new Error("Index too large for merkle height");
+        }
+        const path = [];
+        const isLefts = [];
+        for (let level = 0; level < RollupMerkleTree.height - 1; level += 1) {
+            const isLeft = index % 2n === 0n;
+            const sibling = this.getNode(level, isLeft ? index + 1n : index - 1n);
+            isLefts.push(Bool(isLeft));
+            path.push(sibling);
+            index /= 2n;
+        }
+        return new RollupMerkleWitness({
+            isLeft: isLefts,
+            path,
+        });
+    }
+    // eslint-disable-next-line no-warning-comments, max-len
+    // TODO: should this take an optional offset? should it fail if the array is too long?
+    /**
+     * Fills all leaves of the tree.
+     * @param leaves Values to fill the leaves with.
+     */
+    fill(leaves) {
+        leaves.forEach((value, index) => {
+            this.setLeaf(BigInt(index), value);
+        });
+    }
+    /**
+     * Returns the amount of leaf nodes.
+     * @returns Amount of leaf nodes.
+     */
+    get leafCount() {
+        return RollupMerkleTree.leafCount;
+    }
+}
+RollupMerkleTree.height = 256;
+RollupMerkleTree.EMPTY_ROOT = new RollupMerkleTree(new InMemoryMerkleTreeStorage())
+    .getRoot()
+    .toBigInt();
+__decorate([
+    notInCircuit(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, BigInt]),
+    __metadata("design:returntype", Field)
+], RollupMerkleTree.prototype, "getNode", null);
+__decorate([
+    notInCircuit(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Field)
+], RollupMerkleTree.prototype, "getRoot", null);
+__decorate([
+    notInCircuit(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BigInt, Field]),
+    __metadata("design:returntype", void 0)
+], RollupMerkleTree.prototype, "setLeaf", null);
+__decorate([
+    notInCircuit(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], RollupMerkleTree.prototype, "fill", null);
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var MerkleTreeUtils;
+(function (MerkleTreeUtils) {
+    function normalizeKey(key) {
+        // if(NJORD_MERKLE_TREE_HEIGHT < 256){
+        //     return fieldMod(key, Field(RollupMerkleTree.leafCount).toConstant())
+        // eslint-disable-next-line max-len
+        //     // return modPower2(key, RollupMerkleTree.height - 1) //TODO Fix modPower2
+        // }else{
+        return key;
+        // }
+    }
+    MerkleTreeUtils.normalizeKey = normalizeKey;
+    function checkMembership(witness, root, key, value) {
+        const root2 = witness.calculateRoot(value);
+        const key2 = witness.calculateIndex();
+        key.assertEquals(key2, "Keys of MerkleWitness does not match");
+        return root.equals(root2);
+    }
+    MerkleTreeUtils.checkMembership = checkMembership;
+    function checkMembershipGetRoots(witness, root, key, value) {
+        const root2 = witness.calculateRoot(value);
+        const key2 = witness.calculateIndex();
+        key.assertEquals(key2, "Keys of MerkleWitness does not match");
+        return [root.equals(root2), root, root2];
+    }
+    MerkleTreeUtils.checkMembershipGetRoots = checkMembershipGetRoots;
+    function computeRoot(witness, value) {
+        return witness.calculateRoot(value);
+    }
+    MerkleTreeUtils.computeRoot = computeRoot;
+})(MerkleTreeUtils || (MerkleTreeUtils = {}));
+/**
+ * More efficient version of `maybeSwapBad` which
+ * reuses an intermediate variable
+ */
+function maybeSwap(b, x, y) {
+    const m = b.toField().mul(x.sub(y)); // b*(x - y)
+    const x1 = y.add(m); // y + b*(x - y)
+    const y2 = x.sub(m); // x - b*(x - y) = x + b*(y - x)
+    return [x1, y2];
+}

package/dist/utils/utils.d.ts

@@ -6,6 +6,6 @@ export type Subclass<Class extends new (...args: any) => any> = (new (...args: a
     prototype: InstanceType<Class>;
 };
 export declare function notInCircuit(): MethodDecorator;
-export declare function stringToField(value: string): import("o1js/dist/node/lib/field").Field;
+export declare function stringToField(value: string): import("o1js/dist/node/lib/provable/field").Field;
 export declare function singleFieldToString(value: Field | bigint): string;
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAsB,MAAM,MAAM,CAAC;AAGjD,MAAM,MAAM,UAAU,CAAC,YAAY,SAAS,QAAQ,IAAI,YAAY,SAAS,CAC3E,GAAG,IAAI,EAAE,GAAG,EAAE,KACX,MAAM,MAAM,GACb,MAAM,GACN,GAAG,CAAC;AAER,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,KAAK,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,IAAI,CAAC,KAC/D,GAAG,IAAI,EAAE,GAAG,KACT,YAAY,CAAC,KAAK,CAAC,CAAC,GAAG;KACzB,GAAG,IAAI,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC;CACjC,GAAG;IAAE,SAAS,EAAE,YAAY,CAAC,KAAK,CAAC,CAAA;CAAE,CAAC;AAEvC,wBAAgB,YAAY,IAAI,eAAe,CAoB9C;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,4CAgC1C;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAKjE"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAsB,MAAM,MAAM,CAAC;AAGjD,MAAM,MAAM,UAAU,CAAC,YAAY,SAAS,QAAQ,IAAI,YAAY,SAAS,CAC3E,GAAG,IAAI,EAAE,GAAG,EAAE,KACX,MAAM,MAAM,GACb,MAAM,GACN,GAAG,CAAC;AAER,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,KAAK,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,IAAI,CAAC,KAC/D,GAAG,IAAI,EAAE,GAAG,KACT,YAAY,CAAC,KAAK,CAAC,CAAC,GAAG;KACzB,GAAG,IAAI,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC;CACjC,GAAG;IAAE,SAAS,EAAE,YAAY,CAAC,KAAK,CAAC,CAAA;CAAE,CAAC;AAEvC,wBAAgB,YAAY,IAAI,eAAe,CAkB9C;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,qDA+B1C;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAMjE"}

package/dist/utils/utils.js

@@ -1,5 +1,3 @@
-// eslint-disable-next-line max-len
-/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/ban-types, @typescript-eslint/no-unsafe-return */
 import { Field, Poseidon, Provable } from "o1js";
 import floor from "lodash/floor";
 export function notInCircuit() {
@@ -10,15 +8,13 @@ export function notInCircuit() {
             if (Provable.inCheckedComputation() || Provable.inProver()) {
                 throw new Error(`Method ${propertyKey.toString()} is supposed to be only called outside of the circuit`);
             }
-            // eslint-disable-next-line max-len
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
             return childFunction.apply(this, args);
         };
         return descriptor;
     };
 }
 export function stringToField(value) {
-    const fieldSize = Field.sizeInBytes() - 1;
+    const fieldSize = Field.sizeInBytes - 1;
     // Encode string as byte[]
     const encoder = new TextEncoder();
     const stringBytes = Array.from(encoder.encode(value));
@@ -32,9 +28,7 @@ export function stringToField(value) {
         const arrayIndex = floor(index / fieldSize);
         a[arrayIndex].push(b);
         return a;
-    }, 
-    // eslint-disable-next-line array-func/from-map
-    Array.from({ length: floor(data.length / fieldSize) }).map(() => []));
+    }, Array.from({ length: floor(data.length / fieldSize) }).map(() => []));
     const fields = chunks.map((x) => 
     // We have to add a zero at the highest byte here, because a Field is
     // a bit smaller than 2^256
@@ -42,8 +36,9 @@ export function stringToField(value) {
     return Poseidon.hash(fields);
 }
 export function singleFieldToString(value) {
+    let fieldValue = value;
     if (typeof value === "bigint") {
-        value = Field(value);
+        fieldValue = Field(value);
     }
-    return value.toString();
+    return fieldValue.toString();
 }

package/package.json

@@ -3,14 +3,14 @@
   "license": "MIT",
   "private": false,
   "type": "module",
-  "version": "0.1.1-develop.600+699a7df",
+  "version": "0.1.1-develop.833+397881ed",
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch",
     "lint": "eslint ./src ./test",
     "test:file": "node --experimental-vm-modules --experimental-wasm-modules --experimental-wasm-threads ../../node_modules/jest/bin/jest.js",
-    "test": "npm run test:file -- ./src/** ./test/**",
-    "test:watch": "npm run test:file -- ./src/** ./test/** --watch"
+    "test": "npm run test:file -- ./test/**",
+    "test:watch": "npm run test:file -- ./test/** --watch"
   },
   "main": "dist/index.js",
   "publishConfig": {
@@ -24,7 +24,7 @@
   },
   "peerDependencies": {
     "@proto-kit/common": "*",
-    "o1js": "0.13.1",
+    "o1js": "^1.1.0",
     "ts-pattern": "^4.3.0",
     "tsyringe": "^4.7.0"
   },
@@ -32,5 +32,5 @@
     "@jest/globals": "^29.5.0",
     "@types/lodash": "^4.14.194"
   },
-  "gitHead": "699a7dfa3b5d3415ab4500f0cd495d6781365c6a"
+  "gitHead": "397881ed5d8f98f5005bcd7be7f5a12b3bc6f956"
 }

package/src/{blockmodules/AccountStateModule.ts → hooks/AccountStateHook.ts}

@@ -1,4 +1,5 @@
-import { Provable, PublicKey, Struct, UInt64 } from "o1js";
+import { PublicKey, Struct, UInt64 } from "o1js";
+import { injectable } from "tsyringe";
 
 import { BlockProverExecutionData } from "../prover/block/BlockProvable";
 import { StateMap } from "../state/StateMap";
@@ -10,18 +11,19 @@ export class AccountState extends Struct({
   nonce: UInt64,
 }) {}
 
-export class AccountStateModule extends ProvableTransactionHook {
+@injectable()
+export class AccountStateHook extends ProvableTransactionHook {
   @protocolState() public accountState = StateMap.from<PublicKey, AccountState>(
     PublicKey,
     AccountState
   );
 
-  public onTransaction({ transaction }: BlockProverExecutionData): void {
+  public async onTransaction({ transaction }: BlockProverExecutionData) {
     const sender = transaction.sender.value;
 
-    const accountState = this.accountState
-      .get(sender)
-      .orElse(new AccountState({ nonce: UInt64.zero }));
+    const aso = await this.accountState.get(sender);
+
+    const accountState = aso.orElse(new AccountState({ nonce: UInt64.zero }));
 
     const currentNonce = accountState.nonce;
 
@@ -30,15 +32,17 @@ export class AccountStateModule extends ProvableTransactionHook {
       currentNonce
         .equals(transaction.nonce.value)
         .or(transaction.sender.isSome.not()),
-      "Nonce not matching"
+      () =>
+        `Nonce not matching: tx sent ${transaction.nonce.value.toString()}, onchain value is ${currentNonce.toString()}`
     );
 
     // Optimized version of transaction.sender.isSome ? currentNonce.add(1) : Field(0)
     // Bcs Bool(true).toField() == 1
-    const newNonce = UInt64.from(
+    // TODO Think about if we want to rangecheck this. If not, we should store it as Field
+    const newNonce = UInt64.Unsafe.fromField(
       currentNonce.value.add(1).mul(transaction.sender.isSome.toField())
     );
 
-    this.accountState.set(sender, new AccountState({ nonce: newNonce }));
+    await this.accountState.set(sender, new AccountState({ nonce: newNonce }));
   }
 }

package/src/{blockmodules → hooks}/BlockHeightHook.ts

@@ -1,18 +1,17 @@
-import { Provable } from "o1js";
 import { NetworkState } from "../model/network/NetworkState";
 import { ProvableBlockHook } from "../protocol/ProvableBlockHook";
 
 export class BlockHeightHook extends ProvableBlockHook<Record<string, never>> {
-  public afterBlock(networkState: NetworkState): NetworkState {
+  public async afterBlock(networkState: NetworkState): Promise<NetworkState> {
     return new NetworkState({
       block: {
         height: networkState.block.height.add(1),
       },
-      previous: networkState.previous
+      previous: networkState.previous,
     });
   }
 
-  public beforeBlock(networkState: NetworkState): NetworkState {
+  public async beforeBlock(networkState: NetworkState): Promise<NetworkState> {
     return networkState;
   }
 }

package/src/{blockmodules → hooks}/LastStateRootBlockHook.ts

@@ -5,10 +5,10 @@ import { BlockProverState } from "../prover/block/BlockProver";
 export class LastStateRootBlockHook extends ProvableBlockHook<
   Record<string, never>
 > {
-  public afterBlock(
+  public async afterBlock(
     networkState: NetworkState,
     state: BlockProverState
-  ): NetworkState {
+  ): Promise<NetworkState> {
     return new NetworkState({
       block: networkState.block,
       previous: {
@@ -17,10 +17,10 @@ export class LastStateRootBlockHook extends ProvableBlockHook<
     });
   }
 
-  public beforeBlock(
+  public async beforeBlock(
     networkState: NetworkState,
     state: BlockProverState
-  ): NetworkState {
+  ): Promise<NetworkState> {
     return networkState;
   }
 }

package/src/{blockmodules → hooks}/NoopBlockHook.ts

@@ -1,20 +1,21 @@
+import { NoConfig } from "@proto-kit/common";
+
 import { ProvableBlockHook } from "../protocol/ProvableBlockHook";
 import { NetworkState } from "../model/network/NetworkState";
 import { BlockProverState } from "../prover/block/BlockProver";
-import { NoConfig } from "@proto-kit/common";
 
 export class NoopBlockHook extends ProvableBlockHook<NoConfig> {
-  public afterBlock(
+  public async afterBlock(
     networkState: NetworkState,
     state: BlockProverState
-  ): NetworkState {
+  ): Promise<NetworkState> {
     return networkState;
   }
 
-  public beforeBlock(
+  public async beforeBlock(
     networkState: NetworkState,
     state: BlockProverState
-  ): NetworkState {
+  ): Promise<NetworkState> {
     return networkState;
   }
 }

package/src/{blockmodules → hooks}/NoopSettlementHook.ts

@@ -2,20 +2,19 @@ import { injectable } from "tsyringe";
 import { noop } from "@proto-kit/common";
 import { SmartContract } from "o1js";
 
-import { BlockProof } from "../prover/block/BlockProver";
 import {
   ProvableSettlementHook,
   SettlementHookInputs,
-} from "../settlement/ProvableSettlementHook";
+} from "../settlement/modularity/ProvableSettlementHook";
 
 @injectable()
 export class NoopSettlementHook extends ProvableSettlementHook<
   Record<string, never>
 > {
-  public beforeSettlement(
+  public async beforeSettlement(
     contract: SmartContract,
     state: SettlementHookInputs
-  ): void {
+  ) {
     noop();
   }
 }

package/src/{blockmodules → hooks}/NoopTransactionHook.ts

@@ -1,6 +1,10 @@
+import { noop } from "@proto-kit/common";
+
 import { ProvableTransactionHook } from "../protocol/ProvableTransactionHook";
 import { BlockProverExecutionData } from "../prover/block/BlockProvable";
 
 export class NoopTransactionHook extends ProvableTransactionHook {
-  public onTransaction(executionData: BlockProverExecutionData): void {}
+  public async onTransaction(executionData: BlockProverExecutionData) {
+    noop();
+  }
 }

package/src/index.ts

@@ -1,7 +1,6 @@
-export * from "./blockmodules/AccountStateModule";
-export * from "./blockmodules/BlockHeightHook";
-export * from "./blockmodules/LastStateRootBlockHook";
-export * from "./utils/ProvableHashList";
+export * from "./hooks/AccountStateHook";
+export * from "./hooks/BlockHeightHook";
+export * from "./hooks/LastStateRootBlockHook";
 export * from "./model/StateTransition";
 export * from "./model/StateTransitionProvableBatch";
 export * from "./model/Option";
@@ -10,8 +9,13 @@ export * from "./model/network/NetworkState";
 export * from "./model/transaction/SignedTransaction";
 export * from "./model/transaction/RuntimeTransaction";
 export * from "./model/transaction/ValueOption";
+export * from "./model/MethodPublicOutput";
+export * from "./model/RuntimeLike";
+export * from "./utils/ProvableHashList";
 export * from "./utils/PrefixedProvableHashList";
 export * from "./utils/MinaPrefixedProvableHashList";
+export * from "./utils/ProvableReductionHashList";
+export * from "./utils/StateTransitionReductionList";
 export * from "./utils/utils";
 export * from "./prover/block/BlockProver";
 export * from "./prover/block/BlockProvable";
@@ -19,14 +23,12 @@ export * from "./prover/block/accummulators/BlockHashMerkleTree";
 export * from "./prover/statetransition/StateTransitionProver";
 export * from "./prover/statetransition/StateTransitionProvable";
 export * from "./prover/statetransition/StateTransitionWitnessProvider";
-export * from "./model/MethodPublicOutput";
 export * from "./prover/statetransition/StateTransitionWitnessProviderReference";
 export * from "./protocol/Protocol";
 export * from "./protocol/ProtocolModule";
 export * from "./protocol/ProtocolEnvironment";
 export * from "./protocol/ProvableTransactionHook";
 export * from "./protocol/ProvableBlockHook";
-export * from "./state/context/ProtocolMethodExecutionContext";
 export * from "./state/context/TransitionMethodExecutionContext";
 export * from "./state/context/RuntimeMethodExecutionContext";
 export * from "./state/protocol/ProtocolState";
@@ -35,7 +37,15 @@ export * from "./state/StateMap";
 export * from "./state/StateService";
 export * from "./state/StateServiceProvider";
 export * from "./state/assert/assert";
-export * from "./settlement/SettlementContract";
-export * from "./settlement/ProvableSettlementHook";
+export * from "./settlement/contracts/SettlementSmartContract";
+export * from "./settlement/contracts/SettlementContractProtocolModule";
+export * from "./settlement/contracts/DispatchSmartContract";
+export * from "./settlement/contracts/DispatchContractProtocolModule";
+export * from "./settlement/SettlementContractModule";
+export * from "./settlement/ContractModule";
+export * from "./settlement/modularity/ProvableSettlementHook";
+export * from "./settlement/messages/OutgoingMessageArgument";
 export * from "./settlement/modules/NetworkStateSettlementModule";
+export * from "./settlement/messages/Deposit";
+export * from "./settlement/messages/Withdrawal";
 export { constants as ProtocolConstants } from "./Constants";

package/src/model/MethodPublicOutput.ts

@@ -1,4 +1,4 @@
-import { Bool, Field, Signature, Struct } from "o1js";
+import { Bool, Field, Struct } from "o1js";
 
 /**
  * Public input used to link in-circuit execution with
@@ -10,4 +10,4 @@ export class MethodPublicOutput extends Struct({
   transactionHash: Field,
   networkStateHash: Field,
   isMessage: Bool,
-}) {}
+}) {}

package/src/model/Option.ts

@@ -4,6 +4,7 @@ import {
   type FlexibleProvablePure,
   Poseidon,
   Provable,
+  ProvablePure,
   Struct,
 } from "o1js";
 
@@ -18,7 +19,10 @@ export class ProvableOption extends Struct({
 }
 
 export abstract class OptionBase {
-  protected constructor(public isSome: Bool, public isForcedSome: Bool) {}
+  protected constructor(
+    public isSome: Bool,
+    public isForcedSome: Bool
+  ) {}
 
   protected abstract encodeValueToFields(): Field[];
 
@@ -149,4 +153,20 @@ export class Option<Value> extends OptionBase {
       defaultValue
     );
   }
+
+  public toConstant() {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const valueConstant = (this.valueType as ProvablePure<Value>).fromFields(
+      this.valueType.toFields(this.value).map((field) => field.toConstant())
+    );
+    const boolConstant = (bool: Bool) =>
+      Bool.fromFields([bool.toField().toConstant()]);
+
+    return new Option(
+      boolConstant(this.isSome),
+      valueConstant,
+      this.valueType,
+      boolConstant(this.isForcedSome)
+    );
+  }
 }

package/src/model/Path.ts

@@ -1,6 +1,4 @@
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-/* eslint-disable @shopify/no-fully-static-classes */
-import { Field, type FlexibleProvablePure, Poseidon, Provable } from "o1js";
+import { Field, type FlexibleProvablePure, Poseidon } from "o1js";
 
 import { stringToField } from "../utils/utils";
 

package/src/model/RuntimeLike.ts

@@ -0,0 +1,12 @@
+export type RuntimeMethodInvocationType = "INCOMING_MESSAGE" | "SIGNATURE";
+
+export type RuntimeMethodIdMapping = Record<
+  `${string}.${string}`,
+  { methodId: bigint; type: RuntimeMethodInvocationType }
+>;
+
+export interface RuntimeLike {
+  get methodIdResolver(): {
+    methodIdMap: () => RuntimeMethodIdMapping;
+  };
+}