@shapeshiftoss/unchained-client 10.14.7-alpha.1 → 10.14.7

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

@@ -1,3146 +0,0 @@
-import { ethAssetId, ethChainId } from '@shapeshiftoss/caip';
-import { FOXY_STAKING_CONTRACT, UNI_V2_FOX_STAKING_REWARDS_V3_CONTRACT, WETH_TOKEN_CONTRACT, ZRX_ETHEREUM_PROXY_CONTRACT, } from '@shapeshiftoss/contracts';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { Dex, TradeType, TransferType, TxStatus } from '../../../../types.js';
-import { arbitrumBridgeErc20Claim } from '../../../arbitrum/parser/__tests__/mockData/arbitrumBridgeErc20Claim.js';
-import { arbitrumBridgeErc20DepositTx } from '../../../arbitrum/parser/__tests__/mockData/arbitrumBridgeErc20DepositTx.js';
-import { arbitrumBridgeNativeClaim } from '../../../arbitrum/parser/__tests__/mockData/arbitrumBridgeNativeClaim.js';
-import { arbitrumBridgeNativeCreateRetryableTicketTx } from '../../../arbitrum/parser/__tests__/mockData/arbitrumBridgeNativeCreateRetryableTicketTx.js';
-import { arbitrumBridgeNativeDepositTx } from '../../../arbitrum/parser/__tests__/mockData/arbitrumBridgeNativeDepositTx.js';
-import { TransactionParser } from '../index.js';
-import erc721 from './mockData/erc721.js';
-import erc1155 from './mockData/erc1155.js';
-import ethSelfSend from './mockData/ethSelfSend.js';
-import foxClaim from './mockData/foxClaim.js';
-import foxExit from './mockData/foxExit.js';
-import foxStake from './mockData/foxStake.js';
-import foxyClaimWithdraw from './mockData/foxyClaimWithdraw.js';
-import foxyInstantUnstake from './mockData/foxyInstantUnstake.js';
-import foxyStake from './mockData/foxyStake.js';
-import foxyUnstake from './mockData/foxyUnstake.js';
-import multiSigSendEth from './mockData/multiSigSendEth.js';
-import thorchainLoanOpenEth from './mockData/thorchainLoanOpenEth.js';
-import thorchainLoanOpenOutboundEth from './mockData/thorchainLoanOpenOutboundEth.js';
-import thorchainLoanOpenOutboundToken from './mockData/thorchainLoanOpenOutboundToken.js';
-import thorchainLoanOpenRefundEth from './mockData/thorchainLoanOpenRefundEth.js';
-import thorchainLoanRepaymentEth from './mockData/thorchainLoanRepaymentEth.js';
-import thorchainLoanRepaymentOutboundEth from './mockData/thorchainLoanRepaymentOutboundEth.js';
-import thorchainLoanRepaymentRefundEth from './mockData/thorchainLoanRepaymentRefundEth.js';
-import thorchainLoanRepaymentRefundToken from './mockData/thorchainLoanRepaymentRefundToken.js';
-import thorchainLoanRepaymentToken from './mockData/thorchainLoanRepaymentToken.js';
-import thorchainLpDepositEth from './mockData/thorchainLpDepositEth.js';
-import thorchainLpDepositToken from './mockData/thorchainLpDepositToken.js';
-import thorchainLpOutboundEth from './mockData/thorchainLpOutboundEth.js';
-import thorchainLpOutboundToken from './mockData/thorchainLpOutboundToken.js';
-import thorchainLpRefundEth from './mockData/thorchainLpRefundEth.js';
-import thorchainLpRefundToken from './mockData/thorchainLpRefundToken.js';
-import thorchainLpWithdrawEth from './mockData/thorchainLpWithdrawEth.js';
-import thorchainLpWithdrawToken from './mockData/thorchainLpWithdrawToken.js';
-import thorchainSaversDepositEth from './mockData/thorchainSaversDepositEth.js';
-import thorchainSaversDepositToken from './mockData/thorchainSaversDepositToken.js';
-import thorchainSaversOutboundEth from './mockData/thorchainSaversOutboundEth.js';
-import thorchainSaversOutboundToken from './mockData/thorchainSaversOutboundToken.js';
-import thorchainSaversRefundEth from './mockData/thorchainSaversRefundEth.js';
-import thorchainSaversRefundToken from './mockData/thorchainSaversRefundToken.js';
-import thorchainSaversWithdrawEth from './mockData/thorchainSaversWithdrawEth.js';
-import thorchainSaversWithdrawToken from './mockData/thorchainSaversWithdrawToken.js';
-import thorchainStreamingSwapEth from './mockData/thorchainStreamingSwapEth.js';
-import thorchainStreamingSwapOutboundEth from './mockData/thorchainStreamingSwapOutboundEth.js';
-import thorchainStreamingSwapOutboundToken from './mockData/thorchainStreamingSwapOutboundToken.js';
-import thorchainStreamingSwapRefundEth from './mockData/thorchainStreamingSwapRefundEth.js';
-import thorchainStreamingSwapRefundToken from './mockData/thorchainStreamingSwapRefundToken.js';
-import thorchainStreamingSwapToken from './mockData/thorchainStreamingSwapToken.js';
-import thorchainSwapEth from './mockData/thorchainSwapEth.js';
-import thorchainSwapLongtail from './mockData/thorchainSwapLongtail.js';
-import thorchainSwapOutboundEth from './mockData/thorchainSwapOutboundEth.js';
-import thorchainSwapOutboundLongtail from './mockData/thorchainSwapOutboundLongtail.js';
-import thorchainSwapOutboundToken from './mockData/thorchainSwapOutboundToken.js';
-import thorchainSwapRefundEth from './mockData/thorchainSwapRefundEth.js';
-import thorchainSwapRefundToken from './mockData/thorchainSwapRefundToken.js';
-import thorchainSwapToken from './mockData/thorchainSwapToken.js';
-import { bondToken, foxToken, foxyToken, kishuToken, maticToken, tribeToken, uniToken, uniV2Token, usdcToken, usdtToken, } from './mockData/tokens.js';
-import tokenSelfSend from './mockData/tokenSelfSend.js';
-import uniAddLiquidity from './mockData/uniAddLiquidity.js';
-import uniApprove from './mockData/uniApprove.js';
-import uniRemoveLiquidity from './mockData/uniRemoveLiquidity.js';
-import wethDeposit from './mockData/wethDeposit.js';
-import wethWithdraw from './mockData/wethWithdraw.js';
-import zrxTradeBondToUni from './mockData/zrxTradeBondToUni.js';
-import zrxTradeEthToMatic from './mockData/zrxTradeEthToMatic.js';
-import zrxTradeTetherToKishu from './mockData/zrxTradeTetherToKishu.js';
-import zrxTradeTribeToEth from './mockData/zrxTradeTribeToEth.js';
-const mocks = vi.hoisted(() => {
-    return {
-        get: vi.fn(),
-        post: vi.fn(),
-    };
-});
-const getApi = vi.hoisted(async () => {
-    const actual = await vi.importActual('../../index');
-    const v1Api = vi.mocked(new actual.V1Api());
-    return v1Api;
-});
-vi.mock('axios', () => {
-    const mockAxios = {
-        create: vi.fn(() => ({
-            get: mocks.get,
-            post: mocks.post,
-        })),
-        get: mocks.get,
-        post: mocks.post,
-    };
-    return {
-        default: mockAxios,
-    };
-});
-const makeTxParser = vi.fn(async () => new TransactionParser({
-    api: (await getApi),
-    assetId: ethAssetId,
-    chainId: ethChainId,
-    thorMidgardUrl: 'thor',
-    mayaMidgardUrl: 'maya',
-    rpcUrl: '',
-}));
-describe('parseTx', () => {
-    beforeEach(() => {
-        mocks.get.mockReset();
-    });
-    describe('standard', () => {
-        describe('erc721', () => {
-            it('should be able to parse mempool send', async () => {
-                const { txMempool } = erc721;
-                const address = '0xa5d981BC0Bc57500ffEDb2674c597F14a3Cb68c1';
-                const expected = {
-                    txid: txMempool.txid,
-                    blockHeight: txMempool.blockHeight,
-                    blockTime: txMempool.timestamp,
-                    address,
-                    chainId: 'eip155:1',
-                    confirmations: txMempool.confirmations,
-                    status: TxStatus.Pending,
-                    transfers: [],
-                };
-                const txParser = await makeTxParser();
-                const actual = await txParser.parse(txMempool, address);
-                expect(actual).toEqual(expected);
-            });
-            it('should be able to parse send', async () => {
-                const { tx } = erc721;
-                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: TxStatus.Confirmed,
-                    fee: {
-                        assetId: ethAssetId,
-                        value: '5974629016703985',
-                    },
-                    transfers: [
-                        {
-                            type: 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);
-                expect(actual).toEqual(expected);
-            });
-            it('should be able to parse mempool receive', async () => {
-                const { txMempool } = erc721;
-                const address = '0x86c6B7f9D91D104e53F2Be608549F0Dc6ECABb57';
-                const expected = {
-                    txid: txMempool.txid,
-                    blockHeight: txMempool.blockHeight,
-                    blockTime: txMempool.timestamp,
-                    address,
-                    chainId: 'eip155:1',
-                    confirmations: txMempool.confirmations,
-                    status: TxStatus.Pending,
-                    transfers: [],
-                };
-                const txParser = await makeTxParser();
-                const actual = await txParser.parse(txMempool, address);
-                expect(actual).toEqual(expected);
-            });
-            it('should be able to parse receive', async () => {
-                const { tx } = erc721;
-                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: TxStatus.Confirmed,
-                    transfers: [
-                        {
-                            type: 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);
-                expect(actual).toEqual(expected);
-            });
-        });
-        describe('erc1155', () => {
-            it('should be able to parse mempool send', async () => {
-                const { txMempool } = erc1155;
-                const address = '0x63acA79298884a520776B5bE662230a37de4a327';
-                const expected = {
-                    txid: txMempool.txid,
-                    blockHeight: txMempool.blockHeight,
-                    blockTime: txMempool.timestamp,
-                    address,
-                    chainId: 'eip155:1',
-                    confirmations: txMempool.confirmations,
-                    status: TxStatus.Pending,
-                    transfers: [],
-                };
-                const txParser = await makeTxParser();
-                const actual = await txParser.parse(txMempool, address);
-                expect(actual).toEqual(expected);
-            });
-            it('should be able to parse send', async () => {
-                const { tx } = erc1155;
-                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: TxStatus.Confirmed,
-                    fee: {
-                        assetId: ethAssetId,
-                        value: '28797509921536974',
-                    },
-                    transfers: [
-                        {
-                            type: 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);
-                expect(actual).toEqual(expected);
-            });
-            it('should be able to parse mempool receive', async () => {
-                const { txMempool } = erc1155;
-                const address = '0x3A3548e060Be10c2614d0a4Cb0c03CC9093fD799';
-                const expected = {
-                    txid: txMempool.txid,
-                    blockHeight: txMempool.blockHeight,
-                    blockTime: txMempool.timestamp,
-                    address,
-                    chainId: 'eip155:1',
-                    confirmations: txMempool.confirmations,
-                    status: TxStatus.Pending,
-                    transfers: [],
-                };
-                const txParser = await makeTxParser();
-                const actual = await txParser.parse(txMempool, address);
-                expect(actual).toEqual(expected);
-            });
-            it('should be able to parse receive', async () => {
-                const { tx } = erc1155;
-                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: TxStatus.Confirmed,
-                    transfers: [
-                        {
-                            type: 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);
-                expect(actual).toEqual(expected);
-            });
-        });
-    });
-    describe('multiSig', () => {
-        it('should be able to parse eth multi sig send', async () => {
-            const { tx } = multiSigSendEth;
-            const address = '0x76DA1578aC163CA7ca4143B7dEAa428e85Db3042';
-            const standardTransfer = {
-                assetId: 'eip155:1/slip44:60',
-                components: [{ value: '1201235000000000000' }],
-                from: '0x79fE68B3e4Bc2B91a4C8dfFb5317C7B8813d8Ae7',
-                to: '0x76DA1578aC163CA7ca4143B7dEAa428e85Db3042',
-                token: undefined,
-                totalValue: '1201235000000000000',
-                type: 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: TxStatus.Confirmed,
-                transfers: [standardTransfer],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-    });
-    describe('thorchain', () => {
-        it('should be able to parse eth swap (deposit)', async () => {
-            const { txDeposit: tx } = thorchainSwapEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        assetId: ethAssetId,
-                        components: [{ value: tx.value }],
-                        from: address,
-                        to: tx.to,
-                        totalValue: tx.value,
-                        type: TransferType.Send,
-                    },
-                ],
-                data: {
-                    parser: 'thorchain',
-                    memo,
-                    method: 'swap',
-                    swap: { type: 'Standard' },
-                },
-                trade: { dexName: Dex.Thor, memo, type: TradeType.Swap },
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth swap (depositWithExpiry)', async () => {
-            const { txDepositWithExpiry: tx } = thorchainSwapEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        assetId: ethAssetId,
-                        components: [{ value: tx.value }],
-                        from: address,
-                        to: tx.to,
-                        totalValue: tx.value,
-                        type: TransferType.Send,
-                    },
-                ],
-                data: {
-                    parser: 'thorchain',
-                    memo,
-                    method: 'swap',
-                    swap: { type: 'Standard' },
-                },
-                trade: { dexName: Dex.Thor, memo, type: TradeType.Swap },
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth swap outbound', async () => {
-            const { tx, actionsResponse } = thorchainSwapOutboundEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: ethAssetId,
-                        components: [{ value: '1579727090000000000' }],
-                        from: '0x42A5Ed456650a09Dc10EBc6361A7480fDd61f27B',
-                        to: address,
-                        totalValue: '1579727090000000000',
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth swap refund', async () => {
-            const { tx, actionsResponse } = thorchainSwapRefundEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: ethAssetId,
-                        components: [{ value: '6412730000000000' }],
-                        from: '0x42A5Ed456650a09Dc10EBc6361A7480fDd61f27B',
-                        to: address,
-                        totalValue: '6412730000000000',
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token swap', async () => {
-            const { tx } = thorchainSwapToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-                        components: [{ value: '16598881497' }],
-                        from: address,
-                        to: tx.to,
-                        totalValue: '16598881497',
-                        type: TransferType.Send,
-                        token: usdcToken,
-                    },
-                ],
-                data: {
-                    parser: 'thorchain',
-                    memo,
-                    method: 'swap',
-                    swap: { type: 'Standard' },
-                },
-                trade: { dexName: Dex.Thor, memo, type: TradeType.Swap },
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token swap outbound', async () => {
-            const { tx, actionsResponse } = thorchainSwapOutboundToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-                        components: [{ value: '47596471640' }],
-                        from: '0x42A5Ed456650a09Dc10EBc6361A7480fDd61f27B',
-                        to: address,
-                        totalValue: '47596471640',
-                        type: TransferType.Receive,
-                        token: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token swap refund', async () => {
-            const { tx, actionsResponse } = thorchainSwapRefundToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: 'eip155:1/erc20:0x0bc529c00c6401aef6d220be8c6ea1667f6ad93e',
-                        components: [{ value: '65391780000000000' }],
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        totalValue: '65391780000000000',
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth streaming swap', async () => {
-            const { tx } = thorchainStreamingSwapEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        assetId: ethAssetId,
-                        components: [{ value: '6696393970416121' }],
-                        from: address,
-                        to: tx.to,
-                        totalValue: '6696393970416121',
-                        type: TransferType.Send,
-                    },
-                ],
-                data: {
-                    parser: 'thorchain',
-                    memo,
-                    method: 'swap',
-                    swap: { type: 'Streaming' },
-                },
-                trade: { dexName: Dex.Thor, memo, type: TradeType.Swap },
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth streaming swap outbound', async () => {
-            const { tx, actionsResponse } = thorchainStreamingSwapOutboundEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: ethAssetId,
-                        components: [{ value: '4300220000000000' }],
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        totalValue: '4300220000000000',
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth streaming swap refund', async () => {
-            const { tx, actionsResponse } = thorchainStreamingSwapRefundEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: ethAssetId,
-                        components: [{ value: '4353475000000000000' }],
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        totalValue: '4353475000000000000',
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token streaming swap', async () => {
-            const { tx } = thorchainStreamingSwapToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
-                        components: [{ value: '12000000' }],
-                        from: address,
-                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        totalValue: '12000000',
-                        type: TransferType.Send,
-                        token: usdtToken,
-                    },
-                ],
-                data: {
-                    parser: 'thorchain',
-                    memo,
-                    method: 'swap',
-                    swap: { type: 'Streaming' },
-                },
-                trade: { dexName: Dex.Thor, memo, type: TradeType.Swap },
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token streaming swap outbound', async () => {
-            const { tx, actionsResponse } = thorchainStreamingSwapOutboundToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
-                        components: [{ value: '159339774' }],
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        totalValue: '159339774',
-                        type: TransferType.Receive,
-                        token: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token streaming swap refund', async () => {
-            const { tx, actionsResponse } = thorchainStreamingSwapRefundToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: 'eip155:1/erc20:0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0',
-                        components: [{ value: '125941190000000000' }],
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        totalValue: '125941190000000000',
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth savers deposit', async () => {
-            const { tx } = thorchainSaversDepositEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: '0x5C04b555E86507742455b280A4F6436cC43af314',
-                        assetId: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth savers withdraw', async () => {
-            const { tx } = thorchainSaversWithdrawEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: '0x610c97879CD08D54721fD6CDfA143887778AD8c1',
-                        assetId: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth savers outbound', async () => {
-            const { tx, actionsResponse } = thorchainSaversOutboundEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: ethAssetId,
-                        components: [{ value: '7399090000000000' }],
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        totalValue: '7399090000000000',
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth savers refund', async () => {
-            const { tx, actionsResponse } = thorchainSaversRefundEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: ethAssetId,
-                        components: [{ value: '939834410000000000' }],
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        totalValue: '939834410000000000',
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token savers deposit', async () => {
-            const { tx } = thorchainSaversDepositToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-                        totalValue: '2012368190',
-                        components: [{ value: '2012368190' }],
-                        token: usdcToken,
-                    },
-                ],
-                data: {
-                    parser: 'thorchain',
-                    method: 'deposit',
-                    memo,
-                    liquidity: { type: 'Savers' },
-                },
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token savers withdraw', async () => {
-            const { tx } = thorchainSaversWithdrawToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        assetId: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token savers outbound', async () => {
-            const { tx, actionsResponse } = thorchainSaversOutboundToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
-                        components: [{ value: '2059204899' }],
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        totalValue: '2059204899',
-                        type: TransferType.Receive,
-                        token: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token savers refund', async () => {
-            const { tx, actionsResponse } = thorchainSaversRefundToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
-                        components: [{ value: '2059204899' }],
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        totalValue: '2059204899',
-                        type: TransferType.Receive,
-                        token: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth lp deposit', async () => {
-            const { tx } = thorchainLpDepositEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        assetId: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth lp withdraw', async () => {
-            const { tx } = thorchainLpWithdrawEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        assetId: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth lp outbound', async () => {
-            const { tx, actionsResponse } = thorchainLpOutboundEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: ethAssetId,
-                        components: [{ value: '5312070540000000000' }],
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        totalValue: '5312070540000000000',
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth lp refund', async () => {
-            const { tx, actionsResponse } = thorchainLpRefundEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: ethAssetId,
-                        components: [{ value: '939834410000000000' }],
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        totalValue: '939834410000000000',
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token lp deposit', async () => {
-            const { tx } = thorchainLpDepositToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
-                        totalValue: '62678661',
-                        components: [{ value: '62678661' }],
-                        token: usdtToken,
-                    },
-                ],
-                data: {
-                    parser: 'thorchain',
-                    method: 'deposit',
-                    memo,
-                    liquidity: { type: 'LP' },
-                },
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token lp withdraw', async () => {
-            const { tx } = thorchainLpWithdrawToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        assetId: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token lp outbound', async () => {
-            const { tx, actionsResponse } = thorchainLpOutboundToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
-                        components: [{ value: '105663523' }],
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        totalValue: '105663523',
-                        type: TransferType.Receive,
-                        token: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token lp refund', async () => {
-            const { tx, actionsResponse } = thorchainLpRefundToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
-                        components: [{ value: '2059204899' }],
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        totalValue: '2059204899',
-                        type: TransferType.Receive,
-                        token: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth loan open', async () => {
-            const { tx } = thorchainLoanOpenEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        assetId: ethAssetId,
-                        totalValue: '5000000000000000',
-                        components: [{ value: '5000000000000000' }],
-                    },
-                ],
-                data: { parser: 'thorchain', method: 'loanOpen', memo },
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth loan open outbound', async () => {
-            const { tx, actionsResponse } = thorchainLoanOpenOutboundEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        assetId: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth loan open refund', async () => {
-            const { tx, actionsResponse } = thorchainLoanOpenRefundEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        assetId: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth loan repayment', async () => {
-            const { tx } = thorchainLoanRepaymentEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        assetId: ethAssetId,
-                        totalValue: '45961550000000000',
-                        components: [{ value: '45961550000000000' }],
-                    },
-                ],
-                data: { parser: 'thorchain', method: 'loanRepayment', memo },
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth loan repayment outbound', async () => {
-            const { tx, actionsResponse } = thorchainLoanRepaymentOutboundEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        assetId: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth loan repayment refund', async () => {
-            const { tx, actionsResponse } = thorchainLoanRepaymentRefundEth;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        assetId: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token loan open outbound', async () => {
-            const { tx, actionsResponse } = thorchainLoanOpenOutboundToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-                        totalValue: '1300324741',
-                        components: [{ value: '1300324741' }],
-                        token: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token loan repayment', async () => {
-            const { tx } = thorchainLoanRepaymentToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
-                        totalValue: '751706937',
-                        components: [{ value: '751706937' }],
-                        token: usdtToken,
-                    },
-                ],
-                data: { parser: 'thorchain', method: 'loanRepayment', memo },
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token loan repayment refund', async () => {
-            const { tx, actionsResponse } = thorchainLoanRepaymentRefundToken;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146',
-                        to: address,
-                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-                        totalValue: '110703296',
-                        components: [{ value: '110703296' }],
-                        token: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse longtail swap', async () => {
-            const { tx } = thorchainSwapLongtail;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                fee: {
-                    assetId: ethAssetId,
-                    value: tx.fee,
-                },
-                transfers: [
-                    {
-                        type: 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: Dex.Thor, memo, type: TradeType.Swap },
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse longtail swap outbound', async () => {
-            const { tx, actionsResponse } = thorchainSwapOutboundLongtail;
-            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: TxStatus.Confirmed,
-                address,
-                chainId: ethChainId,
-                transfers: [
-                    {
-                        assetId: 'eip155:1/erc20:0x04fa0d235c4abf4bcf4787af4cf447de572ef828',
-                        components: [{ value: '239486540176872266724' }],
-                        from: '0x157Dfa656Fdf0D18E1bA94075a53600D81cB3a97',
-                        to: address,
-                        totalValue: '239486540176872266724',
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-    });
-    describe('zrx', () => {
-        it('should be able to parse token -> eth', async () => {
-            const { tx } = zrxTradeTribeToEth;
-            const address = '0x5bb96c35a68Cba037D0F261C67477416db137F03';
-            const trade = { dexName: Dex.Zrx, type: TradeType.Trade };
-            const buyTransfer = {
-                assetId: 'eip155:1/slip44:60',
-                components: [{ value: '541566754246167133' }],
-                from: ZRX_ETHEREUM_PROXY_CONTRACT,
-                to: address,
-                totalValue: '541566754246167133',
-                type: TransferType.Receive,
-            };
-            const sellTransfer = {
-                assetId: 'eip155:1/erc20:0xc7283b66eb1eb5fb86327f08e1b5816b0720212b',
-                components: [{ value: '1000000000000000000000' }],
-                from: address,
-                to: '0x7ce01885a13c652241aE02Ea7369Ee8D466802EB',
-                token: tribeToken,
-                totalValue: '1000000000000000000000',
-                type: 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: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth -> token', async () => {
-            const { tx } = zrxTradeEthToMatic;
-            const address = '0x564BcA365D62BCC22dB53d032F8dbD35439C9206';
-            const trade = { dexName: Dex.Zrx, type: TradeType.Trade };
-            const buyTransfer = {
-                assetId: 'eip155:1/erc20:0x455e53cbb86018ac2b8092fdcd39d8444affc3f6',
-                components: [{ value: '50000000000000000000000' }],
-                from: '0x22F9dCF4647084d6C31b2765F6910cd85C178C18',
-                to: address,
-                token: maticToken,
-                totalValue: '50000000000000000000000',
-                type: TransferType.Receive,
-            };
-            const sellTransfer = {
-                assetId: 'eip155:1/slip44:60',
-                components: [{ value: '10000000000000000000' }],
-                from: address,
-                to: ZRX_ETHEREUM_PROXY_CONTRACT,
-                totalValue: '10000000000000000000',
-                type: 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: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token -> token', async () => {
-            const { tx } = zrxTradeTetherToKishu;
-            const address = '0xb8b19c048296E086DaF69F54d48dE2Da444dB047';
-            const trade = { dexName: Dex.Zrx, type: TradeType.Trade };
-            const buyTransfer = {
-                type: TransferType.Receive,
-                from: '0xF82d8Ec196Fb0D56c6B82a8B1870F09502A49F88',
-                to: address,
-                assetId: 'eip155:1/erc20:0xa2b4c0af19cc16a6cfacce81f192b024d625817d',
-                totalValue: '9248567698016204727450',
-                components: [{ value: '9248567698016204727450' }],
-                token: kishuToken,
-            };
-            const sellTransfer = {
-                type: TransferType.Send,
-                from: address,
-                to: '0x0d4a11d5EEaaC28EC3F61d100daF4d40471f1852',
-                assetId: 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
-                totalValue: '45000000000',
-                components: [{ value: '45000000000' }],
-                token: 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: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token -> token (multiple swaps)', async () => {
-            const { tx } = zrxTradeBondToUni;
-            const address = '0x986bB494db49E6f1CDC1be098e3157f8DDC5a821';
-            const trade = {
-                dexName: Dex.Zrx,
-                type: TradeType.Trade,
-            };
-            const buyTransfer1 = {
-                type: TransferType.Receive,
-                from: '0xEBFb684dD2b01E698ca6c14F10e4f289934a54D6',
-                to: address,
-                assetId: 'eip155:1/erc20:0x1f9840a85d5af5bf1d1762f925bdaddc4201f984',
-                totalValue: '56639587020747520629',
-                components: [{ value: '56639587020747520629' }],
-                token: uniToken,
-            };
-            const buyTransfer2 = {
-                type: TransferType.Receive,
-                from: '0xd3d2E2692501A5c9Ca623199D38826e513033a17',
-                to: address,
-                assetId: 'eip155:1/erc20:0x1f9840a85d5af5bf1d1762f925bdaddc4201f984',
-                totalValue: '47448670568188553620',
-                components: [{ value: '47448670568188553620' }],
-                token: uniToken,
-            };
-            const sellTransfer1 = {
-                type: TransferType.Send,
-                from: address,
-                to: '0x6591c4BcD6D7A1eb4E537DA8B78676C1576Ba244',
-                assetId: 'eip155:1/erc20:0x0391d2021f89dc339f60fff84546ea23e337750f',
-                totalValue: '53910224825217010944',
-                components: [{ value: '53910224825217010944' }],
-                token: bondToken,
-            };
-            const sellTransfer2 = {
-                type: TransferType.Send,
-                from: address,
-                to: '0xB17B1342579e4bcE6B6e9A426092EA57d33843D9',
-                assetId: 'eip155:1/erc20:0x0391d2021f89dc339f60fff84546ea23e337750f',
-                totalValue: '46089775174782989056',
-                components: [{ value: '46089775174782989056' }],
-                token: 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: 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);
-            expect(actual).toEqual(expected);
-        });
-    });
-    describe('self send', () => {
-        it('should be able to parse eth mempool', async () => {
-            const { txMempool } = ethSelfSend;
-            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
-            const expected = {
-                txid: txMempool.txid,
-                blockHeight: txMempool.blockHeight,
-                blockTime: txMempool.timestamp,
-                address,
-                chainId: 'eip155:1',
-                confirmations: txMempool.confirmations,
-                data: undefined,
-                status: TxStatus.Pending,
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        to: address,
-                        from: address,
-                        assetId: 'eip155:1/slip44:60',
-                        totalValue: '503100000000000',
-                        components: [{ value: '503100000000000' }],
-                    },
-                    {
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse eth', async () => {
-            const { tx } = ethSelfSend;
-            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: TxStatus.Confirmed,
-                fee: {
-                    value: '399000000000000',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: address,
-                        assetId: 'eip155:1/slip44:60',
-                        totalValue: '503100000000000',
-                        components: [{ value: '503100000000000' }],
-                    },
-                    {
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token mempool', async () => {
-            const { txMempool } = tokenSelfSend;
-            const address = '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C';
-            const expected = {
-                txid: txMempool.txid,
-                blockHeight: txMempool.blockHeight,
-                blockTime: txMempool.timestamp,
-                address,
-                chainId: 'eip155:1',
-                confirmations: txMempool.confirmations,
-                data: undefined,
-                status: TxStatus.Pending,
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: address,
-                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-                        totalValue: '1502080',
-                        components: [{ value: '1502080' }],
-                        token: usdcToken,
-                    },
-                    {
-                        type: TransferType.Receive,
-                        from: address,
-                        to: address,
-                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-                        totalValue: '1502080',
-                        components: [{ value: '1502080' }],
-                        token: usdcToken,
-                    },
-                ],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(txMempool, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse token', async () => {
-            const { tx } = tokenSelfSend;
-            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: TxStatus.Confirmed,
-                fee: {
-                    value: '1011738000000000',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: address,
-                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-                        totalValue: '1502080',
-                        components: [{ value: '1502080' }],
-                        token: usdcToken,
-                    },
-                    {
-                        type: TransferType.Receive,
-                        from: address,
-                        to: address,
-                        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-                        totalValue: '1502080',
-                        components: [{ value: '1502080' }],
-                        token: usdcToken,
-                    },
-                ],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-    });
-    describe('uniswap', () => {
-        it('should be able to parse approve', async () => {
-            const { tx } = uniApprove;
-            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: TxStatus.Confirmed,
-                trade: undefined,
-                fee: {
-                    value: '1447243200000000',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                transfers: [],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse add liquidity mempool', async () => {
-            const { txMempool } = uniAddLiquidity;
-            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: TxStatus.Pending,
-                transfers: [
-                    {
-                        type: 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: 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse add liquidity', async () => {
-            const { tx } = uniAddLiquidity;
-            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: TxStatus.Confirmed,
-                fee: {
-                    value: '26926494400000000',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
-                        to: '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D',
-                        assetId: 'eip155:1/slip44:60',
-                        totalValue: '42673718176645189',
-                        components: [{ value: '42673718176645189' }],
-                    },
-                    {
-                        type: TransferType.Send,
-                        from: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
-                        to: '0x470e8de2eBaef52014A47Cb5E6aF86884947F08c',
-                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
-                        totalValue: '100000000000000000000',
-                        components: [{ value: '100000000000000000000' }],
-                        token: foxToken,
-                    },
-                    {
-                        type: TransferType.Receive,
-                        from: '0x0000000000000000000000000000000000000000',
-                        to: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
-                        assetId: 'eip155:1/erc20:0x470e8de2ebaef52014a47cb5e6af86884947f08c',
-                        totalValue: '1888842410762840601',
-                        components: [{ value: '1888842410762840601' }],
-                        token: uniV2Token,
-                    },
-                ],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse remove liquidity mempool', async () => {
-            const { txMempool } = uniRemoveLiquidity;
-            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: TxStatus.Pending,
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
-                        to: '0x470e8de2eBaef52014A47Cb5E6aF86884947F08c',
-                        assetId: 'eip155:1/erc20:0x470e8de2ebaef52014a47cb5e6af86884947f08c',
-                        totalValue: '298717642142382954',
-                        components: [{ value: '298717642142382954' }],
-                        token: uniV2Token,
-                    },
-                ],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(txMempool, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse remove liquidity', async () => {
-            const { tx } = uniRemoveLiquidity;
-            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: TxStatus.Confirmed,
-                trade: undefined,
-                fee: {
-                    value: '4082585000000000',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
-                        to: '0x470e8de2eBaef52014A47Cb5E6aF86884947F08c',
-                        assetId: 'eip155:1/erc20:0x470e8de2ebaef52014a47cb5e6af86884947f08c',
-                        totalValue: '298717642142382954',
-                        components: [{ value: '298717642142382954' }],
-                        token: uniV2Token,
-                    },
-                    {
-                        type: TransferType.Receive,
-                        from: '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D',
-                        to: '0x6bF198c2B5c8E48Af4e876bc2173175b89b1DA0C',
-                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
-                        totalValue: '15785079906515930982',
-                        components: [{ value: '15785079906515930982' }],
-                        token: foxToken,
-                    },
-                    {
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-    });
-    describe('fox', () => {
-        it('should be able to parse claim', async () => {
-            const { tx } = foxClaim;
-            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: TxStatus.Confirmed,
-                fee: {
-                    value: '2559843000000000',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: '0x02FfdC5bfAbe5c66BE067ff79231585082CA5fe2',
-                        to: address,
-                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
-                        totalValue: '1500000000000000000000',
-                        components: [{ value: '1500000000000000000000' }],
-                        token: foxToken,
-                    },
-                ],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse stake mempool', async () => {
-            const { txMempool } = foxStake;
-            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: TxStatus.Pending,
-                transfers: [],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(txMempool, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse stake', async () => {
-            const { tx } = foxStake;
-            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: TxStatus.Confirmed,
-                fee: {
-                    value: '4650509500000000',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: UNI_V2_FOX_STAKING_REWARDS_V3_CONTRACT,
-                        assetId: 'eip155:1/erc20:0x470e8de2ebaef52014a47cb5e6af86884947f08c',
-                        totalValue: '99572547380794318',
-                        components: [{ value: '99572547380794318' }],
-                        token: uniV2Token,
-                    },
-                ],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse exit mempool', async () => {
-            const { txMempool } = foxExit;
-            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: TxStatus.Pending,
-                transfers: [],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(txMempool, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse exit', async () => {
-            const { tx } = foxExit;
-            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: TxStatus.Confirmed,
-                fee: {
-                    value: '6136186875000000',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: UNI_V2_FOX_STAKING_REWARDS_V3_CONTRACT,
-                        to: address,
-                        assetId: 'eip155:1/erc20:0x470e8de2ebaef52014a47cb5e6af86884947f08c',
-                        totalValue: '531053586030903030',
-                        components: [{ value: '531053586030903030' }],
-                        token: uniV2Token,
-                    },
-                    {
-                        type: TransferType.Receive,
-                        from: UNI_V2_FOX_STAKING_REWARDS_V3_CONTRACT,
-                        to: address,
-                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
-                        totalValue: '317669338073988',
-                        components: [{ value: '317669338073988' }],
-                        token: foxToken,
-                    },
-                ],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-    });
-    describe('foxy', () => {
-        it('should be able to parse stake', async () => {
-            const { tx } = foxyStake;
-            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: TxStatus.Confirmed,
-                fee: {
-                    value: '8343629232016788',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                trade: undefined,
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        to: FOXY_STAKING_CONTRACT,
-                        from: address,
-                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
-                        totalValue: '109548875260073394762',
-                        components: [{ value: '109548875260073394762' }],
-                        token: foxToken,
-                    },
-                    {
-                        type: TransferType.Receive,
-                        to: address,
-                        from: FOXY_STAKING_CONTRACT,
-                        assetId: 'eip155:1/erc20:0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3',
-                        totalValue: '109548875260073394762',
-                        components: [{ value: '109548875260073394762' }],
-                        token: foxyToken,
-                    },
-                ],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse unstake', async () => {
-            const { tx } = foxyUnstake;
-            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: TxStatus.Confirmed,
-                fee: {
-                    value: '7586577934107040',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                trade: undefined,
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        to: FOXY_STAKING_CONTRACT,
-                        from: address,
-                        assetId: 'eip155:1/erc20:0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3',
-                        totalValue: '24292579090466512304',
-                        components: [{ value: '24292579090466512304' }],
-                        token: foxyToken,
-                    },
-                    {
-                        type: TransferType.Receive,
-                        to: address,
-                        from: FOXY_STAKING_CONTRACT,
-                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
-                        totalValue: '22438383781076552673',
-                        components: [{ value: '22438383781076552673' }],
-                        token: foxToken,
-                    },
-                ],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse instant unstake', async () => {
-            const { tx } = foxyInstantUnstake;
-            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: TxStatus.Confirmed,
-                fee: {
-                    value: '10348720598973963',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                trade: undefined,
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        to: FOXY_STAKING_CONTRACT,
-                        from: address,
-                        assetId: 'eip155:1/erc20:0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3',
-                        totalValue: '9885337259647255313',
-                        components: [{ value: '9885337259647255313' }],
-                        token: foxyToken,
-                    },
-                    {
-                        type: TransferType.Receive,
-                        to: address,
-                        from: '0x8EC637Fe2800940C7959f9BAd4fE69e41225CD39',
-                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
-                        totalValue: '9638203828156073931',
-                        components: [{ value: '9638203828156073931' }],
-                        token: foxToken,
-                    },
-                ],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse claim withdraw', async () => {
-            const { tx } = foxyClaimWithdraw;
-            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: TxStatus.Confirmed,
-                fee: {
-                    value: '4735850597827293',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                trade: undefined,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        to: address,
-                        from: FOXY_STAKING_CONTRACT,
-                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
-                        totalValue: '1200000000000000000000',
-                        components: [{ value: '1200000000000000000000' }],
-                        token: foxToken,
-                    },
-                ],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-    });
-    describe('weth', () => {
-        it('should be able to parse deposit', async () => {
-            const { tx } = wethDeposit;
-            const address = '0x2D801972327b0F11422d9Cc14A3d00B07ae0CceB';
-            const contractAddress = 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: TxStatus.Confirmed,
-                fee: {
-                    value: '2161334514900778',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                trade: undefined,
-                transfers: [
-                    {
-                        type: 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: TransferType.Send,
-                    },
-                ],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse deposit extra input data', async () => {
-            const { tx2 } = wethDeposit;
-            const address = '0xE7F92E3d5FDe63C90A917e25854826873497ef3D';
-            const contractAddress = 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: TxStatus.Confirmed,
-                fee: {
-                    value: '1087028000000000',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                trade: undefined,
-                transfers: [
-                    {
-                        type: 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: TransferType.Send,
-                    },
-                ],
-            };
-            const txParser = await makeTxParser();
-            const actual = await txParser.parse(tx2, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse withdrawal', async () => {
-            const { tx } = wethWithdraw;
-            const address = '0xa6F15FB2cc5dC96c2EBA18c101AD3fAD27F74839';
-            const contractAddress = WETH_TOKEN_CONTRACT;
-            const internalTransfer = {
-                assetId: 'eip155:1/slip44:60',
-                components: [{ value: '100000000000000000' }],
-                from: contractAddress,
-                to: address,
-                token: undefined,
-                totalValue: '100000000000000000',
-                type: 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: TxStatus.Confirmed,
-                fee: {
-                    value: '1482222626533792',
-                    assetId: 'eip155:1/slip44:60',
-                },
-                trade: undefined,
-                transfers: [
-                    {
-                        type: 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);
-            expect(actual).toEqual(expected);
-        });
-    });
-    describe('arbitrumBridge', () => {
-        it('should be able to parse erc20 deposit', async () => {
-            const tx = 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse ETH deposit', async () => {
-            const tx = 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse ETH create retryable ticket', async () => {
-            const tx = 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse erc20 claim', async () => {
-            const tx = 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);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse ETH claim', async () => {
-            const tx = 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);
-            expect(actual).toEqual(expected);
-        });
-    });
-});