@avalabs/bridge-unified 2.1.1 → 2.1.2

package/src/utils/ensure-config.test.ts

@@ -1,43 +0,0 @@
-import { BridgeInitializationError } from '../errors';
-import { ErrorReason, type BridgeConfig, type BridgeService } from '../types';
-import { ensureHasConfig } from './ensure-config';
-
-describe('ensure-config', () => {
-  it('throws if it fails to update the config', async () => {
-    const bridgeMock = {
-      updateConfig: jest.fn(),
-    } as unknown as BridgeService;
-
-    await expect(ensureHasConfig(bridgeMock)).rejects.toThrow(
-      new BridgeInitializationError(ErrorReason.CONFIG_NOT_AVAILABLE),
-    );
-    expect(bridgeMock.updateConfig).toHaveBeenCalledTimes(1);
-  });
-
-  it('updates the config correctly', async () => {
-    const config = { foo: 'bar' } as unknown as BridgeConfig;
-    const bridgeMock = {
-      updateConfig: jest.fn().mockImplementation(() => {
-        bridgeMock.config = config;
-      }),
-    } as unknown as BridgeService;
-
-    expect(bridgeMock.config).toBeUndefined();
-    await expect(ensureHasConfig(bridgeMock)).resolves.toBeUndefined();
-    expect(bridgeMock.config).toStrictEqual(config);
-    expect(bridgeMock.updateConfig).toHaveBeenCalledTimes(1);
-  });
-
-  it('does nothing if bridge already has config', async () => {
-    const config = { foo: 'bar' } as unknown as BridgeConfig;
-    const bridgeMock = {
-      config,
-      updateConfig: jest.fn(),
-    } as unknown as BridgeService;
-
-    expect(bridgeMock.config).toStrictEqual(config);
-    await expect(ensureHasConfig(bridgeMock)).resolves.toBeUndefined();
-    expect(bridgeMock.config).toStrictEqual(config);
-    expect(bridgeMock.updateConfig).not.toHaveBeenCalled();
-  });
-});

package/src/utils/ensure-config.ts

@@ -1,12 +0,0 @@
-import { BridgeInitializationError } from '../errors';
-import { ErrorReason, type BridgeService } from '../types';
-
-export async function ensureHasConfig(bridge: BridgeService) {
-  if (!bridge.config) {
-    await bridge.updateConfig();
-
-    if (!bridge.config) {
-      throw new BridgeInitializationError(ErrorReason.CONFIG_NOT_AVAILABLE);
-    }
-  }
-}

package/src/utils/index.ts

@@ -1,2 +0,0 @@
-export * from './bridge-types';
-export { default as caip2 } from './caip2';

package/src/utils/network-fee.test.ts

@@ -1,24 +0,0 @@
-import type { Transaction, TransactionReceipt } from 'viem';
-import { getNetworkFeeEVM } from './network-fee';
-
-describe('network-fee', () => {
-  describe('getNetworkFeeEVM', () => {
-    const transactionMock = {
-      gasPrice: 50,
-    } as unknown as Transaction;
-
-    const receiptMock = {
-      gasUsed: 100,
-    } as unknown as TransactionReceipt;
-
-    it('returns undefined if gasPrice is missing', () => {
-      const networkFee = getNetworkFeeEVM({} as Transaction, receiptMock);
-      expect(networkFee).toBeUndefined();
-    });
-
-    it('returns the correct network fee', () => {
-      const networkFee = getNetworkFeeEVM(transactionMock, receiptMock);
-      expect(networkFee).toEqual(5000n);
-    });
-  });
-});

package/src/utils/network-fee.ts

@@ -1,6 +0,0 @@
-import { type Transaction, type TransactionReceipt } from 'viem';
-
-// returns the network fee for EVM transaction in wei (10**-18)
-export const getNetworkFeeEVM = (transaction: Transaction, receipt: TransactionReceipt) => {
-  return transaction.gasPrice && BigInt(transaction.gasPrice * receipt.gasUsed);
-};

package/src/utils/retry-promise.test.ts

@@ -1,115 +0,0 @@
-import { noop } from 'lodash';
-import { retryPromise } from './retry-promise';
-
-describe('retry-promise', () => {
-  const delay = 5000;
-  const promiseMock = jest.fn();
-
-  beforeEach(() => {
-    jest.resetAllMocks();
-    jest.useFakeTimers();
-  });
-
-  it('rejects when cancelled', (done) => {
-    const test = async () => {
-      promiseMock.mockResolvedValue(undefined);
-
-      const { result, cancel } = retryPromise({ promise: promiseMock, delay });
-
-      for (let i = 1; i <= 5; i++) {
-        expect(promiseMock).toHaveBeenCalledTimes(i);
-        await jest.advanceTimersByTimeAsync(delay);
-      }
-
-      result.catch((err) => {
-        expect(err).toBe('cancelled');
-        done();
-      });
-
-      cancel();
-    };
-
-    test();
-  });
-
-  it('delays execution when `startAfter` is provided', (done) => {
-    const test = async () => {
-      const response = { foo: 'bar' };
-      const startAfter = 3000;
-
-      promiseMock
-        .mockResolvedValueOnce(undefined)
-        .mockResolvedValueOnce(undefined)
-        .mockImplementationOnce(async (done) => {
-          done(response);
-        });
-
-      const { result } = retryPromise({ promise: promiseMock, delay, startAfter });
-      expect(promiseMock).not.toHaveBeenCalled();
-
-      // initial delay
-      await jest.advanceTimersByTimeAsync(startAfter);
-      expect(promiseMock).toHaveBeenCalledTimes(1);
-
-      // normal execution
-      await jest.advanceTimersByTimeAsync(delay);
-      expect(promiseMock).toHaveBeenCalledTimes(2);
-
-      await jest.advanceTimersByTimeAsync(delay);
-      expect(promiseMock).toHaveBeenCalledTimes(3);
-
-      result.then((res) => {
-        expect(res).toStrictEqual(response);
-        done();
-      });
-    };
-
-    test();
-  });
-
-  it('uses exponential backoff after errors and resolves correctly', (done) => {
-    const test = async () => {
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(noop);
-      const response = { foo: 'bar' };
-
-      promiseMock
-        .mockResolvedValueOnce(undefined)
-        .mockRejectedValueOnce(new Error('error 1'))
-        .mockRejectedValueOnce(new Error('error 2'))
-        .mockRejectedValueOnce(new Error('error 3'))
-        .mockResolvedValueOnce(undefined)
-        .mockImplementationOnce(async (done) => {
-          done(response);
-        });
-
-      const { result } = retryPromise({ promise: promiseMock, delay });
-      expect(promiseMock).toHaveBeenCalledTimes(1);
-
-      // error 1
-      await jest.advanceTimersByTimeAsync(delay);
-      expect(promiseMock).toHaveBeenCalledTimes(2);
-      expect(consoleErrorSpy).toHaveBeenNthCalledWith(1, 'error 1');
-      // error 2
-      await jest.advanceTimersByTimeAsync(2 * delay);
-      expect(promiseMock).toHaveBeenCalledTimes(3);
-      expect(consoleErrorSpy).toHaveBeenNthCalledWith(2, 'error 2');
-      // error 3
-      await jest.advanceTimersByTimeAsync(4 * delay);
-      expect(promiseMock).toHaveBeenCalledTimes(4);
-      expect(consoleErrorSpy).toHaveBeenNthCalledWith(3, 'error 3');
-
-      await jest.advanceTimersByTimeAsync(8 * delay);
-      expect(promiseMock).toHaveBeenCalledTimes(5);
-
-      await jest.advanceTimersByTimeAsync(delay);
-      expect(promiseMock).toHaveBeenCalledTimes(6);
-
-      result.then((res) => {
-        expect(res).toStrictEqual(response);
-        done();
-      });
-    };
-
-    test();
-  });
-});

package/src/utils/retry-promise.ts

@@ -1,72 +0,0 @@
-import { wait } from './wait';
-
-export type Done<T> = (data: T) => void;
-
-type Params<T> = {
-  promise: (done: Done<T>) => Promise<unknown>;
-  delay: number;
-  startAfter?: number;
-};
-
-export const retryPromise = <T>({ promise, delay, startAfter }: Params<T>) => {
-  let isRunning = false;
-  let isCancelled = false;
-  let errorCount: number = 0;
-  let resolve: ((data: T) => void) | undefined = undefined;
-  let reject: ((reason?: string) => void) | undefined = undefined;
-
-  const done = (data: T) => {
-    if (resolve && isRunning) {
-      isRunning = false;
-      resolve(data);
-    }
-  };
-
-  const cancel = () => {
-    isCancelled = true;
-
-    if (reject && isRunning) {
-      isRunning = false;
-      reject('cancelled');
-    }
-  };
-
-  const result = new Promise<T>((res, rej) => {
-    isRunning = true;
-    resolve = res;
-    reject = rej;
-
-    const execute = async (): Promise<void> => {
-      if (!isRunning || isCancelled) {
-        return;
-      }
-
-      try {
-        await promise(done);
-
-        if (!isRunning || isCancelled) {
-          return;
-        }
-
-        await wait(delay);
-      } catch (err) {
-        console.error((err as Error).message);
-        errorCount += 1;
-        await wait(2 ** errorCount * delay);
-      }
-
-      await execute();
-    };
-
-    if (startAfter) {
-      setTimeout(execute, startAfter);
-    } else {
-      execute();
-    }
-  });
-
-  return {
-    result,
-    cancel,
-  };
-};

package/src/utils/wait.test.ts

@@ -1,33 +0,0 @@
-import { wait } from './wait';
-
-describe('wait', () => {
-  const delay = 5000;
-
-  beforeEach(() => {
-    jest.useFakeTimers();
-  });
-
-  afterAll(() => {
-    jest.useRealTimers();
-  });
-
-  it('delays the execution correctly', (done) => {
-    const test = async () => {
-      const testFn = jest.fn();
-      const promiseFn = async () => {
-        await wait(delay);
-        testFn();
-      };
-
-      const promise = promiseFn();
-      expect(testFn).not.toHaveBeenCalled();
-
-      await jest.advanceTimersByTimeAsync(delay);
-
-      expect(testFn).toHaveBeenCalledTimes(1);
-      promise.then(done);
-    };
-
-    test();
-  });
-});

package/src/utils/wait.ts

@@ -1,4 +0,0 @@
-export const wait = async (time: number) =>
-  new Promise((res) => {
-    setTimeout(res, time);
-  });

package/tsconfig.jest.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "verbatimModuleSyntax": false,
-    "esModuleInterop": true
-  }
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "@internal/tsconfig/tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "paths": { "abitype": ["./node_modules/abitype"] },
-    "incremental": false // Need to turn off because of tsup dts
-  },
-  "include": ["src", "src/types"]
-}

package/tsup.config.ts

@@ -1,4 +0,0 @@
-import { defineConfig } from 'tsup';
-import { baseConfig } from '@internal/tsup-config';
-
-export default defineConfig(baseConfig);