@sabaaa1/common 0.0.9 → 0.0.12

package/src/data-structures/event-service/AbstractApprovalsSnapshotService.ts

@@ -1,152 +0,0 @@
-import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
-import { NewApprovedUtxoEvent } from '../../types/commitments.types';
-import { BlockchainEventEmitter } from './BlockchainEventEmitter';
-import { ApprovedUtxo } from '../../types/hinkal.types';
-import { toBigInt } from '../../functions/utils/amounts.utils';
-import { caseInsensitiveEqual } from '../../functions/utils/caseInsensitive.utils';
-
-export type ApprovalsSnapshotPayload = {
-  readonly approvals: Map<string, ApprovedUtxo[]>;
-  readonly events: Set<string>;
-};
-
-export type ApprovalsSerializedSnapshot = {
-  latestBlockNumber?: number;
-  approvals: Record<string, ApprovedUtxo<string>[]>;
-  events: string[];
-};
-
-export abstract class AbstractApprovalsSnapshotService extends AbstractSnapshotService<
-  NewApprovedUtxoEvent,
-  NewApprovedUtxoEvent<string>,
-  ApprovalsSnapshotPayload,
-  ApprovalsSerializedSnapshot
-> {
-  constructor(hinkalEventEmitter: BlockchainEventEmitter) {
-    super(hinkalEventEmitter, 'NewApprovedUtxo');
-  }
-
-  private _approvals = new Map<string, ApprovedUtxo[]>();
-
-  public events = new Set<string>();
-
-  get approvals() {
-    return this._approvals;
-  }
-
-  private getEventKey(inHinkalAddress: bigint, tokenAddress: string, txHash: string) {
-    if (typeof inHinkalAddress !== 'bigint' || typeof txHash !== 'string' || typeof tokenAddress !== 'string')
-      return null;
-    return `${txHash}-${tokenAddress}-${inHinkalAddress}`;
-  }
-
-  protected override serializeSnapshot(snapshot: Snapshot<ApprovalsSnapshotPayload>): ApprovalsSerializedSnapshot {
-    const approvalObject = Object.fromEntries(snapshot.payload.approvals);
-
-    const serializedApprovalsArray = Object.entries<ApprovedUtxo[]>(approvalObject).map(([address, utxos]) => {
-      const newUtxos = utxos.map<ApprovedUtxo<string>>((utxo) => ({
-        amount: utxo.amount.toString(),
-        tokenAddress: utxo.tokenAddress,
-        inHinkalAddress: utxo.inHinkalAddress.toString(),
-      }));
-      return [address, newUtxos] as [string, ApprovedUtxo<string>[]];
-    });
-
-    const serializedApprovals = Object.fromEntries(serializedApprovalsArray) as Record<string, ApprovedUtxo<string>[]>;
-
-    return {
-      latestBlockNumber: snapshot.latestBlockNumber,
-      approvals: serializedApprovals,
-      events: [...this.events],
-    };
-  }
-
-  protected override deserializeSnapshot(
-    serializedSnapshot: ApprovalsSerializedSnapshot,
-  ): Snapshot<ApprovalsSnapshotPayload> {
-    const serializedApprovalsObject = serializedSnapshot.approvals;
-    const deserializedApprovalsArray = Object.entries<ApprovedUtxo<string>[]>(serializedApprovalsObject).map(
-      ([address, utxos]) => {
-        const newUtxos = utxos.map<ApprovedUtxo<bigint>>((utxo) => ({
-          amount: BigInt(utxo.amount),
-          tokenAddress: utxo.tokenAddress,
-          inHinkalAddress: BigInt(utxo.inHinkalAddress),
-        }));
-        return [address, newUtxos] as [string, ApprovedUtxo<bigint>[]];
-      },
-    );
-
-    const deserializedApprovals = new Map<string, ApprovedUtxo<bigint>[]>(deserializedApprovalsArray);
-
-    return {
-      latestBlockNumber: serializedSnapshot.latestBlockNumber ?? 0,
-      payload: {
-        approvals: deserializedApprovals,
-        events: new Set(serializedSnapshot.events),
-      },
-    };
-  }
-
-  protected override getSnapshotPayload() {
-    return {
-      approvals: this._approvals,
-      events: this.events,
-    };
-  }
-
-  protected override populateSnapshot({ payload: { approvals, events } }: Snapshot<ApprovalsSnapshotPayload>) {
-    this._approvals = approvals;
-    this.events = events;
-  }
-
-  protected override mapEvent(event: NewApprovedUtxoEvent<string>): NewApprovedUtxoEvent {
-    const { approveTo, tokenAddress, amount, inHinkalAddress } = event;
-    return {
-      approveTo,
-      tokenAddress,
-      amount: toBigInt(amount),
-      inHinkalAddress: toBigInt(inHinkalAddress),
-    };
-  }
-
-  protected acceptEvent(event: NewApprovedUtxoEvent, _blockNumber: number, txHash: string): boolean {
-    const eventKey = this.getEventKey(event.inHinkalAddress, event.tokenAddress, txHash);
-    if (eventKey && !this.events.has(eventKey)) {
-      const { amount, tokenAddress, inHinkalAddress } = event;
-      const value: ApprovedUtxo = {
-        amount,
-        tokenAddress,
-        inHinkalAddress,
-      };
-
-      let existingApprovals = this.approvals.get(event.approveTo) || [];
-
-      let foundEntry = false;
-      for (let i = 0; i < existingApprovals.length; i += 1) {
-        if (
-          caseInsensitiveEqual(tokenAddress, existingApprovals[i].tokenAddress) &&
-          inHinkalAddress === existingApprovals[i].inHinkalAddress
-        ) {
-          existingApprovals[i].amount += amount;
-          foundEntry = true;
-        }
-      }
-
-      // clearing out zero amount entries from approvals
-      existingApprovals = existingApprovals.filter((el) => el.amount !== 0n);
-
-      if (foundEntry && existingApprovals.length === 0) {
-        this.approvals.delete(event.approveTo);
-      } else {
-        const newApprovals: ApprovedUtxo[] = foundEntry ? existingApprovals : [...existingApprovals, value];
-        this.approvals.set(event.approveTo, newApprovals);
-      }
-
-      if (txHash) {
-        this.events.add(eventKey);
-      }
-      return true;
-    }
-    return false;
-  }
-}

package/src/data-structures/event-service/AbstractCommitmentsSnapshotService.ts

@@ -1,116 +0,0 @@
-import { poseidonFunction } from '../../crypto';
-import { MerkleTree, MerkleTreeJson } from '../merkle-tree';
-import { CommitmentEvent, EncryptedOutputWithSign } from '../../types';
-import { toBigInt } from '../../functions/utils/amounts.utils';
-import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
-import { contructMerkleTreeFromSerialized } from '../../functions/utils/merkleTree.utils';
-import { BlockchainEventEmitter } from './BlockchainEventEmitter';
-
-export type CommitmentsSnapshotPayload = {
-  readonly merkleTree: MerkleTree<bigint>;
-  readonly encryptedOutputs: EncryptedOutputWithSign[];
-};
-
-export type CommitmentsSerializedSnapshot = {
-  latestBlockNumber?: number;
-  merkleTree?: MerkleTreeJson;
-  encryptedOutputs?: EncryptedOutputWithSign<string>[];
-};
-
-export abstract class AbstractCommitmentsSnapshotService extends AbstractSnapshotService<
-  CommitmentEvent<bigint>,
-  CommitmentEvent,
-  CommitmentsSnapshotPayload,
-  CommitmentsSerializedSnapshot
-> {
-  constructor(hinkalEventEmitter: BlockchainEventEmitter) {
-    super(hinkalEventEmitter, 'NewCommitment');
-  }
-
-  private _merkleTree!: MerkleTree<bigint>;
-
-  private _encryptedOutputs!: EncryptedOutputWithSign[];
-
-  get merkleTree() {
-    return this._merkleTree;
-  }
-
-  get encryptedOutputs() {
-    return this._encryptedOutputs;
-  }
-
-  protected override serializeSnapshot(snapshot: Snapshot<CommitmentsSnapshotPayload>): CommitmentsSerializedSnapshot {
-    return {
-      merkleTree: snapshot.payload.merkleTree.toJSON(),
-      latestBlockNumber: snapshot.latestBlockNumber,
-      encryptedOutputs: snapshot.payload.encryptedOutputs.map((output) => ({
-        value: output.value,
-        isPositive: String(output.isPositive),
-      })),
-    };
-  }
-
-  protected override deserializeSnapshot(
-    serializedSnapshot: CommitmentsSerializedSnapshot,
-  ): Snapshot<CommitmentsSnapshotPayload> {
-    let merkleTree: MerkleTree<bigint>;
-    if (serializedSnapshot.latestBlockNumber && serializedSnapshot.merkleTree) {
-      merkleTree = contructMerkleTreeFromSerialized(serializedSnapshot.merkleTree);
-    } else {
-      merkleTree = MerkleTree.create(poseidonFunction, 0n);
-    }
-    const encryptedOutputsWithSign = serializedSnapshot.encryptedOutputs?.map((output) => ({
-      value: output.value,
-      isPositive: JSON.parse(output.isPositive) as boolean,
-    }));
-
-    return {
-      latestBlockNumber: serializedSnapshot.latestBlockNumber ?? 0,
-      payload: {
-        merkleTree,
-        encryptedOutputs: encryptedOutputsWithSign || [],
-      },
-    };
-  }
-
-  protected override getSnapshotPayload() {
-    return {
-      merkleTree: this._merkleTree,
-      encryptedOutputs: this._encryptedOutputs,
-    };
-  }
-
-  protected override populateSnapshot({
-    payload: { merkleTree, encryptedOutputs },
-  }: Snapshot<CommitmentsSnapshotPayload>) {
-    this._merkleTree = merkleTree;
-    this._encryptedOutputs = encryptedOutputs;
-  }
-
-  protected override mapEvent(event: CommitmentEvent): CommitmentEvent<bigint> {
-    const { commitment, index, encryptedOutput } = event;
-    return {
-      commitment: toBigInt(commitment),
-      index: toBigInt(index),
-      encryptedOutput,
-    };
-  }
-
-  protected acceptEvent(event: CommitmentEvent<bigint>, _blockNumber: number): boolean {
-    if (!this.encryptedOutputs.map((output) => output.value).includes(event.encryptedOutput)) {
-      const success = this._merkleTree.insert(event.commitment, event.index >= 0 ? event.index : -1n * event.index);
-      if (!success) {
-        // could not insert: because of mt having that node index
-        return false;
-      }
-
-      const encryptedOutputWithSign: EncryptedOutputWithSign = {
-        value: event.encryptedOutput,
-        isPositive: event.index >= 0n,
-      };
-      this._encryptedOutputs.push(encryptedOutputWithSign);
-      return true;
-    }
-    return false;
-  }
-}

package/src/data-structures/event-service/AbstractEventService.ts

@@ -1,44 +0,0 @@
-import { ethers } from 'ethers';
-import { resolveSync } from '../../functions/utils/resolve-sync.utils';
-import { BlockchainEventEmitter } from './BlockchainEventEmitter';
-
-export abstract class AbstractEventService<EventType, SerializedEventType = unknown> {
-  protected blockchainEventEmitter: BlockchainEventEmitter;
-
-  protected readonly eventName: string;
-
-  protected constructor(blockchainEventEmitter: BlockchainEventEmitter, eventName: string) {
-    this.blockchainEventEmitter = blockchainEventEmitter;
-    this.eventName = eventName;
-    blockchainEventEmitter.addEventProcessorFunction(this.processEventsPage.bind(this));
-  }
-
-  get latestBlockNumber() {
-    return this.blockchainEventEmitter.latestBlockNumber;
-  }
-
-  intervalClear() {
-    this.blockchainEventEmitter.intervalClear();
-  }
-
-  private async processEventsPage(events: ethers.Event[]): Promise<number> {
-    const mappedEvents: EventType[] = [];
-    await resolveSync(
-      events.map((event) => async () => {
-        if (event.event !== this.eventName) return;
-        const { args, blockNumber, transactionHash } = event;
-        if (!args) throw new Error('Wrong event structure');
-        const mappedEvent = this.mapEvent(args as SerializedEventType);
-        const success = await this.acceptEvent(mappedEvent, blockNumber, transactionHash);
-        if (success) mappedEvents.push(mappedEvent);
-      }),
-    );
-    const eventsCount = mappedEvents.length;
-    await this.afterEventsAccepted(eventsCount);
-    return mappedEvents.length;
-  }
-
-  protected abstract acceptEvent(event: EventType, blockNumber: number, txHash?: string): boolean | Promise<boolean>;
-  protected abstract mapEvent(event: SerializedEventType): EventType;
-  protected abstract afterEventsAccepted(eventsCount: number): Promise<void>;
-}

package/src/data-structures/event-service/AbstractNullifierSnapshotService.ts

@@ -1,76 +0,0 @@
-import { BigNumber } from 'ethers';
-import { NullifierEvent } from '../../types/commitments.types';
-import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
-import { BlockchainEventEmitter } from './BlockchainEventEmitter';
-
-export type NullifierSnapshotPayload = {
-  readonly nullifiers: Set<string>;
-};
-
-export type NullifierSerializedSnapshot = {
-  latestBlockNumber?: number;
-  nullifiers?: string[];
-};
-
-export abstract class AbstractNullifierSnapshotService extends AbstractSnapshotService<
-  NullifierEvent<string>,
-  NullifierEvent<BigNumber>,
-  NullifierSnapshotPayload,
-  NullifierSerializedSnapshot
-> {
-  constructor(hinkalEventEmitter: BlockchainEventEmitter) {
-    super(hinkalEventEmitter, 'Nullified');
-  }
-
-  private _nullifiers!: Set<string>;
-
-  get nullifiers() {
-    return this._nullifiers;
-  }
-
-  protected override serializeSnapshot(snapshot: Snapshot<NullifierSnapshotPayload>): NullifierSerializedSnapshot {
-    return {
-      nullifiers: Array.from(snapshot.payload.nullifiers).map((value) => value.toString()),
-      latestBlockNumber: snapshot.latestBlockNumber,
-    };
-  }
-
-  protected override deserializeSnapshot(
-    serializedSnapshot: NullifierSerializedSnapshot,
-  ): Snapshot<NullifierSnapshotPayload> {
-    return {
-      latestBlockNumber: serializedSnapshot.latestBlockNumber ?? 0,
-      payload: {
-        nullifiers: new Set(serializedSnapshot.nullifiers ?? []),
-      },
-    };
-  }
-
-  protected acceptEvent(event: NullifierEvent<string>, _blockNumber: number): boolean {
-    try {
-      if (this._nullifiers.has(event.nullifier)) return false;
-      this._nullifiers.add(event.nullifier);
-      return true;
-    } catch (err) {
-      console.error(err);
-      return false;
-    }
-  }
-
-  protected override mapEvent(event: NullifierEvent<BigNumber>): NullifierEvent<string> {
-    const { nullifier } = event;
-    return {
-      nullifier: nullifier.toHexString(),
-    };
-  }
-
-  protected override getSnapshotPayload(): NullifierSnapshotPayload {
-    return {
-      nullifiers: this._nullifiers,
-    };
-  }
-
-  protected override populateSnapshot({ payload: { nullifiers } }: Snapshot<NullifierSnapshotPayload>) {
-    this._nullifiers = nullifiers;
-  }
-}

package/src/data-structures/event-service/AbstractSnapshotService.ts

@@ -1,63 +0,0 @@
-import { saveDepths } from '../../constants/save-depths';
-import { AbstractEventService } from './AbstractEventService';
-import { BlockchainEventEmitter } from './BlockchainEventEmitter';
-
-export interface Snapshot<SnapshotPayloadType> {
-  readonly latestBlockNumber: number;
-  readonly payload: SnapshotPayloadType;
-}
-
-export abstract class AbstractSnapshotService<
-  EventType,
-  SerializedEventType,
-  SnapshotPayloadType,
-  SerializedSnapshotType,
-> extends AbstractEventService<EventType, SerializedEventType> {
-  private savedLatestBlockNumber = 0;
-
-  private chainId = 0;
-
-  protected constructor(blockchainEventEmitter: BlockchainEventEmitter, eventName: string) {
-    super(blockchainEventEmitter, eventName);
-  }
-
-  async init() {
-    await this.loadSnapshot();
-    this.chainId = (await this.blockchainEventEmitter.contract.provider.getNetwork()).chainId;
-  }
-
-  async retrieveEventsFromLatestBlock() {
-    await this.blockchainEventEmitter.retrieveEvents(this.latestBlockNumber);
-  }
-
-  private async loadSnapshot() {
-    const fetchedSnapshot = await this.fetchSnapshot();
-    const snapshot = this.deserializeSnapshot(fetchedSnapshot);
-    this.populateSnapshot(snapshot);
-    this.blockchainEventEmitter.syncFromAtMost(snapshot.latestBlockNumber);
-    this.savedLatestBlockNumber = snapshot.latestBlockNumber;
-  }
-
-  protected saveSnapshot(): Promise<unknown> {
-    this.savedLatestBlockNumber = this.latestBlockNumber;
-    return this.persistSnapshot(
-      this.serializeSnapshot({
-        latestBlockNumber: this.latestBlockNumber,
-        payload: this.getSnapshotPayload(),
-      }),
-    );
-  }
-
-  protected override async afterEventsAccepted(eventsCount: number): Promise<void> {
-    if (eventsCount > 0 || this.savedLatestBlockNumber + saveDepths[this.chainId] < this.latestBlockNumber)
-      await this.saveSnapshot();
-  }
-
-  protected abstract getSnapshotPayload(): SnapshotPayloadType;
-  protected abstract populateSnapshot(snapshot: Snapshot<SnapshotPayloadType>): void;
-  protected abstract serializeSnapshot(snapshot: Snapshot<SnapshotPayloadType>): SerializedSnapshotType;
-  protected abstract deserializeSnapshot(serializedSnapshot: SerializedSnapshotType): Snapshot<SnapshotPayloadType>;
-
-  protected abstract fetchSnapshot(): Promise<SerializedSnapshotType>;
-  protected abstract persistSnapshot(serializedSnapshot: SerializedSnapshotType): Promise<unknown>;
-}

package/src/data-structures/event-service/BlockchainEventEmitter.ts

@@ -1,132 +0,0 @@
-import { ethers } from 'ethers';
-import { blockReorgDepth } from '../../constants/reorg-depths.constants';
-import { getSequence, resolveSync } from '../../functions/utils/resolve-sync.utils';
-import { balanceFetchingMutex } from '../../functions/utils/mutexes.utils';
-
-export type EventProcessorFunction = (events: ethers.Event[]) => Promise<number> | number;
-
-export class BlockchainEventEmitter {
-  public readonly contract: ethers.Contract;
-
-  private _latestBlockNumber: number | undefined;
-
-  private _initialBlockNumber;
-
-  public onEventsProcessed?: (acceptedEventCount: number) => void;
-
-  private eventProcessors = new Set<EventProcessorFunction>();
-
-  private readonly maxPageSize?: number;
-
-  private isReady = false;
-
-  private isServer: boolean;
-
-  private intervalId?: any;
-
-  private inProgress: boolean; // to remove race conditions
-
-  public constructor(contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, maxPageSize?: number) {
-    this.contract = contract;
-    this._initialBlockNumber = initialBlockNumber;
-    this.maxPageSize = maxPageSize;
-    this.isServer = isServer;
-    this.inProgress = false;
-  }
-
-  public get latestBlockNumber() {
-    return this._latestBlockNumber ?? this._initialBlockNumber;
-  }
-
-  public syncFromAtMost(blockNumber: number) {
-    // since multiple services may want to sync from differing block numbers we sync from the lowest value provided
-    if (this._latestBlockNumber === undefined || blockNumber < this._latestBlockNumber) {
-      this._latestBlockNumber = blockNumber;
-    }
-  }
-
-  public intervalClear() {
-    this.isReady = false;
-    this.eventProcessors = new Set<EventProcessorFunction>();
-    clearInterval(this.intervalId);
-  }
-
-  public async init() {
-    if (this.isReady) {
-      throw new Error('Already initialized');
-    }
-    this.isReady = true;
-    await this.retrieveEvents(this.latestBlockNumber + 1);
-
-    this.intervalId = setInterval(async () => {
-      await this.retrieveEvents(this.latestBlockNumber);
-    }, 3500);
-  }
-
-  private requireReady() {
-    if (!this.isReady) {
-      throw new Error('Not ready');
-    }
-  }
-
-  public addEventProcessorFunction(eventProcessorFunction: EventProcessorFunction) {
-    if (this.isReady) throw new Error("Can't add event processor after event emitter initialized");
-    this.eventProcessors.add(eventProcessorFunction);
-  }
-
-  private async getLastBlockNumberForEventRequest() {
-    const lastBlockchainBlockNumber = await this.contract.provider.getBlockNumber();
-    if (!this.isServer) return lastBlockchainBlockNumber;
-    // lastBlockchainBlockNumber is blocknumber of the latest confirmed block
-    // the events/transactions in the latest block will have block confirmation of 1
-    // as such we need to add + 1 here.
-    // Math.max used here since the snapshot file may contain latest block information already
-    const { chainId } = await this.contract.provider.getNetwork();
-    return Math.max(this.latestBlockNumber, lastBlockchainBlockNumber - blockReorgDepth[chainId] + 1);
-  }
-
-  public async retrieveEvents(fromBlockNumber: number, useForce = false): Promise<boolean> {
-    this.requireReady();
-    const result = await balanceFetchingMutex.runExclusive(async () => {
-      try {
-        if (this.inProgress && !useForce) return false;
-        this.inProgress = true;
-        let acceptedEventCount = 0;
-
-        const lastBlockNumber = await this.getLastBlockNumberForEventRequest();
-
-        if (lastBlockNumber < fromBlockNumber) {
-          this.inProgress = false;
-          return false;
-        }
-        const requestSequence = getSequence(fromBlockNumber, lastBlockNumber, this.maxPageSize);
-
-        const allEvents: ethers.Event[] = [];
-
-        await resolveSync(
-          requestSequence.map(({ from, to }) => async () => {
-            const events: ethers.Event[] = await this.contract.queryFilter('*', from, to);
-            allEvents.push(...events);
-          }),
-        );
-
-        const accepetedEventsArray = await Promise.all(
-          [...this.eventProcessors].map((eventProcessor) => {
-            return eventProcessor(allEvents);
-          }),
-        );
-        this._latestBlockNumber = lastBlockNumber;
-        acceptedEventCount += accepetedEventsArray.reduce((prev, cur) => prev + cur, 0);
-
-        this.onEventsProcessed?.(acceptedEventCount);
-        this.inProgress = false;
-        return true;
-      } catch (err: unknown) {
-        console.log('retrieveEvents error:', { err });
-        this.inProgress = false;
-        return false;
-      }
-    });
-    return result;
-  }
-}

package/src/data-structures/merkle-tree/MerkleTree.test.ts

@@ -1,77 +0,0 @@
-import { MerkleTree } from './MerkleTree';
-import { MerkleTreeIncompleteError } from './MerkleTreeIncompleteError';
-
-const testHashFunction = (a: string, b: string) => JSON.stringify([a, b]);
-
-describe('MerkleTree', () => {
-  test('should calculate root hash for 2 elements correctly', async () => {
-    const merkleTree = MerkleTree.create(testHashFunction, '', 2n);
-    const startIndex = merkleTree.getStartIndex();
-    merkleTree.insert('a', startIndex);
-    merkleTree.insert('b', startIndex + 1n);
-
-    expect(merkleTree.getRootHash()).toEqual(testHashFunction('a', 'b'));
-  });
-
-  test('should calculate root hash for multiple elements correctly', async () => {
-    const merkleTree = MerkleTree.create(testHashFunction, '', 3n);
-    const startIndex = merkleTree.getStartIndex();
-    merkleTree.insert('a', startIndex);
-    merkleTree.insert('b', startIndex + 1n);
-    merkleTree.insert('c', startIndex + 2n);
-    merkleTree.insert('d', startIndex + 3n);
-
-    expect(merkleTree.getRootHash()).toEqual(testHashFunction(testHashFunction('a', 'b'), testHashFunction('c', 'd')));
-  });
-
-  test('should calculate root hash correctly if elements are passed out of order', async () => {
-    const merkleTree = MerkleTree.create(testHashFunction, '', 3n);
-    const startIndex = merkleTree.getStartIndex();
-    merkleTree.insert('d', startIndex + 3n);
-    merkleTree.insert('c', startIndex + 2n);
-    merkleTree.insert('b', startIndex + 1n);
-    merkleTree.insert('a', startIndex);
-
-    expect(merkleTree.getRootHash()).toEqual(testHashFunction(testHashFunction('a', 'b'), testHashFunction('c', 'd')));
-  });
-
-  test('should throw when getting root hash if it is incomplete', async () => {
-    const merkleTree = MerkleTree.create(testHashFunction, '', 3n);
-    const startIndex = merkleTree.getStartIndex();
-    merkleTree.insert('a', startIndex + 1n);
-    expect(() => merkleTree.getRootHash()).toThrow(MerkleTreeIncompleteError);
-  });
-
-  test('should throw when getting underlying data if it is incomplete', async () => {
-    const merkleTree = MerkleTree.create(testHashFunction, '', 3n);
-    const startIndex = merkleTree.getStartIndex();
-    merkleTree.insert('a', startIndex + 1n);
-    expect(() => merkleTree.getRootHash()).toThrow(MerkleTreeIncompleteError);
-  });
-
-  test("should return sibling's side indexes", async () => {
-    const merkleTree = MerkleTree.create(testHashFunction, '', 20n);
-    const startIndex = merkleTree.getStartIndex();
-    merkleTree.insert('a', startIndex);
-    merkleTree.insert('b', startIndex + 1n);
-    merkleTree.insert('c', startIndex + 2n);
-    merkleTree.insert('d', startIndex + 3n);
-    merkleTree.insert('e', startIndex + 4n);
-
-    expect(merkleTree.getSiblingSides('a')[0]).toEqual(0n);
-    expect(merkleTree.getSiblingSides('d')[0]).toEqual(1n);
-  });
-
-  test('should work with large indexes', async () => {
-    const merkleTree = MerkleTree.create(testHashFunction, '', 20n);
-    const startIndex = merkleTree.getStartIndex();
-    merkleTree.insert('a', startIndex);
-    let lastRootHash = merkleTree.getRootHash();
-    for (let i = 1n; i < 1000n; i += 1n) {
-      merkleTree.insert('a', startIndex + i);
-      const rootHash = merkleTree.getRootHash();
-      expect(rootHash).not.toEqual(lastRootHash);
-      lastRootHash = rootHash;
-    }
-  });
-});