@avalabs/bridge-unified 1.0.1 → 2.0.1

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

@@ -0,0 +1,779 @@
+import { decodeEventLog } from 'viem';
+import { BridgeType, type BridgeService, ErrorCode, ErrorReason } from '../../../types';
+import { getClientForChain } from '../../../utils/client';
+import { getNetworkFeeEVM } from '../../../utils/network-fee';
+import { retryPromise } from '../../../utils/retry-promise';
+import { getBridgeTrackinParams } from '../__mocks__/bridge-transfer.mock';
+import {
+  CCTP_CONFIG,
+  SOURCE_ROUTER_ADDRESS_RANDOMIZED_CASING,
+  TARGET_TRANSMITTER_ADDRESS,
+} from '../__mocks__/config.mock';
+import { getTrackingDelayByChainId } from '../utils/config';
+import * as tracking from './track-transfer';
+import {
+  MAX_BLOCKS,
+  TRACKING_LIMIT_MS,
+  INITIAL_DELAY,
+  trackSourceTx,
+  trackTargetTx,
+  trackTransfer,
+} from './track-transfer';
+import { SOURCE_CHAIN, TARGET_CHAIN } from '../__mocks__/chain.mocks';
+import { TOKEN_ROUTER_ABI } from '../abis/token-router';
+import { InvalidParamsError } from '../../../errors';
+
+jest.mock('../../../utils/retry-promise');
+jest.mock('../../../utils/client');
+jest.mock('../../../utils/network-fee');
+jest.mock('../utils/config');
+jest.mock('viem');
+
+describe('CCTP trackTransfer', () => {
+  const now = 10;
+  const networkFee = 1000n;
+  const delay = 5000;
+
+  // used for updateListener callback param testing
+  // https://github.com/jestjs/jest/issues/434
+  const updateListenerWithoutReference = jest.fn();
+  const updateListener = jest.fn();
+  const doneMock = jest.fn();
+
+  const txMock = { hash: 'hash' };
+  const bridgeMock = {
+    type: BridgeType.CCTP,
+    config: CCTP_CONFIG,
+    ensureHasConfig: jest.fn(),
+  } as unknown as BridgeService;
+  const sourceClientMock = {
+    getTransactionReceipt: jest.fn(),
+    getTransaction: jest.fn(),
+    getTransactionConfirmations: jest.fn(),
+  };
+  const targetClientMock = {
+    getTransactionReceipt: jest.fn(),
+    getTransaction: jest.fn(),
+    getTransactionConfirmations: jest.fn(),
+    getBlockNumber: jest.fn(),
+    getLogs: jest.fn(),
+  };
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    jest.useFakeTimers().setSystemTime(new Date(now));
+
+    (retryPromise as jest.Mock).mockImplementation(
+      ({ promise }: { promise: (done: () => unknown) => Promise<unknown> }) => ({
+        result: promise(doneMock),
+      }),
+    );
+
+    updateListener.mockImplementation((args) => updateListenerWithoutReference({ ...args }));
+    doneMock.mockImplementation((arg) => arg);
+    sourceClientMock.getTransaction.mockResolvedValue(txMock);
+    targetClientMock.getTransaction.mockResolvedValue(txMock);
+    (getNetworkFeeEVM as jest.Mock).mockReturnValue(networkFee);
+    (getTrackingDelayByChainId as jest.Mock).mockReturnValue(delay);
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe('combined tracking', () => {
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('calls ensureHasConfig', async () => {
+      const params = getBridgeTrackinParams({ updateListener });
+      const error = new Error('error');
+      (bridgeMock.ensureHasConfig as jest.Mock).mockRejectedValueOnce(error);
+
+      const { result } = trackTransfer(bridgeMock, params);
+
+      await expect(result).rejects.toThrow(error);
+    });
+
+    it('tracks the transactions correctly', async () => {
+      const initialParams = getBridgeTrackinParams({ updateListener });
+      const transferAfterSource = { ...initialParams.bridgeTransfer, metadata: { nonce: 1 } };
+      const transferAfterTarget = { ...transferAfterSource, completedAt: 999 };
+
+      const sourceCancel = jest.fn();
+      const targetCancel = jest.fn();
+
+      const sourceTrackerSpy = jest.spyOn(tracking, 'trackSourceTx').mockResolvedValueOnce({
+        result: new Promise((res) => res(transferAfterSource)),
+        cancel: sourceCancel,
+      });
+
+      const targetTrackerSpy = jest.spyOn(tracking, 'trackTargetTx').mockResolvedValueOnce({
+        result: new Promise((res) => res(transferAfterTarget)),
+        cancel: targetCancel,
+      });
+
+      const { result, cancel } = trackTransfer(bridgeMock, initialParams);
+      expect(await result).toStrictEqual(transferAfterTarget);
+      expect(sourceTrackerSpy).toHaveBeenCalledWith(bridgeMock.config, initialParams);
+      expect(targetTrackerSpy).toHaveBeenCalledWith(bridgeMock.config, {
+        ...initialParams,
+        bridgeTransfer: transferAfterSource,
+      });
+
+      cancel();
+      expect(sourceCancel).not.toHaveBeenCalled();
+      expect(targetCancel).toHaveBeenCalled();
+    });
+  });
+
+  describe('source tx tracking', () => {
+    beforeEach(() => {
+      (getClientForChain as jest.Mock)
+        .mockReturnValueOnce(sourceClientMock)
+        .mockReturnValueOnce(targetClientMock)
+        .mockReturnValueOnce(targetClientMock);
+    });
+
+    it('resolves if bridging has already completed', async () => {
+      const params = getBridgeTrackinParams({
+        bridgeTransfer: {
+          completedAt: 1,
+        },
+        updateListener,
+      });
+
+      const { result } = await trackSourceTx(bridgeMock.config!, params);
+      expect(await result).toStrictEqual(params.bridgeTransfer);
+      expect(doneMock).toHaveBeenCalledWith(params.bridgeTransfer);
+      expect(updateListenerWithoutReference).not.toHaveBeenCalled();
+
+      expect(getTrackingDelayByChainId).toHaveBeenCalledWith(SOURCE_CHAIN.chainId);
+      expect(retryPromise).toHaveBeenCalledWith({
+        promise: expect.any(Function),
+        delay,
+        startAfter: INITIAL_DELAY,
+      });
+    });
+
+    it('resolves if message nonce is already known', async () => {
+      const params = getBridgeTrackinParams({
+        bridgeTransfer: {
+          metadata: { nonce: 1 },
+        },
+        updateListener,
+      });
+
+      const { result } = await trackSourceTx(bridgeMock.config!, params);
+      expect(await result).toStrictEqual(params.bridgeTransfer);
+      expect(doneMock).toHaveBeenCalledWith(params.bridgeTransfer);
+      expect(updateListenerWithoutReference).not.toHaveBeenCalled();
+
+      expect(getTrackingDelayByChainId).toHaveBeenCalledWith(SOURCE_CHAIN.chainId);
+      expect(retryPromise).toHaveBeenCalledWith({
+        promise: expect.any(Function),
+        delay,
+        startAfter: INITIAL_DELAY,
+      });
+    });
+
+    it('resolves if transaction has timed out', async () => {
+      const params = getBridgeTrackinParams({
+        updateListener,
+      });
+      const time = params.bridgeTransfer.sourceStartedAt + TRACKING_LIMIT_MS;
+
+      jest.useFakeTimers().setSystemTime(time);
+
+      const { result } = await trackSourceTx(bridgeMock.config!, params);
+      const expectedResult = { ...params.bridgeTransfer, completedAt: time, errorCode: ErrorCode.TIMEOUT };
+
+      expect(await result).toStrictEqual(expectedResult);
+      expect(doneMock).toHaveBeenCalledWith(expectedResult);
+      expect(updateListenerWithoutReference).toHaveBeenCalledTimes(1);
+      expect(updateListenerWithoutReference).toHaveBeenCalledWith(expectedResult);
+
+      expect(getTrackingDelayByChainId).toHaveBeenCalledWith(SOURCE_CHAIN.chainId);
+      expect(retryPromise).toHaveBeenCalledWith({
+        promise: expect.any(Function),
+        delay,
+        startAfter: INITIAL_DELAY,
+      });
+    });
+
+    it('resolves if transaction was reverted', async () => {
+      const receiptMock = {
+        status: 'reverted',
+      };
+      const params = getBridgeTrackinParams({
+        updateListener,
+      });
+
+      sourceClientMock.getTransactionReceipt.mockResolvedValueOnce(receiptMock);
+
+      const { result } = await trackSourceTx(bridgeMock.config!, params);
+      const expectedResult = {
+        ...params.bridgeTransfer,
+        sourceNetworkFee: networkFee,
+        completedAt: now,
+        errorCode: ErrorCode.TRANSACTION_REVERTED,
+      };
+
+      expect(await result).toStrictEqual(expectedResult);
+      expect(doneMock).toHaveBeenCalledWith(expectedResult);
+      expect(updateListenerWithoutReference).toHaveBeenCalledTimes(2);
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(1, {
+        ...params.bridgeTransfer,
+        sourceNetworkFee: networkFee,
+      });
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(2, expectedResult);
+
+      expect(sourceClientMock.getTransactionReceipt).toHaveBeenCalledWith({
+        hash: params.bridgeTransfer.sourceTxHash,
+      });
+      expect(sourceClientMock.getTransaction).toHaveBeenCalledWith({
+        hash: params.bridgeTransfer.sourceTxHash,
+      });
+      expect(getNetworkFeeEVM).toHaveBeenCalledWith(txMock, receiptMock);
+
+      expect(getTrackingDelayByChainId).toHaveBeenCalledWith(SOURCE_CHAIN.chainId);
+      expect(retryPromise).toHaveBeenCalledWith({
+        promise: expect.any(Function),
+        delay,
+        startAfter: INITIAL_DELAY,
+      });
+    });
+
+    it('does not resolve if more confirmations are needed', async () => {
+      const confirmations = 3;
+      const targetBlockNumber = 50n;
+      const receiptMock = {
+        status: 'succeeded',
+      };
+
+      const params = getBridgeTrackinParams({
+        updateListener,
+        bridgeTransfer: {
+          requiredSourceConfirmationCount: 5,
+        },
+      });
+
+      sourceClientMock.getTransactionReceipt.mockResolvedValueOnce(receiptMock);
+      sourceClientMock.getTransactionConfirmations.mockResolvedValueOnce(confirmations);
+      targetClientMock.getBlockNumber.mockResolvedValueOnce(targetBlockNumber);
+
+      const { result } = await trackSourceTx(bridgeMock.config!, params);
+      const expectedResult = {
+        ...params.bridgeTransfer,
+        sourceNetworkFee: networkFee,
+        sourceConfirmationCount: confirmations,
+        startBlockNumber: targetBlockNumber,
+      };
+
+      expect(await result).toBeUndefined();
+      expect(doneMock).not.toHaveBeenCalled();
+      expect(updateListenerWithoutReference).toHaveBeenCalledTimes(2);
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(1, {
+        ...params.bridgeTransfer,
+        sourceNetworkFee: networkFee,
+      });
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(2, expectedResult);
+
+      expect(sourceClientMock.getTransactionReceipt).toHaveBeenCalledWith({
+        hash: params.bridgeTransfer.sourceTxHash,
+      });
+      expect(sourceClientMock.getTransaction).toHaveBeenCalledWith({
+        hash: params.bridgeTransfer.sourceTxHash,
+      });
+      expect(getNetworkFeeEVM).toHaveBeenCalledWith(txMock, receiptMock);
+      expect(sourceClientMock.getTransactionConfirmations).toHaveBeenCalledWith({
+        hash: params.bridgeTransfer.sourceTxHash,
+      });
+
+      expect(getTrackingDelayByChainId).toHaveBeenCalledWith(SOURCE_CHAIN.chainId);
+      expect(retryPromise).toHaveBeenCalledWith({
+        promise: expect.any(Function),
+        delay,
+        startAfter: INITIAL_DELAY,
+      });
+    });
+
+    it('resolves if transaction has enough confirmations', async () => {
+      const nonce = 999;
+      const confirmations = 5;
+      const targetBlockNumber = 50n;
+      const receiptMock = {
+        status: 'succeeded',
+        logs: [{ address: SOURCE_ROUTER_ADDRESS_RANDOMIZED_CASING }],
+      };
+
+      const params = getBridgeTrackinParams({
+        updateListener,
+        bridgeTransfer: {
+          requiredSourceConfirmationCount: confirmations,
+        },
+      });
+
+      (decodeEventLog as jest.Mock)
+        .mockReturnValueOnce({ eventName: 'TransferTokens' })
+        .mockReturnValueOnce({ args: { nonce } });
+      sourceClientMock.getTransactionReceipt.mockResolvedValueOnce(receiptMock);
+      sourceClientMock.getTransactionConfirmations.mockResolvedValueOnce(confirmations);
+      targetClientMock.getBlockNumber.mockResolvedValueOnce(targetBlockNumber);
+
+      const { result } = await trackSourceTx(bridgeMock.config!, params);
+
+      const expectedResult = {
+        ...params.bridgeTransfer,
+        sourceNetworkFee: networkFee,
+        sourceConfirmationCount: confirmations,
+        targetStartedAt: now,
+        startBlockNumber: targetBlockNumber,
+        metadata: {
+          nonce,
+        },
+      };
+
+      expect(await result).toStrictEqual(expectedResult);
+      expect(doneMock).toHaveBeenCalledWith(expectedResult);
+      expect(updateListenerWithoutReference).toHaveBeenCalledTimes(4);
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(1, {
+        ...params.bridgeTransfer,
+        sourceNetworkFee: networkFee,
+      });
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(2, {
+        ...params.bridgeTransfer,
+        sourceNetworkFee: networkFee,
+        sourceConfirmationCount: confirmations,
+      });
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(3, {
+        ...params.bridgeTransfer,
+        sourceNetworkFee: networkFee,
+        sourceConfirmationCount: confirmations,
+        startBlockNumber: targetBlockNumber,
+      });
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(4, expectedResult);
+
+      expect(sourceClientMock.getTransactionReceipt).toHaveBeenCalledWith({
+        hash: params.bridgeTransfer.sourceTxHash,
+      });
+      expect(sourceClientMock.getTransaction).toHaveBeenCalledWith({
+        hash: params.bridgeTransfer.sourceTxHash,
+      });
+      expect(getNetworkFeeEVM).toHaveBeenCalledWith(txMock, receiptMock);
+      expect(sourceClientMock.getTransactionConfirmations).toHaveBeenCalledWith({
+        hash: params.bridgeTransfer.sourceTxHash,
+      });
+      expect(decodeEventLog).toHaveBeenCalledTimes(2);
+      expect(decodeEventLog).toHaveBeenNthCalledWith(1, {
+        abi: TOKEN_ROUTER_ABI,
+        address: SOURCE_ROUTER_ADDRESS_RANDOMIZED_CASING,
+      });
+      expect(decodeEventLog).toHaveBeenNthCalledWith(2, {
+        abi: TOKEN_ROUTER_ABI,
+        eventName: 'TransferTokens',
+        address: SOURCE_ROUTER_ADDRESS_RANDOMIZED_CASING,
+      });
+
+      expect(getTrackingDelayByChainId).toHaveBeenCalledWith(SOURCE_CHAIN.chainId);
+      expect(retryPromise).toHaveBeenCalledWith({
+        promise: expect.any(Function),
+        delay,
+        startAfter: INITIAL_DELAY,
+      });
+    });
+  });
+
+  describe('target tx tracking', () => {
+    const nonce = 999;
+    const startBlockNumber = 12n;
+    const txHash = '0x124124';
+    const msgReceivedEvent = {
+      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' },
+      ],
+    };
+
+    beforeEach(() => {
+      (getClientForChain as jest.Mock).mockReturnValueOnce(targetClientMock);
+    });
+
+    it('throws if message nonce is missing', async () => {
+      const params = getBridgeTrackinParams({
+        updateListener,
+      });
+
+      await expect(trackTargetTx(bridgeMock.config!, params)).rejects.toThrow(
+        new InvalidParamsError(ErrorReason.INVALID_PARAMS, 'nonce is missing'),
+      );
+    });
+
+    it('throws if start block number is missing', async () => {
+      const params = getBridgeTrackinParams({
+        updateListener,
+        bridgeTransfer: {
+          metadata: {
+            nonce,
+          },
+        },
+      });
+
+      await expect(trackTargetTx(bridgeMock.config!, params)).rejects.toThrow(
+        new InvalidParamsError(ErrorReason.INVALID_PARAMS, `startBlockNumber is missing`),
+      );
+    });
+
+    it('resolves if bridging has already completed', async () => {
+      const params = getBridgeTrackinParams({
+        bridgeTransfer: {
+          completedAt: 1,
+          startBlockNumber,
+          metadata: {
+            nonce,
+          },
+        },
+        updateListener,
+      });
+
+      const { result } = await trackTargetTx(bridgeMock.config!, params);
+      expect(await result).toStrictEqual(params.bridgeTransfer);
+      expect(doneMock).toHaveBeenCalledWith(params.bridgeTransfer);
+      expect(updateListenerWithoutReference).not.toHaveBeenCalled();
+
+      expect(getTrackingDelayByChainId).toHaveBeenCalledWith(TARGET_CHAIN.chainId);
+      expect(retryPromise).toHaveBeenCalledWith({
+        promise: expect.any(Function),
+        delay,
+        startAfter: INITIAL_DELAY,
+      });
+    });
+
+    it('resolves if transaction has timed out', async () => {
+      const params = getBridgeTrackinParams({
+        bridgeTransfer: {
+          startBlockNumber,
+          metadata: {
+            nonce,
+          },
+        },
+        updateListener,
+      });
+
+      const time = params.bridgeTransfer.sourceStartedAt + TRACKING_LIMIT_MS;
+
+      jest.useFakeTimers().setSystemTime(time);
+
+      const expectedResult = {
+        ...params.bridgeTransfer,
+        completedAt: time,
+        errorCode: ErrorCode.TIMEOUT,
+      };
+
+      const { result } = await trackTargetTx(bridgeMock.config!, params);
+      expect(await result).toStrictEqual(expectedResult);
+      expect(doneMock).toHaveBeenCalledWith(expectedResult);
+      expect(updateListenerWithoutReference).toHaveBeenCalledTimes(1);
+      expect(updateListenerWithoutReference).toHaveBeenCalledWith(expectedResult);
+
+      expect(getTrackingDelayByChainId).toHaveBeenCalledWith(TARGET_CHAIN.chainId);
+      expect(retryPromise).toHaveBeenCalledWith({
+        promise: expect.any(Function),
+        delay,
+        startAfter: INITIAL_DELAY,
+      });
+    });
+
+    it('resolves if startBlockNumber became invalid', async () => {
+      (retryPromise as jest.Mock).mockImplementationOnce(
+        ({ promise }: { promise: (done: () => unknown) => Promise<unknown> }) => ({
+          result: promise(doneMock).then(() => promise(doneMock)),
+        }),
+      );
+
+      const targetBlockNumber = 0n;
+
+      const params = getBridgeTrackinParams({
+        bridgeTransfer: {
+          requiredTargetConfirmationCount: 5,
+          startBlockNumber,
+          metadata: {
+            nonce,
+          },
+        },
+        updateListener,
+      });
+
+      const expectedResult = {
+        ...params.bridgeTransfer,
+        completedAt: now,
+        startBlockNumber: targetBlockNumber,
+        errorCode: ErrorCode.INVALID_PARAMS,
+      };
+
+      targetClientMock.getBlockNumber.mockResolvedValueOnce(targetBlockNumber);
+      targetClientMock.getLogs.mockResolvedValueOnce([]);
+
+      const { result } = await trackTargetTx(bridgeMock.config!, params);
+      expect(await result).toStrictEqual(expectedResult);
+      expect(doneMock).toHaveBeenCalledWith(expectedResult);
+
+      expect(updateListenerWithoutReference).toHaveBeenCalledTimes(2);
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(1, {
+        ...params.bridgeTransfer,
+        startBlockNumber: targetBlockNumber,
+      });
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(2, expectedResult);
+
+      expect(targetClientMock.getTransactionReceipt).not.toHaveBeenCalled();
+      expect(retryPromise).toHaveBeenCalledWith({
+        promise: expect.any(Function),
+        delay,
+        startAfter: INITIAL_DELAY,
+      });
+    });
+
+    it('resolves if transaction was reverted', async () => {
+      const targetBlockNumber = 50n;
+      const receiptMock = {
+        status: 'reverted',
+      };
+      const params = getBridgeTrackinParams({
+        bridgeTransfer: {
+          startBlockNumber,
+          metadata: {
+            nonce,
+          },
+        },
+        updateListener,
+      });
+
+      targetClientMock.getLogs.mockResolvedValueOnce([{ transactionHash: txHash }]);
+      targetClientMock.getTransactionReceipt.mockResolvedValueOnce(receiptMock);
+      targetClientMock.getBlockNumber.mockResolvedValueOnce(targetBlockNumber);
+
+      const expectedResult = {
+        ...params.bridgeTransfer,
+        targetTxHash: txHash,
+        targetNetworkFee: networkFee,
+        completedAt: now,
+        errorCode: ErrorCode.TRANSACTION_REVERTED,
+      };
+
+      const { result } = await trackTargetTx(bridgeMock.config!, params);
+      expect(await result).toStrictEqual(expectedResult);
+      expect(doneMock).toHaveBeenCalledWith(expectedResult);
+      expect(updateListenerWithoutReference).toHaveBeenCalledTimes(3);
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(1, {
+        ...params.bridgeTransfer,
+        targetTxHash: txHash,
+      });
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(2, {
+        ...params.bridgeTransfer,
+        targetTxHash: txHash,
+        targetNetworkFee: networkFee,
+      });
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(3, expectedResult);
+
+      expect(targetClientMock.getLogs).toHaveBeenCalledWith({
+        address: TARGET_TRANSMITTER_ADDRESS,
+        event: msgReceivedEvent,
+        args: { nonce },
+        fromBlock: 'earliest',
+        toBlock: 'latest',
+      });
+      expect(targetClientMock.getTransactionReceipt).toHaveBeenCalledWith({ hash: txHash });
+      expect(targetClientMock.getTransaction).toHaveBeenCalledWith({ hash: txHash });
+      expect(getNetworkFeeEVM).toHaveBeenCalledWith(txMock, receiptMock);
+
+      expect(getTrackingDelayByChainId).toHaveBeenCalledWith(TARGET_CHAIN.chainId);
+      expect(retryPromise).toHaveBeenCalledWith({
+        promise: expect.any(Function),
+        delay,
+        startAfter: INITIAL_DELAY,
+      });
+    });
+
+    it('does not resolve if transaction hash is unknown', async () => {
+      const targetBlockNumber = 50;
+
+      const params = getBridgeTrackinParams({
+        bridgeTransfer: {
+          requiredTargetConfirmationCount: 5,
+          startBlockNumber,
+          metadata: {
+            nonce,
+          },
+        },
+        updateListener,
+      });
+
+      targetClientMock.getBlockNumber.mockResolvedValueOnce(targetBlockNumber);
+      targetClientMock.getLogs.mockResolvedValueOnce([]);
+
+      const { result } = await trackTargetTx(bridgeMock.config!, params);
+      expect(await result).toBeUndefined();
+      expect(doneMock).not.toHaveBeenCalled();
+
+      expect(updateListenerWithoutReference).toHaveBeenCalledTimes(1);
+      expect(updateListenerWithoutReference).toHaveBeenCalledWith({
+        ...params.bridgeTransfer,
+        startBlockNumber: targetBlockNumber,
+      });
+
+      expect(targetClientMock.getLogs).toHaveBeenCalledWith({
+        address: TARGET_TRANSMITTER_ADDRESS,
+        event: msgReceivedEvent,
+        args: { nonce },
+        fromBlock: 'earliest',
+        toBlock: 'latest',
+      });
+
+      expect(targetClientMock.getTransactionReceipt).not.toHaveBeenCalled();
+      expect(retryPromise).toHaveBeenCalledWith({
+        promise: expect.any(Function),
+        delay,
+        startAfter: INITIAL_DELAY,
+      });
+    });
+
+    it('does not resolve if more confirmations are needed', async () => {
+      const targetBlockNumber = 50;
+      const receiptMock = {
+        status: 'succeeded',
+      };
+      const confirmations = 3;
+      const params = getBridgeTrackinParams({
+        bridgeTransfer: {
+          requiredTargetConfirmationCount: 5,
+          startBlockNumber,
+          metadata: {
+            nonce,
+          },
+        },
+        updateListener,
+      });
+
+      targetClientMock.getLogs.mockResolvedValueOnce([{ transactionHash: txHash }]);
+      targetClientMock.getTransactionReceipt.mockResolvedValueOnce(receiptMock);
+      targetClientMock.getTransactionConfirmations.mockResolvedValueOnce(confirmations);
+      targetClientMock.getBlockNumber.mockResolvedValueOnce(targetBlockNumber);
+
+      const { result } = await trackTargetTx(bridgeMock.config!, params);
+      expect(await result).toBeUndefined();
+      expect(doneMock).not.toHaveBeenCalled();
+      expect(updateListenerWithoutReference).toHaveBeenCalledTimes(3);
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(1, {
+        ...params.bridgeTransfer,
+        targetTxHash: txHash,
+      });
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(2, {
+        ...params.bridgeTransfer,
+        targetTxHash: txHash,
+        targetNetworkFee: networkFee,
+      });
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(3, {
+        ...params.bridgeTransfer,
+        targetTxHash: txHash,
+        targetNetworkFee: networkFee,
+        targetConfirmationCount: confirmations,
+      });
+
+      expect(targetClientMock.getLogs).toHaveBeenCalledWith({
+        address: TARGET_TRANSMITTER_ADDRESS,
+        event: msgReceivedEvent,
+        args: { nonce },
+        fromBlock: 'earliest',
+        toBlock: 'latest',
+      });
+      expect(targetClientMock.getTransactionReceipt).toHaveBeenCalledWith({ hash: txHash });
+      expect(targetClientMock.getTransaction).toHaveBeenCalledWith({ hash: txHash });
+      expect(getNetworkFeeEVM).toHaveBeenCalledWith(txMock, receiptMock);
+      expect(targetClientMock.getTransactionConfirmations).toHaveBeenCalledWith({ hash: txHash });
+
+      expect(getTrackingDelayByChainId).toHaveBeenCalledWith(TARGET_CHAIN.chainId);
+      expect(retryPromise).toHaveBeenCalledWith({
+        promise: expect.any(Function),
+        delay,
+        startAfter: INITIAL_DELAY,
+      });
+    });
+
+    it('resolves if transaction has enough confirmations', async () => {
+      const targetBlockNumber = MAX_BLOCKS * 6n;
+      const receiptMock = {
+        status: 'succeeded',
+      };
+      const confirmations = 3;
+      const params = getBridgeTrackinParams({
+        bridgeTransfer: {
+          requiredTargetConfirmationCount: confirmations,
+          startBlockNumber: MAX_BLOCKS * 2n,
+          metadata: {
+            nonce,
+          },
+        },
+        updateListener,
+      });
+
+      const expectedResult = {
+        ...params.bridgeTransfer,
+        targetTxHash: txHash,
+        targetNetworkFee: networkFee,
+        targetConfirmationCount: confirmations,
+        completedAt: now,
+      };
+
+      targetClientMock.getLogs.mockResolvedValueOnce([{ transactionHash: txHash }]);
+      targetClientMock.getTransactionReceipt.mockResolvedValueOnce(receiptMock);
+      targetClientMock.getTransactionConfirmations.mockResolvedValueOnce(confirmations);
+      targetClientMock.getBlockNumber.mockResolvedValueOnce(targetBlockNumber);
+
+      const { result } = await trackTargetTx(bridgeMock.config!, params);
+      expect(await result).toStrictEqual(expectedResult);
+      expect(doneMock).toHaveBeenCalledWith(expectedResult);
+      expect(updateListenerWithoutReference).toHaveBeenCalledTimes(4);
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(1, {
+        ...params.bridgeTransfer,
+        targetTxHash: txHash,
+      });
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(2, {
+        ...params.bridgeTransfer,
+        targetTxHash: txHash,
+        targetNetworkFee: networkFee,
+      });
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(3, {
+        ...params.bridgeTransfer,
+        targetTxHash: txHash,
+        targetNetworkFee: networkFee,
+        targetConfirmationCount: confirmations,
+      });
+      expect(updateListenerWithoutReference).toHaveBeenNthCalledWith(4, expectedResult);
+
+      expect(targetClientMock.getLogs).toHaveBeenCalledWith({
+        address: TARGET_TRANSMITTER_ADDRESS,
+        event: msgReceivedEvent,
+        args: { nonce },
+        fromBlock: params.bridgeTransfer.startBlockNumber! - MAX_BLOCKS,
+        toBlock: params.bridgeTransfer.startBlockNumber! + MAX_BLOCKS,
+      });
+      expect(targetClientMock.getTransactionReceipt).toHaveBeenCalledWith({ hash: txHash });
+      expect(targetClientMock.getTransaction).toHaveBeenCalledWith({ hash: txHash });
+      expect(getNetworkFeeEVM).toHaveBeenCalledWith(txMock, receiptMock);
+      expect(targetClientMock.getTransactionConfirmations).toHaveBeenCalledWith({ hash: txHash });
+
+      expect(getTrackingDelayByChainId).toHaveBeenCalledWith(TARGET_CHAIN.chainId);
+      expect(retryPromise).toHaveBeenCalledWith({
+        promise: expect.any(Function),
+        delay,
+        startAfter: INITIAL_DELAY,
+      });
+    });
+  });
+});