@proto-kit/protocol 0.1.1-develop.190 → 0.1.1-develop.211

package/src/state/StateService.ts

@@ -0,0 +1,6 @@
+import { Field } from "snarkyjs";
+
+export interface StateService {
+  get: (key: Field) => Field[] | undefined;
+  set: (key: Field, value: Field[] | undefined) => void;
+}

package/src/state/StateServiceProvider.ts

@@ -0,0 +1,37 @@
+import { inject, injectable } from "tsyringe";
+
+import { StateService } from "./StateService";
+
+const errors = {
+  stateServiceNotSet: () =>
+    new Error(
+      `StateService has not been set yet. Be sure to either call your runtime or 
+      protocol function by creating them with an AppChain or by setting the 
+      stateService manually.`
+    ),
+};
+
+@injectable()
+export class StateServiceProvider {
+  private readonly defaultStateService?: StateService =
+    this.currentStateService;
+
+  public constructor(
+    @inject("StateService") private currentStateService?: StateService
+  ) {}
+
+  public get stateService(): StateService {
+    if (this.currentStateService === undefined) {
+      throw errors.stateServiceNotSet();
+    }
+    return this.currentStateService;
+  }
+
+  public setCurrentStateService(service: StateService) {
+    this.currentStateService = service;
+  }
+
+  public resetToDefault() {
+    this.currentStateService = this.defaultStateService;
+  }
+}

package/src/state/assert/assert.test.ts

@@ -0,0 +1,49 @@
+import "reflect-metadata";
+
+import { Bool } from "snarkyjs";
+import { container } from "tsyringe";
+
+import { assert } from "./assert";
+import { RuntimeMethodExecutionContext } from "../context/RuntimeMethodExecutionContext";
+
+describe("assert", () => {
+  const defaultStatusMessage = "something went wrong";
+  const executionContext = container.resolve(RuntimeMethodExecutionContext);
+
+  beforeEach(() => {
+    executionContext.beforeMethod("testConstructor", "test", []);
+  });
+
+  afterEach(() => {
+    executionContext.afterMethod();
+  });
+
+  describe.each([
+    [true, undefined],
+    [false, undefined],
+    [false, defaultStatusMessage],
+  ])("status and message propagation", (status, statusMessage) => {
+    it("should propagate the assertion status and message", () => {
+      expect.assertions(2);
+
+      assert(Bool(status), statusMessage);
+
+      const { status: resultStatus, statusMessage: resultStatusMessage } =
+        executionContext.current().result;
+
+      expect(status).toBe(resultStatus.toBoolean());
+      expect(statusMessage).toBe(resultStatusMessage);
+    });
+  });
+
+  it("should keep a false status, once it was already set", () => {
+    expect.assertions(1);
+
+    assert(Bool(false));
+    assert(Bool(true));
+
+    const { status } = executionContext.current().result;
+
+    expect(status.toBoolean()).toBe(false);
+  });
+});

package/src/state/assert/assert.ts

@@ -0,0 +1,28 @@
+import { Bool, Provable } from "snarkyjs";
+import { container } from "tsyringe";
+import { log } from "@proto-kit/common";
+
+import { RuntimeMethodExecutionContext } from "../context/RuntimeMethodExecutionContext";
+import { exec } from "child_process";
+
+/**
+ * Maintains an execution status of the current runtime module method,
+ * while prioritizing one-time failures. The assertion won't change the
+ * execution status if it has previously failed at least once within the
+ * same method execution context.
+ *
+ * @param condition - Result of the assertion made about the execution status
+ * @param message - Optional message describing the prior status
+ */
+export function assert(condition: Bool, message?: string) {
+  const executionContext = container.resolve(RuntimeMethodExecutionContext);
+  const previousStatus = executionContext.current().result.status;
+  const status = Provable.if(previousStatus, Bool, condition, previousStatus);
+
+  if (!condition.toBoolean()) {
+    log.debug("Assertion failed: ", message);
+    executionContext.setStatusMessage(message);
+  }
+
+  executionContext.setStatus(status);
+}

package/src/state/context/ProtocolMethodExecutionContext.ts

@@ -0,0 +1,36 @@
+import {
+  TransitionMethodExecutionContext,
+  TransitionMethodExecutionResult
+} from "./TransitionMethodExecutionContext";
+import { StateTransition } from "../../model/StateTransition";
+
+export class ProtocolMethodExecutionContext implements TransitionMethodExecutionContext {
+  public result = new TransitionMethodExecutionResult();
+
+  /**
+   * Adds an in-method generated state transition to the current context
+   * @param stateTransition - State transition to add to the context
+   */
+  public addStateTransition<Value>(
+    stateTransition: StateTransition<Value>
+  ) {
+    this.result.stateTransitions.push(stateTransition);
+  }
+
+  /**
+   * Manually clears/resets the execution context
+   */
+  public clear() {
+    this.result = new TransitionMethodExecutionResult();
+  }
+
+  /**
+   * Had to override current() otherwise it would not infer
+   * the type of result correctly (parent type would be reused)
+   */
+  public current() {
+    return {
+      result: this.result,
+    };
+  }
+}

package/src/state/context/RuntimeMethodExecutionContext.ts

@@ -0,0 +1,124 @@
+import { Bool } from "snarkyjs";
+import { singleton } from "tsyringe";
+import { ProvableMethodExecutionContext, ProvableMethodExecutionResult } from "@proto-kit/common";
+import { StateTransition } from "../../model/StateTransition";
+import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
+import { NetworkState } from "../../model/network/NetworkState";
+
+const errors = {
+  setupNotCalled: () =>
+    new Error(
+      "Setup has not been called prior to executing a runtime method. Be sure to do that so that the Runtime is setup property for execution"
+    ),
+};
+
+export class RuntimeProvableMethodExecutionResult extends ProvableMethodExecutionResult {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public stateTransitions: StateTransition<any>[] = [];
+
+  public status: Bool = Bool(true);
+
+  public statusMessage?: string;
+}
+
+export interface RuntimeMethodExecutionData {
+  transaction: RuntimeTransaction;
+  networkState: NetworkState;
+}
+
+/**
+ * Execution context used to wrap runtime module methods,
+ * allowing them to post relevant information (such as execution status)
+ * into the context without any unnecessary 'prop drilling'.
+ */
+@singleton()
+export class RuntimeMethodExecutionContext extends ProvableMethodExecutionContext {
+  public methods: string[] = [];
+
+  public input: RuntimeMethodExecutionData | undefined;
+
+  // The input corresponding to the current result
+  private lastInput: RuntimeMethodExecutionData | undefined;
+
+  public override result = new RuntimeProvableMethodExecutionResult();
+
+  private isSimulated: boolean = false;
+
+  private assertSetupCalled(): asserts this is {
+    input: RuntimeMethodExecutionData;
+  } {
+    if (this.input === undefined) {
+      throw errors.setupNotCalled();
+    }
+  }
+
+  /**
+   * Adds an in-method generated state transition to the current context
+   * @param stateTransition - State transition to add to the context
+   */
+  public addStateTransition<Value>(stateTransition: StateTransition<Value>) {
+    this.assertSetupCalled();
+    this.result.stateTransitions.push(stateTransition);
+  }
+
+  /**
+   * @param message - Status message to acompany the current status
+   */
+  public setStatusMessage(message?: string) {
+    this.assertSetupCalled();
+    if (this.isSimulated) {
+      return;
+    }
+    this.result.statusMessage ??= message;
+  }
+
+  /**
+   * @param status - Execution status of the current method
+   */
+  public setStatus(status: Bool) {
+    this.assertSetupCalled();
+    if (this.isSimulated) {
+      return;
+    }
+    this.result.status = status;
+  }
+
+  /**
+   * @param input Input witness data required for a runtime execution
+   */
+  public setup(input: RuntimeMethodExecutionData) {
+    this.input = input;
+  }
+
+  public setSimulated(simulated: boolean) {
+    this.isSimulated = simulated;
+  }
+
+  /**
+   * Manually clears/resets the execution context
+   */
+  public clear() {
+    this.result = new RuntimeProvableMethodExecutionResult();
+  }
+
+  public afterMethod() {
+    super.afterMethod();
+    if (this.isFinished) {
+      this.lastInput = this.input;
+      this.input = undefined;
+      this.isSimulated = false;
+    }
+  }
+
+  /**
+   * Had to override current() otherwise it would not infer
+   * the type of result correctly (parent type would be reused)
+   */
+  public current() {
+    return {
+      isFinished: this.isFinished,
+      result: this.result,
+      input: this.lastInput,
+    };
+  }
+}

package/src/state/context/TransitionMethodExecutionContext.ts

@@ -0,0 +1,27 @@
+import { StateTransition } from "../../model/StateTransition";
+
+export class TransitionMethodExecutionResult {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public stateTransitions: StateTransition<any>[] = [];
+}
+
+export interface TransitionMethodExecutionContext {
+  /**
+   * Adds an in-method generated state transition to the current context
+   * @param stateTransition - State transition to add to the context
+   */
+  addStateTransition: <Value>(stateTransition: StateTransition<Value>) => void;
+
+  /**
+   * Manually clears/resets the execution context
+   */
+  clear: () => void;
+
+  /**
+   * Had to override current() otherwise it would not infer
+   * the type of result correctly (parent type would be reused)
+   */
+  current: () => {
+    result: TransitionMethodExecutionResult;
+  };
+}

package/src/state/protocol/ProtocolState.ts

@@ -0,0 +1,63 @@
+import { State } from "../State";
+import { ToFieldable } from "../../model/Option";
+import { Path } from "../../model/Path";
+import { TransitioningProtocolModule } from "../../protocol/TransitioningProtocolModule";
+
+const errors = {
+  missingName: (className: string) =>
+    new Error(
+      `Unable to provide a unique identifier for state, ${className} is missing a name. 
+      Did you forget to extend your block module with 'extends ...Hook'?`
+    ),
+
+  missingProtocol: (className: string) =>
+    new Error(
+      `Unable to provide 'procotol' for state, ${className} is missing a name. 
+      Did you forget to extend your block module with 'extends ...Hook'?`
+    ),
+};
+
+/**
+ * Decorates a runtime module property as state, passing down some
+ * underlying values to improve developer experience.
+ */
+export function protocolState() {
+  return <TargetTransitioningModule extends TransitioningProtocolModule>(
+    target: TargetTransitioningModule,
+    propertyKey: string
+  ) => {
+    // eslint-disable-next-line @typescript-eslint/init-declarations
+    let value: State<unknown> | undefined;
+
+    Object.defineProperty(target, propertyKey, {
+      enumerable: true,
+
+      get: function get() {
+        // eslint-disable-next-line max-len
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const self = this as TargetTransitioningModule;
+
+        if (self.name === undefined) {
+          throw errors.missingName(self.constructor.name);
+        }
+
+        if (!self.protocol) {
+          throw errors.missingProtocol(self.constructor.name);
+        }
+
+        // eslint-disable-next-line no-warning-comments
+        // TODO Add Prefix?
+        const path = Path.fromProperty(self.name, propertyKey);
+        if (value) {
+          value.path = path;
+          value.stateServiceProvider = self.protocol.stateServiceProvider;
+        }
+        return value;
+      },
+
+      set: (newValue: State<unknown>) => {
+        value = newValue;
+      },
+    });
+  };
+}

package/test/BlockProver.test.ts

@@ -1,45 +1,114 @@
 import "reflect-metadata";
-import { Bool, Field, Poseidon, Proof } from "snarkyjs";
 import {
-  container as globalContainer,
-  type DependencyContainer,
-} from "tsyringe";
-
-import { MethodPublicOutput } from "@proto-kit/protocol";
+  Bool,
+  Experimental,
+  Field,
+  PrivateKey,
+  Proof,
+  UInt64,
+} from "snarkyjs";
 
 import {
   BlockProver,
   type BlockProverState,
-} from "../src/prover/block/BlockProver.js";
-import { NoOpStateTransitionWitnessProvider } from "../src/prover/statetransition/StateTransitionWitnessProvider.js";
+} from "../src/prover/block/BlockProver";
+import { NoOpStateTransitionWitnessProvider } from "../src/prover/statetransition/StateTransitionWitnessProvider";
 import {
   StateTransitionProverPublicInput,
   StateTransitionProverPublicOutput,
 } from "../src/prover/statetransition/StateTransitionProvable";
 import { BlockProverPublicInput } from "../src/prover/block/BlockProvable";
+import {
+  AreProofsEnabled,
+  PlainZkProgram,
+  WithZkProgrammable,
+  ZkProgrammable,
+} from "@proto-kit/common";
+import ZkProgram = Experimental.ZkProgram;
+import { UnsignedTransaction } from "@proto-kit/sequencer";
+import { AccountStateModule } from "../src/blockmodules/AccountStateModule";
+import { container } from "tsyringe";
+import {
+  BlockModule, DefaultProvableHashList,
+  MethodPublicOutput,
+  NetworkState,
+  Protocol, ProtocolMethodExecutionContext,
+  ProtocolTransaction, ProvableStateTransition, RuntimeTransaction,
+  StateTransitionProver
+} from "../src";
 
 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 = Experimental.ZkProgram({
+      publicOutput: MethodPublicOutput,
+      methods: {},
+    });
+
+    return {
+      compile: program.compile,
+      verify: program.verify,
+      methods: {},
+      Proof: ZkProgram.Proof(program),
+    };
+  }
+}
+
+class RuntimeMock implements WithZkProgrammable<undefined, MethodPublicOutput> {
+  zkProgrammable: ZkProgrammable<undefined, MethodPublicOutput> =
+    new RuntimeZkProgrammable();
+}
+
 describe("blockProver", () => {
-  let container: DependencyContainer;
+  const networkState = new NetworkState({
+    block: {
+      height: UInt64.zero,
+    },
+  });
+
+  const protocol = Protocol.from({
+    modules: {
+      StateTransitionProver: StateTransitionProver,
+      BlockProver: BlockProver,
+    },
+    blockModules: [AccountStateModule],
+  });
 
   beforeEach(() => {
-    const childContainer = globalContainer.createChildContainer();
-    childContainer.register(
-      "StateTransitionWitnessProvider",
-      NoOpStateTransitionWitnessProvider
-    );
-    container = childContainer;
+    protocol.registerValue({
+      StateTransitionWitnessProvider: new NoOpStateTransitionWitnessProvider(),
+      Runtime: new RuntimeMock(),
+    });
   });
 
   function generateTestProofs(
     fromStateRoot: Field,
-    toStateRoot: Field
+    toStateRoot: Field,
+    protocolHash: Field,
+    tx: ProtocolTransaction,
+    networkState: NetworkState
   ): BlockProverProofPair {
-    const transactionHash = Poseidon.hash([Field(12_345)]);
+    const transactionHash =
+      RuntimeTransaction.fromProtocolTransaction(tx).hash();
     const sthash = Field(123);
 
     const appProof = new Proof<undefined, MethodPublicOutput>({
@@ -48,6 +117,7 @@ describe("blockProver", () => {
         transactionHash,
         stateTransitionsHash: sthash,
         status: Bool(true),
+        networkStateHash: networkState.hash(),
       }),
 
       proof: "",
@@ -60,10 +130,12 @@ describe("blockProver", () => {
     >({
       publicInput: new StateTransitionProverPublicInput({
         stateTransitionsHash: Field(0),
+        protocolTransitionsHash: Field(0),
         stateRoot: fromStateRoot,
       }),
       publicOutput: new StateTransitionProverPublicOutput({
         stateTransitionsHash: sthash,
+        protocolTransitionsHash: protocolHash,
         stateRoot: toStateRoot,
       }),
 
@@ -74,49 +146,80 @@ describe("blockProver", () => {
     return [appProof, stProof];
   }
 
-  it("should pass with valid inputs", () => {
-    expect.assertions(0);
-
-    const blockProver = container.resolve(BlockProver);
+  it("previously applied transaction should also pass with derived publicInputs", () => {
+    expect.assertions(2);
 
-    const fromState = Field(1);
-    const toState = Field(2);
+    const priv = PrivateKey.random();
 
-    const [appProof, stProof] = generateTestProofs(fromState, toState);
+    const tx = new UnsignedTransaction({
+      methodId: Field(0),
+      args: [Field(0)],
+      nonce: UInt64.zero,
+      sender: priv.toPublicKey(),
+    })
+      .sign(priv)
+      .toProtocolTransaction();
 
-    const state: BlockProverState = {
-      stateRoot: fromState,
-      transactionsHash: Field(0),
+    const executionData = {
+      networkState,
+      transaction: tx,
     };
-    blockProver.applyTransaction(state, stProof, appProof);
-  });
 
-  it("previously applied transaction should also pass with derived publicInputs", () => {
-    expect.assertions(2);
+    // const asmodule = protocol.resolve()
+
+    protocol.dependencyContainer
+      .resolveAll<BlockModule>("BlockModule")
+      .forEach((module) => {
+        module.createTransitions(executionData);
+      });
+
+    const hashList = new DefaultProvableHashList(ProvableStateTransition);
+
+    container
+      .resolve(ProtocolMethodExecutionContext)
+      .current()
+      .result.stateTransitions.map((x) => x.toProvable())
+      .forEach((st) => {
+        hashList.push(st);
+      });
 
-    const blockProver = container.resolve(BlockProver);
+    const blockProver = protocol.resolve("BlockProver");
 
     const fromState = Field(1);
     const toState = Field(2);
 
-    const [appProof, stProof] = generateTestProofs(fromState, toState);
+    const [appProof, stProof] = generateTestProofs(
+      fromState,
+      toState,
+      hashList.commitment,
+      tx,
+      networkState
+    );
 
     const fromProverState: BlockProverState = {
       stateRoot: fromState,
       transactionsHash: Field(0),
+      networkStateHash: networkState.hash(),
     };
-    const toProverState = { ...fromProverState };
-    blockProver.applyTransaction(toProverState, stProof, appProof);
+
+    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
+      appProof,
+      { networkState, transaction: tx }
     );
 
     expect(publicOutput.stateRoot).toStrictEqual(toProverState.stateRoot);

package/test/Protocol.test.ts

@@ -1,20 +1,20 @@
 import "reflect-metadata";
-import { VanillaProtocol } from "../src/protocol/Protocol";
+import { Protocol, VanillaProtocol } from "../src/protocol/Protocol";
 import { beforeEach } from "@jest/globals";
 import { BlockProver } from "../src/prover/block/BlockProver";
 import { StateTransitionProver } from "../src/prover/statetransition/StateTransitionProver";
-import { NoOpStateTransitionWitnessProvider } from "../src";
+import { NoOpStateTransitionWitnessProvider, ProvableTransactionHook } from "../src";
+import { AccountStateModule } from "../src/blockmodules/AccountStateModule";
 
 describe("protocol", () => {
-  let protocol: ReturnType<typeof VanillaProtocol.create>;
-
   beforeEach(() => {
-    protocol = VanillaProtocol.create();
   });
 
   it("should resolve all provers correctly", async () => {
     expect.assertions(2);
 
+    const protocol = VanillaProtocol.create();
+
     protocol.dependencyContainer.register("StateTransitionWitnessProvider", {
       useValue: new NoOpStateTransitionWitnessProvider()
     })
@@ -24,4 +24,21 @@ describe("protocol", () => {
       protocol.stateTransitionProver instanceof StateTransitionProver
     ).toBe(true);
   });
+
+  it.only("should initialize hooks correctly", () => {
+    expect.assertions(2);
+
+    const protocol = Protocol.from({
+      modules: {
+        BlockProver,
+        StateTransitionProver,
+        AccountStateModule,
+      },
+    });
+
+    const hooks = protocol.dependencyContainer.resolveAll<ProvableTransactionHook>("ProvableTransactionHook")
+
+    expect(hooks).toHaveLength(1);
+    expect(hooks[0].name).toBe("AccountStateModule");
+  })
 });

package/test/StateTransition.test.ts

@@ -20,7 +20,7 @@ describe("stateTransition", () => {
     tree: RollupMerkleTree,
     transitions: ProvableStateTransition[]
   ) {
-    const batch = StateTransitionProvableBatch.fromTransitions(transitions);
+    const batch = StateTransitionProvableBatch.fromTransitions(transitions, []);
 
     const temporaryTree = new RollupMerkleTree(
       new CachedMerkleTreeStore(tree.store)