@proto-kit/protocol 0.1.1-develop.457 → 0.1.1-develop.651

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,88 @@
+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>[] = [];
+
+  for (const st of transitions) {
+    if (reduced.length === 0) {
+      reduced.push(st);
+      continue;
+    }
+
+    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/test/BlockProver.test.ts

@@ -19,16 +19,15 @@ import {
 } from "@proto-kit/common";
 import ZkProgram = Experimental.ZkProgram;
 import { UnsignedTransaction } from "@proto-kit/sequencer";
-import { AccountStateModule } from "../src/blockmodules/AccountStateModule";
+import { AccountStateHook } from "../src/blockmodules/AccountStateHook";
 import { container } from "tsyringe";
 import {
-  BlockModule,
   DefaultProvableHashList,
   MethodPublicOutput,
   NetworkState,
   Protocol,
   ProtocolMethodExecutionContext,
-  ProtocolTransaction,
+  SignedTransaction,
   ProvableStateTransition,
   RuntimeTransaction,
   StateTransitionProver,
@@ -87,7 +86,7 @@ describe("blockProver", () => {
       StateTransitionProver: StateTransitionProver,
       BlockProver: BlockProver,
     },
-    blockModules: [AccountStateModule],
+    blockModules: [AccountStateHook],
   });
 
   beforeEach(() => {
@@ -101,7 +100,7 @@ describe("blockProver", () => {
     fromStateRoot: Field,
     toStateRoot: Field,
     protocolHash: Field,
-    tx: ProtocolTransaction,
+    tx: SignedTransaction,
     networkState: NetworkState
   ): BlockProverProofPair {
     const transactionHash =

package/test/Protocol.test.ts

@@ -3,12 +3,14 @@ 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, ProvableTransactionHook } from "../src";
-import { AccountStateModule } from "../src/blockmodules/AccountStateModule";
+import {
+  NoOpStateTransitionWitnessProvider,
+  ProvableTransactionHook,
+} from "../src";
+import { AccountStateHook } from "../src/blockmodules/AccountStateHook";
 
 describe("protocol", () => {
-  beforeEach(() => {
-  });
+  beforeEach(() => {});
 
   it("should resolve all provers correctly", async () => {
     expect.assertions(2);
@@ -16,8 +18,8 @@ describe("protocol", () => {
     const protocol = VanillaProtocol.create();
 
     protocol.dependencyContainer.register("StateTransitionWitnessProvider", {
-      useValue: new NoOpStateTransitionWitnessProvider()
-    })
+      useValue: new NoOpStateTransitionWitnessProvider(),
+    });
 
     expect(protocol.blockProver instanceof BlockProver).toBe(true);
     expect(
@@ -32,13 +34,16 @@ describe("protocol", () => {
       modules: {
         BlockProver,
         StateTransitionProver,
-        AccountStateModule,
+        AccountStateHook,
       },
     });
 
-    const hooks = protocol.dependencyContainer.resolveAll<ProvableTransactionHook>("ProvableTransactionHook")
+    const hooks =
+      protocol.dependencyContainer.resolveAll<ProvableTransactionHook>(
+        "ProvableTransactionHook"
+      );
 
     expect(hooks).toHaveLength(1);
-    expect(hooks[0].name).toBe("AccountStateModule");
-  })
+    expect(hooks[0].name).toBe("AccountStateHook");
+  });
 });

package/test/settlement/SettlementContract.test.ts

@@ -0,0 +1,45 @@
+describe("inheritance & modularity", () => {
+  function decorator<T extends Base>(
+    target: T & { constructor: any },
+    methodName: string,
+    descriptor: PropertyDescriptor
+  ) {
+    const f = descriptor.value;
+    descriptor.value = function (x: Base) {
+      console.log("Hello");
+      expect((this as any).some()).toBe("testValue");
+      f(this);
+    };
+  }
+
+  class Base {
+    some() {
+      return "testValue";
+    }
+
+    @decorator
+    x() {}
+  }
+
+  it("expect decorator to work with prototype overriding", () => {
+    expect.assertions(3);
+
+    const f = (base: Base) => {
+      expect(base.some()).toBe("testValue");
+    };
+    const propertyDescriptor: PropertyDescriptor = {
+      value: f,
+    };
+    decorator(Base.prototype, "y", propertyDescriptor);
+    (Base.prototype as any).y = propertyDescriptor.value;
+
+    const base = new Base() as Base & { y: () => void };
+
+    base.x();
+    base.y();
+  });
+
+  it("test correct composition", async () => {
+
+  });
+});

package/test/utils/ProvableReductionHashList.test.ts

@@ -0,0 +1,114 @@
+import { Bool, Field, Poseidon } from "o1js";
+
+import { StateTransitionReductionList } from "../../src/utils/ProvableReductionHashList";
+import {
+  DefaultProvableHashList,
+  ProvableStateTransition,
+  StateTransition,
+  Option,
+} from "../../src";
+import { reduceStateTransitions } from "../../src/model/StateTransitionReduction";
+
+interface UnprovableStateTransition {
+  path: number;
+  from: number;
+  to: { isSome: boolean; value: number };
+}
+
+describe("provableReductionHashList", () => {
+  function mapToProvable(
+    sts: UnprovableStateTransition[]
+  ): StateTransition<unknown>[] {
+    return sts.map(
+      (st) =>
+        new StateTransition(
+          Field(st.path),
+          new Option(Bool(true), Field(st.from), Field, Bool(false)),
+          new Option(Bool(st.to.isSome), Field(st.to.value), Field, Bool(false))
+        ) as StateTransition<unknown>
+    );
+  }
+
+  describe.each<[UnprovableStateTransition[], number]>([
+    [
+      [
+        { path: 1, from: 5, to: { isSome: true, value: 10 } },
+        { path: 1, from: 10, to: { isSome: true, value: 15 } },
+      ],
+      1,
+    ],
+    [
+      [
+        { path: 1, from: 5, to: { isSome: true, value: 10 } },
+        { path: 1, from: 10, to: { isSome: false, value: 0 } },
+      ],
+      1,
+    ],
+    [
+      [
+        { path: 1, from: 5, to: { isSome: true, value: 10 } },
+        { path: 1, from: 10, to: { isSome: false, value: 0 } },
+        { path: 1, from: 10, to: { isSome: false, value: 0 } },
+        { path: 5, from: 15, to: { isSome: false, value: 0 } },
+        { path: 5, from: 15, to: { isSome: true, value: 20 } },
+        { path: 1, from: 10, to: { isSome: false, value: 0 } },
+        { path: 5, from: 20, to: { isSome: true, value: 25 } },
+        { path: 5, from: 25, to: { isSome: true, value: 30 } },
+      ],
+      4,
+    ],
+  ])("should reduce and append correctly", (sts, reducedLength) => {
+    it("start from empty list", () => {
+      const reductionList = new StateTransitionReductionList(
+        ProvableStateTransition
+      );
+      const normalList = new DefaultProvableHashList(ProvableStateTransition);
+
+      const provableSTs = mapToProvable(sts);
+
+      provableSTs.forEach((st) => {
+        reductionList.push(st.toProvable());
+      });
+
+      const reduced = reduceStateTransitions(provableSTs);
+      reduced.forEach((st) => {
+        normalList.push(st.toProvable());
+      });
+
+      expect(reduced).toHaveLength(reducedLength);
+      expect(normalList.commitment.toBigInt()).toStrictEqual(
+        reductionList.commitment.toBigInt()
+      );
+      expect(reductionList.unconstrainedList).toHaveLength(reduced.length);
+    });
+
+    it("start from non-zero commitment - skip first reduction", () => {
+      const commitment = Poseidon.hash([Field(123_456)]);
+      const reductionList = new StateTransitionReductionList(
+        ProvableStateTransition,
+        commitment
+      );
+      const normalList = new DefaultProvableHashList(
+        ProvableStateTransition,
+        commitment
+      );
+
+      const provableSTs = mapToProvable(sts);
+
+      provableSTs.forEach((st) => {
+        reductionList.push(st.toProvable());
+      });
+
+      const reduced = reduceStateTransitions(provableSTs);
+      reduced.forEach((st) => {
+        normalList.push(st.toProvable());
+      });
+
+      expect(reduced).toHaveLength(reducedLength);
+      expect(normalList.commitment.toBigInt()).toStrictEqual(
+        reductionList.commitment.toBigInt()
+      );
+      expect(reductionList.unconstrainedList).toHaveLength(reduced.length);
+    });
+  });
+});

package/src/blockmodules/AccountStateModule.ts

@@ -1,33 +0,0 @@
-import { PublicKey, Struct, UInt64 } from "o1js";
-
-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,
-}) {}
-
-export class AccountStateModule extends ProvableTransactionHook {
-  @protocolState() public accountState = StateMap.from<PublicKey, AccountState>(
-    PublicKey,
-    AccountState
-  );
-
-  public onTransaction({ transaction }: BlockProverExecutionData): void {
-    const accountState = this.accountState
-      .get(transaction.sender)
-      .orElse(new AccountState({ nonce: UInt64.zero }));
-
-    const currentNonce = accountState.nonce;
-
-    assert(currentNonce.equals(transaction.nonce), "Nonce not matching");
-
-    this.accountState.set(
-      transaction.sender,
-      new AccountState({ nonce: currentNonce.add(1) })
-    );
-  }
-}

package/src/blockmodules/BlockHeightHook.ts

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

package/src/blockmodules/NoopBlockHook.ts

@@ -1,16 +0,0 @@
-import {
-  AfterBlockParameters,
-  BeforeBlockParameters,
-  ProvableBlockHook
-} from "../protocol/ProvableBlockHook";
-import { NetworkState } from "../model/network/NetworkState";
-
-export class NoopBlockHook extends ProvableBlockHook<Record<string, never>>{
-  public afterBlock(blockData: AfterBlockParameters): NetworkState {
-    return blockData.networkState;
-  }
-
-  public beforeBlock(blockData: BeforeBlockParameters): NetworkState {
-    return blockData.networkState;
-  }
-}

package/src/model/transaction/ProtocolTransaction.ts

@@ -1,25 +0,0 @@
-import { Bool, Field, PublicKey, Signature, Struct, UInt64 } from "o1js";
-
-export class ProtocolTransaction extends Struct({
-  methodId: Field,
-  nonce: UInt64,
-  sender: PublicKey,
-  argsHash: Field,
-  signature: Signature,
-}) {
-  public static getSignatureData(args: {
-    methodId: Field;
-    nonce: UInt64;
-    argsHash: Field;
-  }): Field[] {
-    return [args.methodId, ...args.nonce.toFields(), args.argsHash];
-  }
-
-  public getSignatureData(): Field[] {
-    return ProtocolTransaction.getSignatureData(this);
-  }
-
-  public validateSignature(): Bool {
-    return this.signature.verify(this.sender, this.getSignatureData());
-  }
-}

package/src/prover/block/BlockTransactionPosition.ts

@@ -1,34 +0,0 @@
-import { Bool, Field, Struct } from "o1js";
-import { match } from "ts-pattern";
-
-export type BlockTransactionPositionType = "FIRST" | "LAST" | "MIDDLE";
-
-export class BlockTransactionPosition extends Struct({
-  type: Field,
-}) {
-  private static readonly fieldMapping: Record<
-    BlockTransactionPositionType,
-    number
-  > = {
-    FIRST: 0,
-    MIDDLE: 1,
-    LAST: 2,
-  };
-
-  public static fromPositionType(type: BlockTransactionPositionType) {
-    return new BlockTransactionPosition({
-      type: Field(BlockTransactionPosition.fieldMapping[type]).toConstant(),
-    });
-  }
-
-  public static positionTypeFromIndex(index: number, bundleLength: number) {
-    return match<number, BlockTransactionPositionType>(index)
-      .with(0, () => "FIRST")
-      .with(bundleLength - 1, () => "LAST")
-      .otherwise(() => "MIDDLE");
-  }
-
-  public equals(type: BlockTransactionPosition): Bool {
-    return this.type.equals(type.type);
-  }
-}