@avalabs/bridge-unified 0.0.0-unified-bridge-init-20230824160802 → 2.0.0

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/handlers/check-for-pending-bridge-journey.ts

@@ -1,20 +0,0 @@
-import type { Address } from 'viem';
-import { NotImplementedError } from '../errors';
-
-/**
- * Checks for any currently pending bridge transactions.  Useful for dApps that want
- * to display the current tx's status after a page refresh.
- */
-export const checkForPendingBridgeJourney = async ({
-  address: _address,
-  chainIds: _chainIds,
-}: {
-  address: Address;
-  chainIds: string[];
-}) => {
-  /**
-   * 1. If wallet is Core, request current bridge journey.  Otherwise, check glacier to see if the provided wallet has bridge tx in the past 100 transactions on the provided chains.
-   * 3. Returns an array of txIds for all pending transactions
-   */
-  throw new NotImplementedError();
-};

package/src/handlers/execute-bridge-journey-step.ts

@@ -1,20 +0,0 @@
-import { NotImplementedError } from '../errors';
-
-type ExecuteBridgeJourneyStepParams = {
-  stepIndex: number;
-  journey: unknown;
-};
-
-export const executeBridgeJourneyStep = async (_params: ExecuteBridgeJourneyStepParams) => {
-  /**
-   * 1. Validate the journey
-   * 3. Forward request along to the right bridge platform's package.
-   * 4. Return an observable that emits events when:
-   *    - User signs the transaction (returns the fromChain txId)
-   *    - Every block confirmation on fromChain
-   *    - fromChain tx completed, starting the toChain tx (returns the toChainTxId)
-   *    - Every block confirmation on toChain
-   *    - toChain tx completed
-   */
-  throw new NotImplementedError();
-};

package/src/handlers/plan-bridge-journey.ts

@@ -1,25 +0,0 @@
-import { NotImplementedError } from '../errors';
-import { BridgePlatform, type 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 a list of transaction steps needed to complete a bridge from chain A to B.
- * The response may include multiple steps if the bridge requires multiple hops.
- */
-export const planBridgeJourney = (_params: GetBridgeRouterParams): BridgeTransactionStep[] => {
-  // Implement smart logic for determining how to get the token from chain A to B
-  throw new NotImplementedError();
-};