@shapeshiftoss/unchained-client 10.14.3 → 10.14.4

package/dist/cjs/evm/ethereum/parser/__tests__/ethereum.test.js

@@ -0,0 +1,3151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const caip_1 = require("@shapeshiftoss/caip");
+const contracts_1 = require("@shapeshiftoss/contracts");
+const vitest_1 = require("vitest");
+const types_1 = require("../../../../types");
+const arbitrumBridgeErc20Claim_1 = require("../../../arbitrum/parser/__tests__/mockData/arbitrumBridgeErc20Claim");
+const arbitrumBridgeErc20DepositTx_1 = require("../../../arbitrum/parser/__tests__/mockData/arbitrumBridgeErc20DepositTx");
+const arbitrumBridgeNativeClaim_1 = require("../../../arbitrum/parser/__tests__/mockData/arbitrumBridgeNativeClaim");
+const arbitrumBridgeNativeCreateRetryableTicketTx_1 = require("../../../arbitrum/parser/__tests__/mockData/arbitrumBridgeNativeCreateRetryableTicketTx");
+const arbitrumBridgeNativeDepositTx_1 = require("../../../arbitrum/parser/__tests__/mockData/arbitrumBridgeNativeDepositTx");
+const index_1 = require("../index");
+const erc721_1 = __importDefault(require("./mockData/erc721"));
+const erc1155_1 = __importDefault(require("./mockData/erc1155"));
+const ethSelfSend_1 = __importDefault(require("./mockData/ethSelfSend"));
+const foxClaim_1 = __importDefault(require("./mockData/foxClaim"));
+const foxExit_1 = __importDefault(require("./mockData/foxExit"));
+const foxStake_1 = __importDefault(require("./mockData/foxStake"));
+const foxyClaimWithdraw_1 = __importDefault(require("./mockData/foxyClaimWithdraw"));
+const foxyInstantUnstake_1 = __importDefault(require("./mockData/foxyInstantUnstake"));
+const foxyStake_1 = __importDefault(require("./mockData/foxyStake"));
+const foxyUnstake_1 = __importDefault(require("./mockData/foxyUnstake"));
+const multiSigSendEth_1 = __importDefault(require("./mockData/multiSigSendEth"));
+const thorchainLoanOpenEth_1 = __importDefault(require("./mockData/thorchainLoanOpenEth"));
+const thorchainLoanOpenOutboundEth_1 = __importDefault(require("./mockData/thorchainLoanOpenOutboundEth"));
+const thorchainLoanOpenOutboundToken_1 = __importDefault(require("./mockData/thorchainLoanOpenOutboundToken"));
+const thorchainLoanOpenRefundEth_1 = __importDefault(require("./mockData/thorchainLoanOpenRefundEth"));
+const thorchainLoanRepaymentEth_1 = __importDefault(require("./mockData/thorchainLoanRepaymentEth"));
+const thorchainLoanRepaymentOutboundEth_1 = __importDefault(require("./mockData/thorchainLoanRepaymentOutboundEth"));
+const thorchainLoanRepaymentRefundEth_1 = __importDefault(require("./mockData/thorchainLoanRepaymentRefundEth"));
+const thorchainLoanRepaymentRefundToken_1 = __importDefault(require("./mockData/thorchainLoanRepaymentRefundToken"));
+const thorchainLoanRepaymentToken_1 = __importDefault(require("./mockData/thorchainLoanRepaymentToken"));
+const thorchainLpDepositEth_1 = __importDefault(require("./mockData/thorchainLpDepositEth"));
+const thorchainLpDepositToken_1 = __importDefault(require("./mockData/thorchainLpDepositToken"));
+const thorchainLpOutboundEth_1 = __importDefault(require("./mockData/thorchainLpOutboundEth"));
+const thorchainLpOutboundToken_1 = __importDefault(require("./mockData/thorchainLpOutboundToken"));
+const thorchainLpRefundEth_1 = __importDefault(require("./mockData/thorchainLpRefundEth"));
+const thorchainLpRefundToken_1 = __importDefault(require("./mockData/thorchainLpRefundToken"));
+const thorchainLpWithdrawEth_1 = __importDefault(require("./mockData/thorchainLpWithdrawEth"));
+const thorchainLpWithdrawToken_1 = __importDefault(require("./mockData/thorchainLpWithdrawToken"));
+const thorchainSaversDepositEth_1 = __importDefault(require("./mockData/thorchainSaversDepositEth"));
+const thorchainSaversDepositToken_1 = __importDefault(require("./mockData/thorchainSaversDepositToken"));
+const thorchainSaversOutboundEth_1 = __importDefault(require("./mockData/thorchainSaversOutboundEth"));
+const thorchainSaversOutboundToken_1 = __importDefault(require("./mockData/thorchainSaversOutboundToken"));
+const thorchainSaversRefundEth_1 = __importDefault(require("./mockData/thorchainSaversRefundEth"));
+const thorchainSaversRefundToken_1 = __importDefault(require("./mockData/thorchainSaversRefundToken"));
+const thorchainSaversWithdrawEth_1 = __importDefault(require("./mockData/thorchainSaversWithdrawEth"));
+const thorchainSaversWithdrawToken_1 = __importDefault(require("./mockData/thorchainSaversWithdrawToken"));
+const thorchainStreamingSwapEth_1 = __importDefault(require("./mockData/thorchainStreamingSwapEth"));
+const thorchainStreamingSwapOutboundEth_1 = __importDefault(require("./mockData/thorchainStreamingSwapOutboundEth"));
+const thorchainStreamingSwapOutboundToken_1 = __importDefault(require("./mockData/thorchainStreamingSwapOutboundToken"));
+const thorchainStreamingSwapRefundEth_1 = __importDefault(require("./mockData/thorchainStreamingSwapRefundEth"));
+const thorchainStreamingSwapRefundToken_1 = __importDefault(require("./mockData/thorchainStreamingSwapRefundToken"));
+const thorchainStreamingSwapToken_1 = __importDefault(require("./mockData/thorchainStreamingSwapToken"));
+const thorchainSwapEth_1 = __importDefault(require("./mockData/thorchainSwapEth"));
+const thorchainSwapLongtail_1 = __importDefault(require("./mockData/thorchainSwapLongtail"));
+const thorchainSwapOutboundEth_1 = __importDefault(require("./mockData/thorchainSwapOutboundEth"));
+const thorchainSwapOutboundLongtail_1 = __importDefault(require("./mockData/thorchainSwapOutboundLongtail"));
+const thorchainSwapOutboundToken_1 = __importDefault(require("./mockData/thorchainSwapOutboundToken"));
+const thorchainSwapRefundEth_1 = __importDefault(require("./mockData/thorchainSwapRefundEth"));
+const thorchainSwapRefundToken_1 = __importDefault(require("./mockData/thorchainSwapRefundToken"));
+const thorchainSwapToken_1 = __importDefault(require("./mockData/thorchainSwapToken"));
+const tokens_1 = require("./mockData/tokens");
+const tokenSelfSend_1 = __importDefault(require("./mockData/tokenSelfSend"));
+const uniAddLiquidity_1 = __importDefault(require("./mockData/uniAddLiquidity"));
+const uniApprove_1 = __importDefault(require("./mockData/uniApprove"));
+const uniRemoveLiquidity_1 = __importDefault(require("./mockData/uniRemoveLiquidity"));
+const wethDeposit_1 = __importDefault(require("./mockData/wethDeposit"));
+const wethWithdraw_1 = __importDefault(require("./mockData/wethWithdraw"));
+const zrxTradeBondToUni_1 = __importDefault(require("./mockData/zrxTradeBondToUni"));
+const zrxTradeEthToMatic_1 = __importDefault(require("./mockData/zrxTradeEthToMatic"));
+const zrxTradeTetherToKishu_1 = __importDefault(require("./mockData/zrxTradeTetherToKishu"));
+const zrxTradeTribeToEth_1 = __importDefault(require("./mockData/zrxTradeTribeToEth"));
+const mocks = vitest_1.vi.hoisted(() => {
+    return {
+        get: vitest_1.vi.fn(),
+        post: vitest_1.vi.fn(),
+    };
+});
+const getApi = vitest_1.vi.hoisted(async () => {
+    const actual = await vitest_1.vi.importActual('../../index');
+    const v1Api = vitest_1.vi.mocked(new actual.V1Api());
+    return v1Api;
+});
+vitest_1.vi.mock('axios', () => {
+    const mockAxios = {
+        create: vitest_1.vi.fn(() => ({
+            get: mocks.get,
+            post: mocks.post,
+        })),
+        get: mocks.get,
+        post: mocks.post,
+    };
+    return {
+        default: mockAxios,
+    };
+});
+const makeTxParser = vitest_1.vi.fn(async () => new index_1.TransactionParser({
+    api: (await getApi),
+    assetId: caip_1.ethAssetId,
+    chainId: caip_1.ethChainId,
+    thorMidgardUrl: 'thor',
+    mayaMidgardUrl: 'maya',
+    rpcUrl: '',
+}));
+(0, vitest_1.describe)('parseTx', () => {
+    (0, vitest_1.beforeEach)(() => {
+        mocks.get.mockReset();
+    });
+    (0, vitest_1.describe)('standard', () => {
+        (0, vitest_1.describe)('erc721', () => {
+            (0, vitest_1.it)('should be able to parse mempool send', async () => {
+                const { txMempool } = erc721_1.default;
+                const address = '0xa5d981BC0Bc57500ffEDb2674c597F14a3Cb68c1';
+                const expected = {
+                    txid: txMempool.txid,
+                    blockHeight: txMempool.blockHeight,
+                    blockTime: txMempool.timestamp,
+                    address,
+                    chainId: 'eip155:1',
+                    confirmations: txMempool.confirmations,
+                    status: types_1.TxStatus.Pending,
+                    transfers: [],
+                };
+                const txParser = await makeTxParser();
+                const actual = await txParser.parse(txMempool, address);
+                (0, vitest_1.expect)(actual).toEqual(expected);
+            });
+            (0, vitest_1.it)('should be able to parse send', async () => {
+                const { tx } = erc721_1.default;
+                const address = '0xa5d981BC0Bc57500ffEDb2674c597F14a3Cb68c1';
+                const expected = {
+                    txid: tx.txid,
+                    blockHash: tx.blockHash,
+                    blockHeight: tx.blockHeight,
+                    blockTime: tx.timestamp,
+                    address,
+                    chainId: 'eip155:1',
+                    confirmations: tx.confirmations,
+                    status: types_1.TxStatus.Confirmed,
+                    fee: {
+                        assetId: caip_1.ethAssetId,
+                        value: '5974629016703985',
+                    },
+                    transfers: [
+                        {
+                            type: types_1.TransferType.Send,
+                            to: '0x86c6B7f9D91D104e53F2Be608549F0Dc6ECABb57',
+                            from: address,
+                            assetId: 'eip155:1/erc721:0x68d0f6d1d99bb830e17ffaa8adb5bbed9d6eec2e/2253',
+                            totalValue: '1',
+                            components: [{ value: '1' }],
+                            id: '2253',
+                            token: {
+                                contract: '0x68d0F6d1d99Bb830E17fFaA8aDB5BbeD9D6EEc2E',
+                                decimals: 18,
+                                name: 'Diamond Exhibition',
+                                symbol: 'DIAMOND',
+                            },
+                        },
+                    ],
+                };
+                const txParser = await makeTxParser();
+                const actual = await txParser.parse(tx, address);
+                (0, vitest_1.expect)(actual).toEqual(expected);
+            });
+            (0, vitest_1.it)('should be able to parse mempool receive', async () => {
+                const { txMempool } = erc721_1.default;
+                const address = '0x86c6B7f9D91D104e53F2Be608549F0Dc6ECABb57';
+                const expected = {
+                    txid: txMempool.txid,
+                    blockHeight: txMempool.blockHeight,
+                    blockTime: txMempool.timestamp,
+                    address,
+                    chainId: 'eip155:1',
+                    confirmations: txMempool.confirmations,
+                    status: types_1.TxStatus.Pending,
+                    transfers: [],
+                };
+                const txParser = await makeTxParser();
+                const actual = await txParser.parse(txMempool, address);
+                (0, vitest_1.expect)(actual).toEqual(expected);
+            });
+            (0, vitest_1.it)('should be able to parse receive', async () => {
+                const { tx } = erc721_1.default;
+                const address = '0x86c6B7f9D91D104e53F2Be608549F0Dc6ECABb57';
+                const expected = {
+                    txid: tx.txid,
+                    blockHash: tx.blockHash,
+                    blockHeight: tx.blockHeight,
+                    blockTime: tx.timestamp,
+                    address,
+                    chainId: 'eip155:1',
+                    confirmations: tx.confirmations,
+                    status: types_1.TxStatus.Confirmed,
+                    transfers: [
+                        {
+                            type: types_1.TransferType.Receive,
+                            to: address,
+                            from: '0xa5d981BC0Bc57500ffEDb2674c597F14a3Cb68c1',
+                            assetId: 'eip155:1/erc721:0x68d0f6d1d99bb830e17ffaa8adb5bbed9d6eec2e/2253',
+                            totalValue: '1',
+                            components: [{ value: '1' }],
+                            id: '2253',
+                            token: {
+                                contract: '0x68d0F6d1d99Bb830E17fFaA8aDB5BbeD9D6EEc2E',
+                                decimals: 18,
+                                name: 'Diamond Exhibition',
+                                symbol: 'DIAMOND',
+                            },
+                        },
+                    ],
+                };
+                const txParser = await makeTxParser();
+                const actual = await txParser.parse(tx, address);
+                (0, vitest_1.expect)(actual).toEqual(expected);
+            });
+        });
+        (0, vitest_1.describe)('erc1155', () => {
+            (0, vitest_1.it)('should be able to parse mempool send', async () => {
+                const { txMempool } = erc1155_1.default;
+                const address = '0x63acA79298884a520776B5bE662230a37de4a327';
+                const expected = {
+                    txid: txMempool.txid,
+                    blockHeight: txMempool.blockHeight,
+                    blockTime: txMempool.timestamp,
+                    address,
+                    chainId: 'eip155:1',
+                    confirmations: txMempool.confirmations,
+                    status: types_1.TxStatus.Pending,
+                    transfers: [],
+                };
+                const txParser = await makeTxParser();
+                const actual = await txParser.parse(txMempool, address);
+                (0, vitest_1.expect)(actual).toEqual(expected);
+            });
+            (0, vitest_1.it)('should be able to parse send', async () => {
+                const { tx } = erc1155_1.default;
+                const address = '0x63acA79298884a520776B5bE662230a37de4a327';
+                const expected = {
+                    txid: tx.txid,
+                    blockHash: tx.blockHash,
+                    blockHeight: tx.blockHeight,
+                    blockTime: tx.timestamp,
+                    address,
+                    chainId: 'eip155:1',
+                    confirmations: tx.confirmations,
+                    status: types_1.TxStatus.Confirmed,
+                    fee: {
+                        assetId: caip_1.ethAssetId,
+                        value: '28797509921536974',
+                    },
+                    transfers: [
+                        {
+                            type: types_1.TransferType.Send,
+                            to: '0x3A3548e060Be10c2614d0a4Cb0c03CC9093fD799',
+                            from: address,
+                            assetId: 'eip155:1/erc1155:0x3b287c39ed2812a4c87521301c9c56577b5bdd8d/2',
+                            totalValue: '1',
+                            components: [{ value: '1' }],
+                            id: '2',
+                            token: {
+                                contract: '0x3b287C39ed2812A4C87521301c9C56577b5Bdd8D',
+                                decimals: 18,
+                                name: 'Rene Distort',
+                                symbol: 'RENDIS',
+                            },
+                        },
+                    ],
+                };
+                const txParser = await makeTxParser();
+                const actual = await txParser.parse(tx, address);
+                (0, vitest_1.expect)(actual).toEqual(expected);
+            });
+            (0, vitest_1.it)('should be able to parse mempool receive', async () => {
+                const { txMempool } = erc1155_1.default;
+                const address = '0x3A3548e060Be10c2614d0a4Cb0c03CC9093fD799';
+                const expected = {
+                    txid: txMempool.txid,
+                    blockHeight: txMempool.blockHeight,
+                    blockTime: txMempool.timestamp,
+                    address,
+                    chainId: 'eip155:1',
+                    confirmations: txMempool.confirmations,
+                    status: types_1.TxStatus.Pending,
+                    transfers: [],
+                };
+                const txParser = await makeTxParser();
+                const actual = await txParser.parse(txMempool, address);
+                (0, vitest_1.expect)(actual).toEqual(expected);
+            });
+            (0, vitest_1.it)('should be able to parse receive', async () => {
+                const { tx } = erc1155_1.default;
+                const address = '0x3A3548e060Be10c2614d0a4Cb0c03CC9093fD799';
+                const expected = {
+                    txid: tx.txid,
+                    blockHash: tx.blockHash,
+                    blockHeight: tx.blockHeight,
+                    blockTime: tx.timestamp,
+                    address,
+                    chainId: 'eip155:1',
+                    confirmations: tx.confirmations,
+                    status: types_1.TxStatus.Confirmed,
+                    transfers: [
+                        {
+                            type: types_1.TransferType.Receive,
+                            to: address,
+                            from: '0x63acA79298884a520776B5bE662230a37de4a327',
+                            assetId: 'eip155:1/erc1155:0x3b287c39ed2812a4c87521301c9c56577b5bdd8d/2',
+                            totalValue: '1',
+                            components: [{ value: '1' }],
+                            id: '2',
+                            token: {
+                                contract: '0x3b287C39ed2812A4C87521301c9C56577b5Bdd8D',
+                                decimals: 18,
+                                name: 'Rene Distort',
+                                symbol: 'RENDIS',
+                            },
+                        },
+                    ],
+                };
+                const txParser = await makeTxParser();
+                const actual = await txParser.parse(tx, address);
+                (0, vitest_1.expect)(actual).toEqual(expected);
+            });
+        });
+    });
+    (0, vitest_1.describe)('multiSig', () => {
+        (0, vitest_1.it)('should be able to parse eth multi sig send', async () => {
+            const { tx } = multiSigSendEth_1.default;
+            const address = '0x76DA1578aC163CA7ca4143B7dEAa428e85Db3042';
+            const standardTransfer = {
+                assetId: 'eip155:1/slip44:60',
+                components: [{ value: '1201235000000000000' }],
+                from: '0x79fE68B3e4Bc2B91a4C8dfFb5317C7B8813d8Ae7',
+                to: '0x76DA1578aC163CA7ca4143B7dEAa428e85Db3042',
+                token: undefined,
+                totalValue: '1201235000000000000',
+                type: types_1.TransferType.Receive,
+            };
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: undefined,
+                status: types_1.TxStatus.Confirmed,
+                transfers: [standardTransfer],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+    });
+    (0, vitest_1.describe)('thorchain', () => {
+        (0, vitest_1.it)('should be able to parse eth swap (deposit)', async () => {
+            const { txDeposit: tx } = thorchainSwapEth_1.default;
+            const address = '0xCeb660E7623E8f8312B3379Df747c35f2217b595';
+            const memo = 'SWAP:THOR.RUNE:thor19f3dsgetxzssvdmqnplfep5fe42fsrvq9u87ax:';
+            mocks.get.mockImplementation(() => ({ data: { actions: [{}] } }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        assetId: caip_1.ethAssetId,
+                        components: [{ value: tx.value }],
+                        from: address,
+                        to: tx.to,
+                        totalValue: tx.value,
+                        type: types_1.TransferType.Send,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    method: 'swap',
+                    swap: { type: 'Standard' },
+                },
+                trade: { dexName: types_1.Dex.Thor, memo, type: types_1.TradeType.Swap },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth swap (depositWithExpiry)', async () => {
+            const { txDepositWithExpiry: tx } = thorchainSwapEth_1.default;
+            const address = '0xA2d3301900e429D29179d3c5c7Cd8d813E8Fbba5';
+            const memo = '=:b:3GsSTWcQfbEpMQW4nJ6oPr1UhQZZCS74KD:7415381:t:30';
+            mocks.get.mockImplementation(() => ({ data: { actions: [{}] } }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        assetId: caip_1.ethAssetId,
+                        components: [{ value: tx.value }],
+                        from: address,
+                        to: tx.to,
+                        totalValue: tx.value,
+                        type: types_1.TransferType.Send,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    method: 'swap',
+                    swap: { type: 'Standard' },
+                },
+                trade: { dexName: types_1.Dex.Thor, memo, type: types_1.TradeType.Swap },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth swap outbound', async () => {
+            const { tx, actionsResponse } = thorchainSwapOutboundEth_1.default;
+            const address = '0x5a8C5afbCC1A58cCbe17542957b587F46828B38E';
+            const memo = 'OUT:8C859BA50BC2351797F52F954971E1C6BA1F0A77610AC197BD99C4EEC6A3692A';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: caip_1.ethAssetId,
+                        components: [{ value: '1579727090000000000' }],
+                        from: '0x42A5Ed456650a09Dc10EBc6361A7480fDd61f27B',
+                        to: address,
+                        totalValue: '1579727090000000000',
+                        type: types_1.TransferType.Receive,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.swap?.memo,
+                    method: 'swapOut',
+                    swap: { type: 'Standard' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth swap refund', async () => {
+            const { tx, actionsResponse } = thorchainSwapRefundEth_1.default;
+            const address = '0xfc0Cc6E85dFf3D75e3985e0CB83B090cfD498dd1';
+            const memo = 'REFUND:851B4997CF8F9FBA806B3780E0C178CCB173AE78E3FD5056F7375B059B22BD3A';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: caip_1.ethAssetId,
+                        components: [{ value: '6412730000000000' }],
+                        from: '0x42A5Ed456650a09Dc10EBc6361A7480fDd61f27B',
+                        to: address,
+                        totalValue: '6412730000000000',
+                        type: types_1.TransferType.Receive,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.refund?.memo,
+                    method: 'swapRefund',
+                    swap: { type: 'Standard' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token swap', async () => {
+            const { tx } = thorchainSwapToken_1.default;
+            const address = '0x5a8C5afbCC1A58cCbe17542957b587F46828B38E';
+            const memo = 'SWAP:THOR.RUNE:thor1hhjupkzy3t6ccelhz7qw8epyx4rm8a06nlm5ce:110928642111';
+            mocks.get.mockImplementation(() => ({ data: { actions: [{}] } }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                        components: [{ value: '16598881497' }],
+                        from: address,
+                        to: tx.to,
+                        totalValue: '16598881497',
+                        type: types_1.TransferType.Send,
+                        token: tokens_1.usdcToken,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    method: 'swap',
+                    swap: { type: 'Standard' },
+                },
+                trade: { dexName: types_1.Dex.Thor, memo, type: types_1.TradeType.Swap },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token swap outbound', async () => {
+            const { tx, actionsResponse } = thorchainSwapOutboundToken_1.default;
+            const address = '0x5a8C5afbCC1A58cCbe17542957b587F46828B38E';
+            const memo = 'OUT:F3AC4E90AB5951AB9FEB1715B481422B904A40B0F6753CC844E326B1213CF70E';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                        components: [{ value: '47596471640' }],
+                        from: '0x42A5Ed456650a09Dc10EBc6361A7480fDd61f27B',
+                        to: address,
+                        totalValue: '47596471640',
+                        type: types_1.TransferType.Receive,
+                        token: tokens_1.usdcToken,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.swap?.memo,
+                    method: 'swapOut',
+                    swap: { type: 'Standard' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token swap refund', async () => {
+            const { tx, actionsResponse } = thorchainSwapRefundToken_1.default;
+            const address = '0x9c2E658ffC8ea7Fad00A4829Bd4B554e8a716f73';
+            const memo = 'REFUND:FEFB84289F49F1878A26A5DC7AA039F45C4D60AC216AACEF1082D99FFFBE3468';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: 'eip155:1/erc20:0x0bc529c00c6401aef6d220be8c6ea1667f6ad93e',
+                        components: [{ value: '65391780000000000' }],
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        totalValue: '65391780000000000',
+                        type: types_1.TransferType.Receive,
+                        token: {
+                            contract: '0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e',
+                            decimals: 18,
+                            name: 'yearn.finance',
+                            symbol: 'YFI',
+                        },
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.refund?.memo,
+                    method: 'swapRefund',
+                    swap: { type: 'Standard' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth streaming swap', async () => {
+            const { tx } = thorchainStreamingSwapEth_1.default;
+            const address = '0xb3305D7Ba0A76b519926E2e203A3cBF80DbA555d';
+            const memo = '=:LTC.LTC:ltc1q7k2yhdsacqv6v4rfpp3dzqx538z05qkmcajwg4:0/1/0:ti:70';
+            mocks.get.mockImplementation(() => ({ data: { actions: [{}] } }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        assetId: caip_1.ethAssetId,
+                        components: [{ value: '6696393970416121' }],
+                        from: address,
+                        to: tx.to,
+                        totalValue: '6696393970416121',
+                        type: types_1.TransferType.Send,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    method: 'swap',
+                    swap: { type: 'Streaming' },
+                },
+                trade: { dexName: types_1.Dex.Thor, memo, type: types_1.TradeType.Swap },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth streaming swap outbound', async () => {
+            const { tx, actionsResponse } = thorchainStreamingSwapOutboundEth_1.default;
+            const address = '0x6CC41829d0a67456970529F92d6abACc83d69E61';
+            const memo = 'OUT:65A75EE7D50DD30A9A401678E8582441DFCC43C2F0F4B9EC9CB1123A64F6E3DC';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: caip_1.ethAssetId,
+                        components: [{ value: '4300220000000000' }],
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        totalValue: '4300220000000000',
+                        type: types_1.TransferType.Receive,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.swap?.memo,
+                    method: 'swapOut',
+                    swap: { type: 'Streaming' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth streaming swap refund', async () => {
+            const { tx, actionsResponse } = thorchainStreamingSwapRefundEth_1.default;
+            const address = '0xAAA3bFb53d5D5116FAeDc5Dd457531f8465f78af';
+            const memo = 'REFUND:9FB10E490AF1B763563CFC12FB08E5F32E387FBB6398884E742BF0178FAD6D88';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: caip_1.ethAssetId,
+                        components: [{ value: '4353475000000000000' }],
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        totalValue: '4353475000000000000',
+                        type: types_1.TransferType.Receive,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.refund?.memo,
+                    method: 'swapRefund',
+                    swap: { type: 'Streaming' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token streaming swap', async () => {
+            const { tx } = thorchainStreamingSwapToken_1.default;
+            const address = '0xaFEA60C8BfE8D27f95F3e27F84ED6AB2FE409d39';
+            const memo = '=:GAIA.ATOM:cosmos1ggd2pw5stl9cx4svme4ak59ynsqtam3q8ephqx:0/1/0:ti:70';
+            mocks.get.mockImplementation(() => ({ data: { actions: [{}] } }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
+                        components: [{ value: '12000000' }],
+                        from: address,
+                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        totalValue: '12000000',
+                        type: types_1.TransferType.Send,
+                        token: tokens_1.usdtToken,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    method: 'swap',
+                    swap: { type: 'Streaming' },
+                },
+                trade: { dexName: types_1.Dex.Thor, memo, type: types_1.TradeType.Swap },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token streaming swap outbound', async () => {
+            const { tx, actionsResponse } = thorchainStreamingSwapOutboundToken_1.default;
+            const address = '0x02416c573925A104573E00Fc9b7dd5aD83CF37ae';
+            const memo = 'OUT:97C882D099B95C89C5F73C0E9F89857C6D7676BB1A74A59618FAA917E28052B6';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
+                        components: [{ value: '159339774' }],
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        totalValue: '159339774',
+                        type: types_1.TransferType.Receive,
+                        token: tokens_1.usdtToken,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.swap?.memo,
+                    method: 'swapOut',
+                    swap: { type: 'Streaming' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token streaming swap refund', async () => {
+            const { tx, actionsResponse } = thorchainStreamingSwapRefundToken_1.default;
+            const address = '0x111ae447488df1bfa35C1AC9724b1246e839b0C0';
+            const memo = 'REFUND:4A2DA151915B28172E2191C3226BE0AD6A245B02395D676C51ABF31E99DC511B';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: 'eip155:1/erc20:0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0',
+                        components: [{ value: '125941190000000000' }],
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        totalValue: '125941190000000000',
+                        type: types_1.TransferType.Receive,
+                        token: {
+                            contract: '0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0',
+                            decimals: 18,
+                            name: 'Wrapped liquid staked Ether 2.0',
+                            symbol: 'wstETH',
+                        },
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.refund?.memo,
+                    method: 'swapRefund',
+                    swap: { type: 'Streaming' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth savers deposit', async () => {
+            const { tx } = thorchainSaversDepositEth_1.default;
+            const address = '0x912F42653c9aE29346151baE12Eb80281A95aaBe';
+            const memo = '+:ETH/ETH::ss:0';
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: '0x5C04b555E86507742455b280A4F6436cC43af314',
+                        assetId: caip_1.ethAssetId,
+                        totalValue: '75299305807869161',
+                        components: [{ value: '75299305807869161' }],
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'deposit',
+                    memo,
+                    liquidity: { type: 'Savers' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth savers withdraw', async () => {
+            const { tx } = thorchainSaversWithdrawEth_1.default;
+            const address = '0x2e3E405055d7781cB49716726001AaC26d3F6FC8';
+            const memo = '-:ETH/ETH:5000';
+            mocks.get.mockImplementation(() => ({ data: { actions: [{}] } }));
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: '0x610c97879CD08D54721fD6CDfA143887778AD8c1',
+                        assetId: caip_1.ethAssetId,
+                        totalValue: '10000000000',
+                        components: [{ value: '10000000000' }],
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'withdraw',
+                    memo,
+                    liquidity: { type: 'Savers' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth savers outbound', async () => {
+            const { tx, actionsResponse } = thorchainSaversOutboundEth_1.default;
+            const address = '0x2e3E405055d7781cB49716726001AaC26d3F6FC8';
+            const memo = 'OUT:60D4C809FC6B1FE59761203759ECA4EAB8E2EEC90F25593F0DEBF0DAA78CDC36';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: caip_1.ethAssetId,
+                        components: [{ value: '7399090000000000' }],
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        totalValue: '7399090000000000',
+                        type: types_1.TransferType.Receive,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[1].metadata?.withdraw?.memo,
+                    method: 'withdrawOut',
+                    liquidity: { type: 'Savers' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth savers refund', async () => {
+            const { tx, actionsResponse } = thorchainSaversRefundEth_1.default;
+            const address = '0xc49066C93521a32135574656573458bE11dBA05B';
+            const memo = 'REFUND:8238A7E45925D5A2982B9B72472ED641B710CCB7572AF7B3297999263927D0C4';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: caip_1.ethAssetId,
+                        components: [{ value: '939834410000000000' }],
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        totalValue: '939834410000000000',
+                        type: types_1.TransferType.Receive,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.refund?.memo,
+                    method: 'depositRefund',
+                    liquidity: { type: 'Savers' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token savers deposit', async () => {
+            const { tx } = thorchainSaversDepositToken_1.default;
+            const address = '0xee66F9018D253fc335db47214985cf63FCC6e693';
+            const memo = '+:ETH/USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48::ss:0';
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                        totalValue: '2012368190',
+                        components: [{ value: '2012368190' }],
+                        token: tokens_1.usdcToken,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'deposit',
+                    memo,
+                    liquidity: { type: 'Savers' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token savers withdraw', async () => {
+            const { tx } = thorchainSaversWithdrawToken_1.default;
+            const address = '0x44F87741f17b0fd8079C258F833708a15205BF72';
+            const memo = '-:ETH/USDT-ec7:9900';
+            mocks.get.mockImplementation(() => ({ data: { actions: [{}] } }));
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        assetId: caip_1.ethAssetId,
+                        totalValue: '10000000000',
+                        components: [{ value: '10000000000' }],
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'withdraw',
+                    memo,
+                    liquidity: { type: 'Savers' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token savers outbound', async () => {
+            const { tx, actionsResponse } = thorchainSaversOutboundToken_1.default;
+            const address = '0x44F87741f17b0fd8079C258F833708a15205BF72';
+            const memo = 'OUT:CC5103CBFDC4F24C48DD2C5AECF2C6956613EA3AF6FB74582030DEB6B8FA6298';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
+                        components: [{ value: '2059204899' }],
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        totalValue: '2059204899',
+                        type: types_1.TransferType.Receive,
+                        token: tokens_1.usdtToken,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[1].metadata?.withdraw?.memo,
+                    method: 'withdrawOut',
+                    liquidity: { type: 'Savers' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token savers refund', async () => {
+            const { tx, actionsResponse } = thorchainSaversRefundToken_1.default;
+            const address = '0xc49066C93521a32135574656573458bE11dBA05B';
+            const memo = 'REFUND:8238A7E45925D5A2982B9B72472ED641B710CCB7572AF7B3297999263927D0C4';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
+                        components: [{ value: '2059204899' }],
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        totalValue: '2059204899',
+                        type: types_1.TransferType.Receive,
+                        token: tokens_1.usdtToken,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.refund?.memo,
+                    method: 'depositRefund',
+                    liquidity: { type: 'Savers' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth lp deposit', async () => {
+            const { tx } = thorchainLpDepositEth_1.default;
+            const address = '0xAA07f696a5Eb1C3195B353625be29737419931aD';
+            const memo = '+:ETH.ETH::t:0';
+            mocks.get.mockImplementation(() => ({ data: { actions: [{}] } }));
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        assetId: caip_1.ethAssetId,
+                        totalValue: '7000000000000000000',
+                        components: [{ value: '7000000000000000000' }],
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'deposit',
+                    memo,
+                    liquidity: { type: 'LP' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth lp withdraw', async () => {
+            const { tx } = thorchainLpWithdrawEth_1.default;
+            const address = '0xAA07f696a5Eb1C3195B353625be29737419931aD';
+            const memo = '-:ETH.ETH:10000';
+            mocks.get.mockImplementation(() => ({ data: { actions: [{}] } }));
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        assetId: caip_1.ethAssetId,
+                        totalValue: '10000000000',
+                        components: [{ value: '10000000000' }],
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'withdraw',
+                    memo,
+                    liquidity: { type: 'LP' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth lp outbound', async () => {
+            const { tx, actionsResponse } = thorchainLpOutboundEth_1.default;
+            const address = '0xAA07f696a5Eb1C3195B353625be29737419931aD';
+            const memo = 'OUT:0A57839F87A8ABC586542C9A7F7E7E4D7D50A8BD1C680AE0C2963F6DC8185C52';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: caip_1.ethAssetId,
+                        components: [{ value: '5312070540000000000' }],
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        totalValue: '5312070540000000000',
+                        type: types_1.TransferType.Receive,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.withdraw?.memo,
+                    method: 'withdrawOut',
+                    liquidity: { type: 'LP' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth lp refund', async () => {
+            const { tx, actionsResponse } = thorchainLpRefundEth_1.default;
+            const address = '0xc49066C93521a32135574656573458bE11dBA05B';
+            const memo = 'REFUND:8238A7E45925D5A2982B9B72472ED641B710CCB7572AF7B3297999263927D0C4';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: caip_1.ethAssetId,
+                        components: [{ value: '939834410000000000' }],
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        totalValue: '939834410000000000',
+                        type: types_1.TransferType.Receive,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.refund?.memo,
+                    method: 'depositRefund',
+                    liquidity: { type: 'LP' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token lp deposit', async () => {
+            const { tx } = thorchainLpDepositToken_1.default;
+            const address = '0xc1a256a031A8D2938e1fa6782cf4a7411f5F0d73';
+            const memo = '+:ETH.USDT::wr:100';
+            mocks.get.mockImplementation(() => ({ data: { actions: [{}] } }));
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
+                        totalValue: '62678661',
+                        components: [{ value: '62678661' }],
+                        token: tokens_1.usdtToken,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'deposit',
+                    memo,
+                    liquidity: { type: 'LP' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token lp withdraw', async () => {
+            const { tx } = thorchainLpWithdrawToken_1.default;
+            const address = '0xc1a256a031A8D2938e1fa6782cf4a7411f5F0d73';
+            const memo = '-:ETH.USDT:10000';
+            mocks.get.mockImplementation(() => ({ data: { actions: [{}] } }));
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        assetId: caip_1.ethAssetId,
+                        totalValue: '10000000000',
+                        components: [{ value: '10000000000' }],
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'withdraw',
+                    memo,
+                    liquidity: { type: 'LP' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token lp outbound', async () => {
+            const { tx, actionsResponse } = thorchainLpOutboundToken_1.default;
+            const address = '0xc1a256a031A8D2938e1fa6782cf4a7411f5F0d73';
+            const memo = 'OUT:525DC683F3E79A3CD3A512BE76929D1C583952528493C71A9D68DD7ECAEE9019';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
+                        components: [{ value: '105663523' }],
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        totalValue: '105663523',
+                        type: types_1.TransferType.Receive,
+                        token: tokens_1.usdtToken,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.withdraw?.memo,
+                    method: 'withdrawOut',
+                    liquidity: { type: 'LP' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token lp refund', async () => {
+            const { tx, actionsResponse } = thorchainLpRefundToken_1.default;
+            const address = '0xc49066C93521a32135574656573458bE11dBA05B';
+            const memo = 'REFUND:8238A7E45925D5A2982B9B72472ED641B710CCB7572AF7B3297999263927D0C4';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
+                        components: [{ value: '2059204899' }],
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        totalValue: '2059204899',
+                        type: types_1.TransferType.Receive,
+                        token: tokens_1.usdtToken,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.refund?.memo,
+                    method: 'depositRefund',
+                    liquidity: { type: 'LP' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth loan open', async () => {
+            const { tx } = thorchainLoanOpenEth_1.default;
+            const address = '0x782C14C79945caD46Fbea57bb73d796366e76147';
+            const memo = '$+:ETH.DAI-0X6B175474E89094C44DA98B954EEDEAC495271D0F:0x782C14C79945caD46Fbea57bb73d796366e76147::t:0';
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        assetId: caip_1.ethAssetId,
+                        totalValue: '5000000000000000',
+                        components: [{ value: '5000000000000000' }],
+                    },
+                ],
+                data: { parser: 'thorchain', method: 'loanOpen', memo },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth loan open outbound', async () => {
+            const { tx, actionsResponse } = thorchainLoanOpenOutboundEth_1.default;
+            const address = '0x93Ca9d11740794b5E93f65a9AB63C930B1DB1f95';
+            const memo = 'OUT:55CDFE3F3A6DC2EFAEE9432CD7DEBDA14309955BCDCDADDE6ED96378B1297185';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        assetId: caip_1.ethAssetId,
+                        totalValue: '20948330710000000000',
+                        components: [{ value: '20948330710000000000' }],
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'loanOpenOut',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.swap?.memo,
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth loan open refund', async () => {
+            const { tx, actionsResponse } = thorchainLoanOpenRefundEth_1.default;
+            const address = '0xcc24D4368654599f05b637cdBC935c519a29310c';
+            const memo = 'REFUND:C8A08F3B12A3C371E06BBD036050029B5B940C24D2FAD85F112DC2B758B74B1A';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        assetId: caip_1.ethAssetId,
+                        totalValue: '4997600000000000000',
+                        components: [{ value: '4997600000000000000' }],
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'loanOpenRefund',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.refund?.memo,
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth loan repayment', async () => {
+            const { tx } = thorchainLoanRepaymentEth_1.default;
+            const address = '0xAe96D15537aFa0ceBc7792C8D4977de6CBf759c5';
+            const memo = '$-:BTC.BTC:bc1q85pgumgwvaw26j47xqt6dup5l995a9ecte9sfq';
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        assetId: caip_1.ethAssetId,
+                        totalValue: '45961550000000000',
+                        components: [{ value: '45961550000000000' }],
+                    },
+                ],
+                data: { parser: 'thorchain', method: 'loanRepayment', memo },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth loan repayment outbound', async () => {
+            const { tx, actionsResponse } = thorchainLoanRepaymentOutboundEth_1.default;
+            const address = '0x6293Eb0863C083819731eB329940a9b931cd9Cd9';
+            const memo = 'OUT:BE469BD2AFE7C5896EDE7D48BAB88FE8ABF8DCE9207AAC04FEBD746A7B43417D';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        assetId: caip_1.ethAssetId,
+                        totalValue: '1008315360000000000',
+                        components: [{ value: '1008315360000000000' }],
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'loanRepaymentOut',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.swap?.memo,
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth loan repayment refund', async () => {
+            const { tx, actionsResponse } = thorchainLoanRepaymentRefundEth_1.default;
+            const address = '0x2E2F2A4a49b0c936012aF4b67db562fF0e7D10d7';
+            const memo = 'REFUND:4DD8EEC829D9B5DC7910D4984272BA963600BA0F537F3ECB565C0BC05F589AE6';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        assetId: caip_1.ethAssetId,
+                        totalValue: '305222000000000000',
+                        components: [{ value: '305222000000000000' }],
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'loanRepaymentRefund',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.refund?.memo,
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token loan open outbound', async () => {
+            const { tx, actionsResponse } = thorchainLoanOpenOutboundToken_1.default;
+            const address = '0x0F55f315617869cBF62bdc4f883d8C0AD90Cf63f';
+            const memo = 'OUT:C803297230FA11CE9BFE1F2FC2A6A0A534776DF95AED33DF8EDE62BE0FCB266C';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                        totalValue: '1300324741',
+                        components: [{ value: '1300324741' }],
+                        token: tokens_1.usdcToken,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'loanOpenOut',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.swap?.memo,
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token loan repayment', async () => {
+            const { tx } = thorchainLoanRepaymentToken_1.default;
+            const address = '0x6293Eb0863C083819731eB329940a9b931cd9Cd9';
+            const memo = '$-:ETH.ETH:0x6293eb0863c083819731eb329940a9b931cd9cd9';
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
+                        totalValue: '751706937',
+                        components: [{ value: '751706937' }],
+                        token: tokens_1.usdtToken,
+                    },
+                ],
+                data: { parser: 'thorchain', method: 'loanRepayment', memo },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token loan repayment refund', async () => {
+            const { tx, actionsResponse } = thorchainLoanRepaymentRefundToken_1.default;
+            const address = '0x8a7eAE0fbd128D33022e9d64D912f9903e0f5fcc';
+            const memo = 'REFUND:92627113DC24A26A1DA33D9184CA4D0969628D72FB2B3675F01FAAB6EF6E6DE7';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
+                        to: address,
+                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                        totalValue: '110703296',
+                        components: [{ value: '110703296' }],
+                        token: tokens_1.usdcToken,
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'loanRepaymentRefund',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.refund?.memo,
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse longtail swap', async () => {
+            const { tx } = thorchainSwapLongtail_1.default;
+            const address = '0x10f6f534449A36489D65eF12A54A324102899479';
+            const memo = '=:DOGE.DOGE:D5ZxkWY2dwwjPhUEQBRHcb3wNamft1XGga:654517605534:ss:0';
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                fee: {
+                    assetId: caip_1.ethAssetId,
+                    value: tx.fee,
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: '0x11733abf0cdb43298f7e949c930188451a9A9Ef2',
+                        assetId: 'eip155:1/erc20:0xd533a949740bb3306d119cc777fa900ba034cd52',
+                        totalValue: '1177917668085453396367',
+                        components: [{ value: '1177917668085453396367' }],
+                        token: {
+                            contract: '0xD533a949740bb3306d119CC777fa900bA034cd52',
+                            decimals: 18,
+                            name: 'Curve DAO Token',
+                            symbol: 'CRV',
+                        },
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    method: 'swap',
+                    memo,
+                    swap: { type: 'Standard' },
+                },
+                trade: { dexName: types_1.Dex.Thor, memo, type: types_1.TradeType.Swap },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse longtail swap outbound', async () => {
+            const { tx, actionsResponse } = thorchainSwapOutboundLongtail_1.default;
+            const address = '0x80AcE046480e13b1dFCc5c7535c2D2d4Da652Fc6';
+            const memo = 'OUT:DC9C74908B12B8762E844AB1D143A3AC292D616D38AA5FCF7F8FF6702C21E9FB';
+            mocks.get.mockImplementation(() => ({ data: actionsResponse }));
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: types_1.TxStatus.Confirmed,
+                address,
+                chainId: caip_1.ethChainId,
+                transfers: [
+                    {
+                        assetId: 'eip155:1/erc20:0x04fa0d235c4abf4bcf4787af4cf447de572ef828',
+                        components: [{ value: '239486540176872266724' }],
+                        from: '0x157Dfa656Fdf0D18E1bA94075a53600D81cB3a97',
+                        to: address,
+                        totalValue: '239486540176872266724',
+                        type: types_1.TransferType.Receive,
+                        token: {
+                            contract: '0x04Fa0d235C4abf4BcF4787aF4CF447DE572eF828',
+                            decimals: 18,
+                            name: 'UMA Voting Token v1',
+                            symbol: 'UMA',
+                        },
+                    },
+                ],
+                data: {
+                    parser: 'thorchain',
+                    memo,
+                    originMemo: actionsResponse.actions[0].metadata?.swap?.memo,
+                    method: 'swapOut',
+                    swap: { type: 'Standard' },
+                },
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+    });
+    (0, vitest_1.describe)('zrx', () => {
+        (0, vitest_1.it)('should be able to parse token -> eth', async () => {
+            const { tx } = zrxTradeTribeToEth_1.default;
+            const address = '0x5bb96c35a68Cba037D0F261C67477416db137F03';
+            const trade = { dexName: types_1.Dex.Zrx, type: types_1.TradeType.Trade };
+            const buyTransfer = {
+                assetId: 'eip155:1/slip44:60',
+                components: [{ value: '541566754246167133' }],
+                from: contracts_1.ZRX_ETHEREUM_PROXY_CONTRACT,
+                to: address,
+                totalValue: '541566754246167133',
+                type: types_1.TransferType.Receive,
+            };
+            const sellTransfer = {
+                assetId: 'eip155:1/erc20:0xc7283b66eb1eb5fb86327f08e1b5816b0720212b',
+                components: [{ value: '1000000000000000000000' }],
+                from: address,
+                to: '0x7ce01885a13c652241aE02Ea7369Ee8D466802EB',
+                token: tokens_1.tribeToken,
+                totalValue: '1000000000000000000000',
+                type: types_1.TransferType.Send,
+            };
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: { parser: 'zrx' },
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '8308480000000000',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                transfers: [sellTransfer, buyTransfer],
+                trade,
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth -> token', async () => {
+            const { tx } = zrxTradeEthToMatic_1.default;
+            const address = '0x564BcA365D62BCC22dB53d032F8dbD35439C9206';
+            const trade = { dexName: types_1.Dex.Zrx, type: types_1.TradeType.Trade };
+            const buyTransfer = {
+                assetId: 'eip155:1/erc20:0x455e53cbb86018ac2b8092fdcd39d8444affc3f6',
+                components: [{ value: '50000000000000000000000' }],
+                from: '0x22F9dCF4647084d6C31b2765F6910cd85C178C18',
+                to: address,
+                token: tokens_1.maticToken,
+                totalValue: '50000000000000000000000',
+                type: types_1.TransferType.Receive,
+            };
+            const sellTransfer = {
+                assetId: 'eip155:1/slip44:60',
+                components: [{ value: '10000000000000000000' }],
+                from: address,
+                to: contracts_1.ZRX_ETHEREUM_PROXY_CONTRACT,
+                totalValue: '10000000000000000000',
+                type: types_1.TransferType.Send,
+            };
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: { parser: 'zrx' },
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '19815285000000000',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                transfers: [sellTransfer, buyTransfer],
+                trade,
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token -> token', async () => {
+            const { tx } = zrxTradeTetherToKishu_1.default;
+            const address = '0xb8b19c048296E086DaF69F54d48dE2Da444dB047';
+            const trade = { dexName: types_1.Dex.Zrx, type: types_1.TradeType.Trade };
+            const buyTransfer = {
+                type: types_1.TransferType.Receive,
+                from: '0xF82d8Ec196Fb0D56c6B82a8B1870F09502A49F88',
+                to: address,
+                assetId: 'eip155:1/erc20:0xa2b4c0af19cc16a6cfacce81f192b024d625817d',
+                totalValue: '9248567698016204727450',
+                components: [{ value: '9248567698016204727450' }],
+                token: tokens_1.kishuToken,
+            };
+            const sellTransfer = {
+                type: types_1.TransferType.Send,
+                from: address,
+                to: '0x0d4a11d5EEaaC28EC3F61d100daF4d40471f1852',
+                assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
+                totalValue: '45000000000',
+                components: [{ value: '45000000000' }],
+                token: tokens_1.usdtToken,
+            };
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: { parser: 'zrx' },
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '78183644000000000',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                transfers: [sellTransfer, buyTransfer],
+                trade,
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token -> token (multiple swaps)', async () => {
+            const { tx } = zrxTradeBondToUni_1.default;
+            const address = '0x986bB494db49E6f1CDC1be098e3157f8DDC5a821';
+            const trade = {
+                dexName: types_1.Dex.Zrx,
+                type: types_1.TradeType.Trade,
+            };
+            const buyTransfer1 = {
+                type: types_1.TransferType.Receive,
+                from: '0xEBFb684dD2b01E698ca6c14F10e4f289934a54D6',
+                to: address,
+                assetId: 'eip155:1/erc20:0x1f9840a85d5af5bf1d1762f925bdaddc4201f984',
+                totalValue: '56639587020747520629',
+                components: [{ value: '56639587020747520629' }],
+                token: tokens_1.uniToken,
+            };
+            const buyTransfer2 = {
+                type: types_1.TransferType.Receive,
+                from: '0xd3d2E2692501A5c9Ca623199D38826e513033a17',
+                to: address,
+                assetId: 'eip155:1/erc20:0x1f9840a85d5af5bf1d1762f925bdaddc4201f984',
+                totalValue: '47448670568188553620',
+                components: [{ value: '47448670568188553620' }],
+                token: tokens_1.uniToken,
+            };
+            const sellTransfer1 = {
+                type: types_1.TransferType.Send,
+                from: address,
+                to: '0x6591c4BcD6D7A1eb4E537DA8B78676C1576Ba244',
+                assetId: 'eip155:1/erc20:0x0391d2021f89dc339f60fff84546ea23e337750f',
+                totalValue: '53910224825217010944',
+                components: [{ value: '53910224825217010944' }],
+                token: tokens_1.bondToken,
+            };
+            const sellTransfer2 = {
+                type: types_1.TransferType.Send,
+                from: address,
+                to: '0xB17B1342579e4bcE6B6e9A426092EA57d33843D9',
+                assetId: 'eip155:1/erc20:0x0391d2021f89dc339f60fff84546ea23e337750f',
+                totalValue: '46089775174782989056',
+                components: [{ value: '46089775174782989056' }],
+                token: tokens_1.bondToken,
+            };
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: {
+                    method: undefined,
+                    parser: 'zrx',
+                },
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '18399681000000000',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                transfers: [sellTransfer1, buyTransfer1, sellTransfer2, buyTransfer2],
+                trade,
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+    });
+    (0, vitest_1.describe)('self send', () => {
+        (0, vitest_1.it)('should be able to parse eth mempool', async () => {
+            const { txMempool } = ethSelfSend_1.default;
+            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
+            const expected = {
+                txid: txMempool.txid,
+                blockHeight: txMempool.blockHeight,
+                blockTime: txMempool.timestamp,
+                address,
+                chainId: 'eip155:1',
+                confirmations: txMempool.confirmations,
+                data: undefined,
+                status: types_1.TxStatus.Pending,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        to: address,
+                        from: address,
+                        assetId: 'eip155:1/slip44:60',
+                        totalValue: '503100000000000',
+                        components: [{ value: '503100000000000' }],
+                    },
+                    {
+                        type: types_1.TransferType.Receive,
+                        to: address,
+                        from: address,
+                        assetId: 'eip155:1/slip44:60',
+                        totalValue: '503100000000000',
+                        components: [{ value: '503100000000000' }],
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(txMempool, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse eth', async () => {
+            const { tx } = ethSelfSend_1.default;
+            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: undefined,
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '399000000000000',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: address,
+                        assetId: 'eip155:1/slip44:60',
+                        totalValue: '503100000000000',
+                        components: [{ value: '503100000000000' }],
+                    },
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: address,
+                        to: address,
+                        assetId: 'eip155:1/slip44:60',
+                        totalValue: '503100000000000',
+                        components: [{ value: '503100000000000' }],
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token mempool', async () => {
+            const { txMempool } = tokenSelfSend_1.default;
+            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
+            const expected = {
+                txid: txMempool.txid,
+                blockHeight: txMempool.blockHeight,
+                blockTime: txMempool.timestamp,
+                address,
+                chainId: 'eip155:1',
+                confirmations: txMempool.confirmations,
+                data: undefined,
+                status: types_1.TxStatus.Pending,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: address,
+                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                        totalValue: '1502080',
+                        components: [{ value: '1502080' }],
+                        token: tokens_1.usdcToken,
+                    },
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: address,
+                        to: address,
+                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                        totalValue: '1502080',
+                        components: [{ value: '1502080' }],
+                        token: tokens_1.usdcToken,
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(txMempool, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse token', async () => {
+            const { tx } = tokenSelfSend_1.default;
+            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: undefined,
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '1011738000000000',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: address,
+                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                        totalValue: '1502080',
+                        components: [{ value: '1502080' }],
+                        token: tokens_1.usdcToken,
+                    },
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: address,
+                        to: address,
+                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                        totalValue: '1502080',
+                        components: [{ value: '1502080' }],
+                        token: tokens_1.usdcToken,
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+    });
+    (0, vitest_1.describe)('uniswap', () => {
+        (0, vitest_1.it)('should be able to parse approve', async () => {
+            const { tx } = uniApprove_1.default;
+            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: {
+                    assetId: 'eip155:1/erc20:0x470e8de2ebaef52014a47cb5e6af86884947f08c',
+                    method: 'approve',
+                    parser: 'erc20',
+                    value: '115792089237316195423570985008687907853269984665640564039457584007913129639935',
+                },
+                status: types_1.TxStatus.Confirmed,
+                trade: undefined,
+                fee: {
+                    value: '1447243200000000',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                transfers: [],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse add liquidity mempool', async () => {
+            const { txMempool } = uniAddLiquidity_1.default;
+            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
+            const expected = {
+                txid: txMempool.txid,
+                blockHeight: txMempool.blockHeight,
+                blockTime: txMempool.timestamp,
+                address,
+                chainId: 'eip155:1',
+                confirmations: txMempool.confirmations,
+                data: {
+                    method: 'addLiquidityETH',
+                    parser: 'uniV2',
+                },
+                status: types_1.TxStatus.Pending,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
+                        to: '0x470e8de2eBaef52014A47Cb5E6aF86884947F08c',
+                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                        totalValue: '100000000000000000000',
+                        components: [{ value: '100000000000000000000' }],
+                        token: {
+                            contract: '0xc770EEfAd204B5180dF6a14Ee197D99d808ee52d',
+                            decimals: 18,
+                            name: 'FOX',
+                            symbol: 'FOX',
+                        },
+                    },
+                    {
+                        type: types_1.TransferType.Send,
+                        from: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
+                        to: '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D',
+                        assetId: 'eip155:1/slip44:60',
+                        totalValue: '42673718176645189',
+                        components: [{ value: '42673718176645189' }],
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(txMempool, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse add liquidity', async () => {
+            const { tx } = uniAddLiquidity_1.default;
+            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: {
+                    method: 'addLiquidityETH',
+                    parser: 'uniV2',
+                },
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '26926494400000000',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
+                        to: '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D',
+                        assetId: 'eip155:1/slip44:60',
+                        totalValue: '42673718176645189',
+                        components: [{ value: '42673718176645189' }],
+                    },
+                    {
+                        type: types_1.TransferType.Send,
+                        from: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
+                        to: '0x470e8de2eBaef52014A47Cb5E6aF86884947F08c',
+                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                        totalValue: '100000000000000000000',
+                        components: [{ value: '100000000000000000000' }],
+                        token: tokens_1.foxToken,
+                    },
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: '0x0000000000000000000000000000000000000000',
+                        to: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
+                        assetId: 'eip155:1/erc20:0x470e8de2ebaef52014a47cb5e6af86884947f08c',
+                        totalValue: '1888842410762840601',
+                        components: [{ value: '1888842410762840601' }],
+                        token: tokens_1.uniV2Token,
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse remove liquidity mempool', async () => {
+            const { txMempool } = uniRemoveLiquidity_1.default;
+            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
+            const expected = {
+                txid: txMempool.txid,
+                blockHeight: txMempool.blockHeight,
+                blockTime: txMempool.timestamp,
+                address,
+                chainId: 'eip155:1',
+                confirmations: txMempool.confirmations,
+                data: {
+                    method: 'removeLiquidityETH',
+                    parser: 'uniV2',
+                },
+                status: types_1.TxStatus.Pending,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
+                        to: '0x470e8de2eBaef52014A47Cb5E6aF86884947F08c',
+                        assetId: 'eip155:1/erc20:0x470e8de2ebaef52014a47cb5e6af86884947f08c',
+                        totalValue: '298717642142382954',
+                        components: [{ value: '298717642142382954' }],
+                        token: tokens_1.uniV2Token,
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(txMempool, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse remove liquidity', async () => {
+            const { tx } = uniRemoveLiquidity_1.default;
+            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: {
+                    method: 'removeLiquidityETH',
+                    parser: 'uniV2',
+                },
+                status: types_1.TxStatus.Confirmed,
+                trade: undefined,
+                fee: {
+                    value: '4082585000000000',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
+                        to: '0x470e8de2eBaef52014A47Cb5E6aF86884947F08c',
+                        assetId: 'eip155:1/erc20:0x470e8de2ebaef52014a47cb5e6af86884947f08c',
+                        totalValue: '298717642142382954',
+                        components: [{ value: '298717642142382954' }],
+                        token: tokens_1.uniV2Token,
+                    },
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D',
+                        to: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
+                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                        totalValue: '15785079906515930982',
+                        components: [{ value: '15785079906515930982' }],
+                        token: tokens_1.foxToken,
+                    },
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D',
+                        to: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
+                        assetId: 'eip155:1/slip44:60',
+                        totalValue: '6761476182340434',
+                        components: [{ value: '6761476182340434' }],
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+    });
+    (0, vitest_1.describe)('fox', () => {
+        (0, vitest_1.it)('should be able to parse claim', async () => {
+            const { tx } = foxClaim_1.default;
+            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: undefined,
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '2559843000000000',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: '0x02FfdC5bfAbe5c66BE067ff79231585082CA5fe2',
+                        to: address,
+                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                        totalValue: '1500000000000000000000',
+                        components: [{ value: '1500000000000000000000' }],
+                        token: tokens_1.foxToken,
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse stake mempool', async () => {
+            const { txMempool } = foxStake_1.default;
+            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
+            const expected = {
+                txid: txMempool.txid,
+                blockHeight: txMempool.blockHeight,
+                blockTime: txMempool.timestamp,
+                address,
+                chainId: 'eip155:1',
+                confirmations: txMempool.confirmations,
+                data: {
+                    method: 'stake',
+                    parser: 'uniV2',
+                },
+                status: types_1.TxStatus.Pending,
+                transfers: [],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(txMempool, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse stake', async () => {
+            const { tx } = foxStake_1.default;
+            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: {
+                    method: 'stake',
+                    parser: 'uniV2',
+                },
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '4650509500000000',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        from: address,
+                        to: contracts_1.UNI_V2_FOX_STAKING_REWARDS_V3_CONTRACT,
+                        assetId: 'eip155:1/erc20:0x470e8de2ebaef52014a47cb5e6af86884947f08c',
+                        totalValue: '99572547380794318',
+                        components: [{ value: '99572547380794318' }],
+                        token: tokens_1.uniV2Token,
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse exit mempool', async () => {
+            const { txMempool } = foxExit_1.default;
+            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
+            const expected = {
+                txid: txMempool.txid,
+                blockHeight: txMempool.blockHeight,
+                blockTime: txMempool.timestamp,
+                address,
+                chainId: 'eip155:1',
+                confirmations: txMempool.confirmations,
+                data: {
+                    method: 'exit',
+                    parser: 'uniV2',
+                },
+                status: types_1.TxStatus.Pending,
+                transfers: [],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(txMempool, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse exit', async () => {
+            const { tx } = foxExit_1.default;
+            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: {
+                    method: 'exit',
+                    parser: 'uniV2',
+                },
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '6136186875000000',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                transfers: [
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: contracts_1.UNI_V2_FOX_STAKING_REWARDS_V3_CONTRACT,
+                        to: address,
+                        assetId: 'eip155:1/erc20:0x470e8de2ebaef52014a47cb5e6af86884947f08c',
+                        totalValue: '531053586030903030',
+                        components: [{ value: '531053586030903030' }],
+                        token: tokens_1.uniV2Token,
+                    },
+                    {
+                        type: types_1.TransferType.Receive,
+                        from: contracts_1.UNI_V2_FOX_STAKING_REWARDS_V3_CONTRACT,
+                        to: address,
+                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                        totalValue: '317669338073988',
+                        components: [{ value: '317669338073988' }],
+                        token: tokens_1.foxToken,
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+    });
+    (0, vitest_1.describe)('foxy', () => {
+        (0, vitest_1.it)('should be able to parse stake', async () => {
+            const { tx } = foxyStake_1.default;
+            const address = '0xCBa38513451bCE398A87F9950a154034Cad59cE9';
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: {
+                    method: 'stake',
+                    parser: 'foxy',
+                },
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '8343629232016788',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                trade: undefined,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        to: contracts_1.FOXY_STAKING_CONTRACT,
+                        from: address,
+                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                        totalValue: '109548875260073394762',
+                        components: [{ value: '109548875260073394762' }],
+                        token: tokens_1.foxToken,
+                    },
+                    {
+                        type: types_1.TransferType.Receive,
+                        to: address,
+                        from: contracts_1.FOXY_STAKING_CONTRACT,
+                        assetId: 'eip155:1/erc20:0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3',
+                        totalValue: '109548875260073394762',
+                        components: [{ value: '109548875260073394762' }],
+                        token: tokens_1.foxyToken,
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse unstake', async () => {
+            const { tx } = foxyUnstake_1.default;
+            const address = '0x557C61Ec8F7A675BE03EFe11962430ac8Cff4229';
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: {
+                    method: 'unstake',
+                    parser: 'foxy',
+                },
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '7586577934107040',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                trade: undefined,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        to: contracts_1.FOXY_STAKING_CONTRACT,
+                        from: address,
+                        assetId: 'eip155:1/erc20:0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3',
+                        totalValue: '24292579090466512304',
+                        components: [{ value: '24292579090466512304' }],
+                        token: tokens_1.foxyToken,
+                    },
+                    {
+                        type: types_1.TransferType.Receive,
+                        to: address,
+                        from: contracts_1.FOXY_STAKING_CONTRACT,
+                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                        totalValue: '22438383781076552673',
+                        components: [{ value: '22438383781076552673' }],
+                        token: tokens_1.foxToken,
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse instant unstake', async () => {
+            const { tx } = foxyInstantUnstake_1.default;
+            const address = '0x1f41A6429D2035035253859f6edBd6438Ecf5d39';
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: {
+                    method: 'instantUnstake',
+                    parser: 'foxy',
+                },
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '10348720598973963',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                trade: undefined,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        to: contracts_1.FOXY_STAKING_CONTRACT,
+                        from: address,
+                        assetId: 'eip155:1/erc20:0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3',
+                        totalValue: '9885337259647255313',
+                        components: [{ value: '9885337259647255313' }],
+                        token: tokens_1.foxyToken,
+                    },
+                    {
+                        type: types_1.TransferType.Receive,
+                        to: address,
+                        from: '0x8EC637Fe2800940C7959f9BAd4fE69e41225CD39',
+                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                        totalValue: '9638203828156073931',
+                        components: [{ value: '9638203828156073931' }],
+                        token: tokens_1.foxToken,
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse claim withdraw', async () => {
+            const { tx } = foxyClaimWithdraw_1.default;
+            const address = '0x55FB947880EE0660C90bC2055748aD70956FbE3c';
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: {
+                    method: 'claimWithdraw',
+                    parser: 'foxy',
+                },
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '4735850597827293',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                trade: undefined,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Receive,
+                        to: address,
+                        from: contracts_1.FOXY_STAKING_CONTRACT,
+                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                        totalValue: '1200000000000000000000',
+                        components: [{ value: '1200000000000000000000' }],
+                        token: tokens_1.foxToken,
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+    });
+    (0, vitest_1.describe)('weth', () => {
+        (0, vitest_1.it)('should be able to parse deposit', async () => {
+            const { tx } = wethDeposit_1.default;
+            const address = '0x2D801972327b0F11422d9Cc14A3d00B07ae0CceB';
+            const contractAddress = contracts_1.WETH_TOKEN_CONTRACT;
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: {
+                    method: 'deposit',
+                    parser: 'weth',
+                },
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '2161334514900778',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                trade: undefined,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Receive,
+                        to: address,
+                        from: contractAddress,
+                        assetId: 'eip155:1/erc20:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                        totalValue: '30000000000000000',
+                        components: [{ value: '30000000000000000' }],
+                        token: {
+                            contract: contractAddress,
+                            decimals: 18,
+                            name: 'Wrapped Ether',
+                            symbol: 'WETH',
+                        },
+                    },
+                    {
+                        assetId: 'eip155:1/slip44:60',
+                        components: [{ value: '30000000000000000' }],
+                        from: address,
+                        to: contractAddress,
+                        token: undefined,
+                        totalValue: '30000000000000000',
+                        type: types_1.TransferType.Send,
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse deposit extra input data', async () => {
+            const { tx2 } = wethDeposit_1.default;
+            const address = '0xE7F92E3d5FDe63C90A917e25854826873497ef3D';
+            const contractAddress = contracts_1.WETH_TOKEN_CONTRACT;
+            const expected = {
+                txid: tx2.txid,
+                blockHeight: tx2.blockHeight,
+                blockTime: tx2.timestamp,
+                blockHash: tx2.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx2.confirmations,
+                data: {
+                    method: 'deposit',
+                    parser: 'weth',
+                },
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '1087028000000000',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                trade: undefined,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Receive,
+                        to: address,
+                        from: contractAddress,
+                        assetId: 'eip155:1/erc20:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                        totalValue: '3264000000000000',
+                        components: [{ value: '3264000000000000' }],
+                        token: {
+                            contract: contractAddress,
+                            decimals: 18,
+                            name: 'Wrapped Ether',
+                            symbol: 'WETH',
+                        },
+                    },
+                    {
+                        assetId: 'eip155:1/slip44:60',
+                        components: [{ value: '3264000000000000' }],
+                        from: address,
+                        to: contractAddress,
+                        token: undefined,
+                        totalValue: '3264000000000000',
+                        type: types_1.TransferType.Send,
+                    },
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx2, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse withdrawal', async () => {
+            const { tx } = wethWithdraw_1.default;
+            const address = '0xa6F15FB2cc5dC96c2EBA18c101AD3fAD27F74839';
+            const contractAddress = contracts_1.WETH_TOKEN_CONTRACT;
+            const internalTransfer = {
+                assetId: 'eip155:1/slip44:60',
+                components: [{ value: '100000000000000000' }],
+                from: contractAddress,
+                to: address,
+                token: undefined,
+                totalValue: '100000000000000000',
+                type: types_1.TransferType.Receive,
+            };
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                address,
+                chainId: 'eip155:1',
+                confirmations: tx.confirmations,
+                data: {
+                    method: 'withdraw',
+                    parser: 'weth',
+                },
+                status: types_1.TxStatus.Confirmed,
+                fee: {
+                    value: '1482222626533792',
+                    assetId: 'eip155:1/slip44:60',
+                },
+                trade: undefined,
+                transfers: [
+                    {
+                        type: types_1.TransferType.Send,
+                        to: contractAddress,
+                        from: address,
+                        assetId: 'eip155:1/erc20:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                        totalValue: '100000000000000000',
+                        components: [{ value: '100000000000000000' }],
+                        token: {
+                            contract: contractAddress,
+                            decimals: 18,
+                            name: 'Wrapped Ether',
+                            symbol: 'WETH',
+                        },
+                    },
+                    internalTransfer,
+                ],
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+    });
+    (0, vitest_1.describe)('arbitrumBridge', () => {
+        (0, vitest_1.it)('should be able to parse erc20 deposit', async () => {
+            const tx = arbitrumBridgeErc20DepositTx_1.arbitrumBridgeErc20DepositTx;
+            const address = '0x94a42DB1E578eFf403B1644FA163e523803241Fd';
+            const expected = {
+                address: '0x94a42DB1E578eFf403B1644FA163e523803241Fd',
+                blockHash: '0xed1bdf1823c6d9fc3f2486d795e79e65fdac065173f13e10fe1fdc11c0afc90d',
+                blockHeight: 20146622,
+                blockTime: 1719051767,
+                chainId: 'eip155:1',
+                confirmations: 24456,
+                data: {
+                    assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                    method: 'outboundTransferDeposit',
+                    parser: 'arbitrumBridge',
+                },
+                fee: {
+                    assetId: 'eip155:1/slip44:60',
+                    value: '573646509671922',
+                },
+                status: 'Confirmed',
+                trade: undefined,
+                transfers: [
+                    {
+                        assetId: 'eip155:1/slip44:60',
+                        components: [
+                            {
+                                value: '43769826666368',
+                            },
+                        ],
+                        from: '0x94a42DB1E578eFf403B1644FA163e523803241Fd',
+                        id: undefined,
+                        to: '0x72Ce9c846789fdB6fC1f34aC4AD25Dd9ef7031ef',
+                        token: undefined,
+                        totalValue: '43769826666368',
+                        type: 'Send',
+                    },
+                    {
+                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                        components: [
+                            {
+                                value: '2000000',
+                            },
+                        ],
+                        from: '0x94a42DB1E578eFf403B1644FA163e523803241Fd',
+                        id: undefined,
+                        to: '0xcEe284F754E854890e311e3280b767F80797180d',
+                        token: {
+                            contract: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+                            decimals: 6,
+                            name: 'USD Coin',
+                            symbol: 'USDC',
+                        },
+                        totalValue: '2000000',
+                        type: 'Send',
+                    },
+                ],
+                txid: '0x2b666f87986ed222e45c5299f893258e2468d59068ed36425f26ee2088baeb60',
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse ETH deposit', async () => {
+            const tx = arbitrumBridgeNativeDepositTx_1.arbitrumBridgeNativeDepositTx;
+            const address = '0x94a42DB1E578eFf403B1644FA163e523803241Fd';
+            const expected = {
+                address,
+                blockHash: '0x547baea04677590e3c4887cc8ed8d488e383573aee47e32c9308f98e73af4320',
+                blockHeight: 19832035,
+                blockTime: 1715252267,
+                chainId: 'eip155:1',
+                confirmations: 330563,
+                data: {
+                    assetId: undefined,
+                    method: 'depositEth',
+                    parser: 'arbitrumBridge',
+                },
+                status: 'Confirmed',
+                trade: undefined,
+                transfers: [],
+                txid: '0xd115a9c89b5a387fc4da3be84329038e25cb13e36dd054126de9ac9ae3177f19',
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse ETH create retryable ticket', async () => {
+            const tx = arbitrumBridgeNativeCreateRetryableTicketTx_1.arbitrumBridgeNativeCreateRetryableTicketTx;
+            const address = '0x94a42DB1E578eFf403B1644FA163e523803241Fd';
+            const expected = {
+                address: '0x94a42DB1E578eFf403B1644FA163e523803241Fd',
+                blockHash: '0x612914871278754aa065019e9de359340b6c7b22f5e72d276807d2fc426bddf4',
+                blockHeight: 20146557,
+                blockTime: 1719050987,
+                chainId: 'eip155:1',
+                confirmations: 24521,
+                data: {
+                    assetId: undefined,
+                    method: 'createRetryableTicket',
+                    parser: 'arbitrumBridge',
+                },
+                fee: {
+                    assetId: 'eip155:1/slip44:60',
+                    value: '302058949978604',
+                },
+                status: 'Confirmed',
+                trade: undefined,
+                transfers: [
+                    {
+                        assetId: 'eip155:1/slip44:60',
+                        components: [
+                            {
+                                value: '10013325858196800',
+                            },
+                        ],
+                        from: '0x94a42DB1E578eFf403B1644FA163e523803241Fd',
+                        id: undefined,
+                        to: '0x4Dbd4fc535Ac27206064B68FfCf827b0A60BAB3f',
+                        token: undefined,
+                        totalValue: '10013325858196800',
+                        type: 'Send',
+                    },
+                ],
+                txid: '0x75f20f8f2caead042ac63c3175f34e505bc9a388a10b4c4e64a55831ef4d33cf',
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse erc20 claim', async () => {
+            const tx = arbitrumBridgeErc20Claim_1.arbitrumBridgeErc20Claim;
+            const address = '0x5daF465a9cCf64DEB146eEaE9E7Bd40d6761c986';
+            const expected = {
+                address: '0x5daF465a9cCf64DEB146eEaE9E7Bd40d6761c986',
+                blockHash: '0x224eec4d01a99b1cd011bc5e89fd6ddd468e5b9ad1c9658b6ca852e487ee4d2b',
+                blockHeight: 20627282,
+                blockTime: 1724850443,
+                chainId: 'eip155:1',
+                confirmations: 918,
+                data: {
+                    assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                    method: 'executeTransaction',
+                    parser: 'arbitrumBridge',
+                },
+                fee: {
+                    assetId: 'eip155:1/slip44:60',
+                    value: '572048472071840',
+                },
+                status: 'Confirmed',
+                trade: undefined,
+                transfers: [
+                    {
+                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                        components: [
+                            {
+                                value: '1000000000000000000',
+                            },
+                        ],
+                        from: '0xa3A7B6F88361F48403514059F1F16C8E78d60EeC',
+                        id: undefined,
+                        to: '0x5daF465a9cCf64DEB146eEaE9E7Bd40d6761c986',
+                        token: {
+                            contract: '0xc770EEfAd204B5180dF6a14Ee197D99d808ee52d',
+                            decimals: 18,
+                            name: 'FOX',
+                            symbol: 'FOX',
+                        },
+                        totalValue: '1000000000000000000',
+                        type: 'Receive',
+                    },
+                ],
+                txid: '0x48bd40a3cac5d25b21d2ae31375f6c273a3fe37f78cfca385e05a948038a1c57',
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+        (0, vitest_1.it)('should be able to parse ETH claim', async () => {
+            const tx = arbitrumBridgeNativeClaim_1.arbitrumBridgeNativeClaim;
+            const address = '0x5daF465a9cCf64DEB146eEaE9E7Bd40d6761c986';
+            const expected = {
+                address: '0x5daF465a9cCf64DEB146eEaE9E7Bd40d6761c986',
+                blockHash: '0x22ec673c7bc57087312a368b26abfd183ddb0c19fb225c7c86d15d7d2f3da047',
+                blockHeight: 20627308,
+                blockTime: 1724850755,
+                chainId: 'eip155:1',
+                confirmations: 892,
+                data: {
+                    assetId: undefined,
+                    method: 'executeTransaction',
+                    parser: 'arbitrumBridge',
+                },
+                fee: {
+                    assetId: 'eip155:1/slip44:60',
+                    value: '369113082579370',
+                },
+                status: 'Confirmed',
+                trade: undefined,
+                transfers: [
+                    {
+                        assetId: 'eip155:1/slip44:60',
+                        components: [
+                            {
+                                value: '1000000000000000',
+                            },
+                        ],
+                        from: '0x8315177aB297bA92A06054cE80a67Ed4DBd7ed3a',
+                        id: undefined,
+                        to: '0x5daF465a9cCf64DEB146eEaE9E7Bd40d6761c986',
+                        token: undefined,
+                        totalValue: '1000000000000000',
+                        type: 'Receive',
+                    },
+                ],
+                txid: '0x88d984a81220fe9d45ec0cdc07c56ad22cb31439ac6d5abfe32c069990d86f56',
+            };
+            const txParser = await makeTxParser();
+            const actual = await txParser.parse(tx, address);
+            (0, vitest_1.expect)(actual).toEqual(expected);
+        });
+    });
+});