@avalabs/bridge-unified 1.0.1 → 2.0.1

package/src/utils/retry-promise.ts

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

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

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

package/tsconfig.jest.json

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

package/tsconfig.json

@@ -2,7 +2,8 @@
   "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", "../shared/src/types"]
+  "include": ["src", "src/types"]
 }

package/src/bridge-service.ts

@@ -1,18 +0,0 @@
-import { submitBridgeTransactionStep } from './handlers/submit-bridge-transaction-step';
-import { getBridgeRouter } from './handlers/get-bridge-router';
-import { submitAndWatchBridgeTransaction } from './handlers/submit-and-watch-bridge-transaction';
-import type { Environment, MaybePromise, NativeToken } from '@internal/bridge-shared';
-
-export type BridgeServiceConfig = {
-  environment: `${Environment}`;
-  getChainNativeAsset: ({ evmChainId }: { evmChainId: string }) => MaybePromise<NativeToken>;
-  getChainErc20Asset: ({ evmChainId, address }: { evmChainId: string; address: string }) => MaybePromise<NativeToken>;
-};
-
-export const createBridgeService = (_options: BridgeServiceConfig) => {
-  return {
-    getBridgeRouter,
-    submitBridgeTransactionStep,
-    submitAndWatchBridgeTransaction,
-  };
-};

package/src/handlers/get-bridge-router.ts

@@ -1,25 +0,0 @@
-import { NotImplementedError } from '../errors';
-import type { BridgePlatform, Token } from '@internal/bridge-shared';
-
-type GetBridgeRouterParams = {
-  fromChainId: string;
-  toChainId: string;
-  fromToken: Token;
-};
-
-type BridgeTransactionStep = {
-  fromChainId: string;
-  toChainId: string;
-  bridgePlatform: BridgePlatform;
-  fromToken: Token;
-  toToken: Token;
-};
-
-/**
- * Returns the steps required to complete a bridge transaction.
- * It could sometimes take multiple transactions to complete a bridge from chain A to B.
- */
-export const getBridgeRouter = (_params: GetBridgeRouterParams): BridgeTransactionStep[] => {
-  // Implement smart logic for determining how to get the token from chain A to B
-  throw new NotImplementedError();
-};

package/src/handlers/submit-and-watch-bridge-transaction.ts

@@ -1 +0,0 @@
-export const submitAndWatchBridgeTransaction = () => {};

package/src/handlers/submit-bridge-transaction-step.ts

@@ -1,22 +0,0 @@
-import { type Address } from 'viem';
-import type { Token } from '@internal/bridge-shared';
-import { NotImplementedError } from '../errors';
-
-type SubmitBridgeTransactionParams = {
-  fromChainId: string;
-  toChainId: string;
-  fromAddress: Address;
-  token: Token;
-  amount: string;
-};
-
-export const submitBridgeTransactionStep = async (_params: SubmitBridgeTransactionParams) => {
-  /**
-   * 1. Validate the token is supported on the fromChainId
-   * 2. Validate the token is supported on the toChainId
-   * 3. Figure out which bridge platform to use based on the from/to chains and the token being transferred
-   *       - Ex: Ethereum -> Avalanche USDC = use CCTP, but Ethereum -> Avalanche WAVAX use Avalanche bridge
-   * 4. Return the transaction id
-   */
-  throw new NotImplementedError();
-};