Added unconstrained values to hashlist

Author: rpanic

packages/protocol/src/utils/ProvableHashList.ts

@@ -1,16 +1,26 @@
 import { Field, Poseidon, Bool, Provable, ProvablePure } from "o1js";
+import { NonMethods } from "./utils";
 
 /**
  * Utilities for creating a hash list from a given value type.
  */
 export abstract class ProvableHashList<Value> {
+  private readonly unconstrainedList: NonMethods<Value>[] = [];
+
   public constructor(
     protected readonly valueType: ProvablePure<Value>,
     public commitment: Field = Field(0)
   ) {}
 
   protected abstract hash(elements: Field[]): Field;
 
+  private pushUnconstrained(value: Value) {
+    const valueConstant = this.valueType.fromFields(
+      this.valueType.toFields(value).map((field) => field.toConstant())
+    );
+    this.unconstrainedList.push(valueConstant);
+  }
+
   /**
    * Converts the provided value to Field[] and appends it to
    * the current hashlist.
@@ -23,6 +33,11 @@ export abstract class ProvableHashList<Value> {
       this.commitment,
       ...this.valueType.toFields(value),
     ]);
+
+    Provable.asProver(() => {
+      this.pushUnconstrained(value);
+    });
+
     return this;
   }
 
@@ -32,6 +47,13 @@ export abstract class ProvableHashList<Value> {
       ...this.valueType.toFields(value),
     ]);
     this.commitment = Provable.if(condition, newCommitment, this.commitment);
+
+    Provable.asProver(() => {
+      if (condition.toBoolean()) {
+        this.pushUnconstrained(value);
+      }
+    });
+
     return this;
   }
 
@@ -41,6 +63,10 @@ export abstract class ProvableHashList<Value> {
   public toField() {
     return this.commitment;
   }
+
+  public getUnconstrainedValues(): NonMethods<Value>[] {
+    return this.unconstrainedList;
+  }
 }
 
 export class DefaultProvableHashList<Value> extends ProvableHashList<Value> {

packages/protocol/src/utils/ProvableReductionHashList.ts

@@ -1,8 +1,14 @@
-import { Bool, Field, Poseidon, Provable } from "o1js";
+import { Bool, Field, Poseidon, Provable, ProvablePure } from "o1js";
 
 import { ProvableHashList } from "./ProvableHashList";
+import { NonMethods } from "./utils";
+
+export class ProvableReductionHashList<Value>{
+  public constructor(
+    protected readonly valueType: ProvablePure<Value>,
+    public commitment: Field = Field(0)
+  ) {}
 
-export class ProvableReductionHashList<Value> extends ProvableHashList<Value> {
   public unconstrainedList: Value[] = [];
 
   private constrainedLastValue: Value | undefined = undefined;
@@ -65,4 +71,8 @@ export class ProvableReductionHashList<Value> extends ProvableHashList<Value> {
   public hash(elements: Field[]): Field {
     return Poseidon.hash(elements);
   }
+
+  public getUnconstrainedValues(): NonMethods<Value>[] {
+    return this.unconstrainedList;
+  }
 }

packages/protocol/src/utils/utils.ts

@@ -73,3 +73,8 @@ export function singleFieldToString(value: Field | bigint): string {
   }
   return fieldValue.toString();
 }
+
+type NonMethodKeys<T> = {
+  [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+export type NonMethods<T> = Pick<T, NonMethodKeys<T>>;

packages/protocol/test/utils/ProvableHashList.test.ts

@@ -0,0 +1,41 @@
+import { Bool, Field, Poseidon } from "o1js";
+import { DefaultProvableHashList } from "../../src";
+
+describe("defaultProvableHashList", () => {
+  describe.each([
+    [0, [{ value: 1n, push: true }]],
+    // [
+    //   10,
+    //   [
+    //     { value: 1n, push: true },
+    //     { value: 5n, push: false },
+    //   ],
+    // ],
+    // [
+    //   10,
+    //   [
+    //     { value: 1n, push: true },
+    //     { value: 5n, push: false },
+    //     { value: 6n, push: true },
+    //   ],
+    // ],
+  ])("should correctly append and save", (start, elements) => {
+    it("Using only pushIf", () => {
+      const hashList = new DefaultProvableHashList(Field, Field(start));
+
+      const appended: bigint[] = [];
+      let hash = Field(start);
+
+      for (let element of elements) {
+        hashList.pushIf(Field(element.value), Bool(element.push));
+        if (element.push) {
+          appended.push(element.value);
+
+          hash = Poseidon.hash([hash, Field(element.value)]);
+        }
+      }
+
+      expect([hash]).equalProvable([hashList.commitment]);
+    });
+  });
+});