@proto-kit/common 0.1.1-develop.187 → 0.1.1-develop.188

package/dist/prover/statetransition/StateTransitionWitnessProvider.js

@@ -1,17 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { injectable } from "tsyringe";
-import { RollupMerkleWitness } from "../../utils/merkletree/RollupMerkleTree.js";
-let NoOpStateTransitionWitnessProvider = class NoOpStateTransitionWitnessProvider {
-    getWitness() {
-        return new RollupMerkleWitness({ path: [], isLeft: [] });
-    }
-};
-NoOpStateTransitionWitnessProvider = __decorate([
-    injectable()
-], NoOpStateTransitionWitnessProvider);
-export { NoOpStateTransitionWitnessProvider };

package/dist/src/model/Option.d.ts

@@ -1,158 +0,0 @@
-import { Bool, Field, type FlexibleProvablePure } from "snarkyjs";
-export declare function ProvableOption(value: { isSome: Bool; value: Field }): {
-  isSome: {
-    toField: {};
-    not: {};
-    and: {};
-    or: {};
-    assertEquals: {};
-    assertTrue: {};
-    assertFalse: {};
-    equals: {};
-    sizeInFields: {};
-    toFields: {};
-    toString: {};
-    toJSON: {};
-    toBoolean: {};
-  };
-  value: {
-    neg: {};
-    inv: {};
-    add: {};
-    sub: {};
-    mul: {};
-    div: {};
-    square: {};
-    sqrt: {};
-    toString: {};
-    toBigInt: {};
-    toJSON: {};
-    sizeInFields: {};
-    toFields: {};
-    lessThan: {};
-    lessThanOrEqual: {};
-    greaterThan: {};
-    greaterThanOrEqual: {};
-    assertLessThan: {};
-    assertLessThanOrEqual: {};
-    assertGreaterThan: {};
-    assertGreaterThanOrEqual: {};
-    lt: {};
-    lte: {};
-    gt: {};
-    gte: {};
-    assertLt: {};
-    assertLte: {};
-    assertGt: {};
-    assertGte: {};
-    assertEquals: {};
-    assertBool: {};
-    assertBoolean: {};
-    isZero: {};
-    toBits: {};
-    equals: {};
-    seal: {};
-    rangeCheckHelper: {};
-    isConstant: {};
-    toConstant: {};
-    fromFields: {};
-  };
-};
-export type ProvableOptionStruct = ReturnType<typeof ProvableOption>;
-/**
- * Option facilitating in-circuit values that may or may not exist.
- */
-export declare class Option<Value> {
-  isSome: Bool;
-  value: Value;
-  valueType: FlexibleProvablePure<Value>;
-  /**
-   * Creates a new Option from the provided parameters
-   *
-   * @param isSome
-   * @param value
-   * @param valueType
-   * @returns New option from the provided parameters.
-   */
-  static from<Value>(
-    isSome: Bool,
-    value: Value,
-    valueType: FlexibleProvablePure<Value>
-  ): Option<Value>;
-  /**
-   * @returns Empty / none option
-   */
-  static none(): Option<Field>;
-  constructor(
-    isSome: Bool,
-    value: Value,
-    valueType: FlexibleProvablePure<Value>
-  );
-  /**
-   * @returns Tree representation of the current value
-   */
-  get treeValue(): Field;
-  /**
-   * @returns Provable representation of the current option.
-   */
-  toProvable(): {
-    isSome: {
-      toField: {};
-      not: {};
-      and: {};
-      or: {};
-      assertEquals: {};
-      assertTrue: {};
-      assertFalse: {};
-      equals: {};
-      sizeInFields: {};
-      toFields: {};
-      toString: {};
-      toJSON: {};
-      toBoolean: {};
-    };
-    value: {
-      neg: {};
-      inv: {};
-      add: {};
-      sub: {};
-      mul: {};
-      div: {};
-      square: {};
-      sqrt: {};
-      toString: {};
-      toBigInt: {};
-      toJSON: {};
-      sizeInFields: {};
-      toFields: {};
-      lessThan: {};
-      lessThanOrEqual: {};
-      greaterThan: {};
-      greaterThanOrEqual: {};
-      assertLessThan: {};
-      assertLessThanOrEqual: {};
-      assertGreaterThan: {};
-      assertGreaterThanOrEqual: {};
-      lt: {};
-      lte: {};
-      gt: {};
-      gte: {};
-      assertLt: {};
-      assertLte: {};
-      assertGt: {};
-      assertGte: {};
-      assertEquals: {};
-      assertBool: {};
-      assertBoolean: {};
-      isZero: {};
-      toBits: {};
-      equals: {};
-      seal: {};
-      rangeCheckHelper: {};
-      isConstant: {};
-      toConstant: {};
-      fromFields: {};
-    };
-  };
-}
-//# sourceMappingURL=Option.d.ts.map

package/dist/src/model/Option.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Option.d.ts","sourceRoot":"","sources":["../../../src/model/Option.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAW,KAAK,EAAE,KAAK,oBAAoB,EAAoB,MAAM,UAAU,CAAC;AAE7F,wBAAgB,cAAc,CAAC,KAAK,EAAE;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAInE;AAED,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAErE;;GAEG;AACH,qBAAa,MAAM,CAAC,KAAK;IAoBG,MAAM,EAAE,IAAI;IAAS,KAAK,EAAE,KAAK;IAAS,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAnB1G;;;;;;;OAOG;WACW,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAI5F;;OAEG;WACW,IAAI;gBAIQ,MAAM,EAAE,IAAI,EAAS,KAAK,EAAE,KAAK,EAAS,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAE1G;;OAEG;IACH,IAAW,SAAS,UAMnB;IAED;;OAEG;IACI,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMlB"}

package/dist/src/model/Option.js

@@ -1,53 +0,0 @@
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
-/* eslint-disable new-cap */
-/* eslint-disable max-classes-per-file */
-import { Bool, Circuit, Field, Poseidon, Struct } from "snarkyjs";
-export function ProvableOption(value) {
-  class ProvableOptionStruct extends Struct(value) {}
-  return new ProvableOptionStruct(value);
-}
-/**
- * Option facilitating in-circuit values that may or may not exist.
- */
-export class Option {
-  /**
-   * Creates a new Option from the provided parameters
-   *
-   * @param isSome
-   * @param value
-   * @param valueType
-   * @returns New option from the provided parameters.
-   */
-  static from(isSome, value, valueType) {
-    return new Option(isSome, value, valueType);
-  }
-  /**
-   * @returns Empty / none option
-   */
-  static none() {
-    return new Option(Bool(false), Field(0), Field);
-  }
-  constructor(isSome, value, valueType) {
-    this.isSome = isSome;
-    this.value = value;
-    this.valueType = valueType;
-  }
-  /**
-   * @returns Tree representation of the current value
-   */
-  get treeValue() {
-    const treeValue = Poseidon.hash(this.valueType.toFields(this.value));
-    // if the sequencer claims the value is `None`,
-    // then we use Field(0) as the treeValue so it can be proven later
-    return Circuit.if(this.isSome, treeValue, Field(0));
-  }
-  /**
-   * @returns Provable representation of the current option.
-   */
-  toProvable() {
-    return ProvableOption({
-      isSome: this.isSome,
-      value: this.treeValue,
-    });
-  }
-}

package/dist/src/model/Path.d.ts

@@ -1,35 +0,0 @@
-import { Field, type FlexibleProvablePure } from "snarkyjs";
-/**
- * Helps manage path (key) identifiers for key-values in trees.
- */
-export declare class Path {
-  /**
-   * Encodes a JS string as a Field
-   *
-   * @param value
-   * @returns Field representation of the provided value
-   */
-  static toField(value: string): Field;
-  /**
-   * Encodes a class name and its property name into a Field
-   *
-   * @param className
-   * @param propertyKey
-   * @returns Field representation of class name + property name
-   */
-  static fromProperty(className: string, propertyKey: string): Field;
-  /**
-   * Encodes an existing path with the provided key into a single Field.
-   *
-   * @param path
-   * @param keyType
-   * @param key
-   * @returns Field representation of the leading path + the provided key.
-   */
-  static fromKey<KeyType>(
-    path: Field,
-    keyType: FlexibleProvablePure<KeyType>,
-    key: KeyType
-  ): Field;
-}
-//# sourceMappingURL=Path.d.ts.map

package/dist/src/model/Path.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Path.d.ts","sourceRoot":"","sources":["../../../src/model/Path.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,EAAE,KAAK,oBAAoB,EAAY,MAAM,UAAU,CAAC;AAEtE;;GAEG;AACH,qBAAa,IAAI;IACf;;;;;OAKG;WACW,OAAO,CAAC,KAAK,EAAE,MAAM;IAUnC;;;;;;OAMG;WACW,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,KAAK;IAQzE;;;;;;;OAOG;WACW,OAAO,CAAC,OAAO,EAC3B,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACtC,GAAG,EAAE,OAAO,GACX,KAAK;CAIT"}

package/dist/src/model/Path.js

@@ -1,51 +0,0 @@
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
-/* eslint-disable new-cap */
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-/* eslint-disable @shopify/no-fully-static-classes */
-/* eslint-disable import/prefer-default-export */
-import { Field, Poseidon } from "snarkyjs";
-/**
- * Helps manage path (key) identifiers for key-values in trees.
- */
-export class Path {
-  /**
-   * Encodes a JS string as a Field
-   *
-   * @param value
-   * @returns Field representation of the provided value
-   */
-  static toField(value) {
-    const fields = value
-      .split("")
-      .map((character) => character.codePointAt(0))
-      .filter((code) => code !== undefined)
-      .map((code) => Field(code));
-    return Poseidon.hash(fields);
-  }
-  /**
-   * Encodes a class name and its property name into a Field
-   *
-   * @param className
-   * @param propertyKey
-   * @returns Field representation of class name + property name
-   */
-  static fromProperty(className, propertyKey) {
-    return Poseidon.hash([
-      Path.toField(className),
-      Path.toField(propertyKey),
-      Field(0),
-    ]);
-  }
-  /**
-   * Encodes an existing path with the provided key into a single Field.
-   *
-   * @param path
-   * @param keyType
-   * @param key
-   * @returns Field representation of the leading path + the provided key.
-   */
-  static fromKey(path, keyType, key) {
-    const keyHash = Poseidon.hash(keyType.toFields(key));
-    return Poseidon.hash([path, keyHash]);
-  }
-}

package/dist/src/model/StateTransition.d.ts

@@ -1,201 +0,0 @@
-import { Field } from "snarkyjs";
-import { Option, ProvableOptionStruct } from "./Option.js";
-/**
- * Provable representation of a State Transition, used to
- * normalize state transitions of various value types for
- * the state transition circuit.
- */
-export declare function ProvableStateTransition(value: {
-  path: Field;
-  from: ProvableOptionStruct;
-  to: ProvableOptionStruct;
-}): {
-  path: {
-    neg: {};
-    inv: {};
-    add: {};
-    sub: {};
-    mul: {};
-    div: {};
-    square: {};
-    sqrt: {};
-    toString: {};
-    toBigInt: {};
-    toJSON: {};
-    sizeInFields: {};
-    toFields: {};
-    lessThan: {};
-    lessThanOrEqual: {};
-    greaterThan: {};
-    greaterThanOrEqual: {};
-    assertLessThan: {};
-    assertLessThanOrEqual: {};
-    assertGreaterThan: {};
-    assertGreaterThanOrEqual: {};
-    lt: {};
-    lte: {};
-    gt: {};
-    gte: {};
-    assertLt: {};
-    assertLte: {};
-    assertGt: {};
-    assertGte: {};
-    assertEquals: {};
-    assertBool: {};
-    assertBoolean: {};
-    isZero: {};
-    toBits: {};
-    equals: {};
-    seal: {};
-    rangeCheckHelper: {};
-    isConstant: {};
-    toConstant: {};
-    fromFields: {};
-  };
-  from: {
-    isSome: {
-      toField: {};
-      not: {};
-      and: {};
-      or: {};
-      assertEquals: {};
-      assertTrue: {};
-      assertFalse: {};
-      equals: {};
-      sizeInFields: {};
-      toFields: {};
-      toString: {};
-      toJSON: {};
-      toBoolean: {};
-    };
-    value: {
-      neg: {};
-      inv: {};
-      add: {};
-      sub: {};
-      mul: {};
-      div: {};
-      square: {};
-      sqrt: {};
-      toString: {};
-      toBigInt: {};
-      toJSON: {};
-      sizeInFields: {};
-      toFields: {};
-      lessThan: {};
-      lessThanOrEqual: {};
-      greaterThan: {};
-      greaterThanOrEqual: {};
-      assertLessThan: {};
-      assertLessThanOrEqual: {};
-      assertGreaterThan: {};
-      assertGreaterThanOrEqual: {};
-      lt: {};
-      lte: {};
-      gt: {};
-      gte: {};
-      assertLt: {};
-      assertLte: {};
-      assertGt: {};
-      assertGte: {};
-      assertEquals: {};
-      assertBool: {};
-      assertBoolean: {};
-      isZero: {};
-      toBits: {};
-      equals: {};
-      seal: {};
-      rangeCheckHelper: {};
-      isConstant: {};
-      toConstant: {};
-      fromFields: {};
-    };
-  };
-  to: {
-    isSome: {
-      toField: {};
-      not: {};
-      and: {};
-      or: {};
-      assertEquals: {};
-      assertTrue: {};
-      assertFalse: {};
-      equals: {};
-      sizeInFields: {};
-      toFields: {};
-      toString: {};
-      toJSON: {};
-      toBoolean: {};
-    };
-    value: {
-      neg: {};
-      inv: {};
-      add: {};
-      sub: {};
-      mul: {};
-      div: {};
-      square: {};
-      sqrt: {};
-      toString: {};
-      toBigInt: {};
-      toJSON: {};
-      sizeInFields: {};
-      toFields: {};
-      lessThan: {};
-      lessThanOrEqual: {};
-      greaterThan: {};
-      greaterThanOrEqual: {};
-      assertLessThan: {};
-      assertLessThanOrEqual: {};
-      assertGreaterThan: {};
-      assertGreaterThanOrEqual: {};
-      lt: {};
-      lte: {};
-      gt: {};
-      gte: {};
-      assertLt: {};
-      assertLte: {};
-      assertGt: {};
-      assertGte: {};
-      assertEquals: {};
-      assertBool: {};
-      assertBoolean: {};
-      isZero: {};
-      toBits: {};
-      equals: {};
-      seal: {};
-      rangeCheckHelper: {};
-      isConstant: {};
-      toConstant: {};
-      fromFields: {};
-    };
-  };
-};
-export type ProvableStateTransitionStruct = ReturnType<
-  typeof ProvableStateTransition
->;
-/**
- * Generic state transition that constraints the current method circuit
- * to external state, by providing a state anchor.
- */
-export declare class StateTransition<Value> {
-  path: Field;
-  from: Option<Field> | Option<Value>;
-  to: Option<Field> | Option<Value>;
-  toValue?: Value | undefined;
-  static from<Value>(path: Field, from: Option<Value>): StateTransition<Value>;
-  static fromTo<Value>(
-    path: Field,
-    from: Option<Field> | Option<Value>,
-    to: Option<Field> | Option<Value>,
-    toValue: Value
-  ): StateTransition<Value>;
-  constructor(
-    path: Field,
-    from: Option<Field> | Option<Value>,
-    to: Option<Field> | Option<Value>,
-    toValue?: Value | undefined
-  );
-  toProvable(): ProvableStateTransitionStruct;
-}
-//# sourceMappingURL=StateTransition.d.ts.map

package/dist/src/model/StateTransition.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StateTransition.d.ts","sourceRoot":"","sources":["../../../src/model/StateTransition.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,EAAU,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAE3D;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,oBAAoB,CAAC;IAAC,EAAE,EAAE,oBAAoB,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAInH;AAED,MAAM,MAAM,6BAA6B,GAAG,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEvF;;;GAGG;AACH,qBAAa,eAAe,CAAC,KAAK;IAYvB,IAAI,EAAE,KAAK;IACX,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IACnC,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IACjC,OAAO,CAAC;WAdH,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC;WAK5C,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,KAAK;gBAMtH,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,EACnC,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,EACjC,OAAO,CAAC,mBAAO;IAGjB,UAAU,IAAI,6BAA6B;CAOnD"}

package/dist/src/model/StateTransition.js

@@ -1,43 +0,0 @@
-/* eslint-disable import/no-unused-modules */
-/* eslint-disable max-classes-per-file */
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
-/* eslint-disable new-cap */
-/* eslint-disable import/prefer-default-export */
-import { Struct } from "snarkyjs";
-import { Option } from "./Option.js";
-/**
- * Provable representation of a State Transition, used to
- * normalize state transitions of various value types for
- * the state transition circuit.
- */
-export function ProvableStateTransition(value) {
-  class ProvableStateTransitionStruct extends Struct(value) {}
-  return new ProvableStateTransitionStruct(value);
-}
-/**
- * Generic state transition that constraints the current method circuit
- * to external state, by providing a state anchor.
- */
-export class StateTransition {
-  static from(path, from) {
-    return new StateTransition(path, from, Option.none());
-  }
-  // eslint-disable-next-line max-params
-  static fromTo(path, from, to, toValue) {
-    return new StateTransition(path, from, to, toValue);
-  }
-  // eslint-disable-next-line max-params
-  constructor(path, from, to, toValue) {
-    this.path = path;
-    this.from = from;
-    this.to = to;
-    this.toValue = toValue;
-  }
-  toProvable() {
-    return ProvableStateTransition({
-      path: this.path,
-      from: this.from.toProvable(),
-      to: this.to.toProvable(),
-    });
-  }
-}

package/dist/src/utils/PrefixedHashList.d.ts

@@ -1,15 +0,0 @@
-import { Field, FlexibleProvablePure } from "snarkyjs";
-import { ProvableHashList } from "./ProvableHashList.js";
-export declare class PrefixedProvableHashList<
-  Value
-> extends ProvableHashList<Value> {
-  private readonly prefix;
-  constructor(
-    valueType: FlexibleProvablePure<Value>,
-    prefix: string,
-    internalCommitment?: Field
-  );
-  protected hash(e: Field[]): Field;
-}
-export declare function prefixToField(prefix: string): Field;
-//# sourceMappingURL=PrefixedHashList.d.ts.map

package/dist/src/utils/PrefixedHashList.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefixedHashList.d.ts","sourceRoot":"","sources":["../../../src/utils/PrefixedHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAY,MAAM,UAAU,CAAC;AAEjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,qBAAa,wBAAwB,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IAE1E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;gBAG7B,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,EACtC,MAAM,EAAE,MAAM,EACd,kBAAkB,GAAE,KAAgB;IAMtC,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,KAAK;CAIlC;AAGD,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,SAmB3C"}

package/dist/src/utils/PrefixedHashList.js

@@ -1,28 +0,0 @@
-import { Field, Poseidon } from "snarkyjs";
-import { TextEncoder } from "node:util";
-import { ProvableHashList } from "./ProvableHashList.js";
-export class PrefixedProvableHashList extends ProvableHashList {
-  constructor(valueType, prefix, internalCommitment = Field(0)) {
-    super(valueType, internalCommitment);
-    this.prefix = prefixToField(prefix);
-  }
-  hash(e) {
-    return Poseidon.hash([this.prefix, ...e]);
-  }
-}
-export function prefixToField(prefix) {
-  const fieldSize = Field.sizeInBytes();
-  if (prefix.length >= fieldSize) {
-    throw new Error("prefix too long");
-  }
-  const encoder = new TextEncoder();
-  function stringToBytes(s) {
-    return Array.from(encoder.encode(s));
-  }
-  const stringBytes = stringToBytes(prefix);
-  const padding = Array.from({ length: fieldSize - stringBytes.length }).fill(
-    0
-  );
-  const data = stringBytes.concat(padding);
-  return Field.fromBytes(data);
-}

package/dist/src/utils/ProvableHashList.d.ts

@@ -1,30 +0,0 @@
-import { type Bool, Field } from "snarkyjs";
-import { FlexibleProvablePure } from "snarkyjs";
-/**
- * Utilities for creating a hash list from a given value type.
- */
-export declare abstract class ProvableHashList<Value> {
-  private readonly valueType;
-  commitment: Field;
-  constructor(valueType: FlexibleProvablePure<Value>, commitment?: Field);
-  protected abstract hash(e: Field[]): Field;
-  /**
-   * Converts the provided value to Field[] and appends it to
-   * the current hashlist.
-   *
-   * @param value - Value to be appended to the hash list
-   * @returns Current hash list.
-   */
-  push(value: Value): this;
-  remove(preimage: Field, value: Value): Bool;
-  /**
-   * @returns Traling hash of the current hashlist.
-   */
-  toField(): Field;
-}
-export declare class DefaultProvableHashList<
-  Value
-> extends ProvableHashList<Value> {
-  hash(e: Field[]): Field;
-}
-//# sourceMappingURL=ProvableHashList.d.ts.map

package/dist/src/utils/ProvableHashList.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ProvableHashList.d.ts","sourceRoot":"","sources":["../../../src/utils/ProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAW,KAAK,EAAY,MAAM,UAAU,CAAC;AAC/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAGhD;;GAEG;AACH,8BAAsB,gBAAgB,CAAC,KAAK;IAGxC,OAAO,CAAC,QAAQ,CAAC,SAAS;IACnB,UAAU,EAAE,KAAK;gBADP,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,EAChD,UAAU,GAAE,KAAgB;IAIrC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,KAAK;IAE1C;;;;;;OAMG;IACI,IAAI,CAAC,KAAK,EAAE,KAAK;IAKjB,MAAM,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAMlD;;OAEG;IACI,OAAO;CAIf;AAED,qBAAa,uBAAuB,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IAElE,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,KAAK;CAI/B"}