@avalabs/bridge-unified 2.1.1 → 3.0.0

package/src/bridges/cctp/handlers/track-transfer.ts

@@ -1,365 +0,0 @@
-import { decodeEventLog, type Address } from 'viem';
-import {
-  ErrorReason,
-  type BridgeConfig,
-  type BridgeService,
-  type BridgeTransfer,
-  type TrackingParams,
-  ErrorCode,
-} from '../../../types';
-import { getClientForChain } from '../../../utils/client';
-import { TOKEN_ROUTER_ABI } from '../abis/token-router';
-import { getNetworkFeeEVM } from '../../../utils/network-fee';
-import { retryPromise, type Done } from '../../../utils/retry-promise';
-import { getTrackingDelayByChainId } from '../utils/config';
-import { InvalidParamsError } from '../../../errors';
-
-// Maximum time (in ms) before the transaction is considered "timed out"
-export const TRACKING_LIMIT_MS = 1000 * 60 * 60 * 3;
-// The max blocks that can be queried before receiving an error response
-export const MAX_BLOCKS = 1024n;
-// The delay time before tracking starts
-export const INITIAL_DELAY = 5000;
-
-/**
- * Mutates the `initial` transfer by merging it with the `updated` properties if they are not undefined
- * Invokes the `updateListener` with a copy of the updated `initial` transfer
- */
-const updateTransfer = (
-  initial: BridgeTransfer,
-  updated: Partial<BridgeTransfer>,
-  updateListener: TrackingParams['updateListener'],
-) => {
-  Object.assign(initial, Object.fromEntries(Object.entries(updated).filter(([, value]) => value !== undefined)));
-  updateListener({ ...initial });
-};
-
-/**
- * Polls the source network until it's able to get the CCTP message's `nonce` from the source transaction's logs
- * Updates the provided `BridgeTransfer` and broadcasts the changes via `updateListener`
- */
-export const trackSourceTx = async (config: BridgeConfig, params: TrackingParams) => {
-  const { sourceProvider, targetProvider, updateListener, bridgeTransfer } = params;
-  const sourceClient = getClientForChain({ chain: bridgeTransfer.sourceChain, provider: sourceProvider });
-  const sourceChainData = config.find((chainData) => chainData.chainId === bridgeTransfer.sourceChain.chainId);
-  const targetClient = getClientForChain({ chain: bridgeTransfer.targetChain, provider: targetProvider });
-  const targetChainData = config.find((chainData) => chainData.chainId === bridgeTransfer.targetChain.chainId);
-  const updateableTransfer = { ...bridgeTransfer };
-
-  if (!sourceChainData || !targetChainData) {
-    throw new InvalidParamsError(ErrorReason.CHAIN_NOT_SUPPORTED);
-  }
-
-  const tracker = async (done: Done<BridgeTransfer>) => {
-    /**
-     * Return early if:
-     *  - transfer has already completed successfully or due to some error
-     *  - the transfer state already has the message's nonce
-     */
-    if (updateableTransfer.completedAt || updateableTransfer.metadata?.nonce) {
-      return done(updateableTransfer);
-    }
-
-    /**
-     * Check if the transaction has timed out
-     */
-    if (updateableTransfer.sourceStartedAt + TRACKING_LIMIT_MS <= Date.now()) {
-      updateTransfer(updateableTransfer, { completedAt: Date.now(), errorCode: ErrorCode.TIMEOUT }, updateListener);
-      return done(updateableTransfer);
-    }
-
-    /**
-     * Get the transaction's receipt.
-     * Throws if the transaction has't been processed by the network yet.
-     */
-    const txReceipt = await sourceClient.getTransactionReceipt({
-      hash: updateableTransfer.sourceTxHash as Address,
-    });
-
-    /**
-     * Calculate the network fee if needed.
-     */
-    if (!updateableTransfer.sourceNetworkFee) {
-      const tx = await sourceClient.getTransaction({ hash: updateableTransfer.sourceTxHash as Address });
-      const networkFee = getNetworkFeeEVM(tx, txReceipt);
-
-      if (networkFee) {
-        updateTransfer(updateableTransfer, { sourceNetworkFee: networkFee }, updateListener);
-      }
-    }
-
-    /**
-     * Update the state and terminate if the transaction was reverted
-     */
-    if (txReceipt.status === 'reverted') {
-      updateTransfer(
-        updateableTransfer,
-        { completedAt: Date.now(), errorCode: ErrorCode.TRANSACTION_REVERTED },
-        updateListener,
-      );
-      return done(updateableTransfer);
-    }
-
-    /**
-     * Check the confirmation count.
-     *  - update the sourceConfirmationCount if it increased
-     *  - update the startBlockNumber if confirmation count increased but is not enough
-     *  - keeps polling until it's greater than requiredSourceConfirmationCount
-     */
-    const confirmationCount = await sourceClient.getTransactionConfirmations({
-      hash: updateableTransfer.sourceTxHash as Address,
-    });
-    const hasMoreConfirmations = confirmationCount > updateableTransfer.sourceConfirmationCount;
-    const hasRequiredConfirmations = confirmationCount >= updateableTransfer.requiredSourceConfirmationCount;
-
-    if (hasMoreConfirmations) {
-      const changes = {} as Partial<BridgeTransfer>;
-      changes.sourceConfirmationCount = Number(confirmationCount);
-
-      if (!hasRequiredConfirmations) {
-        changes.startBlockNumber = await targetClient.getBlockNumber();
-      }
-
-      updateTransfer(updateableTransfer, changes, updateListener);
-    }
-
-    if (!hasRequiredConfirmations) {
-      return;
-    }
-
-    if (!updateableTransfer.startBlockNumber) {
-      updateTransfer(updateableTransfer, { startBlockNumber: await targetClient.getBlockNumber() }, updateListener);
-    }
-
-    /**
-     * Get the `TransferTokens` event's log entry from the receipt
-     */
-    const transferEventLog = txReceipt.logs.find((log) => {
-      if (log.address.toLowerCase() === sourceChainData.tokenRouterAddress.toLowerCase()) {
-        const event = decodeEventLog({
-          abi: TOKEN_ROUTER_ABI,
-          ...log,
-        });
-
-        return event.eventName === 'TransferTokens';
-      }
-
-      return false;
-    });
-
-    if (!transferEventLog) {
-      throw new InvalidParamsError(
-        ErrorReason.INVALID_PARAMS,
-        `unable to find a TransferTokens event in source transaction "${updateableTransfer.sourceTxHash}"`,
-      );
-    }
-
-    /**
-     * Get the nonce used by the message transmitter from the event's log
-     * https://developers.circle.com/stablecoins/docs/evm-smart-contracts#receivemessage
-     */
-    const transferEvent = decodeEventLog({
-      abi: TOKEN_ROUTER_ABI,
-      eventName: 'TransferTokens',
-      ...transferEventLog,
-    });
-
-    // save the nonce and broadcast
-    const nonce = transferEvent.args.nonce;
-    updateTransfer(updateableTransfer, { targetStartedAt: Date.now(), metadata: { nonce } }, updateListener);
-    return done(updateableTransfer);
-  };
-
-  return retryPromise<BridgeTransfer>({
-    promise: tracker,
-    delay: getTrackingDelayByChainId(sourceChainData.chainId),
-    startAfter: INITIAL_DELAY,
-  });
-};
-
-/**
- * Polls the target network until it finds the transaction that matches the message's nonce
- * Updates the provided `BridgeTransfer` and broadcasts the changes via `updateListener`
- */
-export const trackTargetTx = async (config: BridgeConfig, params: TrackingParams) => {
-  const { targetProvider, updateListener, bridgeTransfer } = params;
-  const updateableTransfer = { ...bridgeTransfer };
-
-  if (!bridgeTransfer.completedAt && !bridgeTransfer.metadata?.nonce) {
-    throw new InvalidParamsError(ErrorReason.INVALID_PARAMS, `nonce is missing`);
-  }
-
-  if (!bridgeTransfer.startBlockNumber) {
-    throw new InvalidParamsError(ErrorReason.INVALID_PARAMS, `startBlockNumber is missing`);
-  }
-
-  const targetClient = getClientForChain({ chain: bridgeTransfer.targetChain, provider: targetProvider });
-  const targetChainData = config.find((chainData) => chainData.chainId === bridgeTransfer.targetChain.chainId);
-
-  if (!targetChainData) {
-    throw new InvalidParamsError(
-      ErrorReason.INVALID_PARAMS,
-      `unknown target chain "${bridgeTransfer.targetChain.chainId}"`,
-    );
-  }
-
-  const tracker = async (done: Done<BridgeTransfer>) => {
-    /**
-     * Return early if:
-     *  - transfer has already completed successfully or due to some error
-     */
-    if (updateableTransfer.completedAt) {
-      return done(updateableTransfer);
-    }
-
-    /**
-     * Check if `startBlockNumber` became falsy for whatever reason
-     */
-    if (!updateableTransfer.startBlockNumber) {
-      updateTransfer(
-        updateableTransfer,
-        { completedAt: Date.now(), errorCode: ErrorCode.INVALID_PARAMS },
-        updateListener,
-      );
-      return done(updateableTransfer);
-    }
-
-    /**
-     * Check if the transaction has timed out
-     */
-    if (updateableTransfer.sourceStartedAt + TRACKING_LIMIT_MS <= Date.now()) {
-      updateTransfer(updateableTransfer, { completedAt: Date.now(), errorCode: ErrorCode.TIMEOUT }, updateListener);
-      return done(updateableTransfer);
-    }
-
-    if (!updateableTransfer.targetTxHash) {
-      const lastBlockNumber = await targetClient.getBlockNumber();
-      const lowestBlockNumber = updateableTransfer.startBlockNumber - MAX_BLOCKS;
-      const fromBlock = lowestBlockNumber >= 0n ? lowestBlockNumber : 'earliest';
-      const highestBlockNumber = updateableTransfer.startBlockNumber + MAX_BLOCKS;
-      const toBlock = highestBlockNumber < lastBlockNumber ? highestBlockNumber : 'latest';
-
-      const targetLogs = await targetClient.getLogs({
-        address: targetChainData.messageTransmitterAddress,
-        event: {
-          name: 'MessageReceived',
-          type: 'event',
-          inputs: [
-            { indexed: true, internalType: 'address', name: 'caller', type: 'address' },
-            { indexed: false, internalType: 'uint32', name: 'sourceDomain', type: 'uint32' },
-            { indexed: true, internalType: 'uint64', name: 'nonce', type: 'uint64' },
-            { indexed: false, internalType: 'bytes32', name: 'sender', type: 'bytes32' },
-            { indexed: false, internalType: 'bytes', name: 'messageBody', type: 'bytes' },
-          ],
-        },
-        args: { nonce: updateableTransfer.metadata!.nonce as bigint },
-        fromBlock,
-        toBlock,
-      });
-
-      if (targetLogs[0]?.transactionHash) {
-        updateTransfer(updateableTransfer, { targetTxHash: targetLogs[0].transactionHash }, updateListener);
-      } else {
-        updateTransfer(updateableTransfer, { startBlockNumber: lastBlockNumber }, updateListener);
-        return;
-      }
-    }
-
-    /**
-     * Get the transaction's receipt.
-     * Throws if the transaction has't been processed by the network yet.
-     */
-    const txReceipt = await targetClient.getTransactionReceipt({
-      hash: updateableTransfer.targetTxHash as Address,
-    });
-
-    /**
-     * Calculate the network fee if needed.
-     */
-    if (!updateableTransfer.targetNetworkFee) {
-      const tx = await targetClient.getTransaction({ hash: updateableTransfer.targetTxHash as Address });
-      const networkFee = getNetworkFeeEVM(tx, txReceipt);
-
-      if (networkFee) {
-        updateTransfer(updateableTransfer, { targetNetworkFee: networkFee }, updateListener);
-      }
-    }
-
-    /**
-     * Update the state and terminate if the transaction was reverted
-     */
-    if (txReceipt.status === 'reverted') {
-      updateTransfer(
-        updateableTransfer,
-        { completedAt: Date.now(), errorCode: ErrorCode.TRANSACTION_REVERTED },
-        updateListener,
-      );
-      return done(updateableTransfer);
-    }
-
-    /**
-     * Check the confirmation count.
-     *  - update the targetConfirmationCount if it increased
-     *  - keeps polling until it's greater than requiredTargetConfirmationCount
-     */
-    const confirmationCount = await targetClient.getTransactionConfirmations({
-      hash: updateableTransfer.targetTxHash as Address,
-    });
-    const hasMoreConfirmations = confirmationCount > updateableTransfer.targetConfirmationCount;
-    const hasRequiredConfirmations = confirmationCount >= updateableTransfer.requiredTargetConfirmationCount;
-
-    if (hasMoreConfirmations) {
-      updateTransfer(updateableTransfer, { targetConfirmationCount: Number(confirmationCount) }, updateListener);
-    }
-
-    if (!hasRequiredConfirmations) {
-      return;
-    }
-
-    updateTransfer(updateableTransfer, { completedAt: Date.now() }, updateListener);
-    return done(updateableTransfer);
-  };
-
-  return retryPromise<BridgeTransfer>({
-    promise: tracker,
-    delay: getTrackingDelayByChainId(targetChainData.chainId),
-    startAfter: INITIAL_DELAY,
-  });
-};
-
-export function trackTransfer(bridge: BridgeService, params: TrackingParams) {
-  let abortFn: (() => void) | undefined;
-
-  const cancel = () => {
-    abortFn?.();
-  };
-
-  const executeTracking = async () => {
-    await bridge.ensureHasConfig();
-
-    const { sourceProvider, targetProvider, updateListener, bridgeTransfer } = params;
-
-    const { result: sourceTracker, cancel: cancelSourceTracking } = await trackSourceTx(bridge.config!, {
-      sourceProvider,
-      targetProvider,
-      updateListener,
-      bridgeTransfer,
-    });
-    abortFn = cancelSourceTracking;
-    const transferAfterSourceFinished = await sourceTracker;
-
-    const { result: targetTracker, cancel: cancelTargetTracking } = await trackTargetTx(bridge.config!, {
-      sourceProvider,
-      targetProvider,
-      updateListener,
-      bridgeTransfer: transferAfterSourceFinished,
-    });
-    abortFn = cancelTargetTracking;
-    return targetTracker;
-  };
-
-  return {
-    result: executeTracking(),
-    cancel,
-  };
-}