@proto-kit/protocol 0.1.1-develop.165 → 0.1.1-develop.185

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"}

package/dist/src/utils/ProvableHashList.js

@@ -1,43 +0,0 @@
-import { Circuit, Field, Poseidon } from "snarkyjs";
-/**
- * Utilities for creating a hash list from a given value type.
- */
-export class ProvableHashList {
-  constructor(valueType, commitment = Field(0)) {
-    this.valueType = valueType;
-    this.commitment = commitment;
-  }
-  /**
-   * 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) {
-    this.commitment = this.hash([
-      this.commitment,
-      ...this.valueType.toFields(value),
-    ]);
-    return this;
-  }
-  remove(preimage, value) {
-    const success = this.hash([
-      preimage,
-      ...this.valueType.toFields(value),
-    ]).equals(this.commitment);
-    this.commitment = Circuit.if(success, preimage, this.commitment);
-    return success;
-  }
-  /**
-   * @returns Traling hash of the current hashlist.
-   */
-  toField() {
-    return this.commitment;
-  }
-}
-export class DefaultProvableHashList extends ProvableHashList {
-  hash(e) {
-    return Poseidon.hash(e);
-  }
-}

package/dist/utils/PrefixedHashList.d.ts

@@ -1,14 +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(elements: Field[]): Field;
-}
-//# sourceMappingURL=PrefixedHashList.d.ts.map

package/dist/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;AAGzD,qBAAa,wBAAwB,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IAC1E,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,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAGzC"}

package/dist/utils/PrefixedHashList.js

@@ -1,12 +0,0 @@
-import { Field, Poseidon } from "snarkyjs";
-import { ProvableHashList } from "./ProvableHashList.js";
-import { stringToField } from "./Utils";
-export class PrefixedProvableHashList extends ProvableHashList {
-  constructor(valueType, prefix, internalCommitment = Field(0)) {
-    super(valueType, internalCommitment);
-    this.prefix = stringToField(prefix);
-  }
-  hash(elements) {
-    return Poseidon.hash([this.prefix, ...elements]);
-  }
-}

package/dist/utils/Utils.js

@@ -1,64 +0,0 @@
-// eslint-disable-next-line max-len
-/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/ban-types, @typescript-eslint/no-unsafe-return,@typescript-eslint/no-empty-function */
-import { Circuit, Field, Poseidon } from "snarkyjs";
-export function notInCircuit() {
-    return function ReplacedFunction(target, propertyKey, descriptor) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const childFunction = descriptor.value;
-        descriptor.value = function value(...args) {
-            if (Circuit.inCheckedComputation() || Circuit.inProver()) {
-                throw new Error(`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;
-    };
-}
-export function stringToField(value, throwOnOverflow = false) {
-    const fieldSize = Field.sizeInBytes();
-    // eslint-disable-next-line putout/putout
-    const encoder = new TextEncoder();
-    const stringBytes = Array.from(encoder.encode(value));
-    const padding = Array.from({
-        length: fieldSize - stringBytes.length,
-    }).fill(0);
-    const data = stringBytes.concat(padding);
-    if (data.length > fieldSize) {
-        if (throwOnOverflow) {
-            throw new Error("Trying to encode a stringt that is larger than 256 bits");
-        }
-        // Hash the result Field[] to reduce it to
-        const chunks = data.reduce((a, b, index) => {
-            const arrayIndex = index / fieldSize;
-            if (a.length <= arrayIndex) {
-                a.push([]);
-            }
-            a[arrayIndex].push(b);
-            return a;
-        }, []);
-        return Poseidon.hash(chunks.map((x) => Field.fromBytes(x)));
-    }
-    return Field.fromBytes(data);
-}
-/**
- * Note: This only works for strings that have been encoded using the `throwOnOverflow` set to true
- */
-export function fieldToString(value) {
-    if (typeof value === "bigint") {
-        value = Field(value);
-    }
-    let bytes = Field.toBytes(value);
-    // Find start of padded zeroes in order to remove them.
-    const zeroesStart = bytes.length -
-        bytes
-            .slice()
-            .reverse()
-            .findIndex((element) => element !== 0);
-    bytes = bytes.slice(0, zeroesStart);
-    // eslint-disable-next-line putout/putout
-    const decoder = new TextDecoder();
-    return decoder.decode(new Uint8Array(bytes));
-}
-export function noop() { }

package/dist/utils/merkletree/MemoryMerkleTreeStorage.d.ts

@@ -1,26 +0,0 @@
-import { type MerkleTreeStore, type SyncMerkleTreeStore } from "./RollupMerkleTree.js";
-export declare class NoOpMerkleTreeStorage implements SyncMerkleTreeStore {
-    parent: MerkleTreeStore;
-    openTransaction(): void;
-    commit(): void;
-    getNode(): bigint | undefined;
-    setNode(): void;
-    virtualize(): MerkleTreeStore;
-    getNodeAsync(): Promise<bigint | undefined>;
-    setNodeAsync(): Promise<void>;
-}
-export declare class MemoryMerkleTreeStorage implements SyncMerkleTreeStore {
-    private readonly nodes;
-    private readonly cache;
-    parent: SyncMerkleTreeStore;
-    constructor(parent?: SyncMerkleTreeStore | undefined);
-    openTransaction(): void;
-    commit(): void;
-    getNode(key: bigint, level: number): bigint | undefined;
-    setNode(key: bigint, level: number, value: bigint): void;
-    virtualize(): MerkleTreeStore;
-    getNodeAsync(key: bigint, level: number): Promise<bigint | undefined>;
-    setNodeAsync(key: bigint, level: number, value: bigint): Promise<void>;
-    cacheFromParent(index: bigint): Promise<void>;
-}
-//# sourceMappingURL=MemoryMerkleTreeStorage.d.ts.map

package/dist/utils/merkletree/MemoryMerkleTreeStorage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MemoryMerkleTreeStorage.d.ts","sourceRoot":"","sources":["../../../src/utils/merkletree/MemoryMerkleTreeStorage.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,mBAAmB,EACzB,MAAM,uBAAuB,CAAC;AAE/B,qBAAa,qBAAsB,YAAW,mBAAmB;IACxD,MAAM,EAAE,eAAe,CAAQ;IAE/B,eAAe,IAAI,IAAI;IAIvB,MAAM,IAAI,IAAI;IAId,OAAO,IAAI,MAAM,GAAG,SAAS;IAI7B,OAAO,IAAI,IAAI;IAIf,UAAU,IAAI,eAAe;IAIvB,YAAY,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAI3C,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;CAG3C;AAED,qBAAa,uBAAwB,YAAW,mBAAmB;IACjE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAGf;IAEP,OAAO,CAAC,QAAQ,CAAC,KAAK,CAGf;IAEA,MAAM,EAAE,mBAAmB,CAAC;gBAEhB,MAAM,GAAE,mBAAmB,GAAG,SAAqB;IAI/D,eAAe,IAAI,IAAI;IAIvB,MAAM,IAAI,IAAI;IAId,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAQvD,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAIxD,UAAU,IAAI,eAAe;IAIvB,YAAY,CACvB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAIjB,YAAY,CACvB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC;IAKH,eAAe,CAAC,KAAK,EAAE,MAAM;CAoB3C"}

package/dist/utils/merkletree/MemoryMerkleTreeStorage.js

@@ -1,79 +0,0 @@
-/* eslint-disable @typescript-eslint/no-magic-numbers */
-import { noop } from "../utils";
-import { RollupMerkleTree, } from "./RollupMerkleTree.js";
-export class NoOpMerkleTreeStorage {
-    constructor() {
-        this.parent = this;
-    }
-    openTransaction() {
-        noop();
-    }
-    commit() {
-        noop();
-    }
-    getNode() {
-        return undefined;
-    }
-    setNode() {
-        noop();
-    }
-    virtualize() {
-        return this;
-    }
-    async getNodeAsync() {
-        return undefined;
-    }
-    async setNodeAsync() {
-        return undefined;
-    }
-}
-export class MemoryMerkleTreeStorage {
-    constructor(parent = undefined) {
-        this.nodes = {};
-        this.cache = {};
-        this.parent = parent ?? new NoOpMerkleTreeStorage();
-    }
-    openTransaction() {
-        noop();
-    }
-    commit() {
-        noop();
-    }
-    getNode(key, level) {
-        return (this.nodes[level]?.[key.toString()] ??
-            this.cache[level]?.[key.toString()] ??
-            this.parent.getNode(key, level));
-    }
-    setNode(key, level, value) {
-        var _a;
-        ((_a = this.nodes)[level] ?? (_a[level] = {}))[key.toString()] = value;
-    }
-    virtualize() {
-        return new MemoryMerkleTreeStorage(this);
-    }
-    async getNodeAsync(key, level) {
-        return this.getNode(key, level);
-    }
-    async setNodeAsync(key, level, value) {
-        this.setNode(key, level, value);
-        return undefined;
-    }
-    async cacheFromParent(index) {
-        var _a;
-        // Algo from RollupMerkleTree.getWitness()
-        const { leafCount, height } = RollupMerkleTree;
-        if (index >= leafCount) {
-            index %= leafCount;
-        }
-        for (let level = 0; level < height - 1; level++) {
-            const isLeft = index % 2n === 0n;
-            const key = isLeft ? index + 1n : index - 1n;
-            // eslint-disable-next-line no-await-in-loop
-            const value = await this.parent.getNodeAsync(key, level);
-            if (value !== undefined) {
-                ((_a = this.nodes)[level] ?? (_a[level] = {}))[key.toString()] = value;
-            }
-            index /= 2n;
-        }
-    }
-}