@proto-kit/protocol 0.1.1-develop.1086

package/dist/utils/ProvableReductionHashList.js

@@ -0,0 +1,50 @@
+import { Bool, Poseidon, Provable } from "o1js";
+import { ProvableHashList } from "./ProvableHashList";
+export class ProvableReductionHashList extends ProvableHashList {
+    constructor() {
+        super(...arguments);
+        this.unconstrainedList = [];
+        this.constrainedLastValue = undefined;
+        this.preimage = this.commitment;
+    }
+    pushAndReduce(value, reduce) {
+        let valueToPush = value;
+        let popLast = Bool(false);
+        // Theoretically, we can feed the preimage + last value as a witness
+        // for non-zero commitment starts (like used in the BlockProver), because
+        // currently it won't reduce across chunks. But this is okay for now I think
+        if (this.constrainedLastValue !== undefined) {
+            [valueToPush, popLast] = reduce(this.constrainedLastValue);
+        }
+        Provable.asProver(() => {
+            if (popLast.toBoolean()) {
+                this.unconstrainedList.pop();
+            }
+            const valueAsConstant = this.valueType.fromFields(this.valueType.toFields(valueToPush).map((field) => field.toConstant()));
+            this.unconstrainedList.push(valueAsConstant);
+        });
+        const currentCommitment = this.commitment;
+        const noPopCommitment = this.hash([
+            currentCommitment,
+            ...this.valueType.toFields(valueToPush),
+        ]);
+        const popCommitment = this.hash([
+            this.preimage,
+            ...this.valueType.toFields(valueToPush),
+        ]);
+        this.commitment = Provable.if(popLast, popCommitment, noPopCommitment);
+        this.constrainedLastValue = valueToPush;
+        this.preimage = Provable.if(popLast, this.preimage, currentCommitment);
+        return {
+            popLast,
+            value: valueToPush,
+        };
+    }
+    pushIf(value, condition) {
+        throw new Error("pushIf is not implemented for ReducedHashList");
+        return this;
+    }
+    hash(elements) {
+        return Poseidon.hash(elements);
+    }
+}

package/dist/utils/StateTransitionReductionList.d.ts

@@ -0,0 +1,11 @@
+import { ProvableStateTransition, StateTransition } from "../model/StateTransition";
+import { ProvableReductionHashList } from "./ProvableReductionHashList";
+export declare class StateTransitionReductionList extends ProvableReductionHashList<ProvableStateTransition> {
+    push(value: ProvableStateTransition): this;
+    pushWithMetadata(value: ProvableStateTransition): {
+        popLast: import("o1js/dist/node/lib/provable/bool").Bool;
+        value: ProvableStateTransition;
+    };
+}
+export declare function reduceStateTransitions(transitions: StateTransition<unknown>[]): StateTransition<unknown>[];
+//# sourceMappingURL=StateTransitionReductionList.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionReductionList.d.ts","sourceRoot":"","sources":["../../src/utils/StateTransitionReductionList.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,uBAAuB,EACvB,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAExE,qBAAa,4BAA6B,SAAQ,yBAAyB,CAAC,uBAAuB,CAAC;IAC3F,IAAI,CAAC,KAAK,EAAE,uBAAuB;IAMnC,gBAAgB,CAAC,KAAK,EAAE,uBAAuB;;;;CAyCvD;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,GACtC,eAAe,CAAC,OAAO,CAAC,EAAE,CA0B5B"}

package/dist/utils/StateTransitionReductionList.js

@@ -0,0 +1,60 @@
+import { Provable } from "o1js";
+import { ProvableOption } from "../model/Option";
+import { ProvableStateTransition, StateTransition, } from "../model/StateTransition";
+import { ProvableReductionHashList } from "./ProvableReductionHashList";
+export class StateTransitionReductionList extends ProvableReductionHashList {
+    push(value) {
+        this.pushWithMetadata(value);
+        return this;
+    }
+    pushWithMetadata(value) {
+        return this.pushAndReduce(value, (previous) => {
+            const pathsMatch = previous.path.equals(value.path);
+            // Take the previous.from if the paths match, otherwise leave ST as is
+            const from = Provable.if(pathsMatch, ProvableOption, previous.from, value.from);
+            // In case we have a layout like
+            // { from: 5, to: 10 }, { from: 10, to: none }
+            // we just take the first and discard the second
+            const to = Provable.if(value.to.isSome.or(pathsMatch.not()), ProvableOption, value.to, previous.to);
+            const transition = new ProvableStateTransition({
+                path: value.path,
+                from: new ProvableOption(from),
+                to: new ProvableOption(to),
+            });
+            // Assert that connection is correct
+            previous.to.value
+                .equals(value.from.value)
+                .or(previous.to.isSome
+                .not()
+                .and(previous.from.value.equals(value.from.value)))
+                .or(pathsMatch.not())
+                .assertTrue();
+            return [transition, pathsMatch];
+        });
+    }
+}
+export function reduceStateTransitions(transitions) {
+    const reduced = [];
+    transitions.forEach((st) => {
+        if (reduced.length === 0) {
+            reduced.push(st);
+            return;
+        }
+        const last = reduced.at(-1);
+        if (last.path.equals(st.path).toBoolean()) {
+            if (st.toValue.isSome.toBoolean()) {
+                reduced.pop();
+                reduced.push(new StateTransition(st.path, last.fromValue, st.toValue));
+            }
+            else {
+                // Do nothing, because we discard that ST
+                // { from: 5, to: 10 }, { from: 10, to: none }
+                // cancel the 2nd
+            }
+        }
+        else {
+            reduced.push(st);
+        }
+    });
+    return reduced;
+}

package/dist/utils/utils.d.ts

@@ -0,0 +1,11 @@
+import { Field } from "o1js";
+export type ReturnType<FunctionType extends Function> = FunctionType extends (...args: any[]) => infer Return ? Return : any;
+export type Subclass<Class extends new (...args: any) => any> = (new (...args: any) => InstanceType<Class>) & {
+    [Key in keyof Class]: Class[Key];
+} & {
+    prototype: InstanceType<Class>;
+};
+export declare function notInCircuit(): MethodDecorator;
+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

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

@@ -0,0 +1,44 @@
+import { Field, Poseidon, Provable } from "o1js";
+import floor from "lodash/floor";
+export function notInCircuit() {
+    return function ReplacedFunction(target, propertyKey, descriptor) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const childFunction = descriptor.value;
+        descriptor.value = function value(...args) {
+            if (Provable.inCheckedComputation() || Provable.inProver()) {
+                throw new Error(`Method ${propertyKey.toString()} is supposed to be only called outside of the circuit`);
+            }
+            return childFunction.apply(this, args);
+        };
+        return descriptor;
+    };
+}
+export function stringToField(value) {
+    const fieldSize = Field.sizeInBytes - 1;
+    // Encode string as byte[]
+    const encoder = new TextEncoder();
+    const stringBytes = Array.from(encoder.encode(value));
+    // Add padding in case the string is not a multiple of Field.sizeInBytes
+    const padding = Array.from({
+        length: fieldSize - (stringBytes.length % fieldSize),
+    }).fill(0);
+    const data = stringBytes.concat(padding).reverse();
+    // Hash the result Field[] to reduce it to
+    const chunks = data.reduce((a, b, index) => {
+        const arrayIndex = floor(index / fieldSize);
+        a[arrayIndex].push(b);
+        return a;
+    }, 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
+    Field.fromBytes(x.concat([0])));
+    return Poseidon.hash(fields);
+}
+export function singleFieldToString(value) {
+    let fieldValue = value;
+    if (typeof value === "bigint") {
+        fieldValue = Field(value);
+    }
+    return fieldValue.toString();
+}

package/jest.config.cjs

@@ -0,0 +1 @@
+module.exports = require("../../jest.config.cjs");

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@proto-kit/protocol",
+  "license": "MIT",
+  "private": false,
+  "type": "module",
+  "version": "0.1.1-develop.1086+eeb4563a",
+  "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 -- ./test/**",
+    "test:watch": "npm run test:file -- ./test/** --watch"
+  },
+  "main": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "loglevel": "^1.8.1",
+    "reflect-metadata": "^0.1.13",
+    "ts-mixer": "^6.0.3"
+  },
+  "peerDependencies": {
+    "@proto-kit/common": "*",
+    "o1js": "^1.1.0",
+    "ts-pattern": "^4.3.0",
+    "tsyringe": "^4.7.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/lodash": "^4.14.194"
+  },
+  "gitHead": "eeb4563a685b29525358ec7404fa9f0251d258d4"
+}

package/src/Constants.ts

@@ -0,0 +1,3 @@
+export const constants = {
+  stateTransitionProverBatchSize: 4,
+};

package/src/hooks/AccountStateHook.ts

@@ -0,0 +1,48 @@
+import { PublicKey, Struct, UInt64 } from "o1js";
+import { injectable } from "tsyringe";
+
+import { BlockProverExecutionData } from "../prover/block/BlockProvable";
+import { StateMap } from "../state/StateMap";
+import { protocolState } from "../state/protocol/ProtocolState";
+import { ProvableTransactionHook } from "../protocol/ProvableTransactionHook";
+import { assert } from "../state/assert/assert";
+
+export class AccountState extends Struct({
+  nonce: UInt64,
+}) {}
+
+@injectable()
+export class AccountStateHook extends ProvableTransactionHook {
+  @protocolState() public accountState = StateMap.from<PublicKey, AccountState>(
+    PublicKey,
+    AccountState
+  );
+
+  public async onTransaction({ transaction }: BlockProverExecutionData) {
+    const sender = transaction.sender.value;
+
+    const aso = await this.accountState.get(sender);
+
+    const accountState = aso.orElse(new AccountState({ nonce: UInt64.zero }));
+
+    const currentNonce = accountState.nonce;
+
+    // Either the nonce matches or the tx is a message, in which case we don't care
+    assert(
+      currentNonce
+        .equals(transaction.nonce.value)
+        .or(transaction.sender.isSome.not()),
+      () =>
+        `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
+    // 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())
+    );
+
+    await this.accountState.set(sender, new AccountState({ nonce: newNonce }));
+  }
+}

package/src/hooks/BlockHeightHook.ts

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

package/src/hooks/LastStateRootBlockHook.ts

@@ -0,0 +1,26 @@
+import { ProvableBlockHook } from "../protocol/ProvableBlockHook";
+import { NetworkState } from "../model/network/NetworkState";
+import { BlockProverState } from "../prover/block/BlockProver";
+
+export class LastStateRootBlockHook extends ProvableBlockHook<
+  Record<string, never>
+> {
+  public async afterBlock(
+    networkState: NetworkState,
+    state: BlockProverState
+  ): Promise<NetworkState> {
+    return new NetworkState({
+      block: networkState.block,
+      previous: {
+        rootHash: state.stateRoot,
+      },
+    });
+  }
+
+  public async beforeBlock(
+    networkState: NetworkState,
+    state: BlockProverState
+  ): Promise<NetworkState> {
+    return networkState;
+  }
+}

package/src/hooks/NoopBlockHook.ts

@@ -0,0 +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";
+
+export class NoopBlockHook extends ProvableBlockHook<NoConfig> {
+  public async afterBlock(
+    networkState: NetworkState,
+    state: BlockProverState
+  ): Promise<NetworkState> {
+    return networkState;
+  }
+
+  public async beforeBlock(
+    networkState: NetworkState,
+    state: BlockProverState
+  ): Promise<NetworkState> {
+    return networkState;
+  }
+}

package/src/hooks/NoopSettlementHook.ts

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

package/src/hooks/NoopTransactionHook.ts

@@ -0,0 +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 async onTransaction(executionData: BlockProverExecutionData) {
+    noop();
+  }
+}

package/src/index.ts

@@ -0,0 +1,53 @@
+export * from "./hooks/AccountStateHook";
+export * from "./hooks/BlockHeightHook";
+export * from "./hooks/LastStateRootBlockHook";
+export * from "./model/StateTransition";
+export * from "./model/StateTransitionProvableBatch";
+export * from "./model/Option";
+export * from "./model/Path";
+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";
+export * from "./prover/block/accummulators/RuntimeVerificationKeyTree";
+export * from "./prover/block/accummulators/BlockHashMerkleTree";
+export * from "./prover/block/services/RuntimeVerificationKeyRootService";
+export * from "./prover/statetransition/StateTransitionProver";
+export * from "./prover/statetransition/StateTransitionProvable";
+export * from "./prover/statetransition/StateTransitionWitnessProvider";
+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/TransitionMethodExecutionContext";
+export * from "./state/context/RuntimeMethodExecutionContext";
+export * from "./state/protocol/ProtocolState";
+export * from "./state/State";
+export * from "./state/StateMap";
+export * from "./state/StateService";
+export * from "./state/StateServiceProvider";
+export * from "./state/assert/assert";
+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

@@ -0,0 +1,14 @@
+import { Bool, Field, Struct } from "o1js";
+
+/**
+ * Public input used to link in-circuit execution with
+ * the proof's public input.
+ */
+export class MethodPublicOutput extends Struct({
+  stateTransitionsHash: Field,
+  status: Bool,
+  transactionHash: Field,
+  networkStateHash: Field,
+  isMessage: Bool,
+  eventsHash: Field,
+}) {}

package/src/model/Option.ts

@@ -0,0 +1,172 @@
+import {
+  Bool,
+  Field,
+  type FlexibleProvablePure,
+  Poseidon,
+  Provable,
+  ProvablePure,
+  Struct,
+} from "o1js";
+
+export class ProvableOption extends Struct({
+  isSome: Bool,
+  value: Field,
+}) {
+  public toSome() {
+    this.isSome = Bool(true);
+    return this;
+  }
+}
+
+export abstract class OptionBase {
+  protected constructor(
+    public isSome: Bool,
+    public isForcedSome: Bool
+  ) {}
+
+  protected abstract encodeValueToFields(): Field[];
+
+  protected abstract clone(): OptionBase;
+
+  /**
+   * @returns Tree representation of the current value
+   */
+  public get treeValue() {
+    const treeValue = Poseidon.hash(this.encodeValueToFields());
+
+    return Provable.if(
+      this.isSome.and(this.isForcedSome.not()),
+      treeValue,
+      Field(0)
+    );
+  }
+
+  public forceSome() {
+    this.isForcedSome = Provable.if(this.isSome, Bool(false), Bool(true));
+    this.isSome = Bool(true);
+  }
+
+  /**
+   * Returns the `to`-value as decoded as a list of fields
+   * Not in circuit
+   */
+  public toFields(): Field[] {
+    if (this.isSome.toBoolean()) {
+      return this.encodeValueToFields();
+    }
+    return [Field(0)];
+  }
+
+  /**
+   * @returns Provable representation of the current option.
+   */
+  public toProvable() {
+    return new ProvableOption({
+      isSome: this.isSome,
+      value: this.treeValue,
+    });
+  }
+
+  public toJSON() {
+    const value = this.encodeValueToFields().map((field) => field.toString());
+
+    return {
+      isSome: this.isSome.toBoolean(),
+      isForcedSome: this.isForcedSome.toBoolean(),
+      value,
+    };
+  }
+}
+
+/**
+ * Option facilitating in-circuit values that may or may not exist.
+ */
+export class Option<Value> extends OptionBase {
+  /**
+   * Creates a new Option from the provided parameters
+   *
+   * @param isSome
+   * @param value
+   * @param valueType
+   * @returns New option from the provided parameters.
+   */
+  public static from<Value>(
+    isSome: Bool,
+    value: Value,
+    valueType: FlexibleProvablePure<Value>
+  ) {
+    return new Option(isSome, value, valueType);
+  }
+
+  /**
+   * Creates a new Option from the provided parameters
+   *
+   * @param value
+   * @param valueType
+   * @returns New option from the provided parameters.
+   */
+  public static fromValue<Value>(
+    value: Value,
+    valueType: FlexibleProvablePure<Value>
+  ) {
+    return this.from(Bool(true), value, valueType);
+  }
+
+  /**
+   * @returns Empty / none option
+   */
+  public static none() {
+    return new Option(Bool(false), Field(0), Field);
+  }
+
+  public constructor(
+    isSome: Bool,
+    public value: Value,
+    public valueType: FlexibleProvablePure<Value>,
+    isForcedSome = Bool(false)
+  ) {
+    super(isSome, isForcedSome);
+  }
+
+  public encodeValueToFields(): Field[] {
+    return this.valueType.toFields(this.value);
+  }
+
+  public clone(): Option<Value> {
+    return new Option(
+      this.isSome,
+      this.value,
+      this.valueType,
+      this.isForcedSome
+    );
+  }
+
+  /**
+   * @returns Returns the value of this option if it isSome,
+   * otherwise returns the given defaultValue
+   */
+  public orElse(defaultValue: Value): Value {
+    return Provable.if<Value>(
+      this.isSome,
+      this.valueType,
+      this.value,
+      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

@@ -0,0 +1,50 @@
+import { Field, type FlexibleProvablePure, Poseidon } from "o1js";
+
+import { stringToField } from "../utils/utils";
+
+/**
+ * Helps manage path (key) identifiers for key-values in trees.
+ */
+export class Path {
+  /**
+   * Encodes a JS string as a Field
+   *
+   * @param value
+   * @returns Field representation of the provided value
+   */
+  public static toField(value: string) {
+    return stringToField(value);
+  }
+
+  /**
+   * Encodes a class name and its property name into a Field
+   *
+   * @param className
+   * @param propertyKey
+   * @returns Field representation of class name + property name
+   */
+  public static fromProperty(className: string, propertyKey: string): Field {
+    return Poseidon.hash([
+      Path.toField(className),
+      Path.toField(propertyKey),
+      Field(0),
+    ]);
+  }
+
+  /**
+   * Encodes an existing path with the provided key into a single Field.
+   *
+   * @param path
+   * @param keyType
+   * @param key
+   * @returns Field representation of the leading path + the provided key.
+   */
+  public static fromKey<KeyType>(
+    path: Field,
+    keyType: FlexibleProvablePure<KeyType>,
+    key: KeyType
+  ): Field {
+    const keyHash = Poseidon.hash(keyType.toFields(key));
+    return Poseidon.hash([path, keyHash]);
+  }
+}