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

package/src/settlement/{SettlementContract.ts → contracts/SettlementSmartContract.ts}

@@ -1,3 +1,4 @@
+import { prefixToField, RollupMerkleTree, TypedClass } from "@proto-kit/common";
 import {
   AccountUpdate,
   Bool,
@@ -7,46 +8,36 @@ import {
   Poseidon,
   Proof,
   Provable,
-  ProvableExtended,
   PublicKey,
-  Reducer,
   Signature,
   SmartContract,
   State,
   state,
-  Struct,
   TokenId,
   UInt32,
   UInt64,
 } from "o1js";
+import { NetworkState } from "../../model/network/NetworkState";
+import { Path } from "../../model/Path";
+import { BlockHashMerkleTree } from "../../prover/block/accummulators/BlockHashMerkleTree";
 import {
-  EMPTY_PUBLICKEY,
-  prefixToField,
-  RollupMerkleTree,
-  RollupMerkleTreeWitness,
-} from "@proto-kit/common";
-import { inject, injectable, injectAll } from "tsyringe";
-
-import { ProtocolModule } from "../protocol/ProtocolModule";
-import { BlockProver } from "../prover/block/BlockProver";
-import {
-  BlockProvable,
   BlockProverPublicInput,
   BlockProverPublicOutput,
-} from "../prover/block/BlockProvable";
-import { NetworkState } from "../model/network/NetworkState";
-import { BlockHashMerkleTree } from "../prover/block/accummulators/BlockHashMerkleTree";
-import { RuntimeTransaction } from "../model/transaction/RuntimeTransaction";
-import { Path } from "../model/Path";
-import { MinaActions, MinaEvents } from "../utils/MinaPrefixedProvableHashList";
-
+} from "../../prover/block/BlockProvable";
+import {
+  OUTGOING_MESSAGE_BATCH_SIZE,
+  OutgoingMessageArgumentBatch,
+} from "../messages/OutgoingMessageArgument";
+import { Withdrawal } from "../messages/Withdrawal";
 import {
   ProvableSettlementHook,
   SettlementHookInputs,
   SettlementStateRecord,
-} from "./ProvableSettlementHook";
+} from "../modularity/ProvableSettlementHook";
 
-class LazyBlockProof extends Proof<
+import { DispatchContractType } from "./DispatchSmartContract";
+
+export class LazyBlockProof extends Proof<
   BlockProverPublicInput,
   BlockProverPublicOutput
 > {
@@ -59,69 +50,37 @@ class LazyBlockProof extends Proof<
   };
 }
 
-export type SettlementMethodIdMapping = Record<`${string}.${string}`, bigint>;
-
-export class Deposit extends Struct({
-  address: PublicKey,
-  amount: UInt64,
-}) {}
-
-export class Withdrawal extends Struct({
-  address: PublicKey,
-  amount: UInt64,
-}) {
-  static dummy() {
-    return new Withdrawal({
-      address: EMPTY_PUBLICKEY,
-      amount: UInt64.from(0),
-    });
-  }
-}
-
-export const OUTGOING_MESSAGE_BATCH_SIZE = 1;
-
-export class OutgoingMessageArgument extends Struct({
-  witness: RollupMerkleTreeWitness,
-  value: Withdrawal,
-}) {
-  public static dummy(): OutgoingMessageArgument {
-    return new OutgoingMessageArgument({
-      witness: RollupMerkleTreeWitness.dummy(),
-      value: Withdrawal.dummy(),
-    });
-  }
-}
-
-export class OutgoingMessageArgumentBatch extends Struct({
-  arguments: Provable.Array(
-    OutgoingMessageArgument,
-    OUTGOING_MESSAGE_BATCH_SIZE
-  ),
-
-  isDummys: Provable.Array(Bool, OUTGOING_MESSAGE_BATCH_SIZE),
-}) {
-  public static fromMessages(providedArguments: OutgoingMessageArgument[]) {
-    const batch = providedArguments.slice();
-    const isDummys = batch.map(() => Bool(false));
-
-    while (batch.length < OUTGOING_MESSAGE_BATCH_SIZE) {
-      batch.push(OutgoingMessageArgument.dummy());
-      isDummys.push(Bool(true));
-    }
-
-    return new OutgoingMessageArgumentBatch({
-      arguments: batch,
-      isDummys,
-    });
-  }
+export interface SettlementContractType {
+  initialize: (sequencer: PublicKey, dispatchContract: PublicKey) => void;
+  settle: (
+    blockProof: LazyBlockProof,
+    signature: Signature,
+    dispatchContractAddress: PublicKey,
+    publicKey: PublicKey,
+    inputNetworkState: NetworkState,
+    outputNetworkState: NetworkState,
+    newPromisedMessagesHash: Field
+  ) => void;
+  rollupOutgoingMessages: (batch: OutgoingMessageArgumentBatch) => void;
+  redeem: (additionUpdate: AccountUpdate) => void;
 }
 
 // Some random prefix for the sequencer signature
 export const BATCH_SIGNATURE_PREFIX = prefixToField("pk-batchSignature");
 
-export const ACTIONS_EMPTY_HASH = Reducer.initialActionState;
+export class SettlementSmartContract
+  extends SmartContract
+  implements SettlementContractType
+{
+  // This pattern of injecting args into a smartcontract is currently the only
+  // viable solution that works given the inheritance issues of o1js
+  public static args: {
+    DispatchContract: TypedClass<DispatchContractType & SmartContract>;
+    hooks: ProvableSettlementHook<unknown>[];
+    withdrawalStatePath: [string, string];
+    escapeHatchSlotsInterval: number;
+  };
 
-export class SettlementContract extends SmartContract {
   @state(Field) public sequencerKey = State<Field>();
   @state(UInt32) public lastSettlementL1Block = State<UInt32>();
 
@@ -129,47 +88,33 @@ export class SettlementContract extends SmartContract {
   @state(Field) public networkStateHash = State<Field>();
   @state(Field) public blockHashRoot = State<Field>();
 
-  @state(Field) public promisedMessagesHash = State<Field>();
-  @state(Field) public honoredMessagesHash = State<Field>();
+  @state(Field) public dispatchContractAddressX = State<Field>();
 
   @state(Field) public outgoingMessageCursor = State<Field>();
 
-  public constructor(
-    address: PublicKey,
-    private readonly methodIdMappings: Record<string, bigint>,
-    private readonly hooks: ProvableSettlementHook<unknown>[],
-    private readonly withdrawalStatePath: [string, string],
-    private readonly incomingMessagesPaths: Record<
-      string,
-      `${string}.${string}`
-    >,
-    // 24 hours
-    private readonly escapeHatchSlotsInterval = (60 / 3) * 24
-  ) {
-    super(address);
-  }
-
   @method
-  public initialize(sequencer: PublicKey) {
+  public initialize(sequencer: PublicKey, dispatchContract: PublicKey) {
     this.sequencerKey.getAndAssertEquals().assertEquals(Field(0));
     this.stateRoot.getAndAssertEquals().assertEquals(Field(0));
     this.blockHashRoot.getAndAssertEquals().assertEquals(Field(0));
     this.networkStateHash.getAndAssertEquals().assertEquals(Field(0));
-    this.promisedMessagesHash.getAndAssertEquals().assertEquals(Field(0));
-    this.honoredMessagesHash.getAndAssertEquals().assertEquals(Field(0));
+    this.dispatchContractAddressX.getAndAssertEquals().assertEquals(Field(0));
 
     this.sequencerKey.set(sequencer.x);
     this.stateRoot.set(Field(RollupMerkleTree.EMPTY_ROOT));
     this.blockHashRoot.set(Field(BlockHashMerkleTree.EMPTY_ROOT));
     this.networkStateHash.set(NetworkState.empty().hash());
-    this.promisedMessagesHash.set(ACTIONS_EMPTY_HASH);
-    this.honoredMessagesHash.set(ACTIONS_EMPTY_HASH);
+    this.dispatchContractAddressX.set(dispatchContract.x);
+
+    const DispatchContract = SettlementSmartContract.args.DispatchContract;
+    new DispatchContract(dispatchContract).initialize(this.address);
   }
 
   @method
   public settle(
     blockProof: LazyBlockProof,
     signature: Signature,
+    dispatchContractAddress: PublicKey,
     publicKey: PublicKey,
     inputNetworkState: NetworkState,
     outputNetworkState: NetworkState,
@@ -183,16 +128,31 @@ export class SettlementContract extends SmartContract {
     const networkStateHash = this.networkStateHash.getAndAssertEquals();
     const blockHashRoot = this.blockHashRoot.getAndAssertEquals();
     const sequencerKey = this.sequencerKey.getAndAssertEquals();
-    const promisedMessagesHash = this.promisedMessagesHash.getAndAssertEquals();
-    const honoredMessagesHash = this.honoredMessagesHash.getAndAssertEquals();
     const lastSettlementL1Block =
       this.lastSettlementL1Block.getAndAssertEquals();
+    const onChainDispatchContractAddressX =
+      this.dispatchContractAddressX.getAndAssertEquals();
+
+    onChainDispatchContractAddressX.assertEquals(
+      dispatchContractAddress.x,
+      "DispatchContract address not provided correctly"
+    );
+
+    const { DispatchContract, escapeHatchSlotsInterval, hooks } =
+      SettlementSmartContract.args;
+
+    // Get dispatch contract values
+    // These values are witnesses but will be checked later on the AU
+    // call to the dispatch contract via .updateMessagesHash()
+    const dispatchContract = new DispatchContract(dispatchContractAddress);
+    const promisedMessagesHash = dispatchContract.promisedMessagesHash.get();
 
     // Get block height and use the lower bound for all ops
     const minBlockIncluded = this.network.globalSlotSinceGenesis.get();
     this.network.globalSlotSinceGenesis.assertBetween(
       minBlockIncluded,
-      minBlockIncluded.add(20)
+      // 5 because that is the length the newPromisedMessagesHash will be valid
+      minBlockIncluded.add(4)
     );
 
     // Check signature/escape catch
@@ -205,7 +165,7 @@ export class SettlementContract extends SmartContract {
       lastSettlementL1Block.value,
     ]);
     const escapeHatchActivated = lastSettlementL1Block
-      .add(UInt32.from(this.escapeHatchSlotsInterval))
+      .add(UInt32.from(escapeHatchSlotsInterval))
       .lessThan(minBlockIncluded);
     signatureValid
       .or(escapeHatchActivated)
@@ -214,6 +174,10 @@ export class SettlementContract extends SmartContract {
       );
 
     // Assert correctness of networkState witness
+    Provable.log("Network State Hash ", networkStateHash);
+    Provable.log("input Hash ", inputNetworkState.hash());
+    Provable.log("equals ", inputNetworkState.hash().equals(networkStateHash));
+
     inputNetworkState
       .hash()
       .assertEquals(networkStateHash, "InputNetworkState witness not valid");
@@ -234,10 +198,8 @@ export class SettlementContract extends SmartContract {
       blockHashRoot,
       stateRoot,
       networkStateHash,
-      honoredMessagesHash,
       lastSettlementL1Block,
-      promisedMessagesHash,
-      sequencerKey,
+      sequencerKey: publicKey,
     };
     const inputs: SettlementHookInputs = {
       blockProof,
@@ -247,7 +209,7 @@ export class SettlementContract extends SmartContract {
       toNetworkState: outputNetworkState,
       currentL1Block: minBlockIncluded,
     };
-    this.hooks.forEach((hook) => {
+    hooks.forEach((hook) => {
       hook.beforeSettlement(this, inputs);
     });
 
@@ -256,6 +218,10 @@ export class SettlementContract extends SmartContract {
       blockProof.publicInput.stateRoot,
       "Input state root not matching"
     );
+    Provable.log("Network State Hash ", networkStateHash);
+    Provable.log("input Hash ", inputNetworkState.hash());
+    Provable.log("Proof Hash ", blockProof.publicInput.networkStateHash);
+
     networkStateHash.assertEquals(
       blockProof.publicInput.networkStateHash,
       "Input networkStateHash not matching"
@@ -273,69 +239,27 @@ export class SettlementContract extends SmartContract {
       blockProof.publicOutput.incomingMessagesHash,
       "Promised messages not honored"
     );
-    this.honoredMessagesHash.set(promisedMessagesHash);
 
-    // Assert and apply new promisedMessagesHash
-    this.self.account.actionState.assertEquals(newPromisedMessagesHash);
-    this.promisedMessagesHash.set(newPromisedMessagesHash);
+    // Call DispatchContract
+    // This call checks that the promisedMessagesHash, which is already proven
+    // to be the blockProofs publicoutput, is actually the current on-chain
+    // promisedMessageHash. It also checks the newPromisedMessagesHash to be
+    // a current sequencestate value
+    dispatchContract.updateMessagesHash(
+      promisedMessagesHash,
+      newPromisedMessagesHash
+    );
 
     this.lastSettlementL1Block.set(minBlockIncluded);
   }
 
-  private dispatchMessage<Type>(
-    methodId: Field,
-    value: Type,
-    valueType: ProvableExtended<Type>
-  ) {
-    const args = valueType.toFields(value);
-    // Should be the same as RuntimeTransaction.hash
-    const argsHash = Poseidon.hash(args);
-    const runtimeTransaction = RuntimeTransaction.fromMessage({
-      methodId,
-      argsHash,
-    });
-
-    // Append tx to incomingMessagesHash
-    const actionData = runtimeTransaction.hashData();
-    const actionHash = MinaActions.actionHash(actionData);
-
-    this.self.body.actions = {
-      hash: actionHash,
-      data: [actionData],
-    };
-
-    const eventHash = MinaEvents.eventHash(args);
-    this.self.body.events = {
-      hash: eventHash,
-      data: [args],
-    };
-  }
-
-  @method
-  public deposit(amount: UInt64) {
-    // Save this, since otherwise it would be a second witness later,
-    // which could be a different values than the first
-    const sender = this.sender;
-
-    // Credit the amount to the bridge contract
-    this.self.balance.addInPlace(amount);
-
-    const action = new Deposit({
-      address: sender,
-      amount,
-    });
-    const methodId = Field(
-      this.methodIdMappings[this.incomingMessagesPaths["deposit"]]
-    );
-    this.dispatchMessage(methodId.toConstant(), action, Deposit);
-  }
-
   @method
   public rollupOutgoingMessages(batch: OutgoingMessageArgumentBatch) {
     let counter = this.outgoingMessageCursor.getAndAssertEquals();
     const stateRoot = this.stateRoot.getAndAssertEquals();
 
-    const [withdrawalModule, withdrawalStateName] = this.withdrawalStatePath;
+    const [withdrawalModule, withdrawalStateName] =
+      SettlementSmartContract.args.withdrawalStatePath;
     const mapPath = Path.fromProperty(withdrawalModule, withdrawalStateName);
 
     let accountCreationFeePaid = Field(0);
@@ -403,42 +327,3 @@ export class SettlementContract extends SmartContract {
     this.balance.subInPlace(amount);
   }
 }
-
-export interface SettlementContractModuleConfig {
-  withdrawalStatePath: `${string}.${string}`;
-  withdrawalMethodPath: `${string}.${string}`;
-  incomingMessagesMethods: Record<string, `${string}.${string}`>;
-}
-
-@injectable()
-export class SettlementContractModule extends ProtocolModule<SettlementContractModuleConfig> {
-  public constructor(
-    @injectAll("ProvableSettlementHook")
-    private readonly hooks: ProvableSettlementHook<unknown>[],
-    @inject("BlockProver")
-    private readonly blockProver: BlockProvable
-  ) {
-    super();
-    LazyBlockProof.tag = blockProver.zkProgrammable.zkProgram.Proof.tag;
-  }
-
-  public getContractClass(): typeof SettlementContract {
-    return SettlementContract;
-  }
-
-  public createContract(
-    address: PublicKey,
-    methodIdMappings: SettlementMethodIdMapping
-  ): SettlementContract {
-    // We know that this returns [string, string], but TS can't infer that
-    const withdrawalPath = this.config.withdrawalStatePath.split(".");
-
-    return new SettlementContract(
-      address,
-      methodIdMappings,
-      this.hooks,
-      [withdrawalPath[0], withdrawalPath[1]],
-      this.config.incomingMessagesMethods
-    );
-  }
-}

package/src/settlement/messages/Deposit.ts

@@ -0,0 +1,6 @@
+import { PublicKey, Struct, UInt64 } from "o1js";
+
+export class Deposit extends Struct({
+  address: PublicKey,
+  amount: UInt64,
+}) {}

package/src/settlement/messages/OutgoingMessageArgument.ts

@@ -0,0 +1,41 @@
+import { Bool, Provable, Struct } from "o1js";
+import { RollupMerkleTreeWitness } from "@proto-kit/common";
+import { Withdrawal } from "./Withdrawal";
+
+export const OUTGOING_MESSAGE_BATCH_SIZE = 1;
+
+export class OutgoingMessageArgument extends Struct({
+  witness: RollupMerkleTreeWitness,
+  value: Withdrawal,
+}) {
+  public static dummy(): OutgoingMessageArgument {
+    return new OutgoingMessageArgument({
+      witness: RollupMerkleTreeWitness.dummy(),
+      value: Withdrawal.dummy(),
+    });
+  }
+}
+
+export class OutgoingMessageArgumentBatch extends Struct({
+  arguments: Provable.Array(
+    OutgoingMessageArgument,
+    OUTGOING_MESSAGE_BATCH_SIZE
+  ),
+
+  isDummys: Provable.Array(Bool, OUTGOING_MESSAGE_BATCH_SIZE),
+}) {
+  public static fromMessages(providedArguments: OutgoingMessageArgument[]) {
+    const batch = providedArguments.slice();
+    const isDummys = batch.map(() => Bool(false));
+
+    while (batch.length < OUTGOING_MESSAGE_BATCH_SIZE) {
+      batch.push(OutgoingMessageArgument.dummy());
+      isDummys.push(Bool(true));
+    }
+
+    return new OutgoingMessageArgumentBatch({
+      arguments: batch,
+      isDummys,
+    });
+  }
+}

package/src/settlement/messages/Withdrawal.ts

@@ -0,0 +1,14 @@
+import { PublicKey, Struct, UInt64 } from "o1js";
+import { EMPTY_PUBLICKEY } from "@proto-kit/common";
+
+export class Withdrawal extends Struct({
+  address: PublicKey,
+  amount: UInt64,
+}) {
+  public static dummy() {
+    return new Withdrawal({
+      address: EMPTY_PUBLICKEY,
+      amount: UInt64.from(0),
+    });
+  }
+}

package/src/settlement/{ProvableSettlementHook.ts → modularity/ProvableSettlementHook.ts}

@@ -1,21 +1,18 @@
-import { Field, UInt32 } from "o1js";
+import { Field, PublicKey, UInt32 } from "o1js";
 
-import type { BlockProof } from "../prover/block/BlockProver";
-import { ProtocolModule } from "../protocol/ProtocolModule";
-import { NetworkState } from "../model/network/NetworkState";
+import type { BlockProof } from "../../prover/block/BlockProver";
+import { ProtocolModule } from "../../protocol/ProtocolModule";
+import { NetworkState } from "../../model/network/NetworkState";
 
-import type { SettlementContract } from "./SettlementContract";
+import type { SettlementSmartContract } from "../contracts/SettlementSmartContract";
 
 export type SettlementStateRecord = {
-  sequencerKey: Field;
+  sequencerKey: PublicKey;
   lastSettlementL1Block: UInt32;
 
   stateRoot: Field;
   networkStateHash: Field;
   blockHashRoot: Field;
-
-  promisedMessagesHash: Field;
-  honoredMessagesHash: Field;
 };
 
 export type SettlementHookInputs = {
@@ -31,7 +28,7 @@ export abstract class ProvableSettlementHook<
   Config
 > extends ProtocolModule<Config> {
   public abstract beforeSettlement(
-    smartContract: SettlementContract,
+    smartContract: SettlementSmartContract,
     inputs: SettlementHookInputs
   ): void;
 }

package/src/settlement/modules/NetworkStateSettlementModule.ts

@@ -3,8 +3,8 @@ import { UInt64 } from "o1js";
 import {
   ProvableSettlementHook,
   SettlementHookInputs,
-} from "../ProvableSettlementHook";
-import { SettlementContract } from "../SettlementContract";
+} from "../modularity/ProvableSettlementHook";
+import { SettlementSmartContract } from "../contracts/SettlementSmartContract";
 
 type NetworkStateSettlementModuleConfig = {
   blocksPerL1Block: UInt64;
@@ -12,7 +12,7 @@ type NetworkStateSettlementModuleConfig = {
 
 export class NetworkStateSettlementModule extends ProvableSettlementHook<NetworkStateSettlementModuleConfig> {
   public beforeSettlement(
-    smartContract: SettlementContract,
+    smartContract: SettlementSmartContract,
     {
       blockProof,
       fromNetworkState,

package/src/state/State.ts

@@ -72,7 +72,8 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
       .current().result;
 
     // First try to find a match inside already created stateTransitions
-    const previousMutatingTransitions = stateTransitions.filter((transition) =>
+    let previousMutatingTransitions: StateTransition<any>[] = [];
+    previousMutatingTransitions = stateTransitions.filter((transition) =>
       transition.path.equals(path).and(transition.to.isSome).toBoolean()
     );
     const pmtLength = previousMutatingTransitions.length;

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";
 
@@ -18,12 +18,14 @@ export function assert(condition: Bool, message?: string) {
   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);
+      }
+      executionContext.setStatusMessage(message);
     }
-    executionContext.setStatusMessage(message);
-  }
+  });
 
   executionContext.setStatus(status);
 }

package/src/state/context/RuntimeMethodExecutionContext.ts

@@ -29,10 +29,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,
@@ -125,7 +127,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/utils/MinaPrefixedProvableHashList.ts

@@ -1,4 +1,4 @@
-import { Field, FlexibleProvablePure, Poseidon } from "o1js";
+import { Field, Poseidon, ProvablePure } from "o1js";
 import { hashWithPrefix, prefixToField } from "@proto-kit/common";
 
 import { ProvableHashList } from "./ProvableHashList";
@@ -51,7 +51,7 @@ export class MinaPrefixedProvableHashList<
   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)
   ) {}
 
@@ -47,4 +47,4 @@ export class DefaultProvableHashList<Value> extends ProvableHashList<Value> {
   public hash(elements: Field[]): Field {
     return Poseidon.hash(elements);
   }
-}
+}