@avalabs/bridge-unified 2.1.1 → 2.1.2

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

@@ -1,779 +0,0 @@
-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,
-      });
-    });
-  });
-});