@sabaaa1/common 0.0.11 → 0.0.13

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

@@ -0,0 +1,152 @@
+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

@@ -0,0 +1,116 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,132 @@
+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/index.ts

@@ -0,0 +1,18 @@
+export * from './ValueCache';
+export * from './crypto-keys';
+export * from './Hinkal';
+export * from './merkle-tree';
+export * from './provider-adapter/IProviderAdapter';
+export * from './event-service';
+export * from './utxo/Utxo';
+export * from './custom-token-registry/CustomTokenRegistry';
+export * from './token-price-fetcher';
+export * from './transactions-manager';
+export * from './MultiThreadedUtxoUtils/MultiThreadedUtxoUtils';
+export * from './cacheDevices';
+export * from './IndexedDB';
+export * from './TokenDBs';
+export * from './presale';
+export * from './snapshot';
+// export * from './tor';
+export * from './ApprovalDBs';

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

@@ -0,0 +1,77 @@
+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;
+    }
+  });
+});