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

package/src/state/assert/assert.ts

@@ -1,4 +1,4 @@
-import { Bool } from "o1js";
+import { Bool, Provable } from "o1js";
 import { container } from "tsyringe";
 import { log } from "@proto-kit/common";
 
@@ -13,17 +13,23 @@ import { RuntimeMethodExecutionContext } from "../context/RuntimeMethodExecution
  * @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) {
+export function assert(condition: Bool, message?: string | (() => string)) {
   const executionContext = container.resolve(RuntimeMethodExecutionContext);
   const previousStatus = executionContext.current().result.status;
   const status = condition.and(previousStatus);
 
-  if (!condition.toBoolean()) {
-    if (!executionContext.current().isSimulated) {
-      log.debug("Assertion failed: ", message);
+  Provable.asProver(() => {
+    if (!condition.toBoolean()) {
+      if (!executionContext.current().isSimulated) {
+        log.debug("Assertion failed: ", message);
+      }
+      const messageString =
+        message !== undefined && typeof message === "function"
+          ? message()
+          : message;
+      executionContext.setStatusMessage(messageString, new Error().stack);
     }
-    executionContext.setStatusMessage(message);
-  }
+  });
 
   executionContext.setStatus(status);
 }

package/src/state/context/RuntimeMethodExecutionContext.ts

@@ -4,6 +4,7 @@ import {
   ProvableMethodExecutionContext,
   ProvableMethodExecutionResult,
 } from "@proto-kit/common";
+
 import { StateTransition } from "../../model/StateTransition";
 import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
 import { NetworkState } from "../../model/network/NetworkState";
@@ -16,12 +17,13 @@ const errors = {
 };
 
 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;
+
+  public stackTrace?: string;
 }
 
 export interface RuntimeMethodExecutionData {
@@ -29,10 +31,12 @@ export interface RuntimeMethodExecutionData {
   networkState: NetworkState;
 }
 
-export class RuntimeMethodExecutionDataStruct extends Struct({
-  transaction: RuntimeTransaction,
-  networkState: NetworkState,
-}) {}
+export class RuntimeMethodExecutionDataStruct
+  extends Struct({
+    transaction: RuntimeTransaction,
+    networkState: NetworkState,
+  })
+  implements RuntimeMethodExecutionData {}
 
 /**
  * Execution context used to wrap runtime module methods,
@@ -72,12 +76,13 @@ export class RuntimeMethodExecutionContext extends ProvableMethodExecutionContex
   /**
    * @param message - Status message to acompany the current status
    */
-  public setStatusMessage(message?: string) {
+  public setStatusMessage(message?: string, stackTrace?: string) {
     this.assertSetupCalled();
     if (this.isSimulated) {
       return;
     }
     this.result.statusMessage ??= message;
+    this.result.stackTrace ??= stackTrace;
   }
 
   /**
@@ -125,7 +130,8 @@ export class RuntimeMethodExecutionContext extends ProvableMethodExecutionContex
     super.afterMethod();
     if (this.isFinished) {
       this.lastInput = this.input;
-      this.input = undefined;
+      // TODO: find out why input isnt set in TransactionFeeHook during assert
+      // this.input = undefined;
       this.isSimulated = false;
     }
   }

package/src/state/context/TransitionMethodExecutionContext.ts

@@ -1,7 +1,6 @@
 import { StateTransition } from "../../model/StateTransition";
 
 export class TransitionMethodExecutionResult {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   public stateTransitions: StateTransition<any>[] = [];
 }
 

package/src/state/protocol/ProtocolState.ts

@@ -22,19 +22,17 @@ const errors = {
  */
 export function protocolState() {
   return <
-    TargetTransitioningModule extends TransitioningProtocolModule<unknown>
+    TargetTransitioningModule extends TransitioningProtocolModule<unknown>,
   >(
     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;
 
@@ -46,7 +44,6 @@ export function protocolState() {
           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) {

package/src/utils/MinaPrefixedProvableHashList.ts

@@ -1,9 +1,10 @@
-import { Field, FlexibleProvablePure, Poseidon } from "o1js";
+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)]
@@ -48,10 +49,10 @@ export class MinaEvents {
 }
 
 export class MinaPrefixedProvableHashList<
-  Value
+  Value,
 > extends ProvableHashList<Value> {
   public constructor(
-    valueType: FlexibleProvablePure<Value>,
+    valueType: ProvablePure<Value>,
     public readonly prefix: string,
     internalCommitment: Field = Field(0)
   ) {

package/src/utils/PrefixedProvableHashList.ts

@@ -1,4 +1,4 @@
-import { Field, FlexibleProvablePure, Poseidon } from "o1js";
+import { Field, ProvablePure, Poseidon } from "o1js";
 
 import { ProvableHashList } from "./ProvableHashList.js";
 import { stringToField } from "./utils";
@@ -7,7 +7,7 @@ export class PrefixedProvableHashList<Value> extends ProvableHashList<Value> {
   private readonly prefix: Field;
 
   public constructor(
-    valueType: FlexibleProvablePure<Value>,
+    valueType: ProvablePure<Value>,
     prefix: string,
     internalCommitment: Field = Field(0)
   ) {

package/src/utils/ProvableHashList.ts

@@ -1,11 +1,11 @@
-import { Field, Poseidon, FlexibleProvablePure, Bool, Provable } from "o1js";
+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(
-    private readonly valueType: FlexibleProvablePure<Value>,
+    protected readonly valueType: ProvablePure<Value>,
     public commitment: Field = Field(0)
   ) {}
 

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

@@ -1,6 +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";
 
@@ -30,8 +27,6 @@ export function notInCircuit(): MethodDecorator {
           `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;
@@ -39,7 +34,7 @@ export function notInCircuit(): MethodDecorator {
 }
 
 export function stringToField(value: string) {
-  const fieldSize = Field.sizeInBytes() - 1;
+  const fieldSize = Field.sizeInBytes - 1;
 
   // Encode string as byte[]
   const encoder = new TextEncoder();
@@ -59,7 +54,6 @@ export function stringToField(value: string) {
       return a;
     },
 
-    // eslint-disable-next-line array-func/from-map
     Array.from<number[]>({ length: floor(data.length / fieldSize) }).map(
       () => []
     )
@@ -73,8 +67,9 @@ export function stringToField(value: string) {
 }
 
 export function singleFieldToString(value: Field | bigint): string {
+  let fieldValue = value;
   if (typeof value === "bigint") {
-    value = Field(value);
+    fieldValue = Field(value);
   }
-  return value.toString();
+  return fieldValue.toString();
 }