@proto-kit/protocol 0.1.1-develop.1086

package/src/utils/MinaPrefixedProvableHashList.ts

@@ -0,0 +1,73 @@
+import { Field, Poseidon, ProvablePure } from "o1js";
+import { hashWithPrefix, prefixToField } from "@proto-kit/common";
+
+import { ProvableHashList } from "./ProvableHashList";
+
+function salt(prefix: string) {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return Poseidon.update(
+    [Field(0), Field(0), Field(0)],
+    [prefixToField(prefix)]
+  ) as [Field, Field, Field];
+}
+
+export const MINA_EVENT_PREFIXES = {
+  event: "MinaZkappEvent******",
+  events: "MinaZkappEvents*****",
+  sequenceEvents: "MinaZkappSeqEvents**",
+} as const;
+
+export function emptyActions(): Field {
+  return salt("MinaZkappActionsEmpty")[0];
+}
+
+export function emptyEvents(): Field {
+  return salt("MinaZkappEventsEmpty")[0];
+}
+
+export class MinaActions {
+  static actionHash(
+    action: Field[],
+    previousHash: Field = emptyActions()
+  ): Field {
+    const actionDataHash = hashWithPrefix(MINA_EVENT_PREFIXES.event, action);
+    return hashWithPrefix(MINA_EVENT_PREFIXES.sequenceEvents, [
+      previousHash,
+      actionDataHash,
+    ]);
+  }
+}
+
+export class MinaEvents {
+  static eventHash(event: Field[], previousHash: Field = emptyEvents()): Field {
+    const actionDataHash = hashWithPrefix(MINA_EVENT_PREFIXES.event, event);
+    return hashWithPrefix(MINA_EVENT_PREFIXES.events, [
+      previousHash,
+      actionDataHash,
+    ]);
+  }
+}
+
+export class MinaPrefixedProvableHashList<
+  Value,
+> extends ProvableHashList<Value> {
+  public constructor(
+    valueType: ProvablePure<Value>,
+    public readonly prefix: string,
+    internalCommitment: Field = Field(0)
+  ) {
+    super(valueType, internalCommitment);
+  }
+
+  protected hash(elements: Field[]): Field {
+    const init = salt(this.prefix);
+    const digest = Poseidon.update(init, elements);
+    return digest[0];
+  }
+}
+
+export class MinaActionsHashList extends MinaPrefixedProvableHashList<Field> {
+  public constructor(internalCommitment: Field = Field(0)) {
+    super(Field, MINA_EVENT_PREFIXES.sequenceEvents, internalCommitment);
+  }
+}

package/src/utils/PrefixedProvableHashList.ts

@@ -0,0 +1,21 @@
+import { Field, ProvablePure, Poseidon } from "o1js";
+
+import { ProvableHashList } from "./ProvableHashList.js";
+import { stringToField } from "./utils";
+
+export class PrefixedProvableHashList<Value> extends ProvableHashList<Value> {
+  private readonly prefix: Field;
+
+  public constructor(
+    valueType: ProvablePure<Value>,
+    prefix: string,
+    internalCommitment: Field = Field(0)
+  ) {
+    super(valueType, internalCommitment);
+    this.prefix = stringToField(prefix);
+  }
+
+  protected hash(elements: Field[]): Field {
+    return Poseidon.hash([this.prefix, ...elements]);
+  }
+}

package/src/utils/ProvableHashList.ts

@@ -0,0 +1,50 @@
+import { Field, Poseidon, Bool, Provable, ProvablePure } from "o1js";
+
+/**
+ * Utilities for creating a hash list from a given value type.
+ */
+export abstract class ProvableHashList<Value> {
+  public constructor(
+    protected readonly valueType: ProvablePure<Value>,
+    public commitment: Field = Field(0)
+  ) {}
+
+  protected abstract hash(elements: Field[]): Field;
+
+  /**
+   * Converts the provided value to Field[] and appends it to
+   * the current hashlist.
+   *
+   * @param value - Value to be appended to the hash list
+   * @returns Current hash list.
+   */
+  public push(value: Value) {
+    this.commitment = this.hash([
+      this.commitment,
+      ...this.valueType.toFields(value),
+    ]);
+    return this;
+  }
+
+  public pushIf(value: Value, condition: Bool) {
+    const newCommitment = this.hash([
+      this.commitment,
+      ...this.valueType.toFields(value),
+    ]);
+    this.commitment = Provable.if(condition, newCommitment, this.commitment);
+    return this;
+  }
+
+  /**
+   * @returns Traling hash of the current hashlist.
+   */
+  public toField() {
+    return this.commitment;
+  }
+}
+
+export class DefaultProvableHashList<Value> extends ProvableHashList<Value> {
+  public hash(elements: Field[]): Field {
+    return Poseidon.hash(elements);
+  }
+}

package/src/utils/ProvableReductionHashList.ts

@@ -0,0 +1,68 @@
+import { Bool, Field, Poseidon, Provable } from "o1js";
+
+import { ProvableHashList } from "./ProvableHashList";
+
+export class ProvableReductionHashList<Value> extends ProvableHashList<Value> {
+  public unconstrainedList: Value[] = [];
+
+  private constrainedLastValue: Value | undefined = undefined;
+
+  private preimage: Field = this.commitment;
+
+  public pushAndReduce(
+    value: Value,
+    reduce: (previous: Value) => [Value, Bool]
+  ): { popLast: Bool; value: Value } {
+    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,
+    };
+  }
+
+  public pushIf(value: Value, condition: Bool) {
+    throw new Error("pushIf is not implemented for ReducedHashList");
+
+    return this;
+  }
+
+  public hash(elements: Field[]): Field {
+    return Poseidon.hash(elements);
+  }
+}

package/src/utils/StateTransitionReductionList.ts

@@ -0,0 +1,89 @@
+import { Provable } from "o1js";
+
+import { ProvableOption } from "../model/Option";
+import {
+  ProvableStateTransition,
+  StateTransition,
+} from "../model/StateTransition";
+
+import { ProvableReductionHashList } from "./ProvableReductionHashList";
+
+export class StateTransitionReductionList extends ProvableReductionHashList<ProvableStateTransition> {
+  public push(value: ProvableStateTransition) {
+    this.pushWithMetadata(value);
+
+    return this;
+  }
+
+  public pushWithMetadata(value: ProvableStateTransition) {
+    return this.pushAndReduce(value, (previous: ProvableStateTransition) => {
+      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: StateTransition<unknown>[]
+): StateTransition<unknown>[] {
+  const reduced: StateTransition<unknown>[] = [];
+
+  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<unknown>(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/src/utils/utils.ts

@@ -0,0 +1,75 @@
+import { Field, Poseidon, Provable } from "o1js";
+import floor from "lodash/floor";
+
+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 function notInCircuit(): MethodDecorator {
+  return function ReplacedFunction(
+    target: any,
+    propertyKey: string | symbol,
+    descriptor: PropertyDescriptor
+  ) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const childFunction = descriptor.value;
+    descriptor.value = function value(this: any, ...args: any[]) {
+      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: string) {
+  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<number>({
+    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<number[][]>(
+    (a, b, index) => {
+      const arrayIndex = floor(index / fieldSize);
+      a[arrayIndex].push(b);
+      return a;
+    },
+
+    Array.from<number[]>({ 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: Field | bigint): string {
+  let fieldValue = value;
+  if (typeof value === "bigint") {
+    fieldValue = Field(value);
+  }
+  return fieldValue.toString();
+}

package/test/BlockProver.test.ts

@@ -0,0 +1,211 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  AreProofsEnabled,
+  PlainZkProgram,
+  ZkProgrammable,
+} from "@proto-kit/common";
+import { Bool, Field, Proof, UInt64, ZkProgram } from "o1js";
+import "reflect-metadata";
+
+import {
+  MethodPublicOutput,
+  NetworkState,
+  SignedTransaction,
+  StateTransitionProverPublicInput,
+  StateTransitionProverPublicOutput,
+} from "../src";
+
+import { createAndInitTestingProtocol } from "./TestingProtocol";
+
+type BlockProverProofPair = [
+  Proof<void, MethodPublicOutput>,
+  Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>,
+];
+
+class MockAppChain implements AreProofsEnabled {
+  public areProofsEnabled: boolean = false;
+
+  setProofsEnabled(areProofsEnabled: boolean): void {
+    this.areProofsEnabled = areProofsEnabled;
+  }
+}
+
+class RuntimeZkProgrammable extends ZkProgrammable<
+  undefined,
+  MethodPublicOutput
+> {
+  get appChain(): AreProofsEnabled | undefined {
+    return new MockAppChain();
+  }
+
+  zkProgramFactory(): PlainZkProgram<undefined, MethodPublicOutput>[] {
+    const program = ZkProgram({
+      name: "BlockProverTestProgram",
+      publicOutput: MethodPublicOutput,
+      methods: {},
+    });
+
+    return [
+      {
+        compile: program.compile.bind(program),
+        verify: program.verify.bind(program),
+        analyzeMethods: program.analyzeMethods.bind(program),
+        methods: {},
+        Proof: ZkProgram.Proof(program),
+      },
+    ];
+  }
+}
+
+describe("blockProver", () => {
+  const networkState = new NetworkState({
+    block: {
+      height: UInt64.zero,
+    },
+    previous: {
+      rootHash: Field(0),
+    },
+  });
+
+  const protocol = createAndInitTestingProtocol();
+
+  function generateTestProofs(
+    fromStateRoot: Field,
+    toStateRoot: Field,
+    toProtocolRoot: Field,
+    protocolHash: Field,
+    tx: SignedTransaction,
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    networkState: NetworkState
+  ): BlockProverProofPair {
+    const transactionHash = tx.transaction.hash();
+    const sthash = Field(123);
+
+    const appProof = new Proof<undefined, MethodPublicOutput>({
+      publicInput: undefined,
+      publicOutput: new MethodPublicOutput({
+        transactionHash,
+        stateTransitionsHash: sthash,
+        status: Bool(true),
+        networkStateHash: networkState.hash(),
+        isMessage: Bool(false),
+        eventsHash: Field(0),
+      }),
+
+      proof: "",
+      maxProofsVerified: 2,
+    });
+
+    const stProof = new Proof<
+      StateTransitionProverPublicInput,
+      StateTransitionProverPublicOutput
+    >({
+      publicInput: new StateTransitionProverPublicInput({
+        stateTransitionsHash: Field(0),
+        protocolTransitionsHash: Field(0),
+        stateRoot: fromStateRoot,
+        protocolStateRoot: fromStateRoot,
+      }),
+      publicOutput: new StateTransitionProverPublicOutput({
+        stateTransitionsHash: sthash,
+        protocolTransitionsHash: protocolHash,
+        stateRoot: toStateRoot,
+        protocolStateRoot: toProtocolRoot,
+      }),
+
+      proof: "",
+      maxProofsVerified: 2,
+    });
+
+    return [appProof, stProof];
+  }
+
+  it("dummy", () => {
+    expect(1).toBe(1);
+  });
+
+  // TODO
+  // it("previously applied transaction should also pass with derived publicInputs", () => {
+  //   expect.assertions(2);
+  //
+  //   const priv = PrivateKey.random();
+  //
+  //   const tx = new UnsignedTransaction({
+  //     methodId: Field(0),
+  //     args: [Field(0)],
+  //     nonce: UInt64.zero,
+  //     sender: priv.toPublicKey(),
+  //   })
+  //     .sign(priv)
+  //     .toProtocolTransaction();
+  //
+  //   const executionData = {
+  //     networkState,
+  //     transaction: tx,
+  //   };
+  //
+  //   // const asmodule = protocol.resolve()
+  //
+  //   protocol.dependencyContainer
+  //     .resolveAll<ProvableBlockHook<unknown>>("ProvableBlockHook")
+  //     .forEach((module) => {
+  //       module.beforeBlock(executionData);
+  //     });
+  //
+  //   const hashList = new DefaultProvableHashList(ProvableStateTransition);
+  //
+  //   container
+  //     .resolve(ProtocolMethodExecutionContext)
+  //     .current()
+  //     .result.stateTransitions.map((x) => x.toProvable())
+  //     .forEach((st) => {
+  //       hashList.push(st);
+  //     });
+  //
+  //   const blockProver = protocol.resolve("BlockProver");
+  //
+  //   const fromState = Field(1);
+  //   const toState = Field(2);
+  //
+  //   const [appProof, stProof] = generateTestProofs(
+  //     fromState,
+  //     toState,
+  //     hashList.commitment,
+  //     tx,
+  //     networkState
+  //   );
+  //
+  //   const fromProverState: BlockProverState = {
+  //     stateRoot: fromState,
+  //     transactionsHash: Field(0),
+  //     networkStateHash: networkState.hash(),
+  //   };
+  //
+  //   const toProverState = blockProver.applyTransaction(
+  //     fromProverState,
+  //     stProof,
+  //     appProof,
+  //     executionData
+  //   );
+  //
+  //   const publicInput = new BlockProverPublicInput({
+  //     stateRoot: fromProverState.stateRoot,
+  //     transactionsHash: fromProverState.transactionsHash,
+  //     networkStateHash: networkState.hash(),
+  //   });
+  //
+  //   const publicOutput = blockProver.proveTransaction(
+  //     publicInput,
+  //     stProof,
+  //     appProof,
+  //     { networkState, transaction: tx }
+  //   );
+  //
+  //   expect(publicOutput.stateRoot).toStrictEqual(toProverState.stateRoot);
+  //   expect(publicOutput.transactionsHash).toStrictEqual(
+  //     toProverState.transactionsHash
+  //   );
+  // });
+});
+
+/* eslint-enable */

package/test/Protocol.test.ts

@@ -0,0 +1,37 @@
+import "reflect-metadata";
+import { beforeEach } from "@jest/globals";
+
+import { BlockProver } from "../src/prover/block/BlockProver";
+import { StateTransitionProver } from "../src/prover/statetransition/StateTransitionProver";
+import { ProvableTransactionHook } from "../src";
+
+import { createAndInitTestingProtocol } from "./TestingProtocol";
+
+describe("protocol", () => {
+  beforeEach(() => {});
+
+  it("should resolve all provers correctly", async () => {
+    expect.assertions(2);
+
+    const protocol = createAndInitTestingProtocol();
+
+    expect(protocol.blockProver instanceof BlockProver).toBe(true);
+    expect(
+      protocol.stateTransitionProver instanceof StateTransitionProver
+    ).toBe(true);
+  });
+
+  it("should initialize hooks correctly", () => {
+    expect.assertions(2);
+
+    const protocol = createAndInitTestingProtocol();
+
+    const hooks =
+      protocol.dependencyContainer.resolveAll<ProvableTransactionHook>(
+        "ProvableTransactionHook"
+      );
+
+    expect(hooks).toHaveLength(1);
+    expect(hooks[0].name).toBe("AccountState");
+  });
+});

package/test/State.test.ts

@@ -0,0 +1,45 @@
+import "reflect-metadata";
+import { noop } from "@proto-kit/common";
+import { Bool, Field, UInt64 } from "o1js";
+import { container } from "tsyringe";
+
+import {
+  NetworkState,
+  RuntimeMethodExecutionContext,
+  RuntimeTransaction,
+  State,
+  SimpleAsyncStateService,
+  StateServiceProvider,
+} from "../src";
+
+describe("state", () => {
+  beforeEach(() => {
+    const executionContext = container.resolve(RuntimeMethodExecutionContext);
+
+    executionContext.setup({
+      transaction: undefined as unknown as RuntimeTransaction,
+      networkState: undefined as unknown as NetworkState,
+    });
+  });
+
+  it("should decode state correctly", async () => {
+    expect.assertions(2);
+
+    const state = State.from<UInt64>(UInt64);
+    const stateService: SimpleAsyncStateService = {
+      get: async () => [Field(123)],
+
+      set: async () => {
+        noop();
+      },
+    };
+    state.stateServiceProvider = new StateServiceProvider();
+    state.stateServiceProvider.setCurrentStateService(stateService);
+    state.path = Field(1);
+
+    const retrieved = await state.get();
+
+    expect(retrieved.isSome).toStrictEqual(Bool(true));
+    expect(retrieved.value).toStrictEqual(UInt64.from(123));
+  });
+});