@shapeshiftoss/unchained-client 10.14.1 → 10.14.4

package/dist/cosmossdk/cosmos/parser/__tests__/cosmos.test.js

@@ -1,848 +0,0 @@
-import { cosmosAssetId, cosmosChainId } from '@shapeshiftoss/caip';
-import { describe, expect, it, vi } from 'vitest';
-import { Dex, TradeType, TransferType, TxStatus } from '../../../../types';
-import { TransactionParser } from '../index';
-import delegate from './mockData/delegate';
-import ibc_receive from './mockData/ibc_receive';
-import ibc_transfer from './mockData/ibc_transfer';
-import redelegate from './mockData/redelegate';
-import reward from './mockData/reward';
-import standard from './mockData/standard';
-import thorchainLoanOpenOutbound from './mockData/thorchainLoanOpenOutbound';
-import thorchainLoanRepayment from './mockData/thorchainLoanRepayment';
-import thorchainLoanRepaymentRefund from './mockData/thorchainLoanRepaymentRefund';
-import thorchainLpDeposit from './mockData/thorchainLpDeposit';
-import thorchainLpOutbound from './mockData/thorchainLpOutbound';
-import thorchainLpRefund from './mockData/thorchainLpRefund';
-import thorchainLpWithdraw from './mockData/thorchainLpWithdraw';
-import thorchainSaversDeposit from './mockData/thorchainSaversDeposit';
-import thorchainSaversOutbound from './mockData/thorchainSaversOutbound';
-import thorchainSaversRefund from './mockData/thorchainSaversRefund';
-import thorchainSaversWithdraw from './mockData/thorchainSaversWithdraw';
-import thorchainStreamingSwap from './mockData/thorchainStreamingSwap';
-import thorchainStreamingSwapOutbound from './mockData/thorchainStreamingSwapOutbound';
-import thorchainStreamingSwapRefund from './mockData/thorchainStreamingSwapRefund';
-import thorchainSwap from './mockData/thorchainSwap';
-import thorchainSwapOutbound from './mockData/thorchainSwapOutbound';
-import thorchainSwapRefund from './mockData/thorchainSwapRefund';
-import undelegate from './mockData/undelegate';
-const mocks = vi.hoisted(() => ({
-    get: vi.fn(),
-}));
-vi.mock('axios', () => {
-    const mockAxios = {
-        create: vi.fn(() => ({
-            get: mocks.get,
-        })),
-    };
-    return {
-        default: mockAxios,
-    };
-});
-const txParser = new TransactionParser({
-    chainId: cosmosChainId,
-    assetId: cosmosAssetId,
-    midgardUrl: '',
-});
-describe('parseTx', () => {
-    it('should be able to parse a standard send tx', async () => {
-        const { tx } = standard;
-        const address = 'cosmos1t5u0jfg3ljsjrh2m9e47d4ny2hea7eehxrzdgd';
-        const expected = {
-            txid: tx.txid,
-            blockHash: tx.blockHash,
-            blockHeight: tx.blockHeight,
-            blockTime: tx.timestamp,
-            confirmations: tx.confirmations,
-            status: TxStatus.Confirmed,
-            address,
-            chainId: cosmosChainId,
-            fee: {
-                assetId: cosmosAssetId,
-                value: '2500',
-            },
-            transfers: [
-                {
-                    type: TransferType.Send,
-                    from: address,
-                    to: 'cosmos14e25lpsedq863vgweqg4m9n0z28c203kfdlzmz',
-                    assetId: cosmosAssetId,
-                    totalValue: '2002965',
-                    components: [{ value: '2002965' }],
-                },
-            ],
-        };
-        const actual = await txParser.parse(tx, address);
-        expect(expected).toEqual(actual);
-    });
-    it('should be able to parse a standard receive tx', async () => {
-        const { tx } = standard;
-        const address = 'cosmos14e25lpsedq863vgweqg4m9n0z28c203kfdlzmz';
-        const expected = {
-            txid: tx.txid,
-            blockHash: tx.blockHash,
-            blockHeight: tx.blockHeight,
-            blockTime: tx.timestamp,
-            confirmations: tx.confirmations,
-            status: TxStatus.Confirmed,
-            address,
-            chainId: cosmosChainId,
-            transfers: [
-                {
-                    type: TransferType.Receive,
-                    from: 'cosmos1t5u0jfg3ljsjrh2m9e47d4ny2hea7eehxrzdgd',
-                    to: address,
-                    assetId: cosmosAssetId,
-                    totalValue: '2002965',
-                    components: [{ value: '2002965' }],
-                },
-            ],
-        };
-        const actual = await txParser.parse(tx, address);
-        expect(expected).toEqual(actual);
-    });
-    it('should be able to parse a delegate tx', async () => {
-        const { tx } = delegate;
-        const address = 'cosmos179k2lz70rxvjrvvr65cynw9x5c8v3kftg46v05';
-        const expected = {
-            txid: tx.txid,
-            blockHash: tx.blockHash,
-            blockHeight: tx.blockHeight,
-            blockTime: tx.timestamp,
-            confirmations: tx.confirmations,
-            status: TxStatus.Confirmed,
-            address,
-            chainId: cosmosChainId,
-            fee: {
-                assetId: cosmosAssetId,
-                value: '6250',
-            },
-            transfers: [
-                {
-                    type: TransferType.Send,
-                    assetId: cosmosAssetId,
-                    from: address,
-                    to: 'cosmosvaloper1lzhlnpahvznwfv4jmay2tgaha5kmz5qxerarrl',
-                    totalValue: '1920000',
-                    components: [{ value: '1920000' }],
-                },
-            ],
-            data: {
-                parser: 'staking',
-                method: 'delegate',
-                delegator: address,
-                destinationValidator: 'cosmosvaloper1lzhlnpahvznwfv4jmay2tgaha5kmz5qxerarrl',
-                assetId: cosmosAssetId,
-                value: '1920000',
-            },
-        };
-        const actual = await txParser.parse(tx, address);
-        expect(expected).toEqual(actual);
-    });
-    it('should be able to parse a undelegate tx', async () => {
-        const { tx } = undelegate;
-        const address = 'cosmos1fx4jwv3aalxqwmrpymn34l582lnehr3eqwuz9e';
-        const expected = {
-            txid: tx.txid,
-            blockHash: tx.blockHash,
-            blockHeight: tx.blockHeight,
-            blockTime: tx.timestamp,
-            confirmations: tx.confirmations,
-            status: TxStatus.Confirmed,
-            address,
-            chainId: cosmosChainId,
-            fee: {
-                assetId: cosmosAssetId,
-                value: '6250',
-            },
-            transfers: [
-                {
-                    assetId: cosmosAssetId,
-                    components: [{ value: '200000' }],
-                    from: 'cosmosvaloper1sjllsnramtg3ewxqwwrwjxfgc4n4ef9u2lcnj0',
-                    to: address,
-                    totalValue: '200000',
-                    type: TransferType.Receive,
-                },
-            ],
-            data: {
-                parser: 'staking',
-                method: 'begin_unbonding',
-                delegator: address,
-                destinationValidator: 'cosmosvaloper1sjllsnramtg3ewxqwwrwjxfgc4n4ef9u2lcnj0',
-                assetId: cosmosAssetId,
-                value: '200000',
-            },
-        };
-        const actual = await txParser.parse(tx, address);
-        expect(expected).toEqual(actual);
-    });
-    it('should be able to parse a redelegate tx', async () => {
-        const { tx } = redelegate;
-        const address = 'cosmos1fx4jwv3aalxqwmrpymn34l582lnehr3eqwuz9e';
-        const expected = {
-            txid: tx.txid,
-            blockHash: tx.blockHash,
-            blockHeight: tx.blockHeight,
-            blockTime: tx.timestamp,
-            confirmations: tx.confirmations,
-            status: TxStatus.Confirmed,
-            address,
-            chainId: cosmosChainId,
-            fee: {
-                assetId: cosmosAssetId,
-                value: '6250',
-            },
-            transfers: [],
-            data: {
-                parser: 'staking',
-                method: 'begin_redelegate',
-                sourceValidator: 'cosmosvaloper1sjllsnramtg3ewxqwwrwjxfgc4n4ef9u2lcnj0',
-                delegator: address,
-                destinationValidator: 'cosmosvaloper156gqf9837u7d4c4678yt3rl4ls9c5vuursrrzf',
-                assetId: cosmosAssetId,
-                value: '500000',
-            },
-        };
-        const actual = await txParser.parse(tx, address);
-        expect(expected).toEqual(actual);
-    });
-    it('should be able to parse a reward tx', async () => {
-        const { tx } = reward;
-        const address = 'cosmos179k2lz70rxvjrvvr65cynw9x5c8v3kftg46v05';
-        const expected = {
-            txid: tx.txid,
-            blockHash: tx.blockHash,
-            blockHeight: tx.blockHeight,
-            blockTime: tx.timestamp,
-            confirmations: tx.confirmations,
-            status: TxStatus.Confirmed,
-            address,
-            chainId: cosmosChainId,
-            fee: {
-                assetId: cosmosAssetId,
-                value: '7000',
-            },
-            transfers: [
-                {
-                    type: TransferType.Receive,
-                    assetId: cosmosAssetId,
-                    from: 'cosmosvaloper1hdrlqvyjfy5sdrseecjrutyws9khtxxaux62l7',
-                    to: address,
-                    totalValue: '39447',
-                    components: [{ value: '39447' }],
-                },
-                {
-                    type: TransferType.Receive,
-                    assetId: cosmosAssetId,
-                    from: 'cosmosvaloper1lzhlnpahvznwfv4jmay2tgaha5kmz5qxerarrl',
-                    to: address,
-                    totalValue: '7',
-                    components: [{ value: '7' }],
-                },
-            ],
-            data: {
-                parser: 'staking',
-                method: 'withdraw_delegator_reward',
-                delegator: address,
-                destinationValidator: address,
-                value: '39447',
-                assetId: cosmosAssetId,
-            },
-        };
-        const actual = await txParser.parse(tx, address);
-        expect(expected).toEqual(actual);
-    });
-    it('should be able to parse an ibc transfer tx', async () => {
-        const { tx } = ibc_transfer;
-        const address = 'cosmos1syj2za9lxkhgpd9zm5lzfss9f6qcuyca354whm';
-        const expected = {
-            txid: tx.txid,
-            blockHash: tx.blockHash,
-            blockHeight: tx.blockHeight,
-            blockTime: tx.timestamp,
-            confirmations: tx.confirmations,
-            status: TxStatus.Confirmed,
-            address,
-            chainId: cosmosChainId,
-            fee: {
-                assetId: cosmosAssetId,
-                value: '3250',
-            },
-            transfers: [
-                {
-                    type: TransferType.Send,
-                    assetId: cosmosAssetId,
-                    from: address,
-                    to: 'osmo1syj2za9lxkhgpd9zm5lzfss9f6qcuycae0x7pf',
-                    totalValue: '600000',
-                    components: [{ value: '600000' }],
-                },
-            ],
-            data: {
-                parser: 'ibc',
-                method: 'transfer',
-                ibcDestination: 'osmo1syj2za9lxkhgpd9zm5lzfss9f6qcuycae0x7pf',
-                ibcSource: address,
-                assetId: cosmosAssetId,
-                value: '600000',
-                sequence: '1258481',
-            },
-        };
-        const actual = await txParser.parse(tx, address);
-        expect(expected).toEqual(actual);
-    });
-    it('should be able to parse an ibc receive tx', async () => {
-        const { tx } = ibc_receive;
-        const address = 'cosmos1fx4jwv3aalxqwmrpymn34l582lnehr3eqwuz9e';
-        const expected = {
-            txid: tx.txid,
-            blockHash: tx.blockHash,
-            blockHeight: tx.blockHeight,
-            blockTime: tx.timestamp,
-            confirmations: tx.confirmations,
-            status: TxStatus.Confirmed,
-            address,
-            chainId: cosmosChainId,
-            transfers: [
-                {
-                    type: TransferType.Receive,
-                    assetId: cosmosAssetId,
-                    from: 'osmo1fx4jwv3aalxqwmrpymn34l582lnehr3eg40jnt',
-                    to: address,
-                    totalValue: '3230396',
-                    components: [{ value: '3230396' }],
-                },
-            ],
-            data: {
-                parser: 'ibc',
-                method: 'recv_packet',
-                ibcDestination: address,
-                ibcSource: 'osmo1fx4jwv3aalxqwmrpymn34l582lnehr3eg40jnt',
-                assetId: cosmosAssetId,
-                value: '3230396',
-                sequence: '516701',
-            },
-        };
-        const actual = await txParser.parse(tx, address);
-        expect(expected).toEqual(actual);
-    });
-    describe('thorchain', () => {
-        it('should be able to parse swap', async () => {
-            const { tx } = thorchainSwap;
-            const address = 'cosmos1dnssyzyhnja28zdww2ffa6fcxaxwanguf7nmq7';
-            const memo = 'SWAP:THOR.RUNE:thor166n4w5039meulfa3p6ydg60ve6ueac7tlt0jws:30984116284';
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                fee: {
-                    assetId: cosmosAssetId,
-                    value: '2000',
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: 'cosmos1eejue3dchfzd7e6pr089mkrqx7fmhghlux920v',
-                        assetId: cosmosAssetId,
-                        totalValue: '140122500',
-                        components: [{ value: '140122500' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'swap', swap: { type: 'Standard' } },
-                trade: { dexName: Dex.Thor, memo, type: TradeType.Swap },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse swap outbound', async () => {
-            const { tx, actionsResponse } = thorchainSwapOutbound;
-            const address = 'cosmos10hng6437uh2yvjy6ax7dsmhkm0446z224s3ag6';
-            const memo = 'OUT:818B5E84218B3A159EFD4F8DDA6484E005A9CE6558E9C12DD188E323B3E6F180';
-            mocks.get.mockImplementationOnce(() => ({ data: actionsResponse }));
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: 'cosmos17hvcftcmc772t8e46cm4s2gv2r0m9pnszjcqpy',
-                        to: address,
-                        assetId: cosmosAssetId,
-                        totalValue: '42366561',
-                        components: [{ value: '42366561' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'swapOut', swap: { type: 'Standard' } },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse swap refund', async () => {
-            const { tx, actionsResponse } = thorchainSwapRefund;
-            const address = 'cosmos1dnssyzyhnja28zdww2ffa6fcxaxwanguf7nmq7';
-            const memo = 'REFUND:361F10B0AEAB2DD40B431EA4941D0EA5A18BE6AE10E29C0F845375955B4860F4';
-            mocks.get.mockImplementationOnce(() => ({ data: actionsResponse }));
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: 'cosmos1eejue3dchfzd7e6pr089mkrqx7fmhghlux920v',
-                        to: address,
-                        assetId: cosmosAssetId,
-                        totalValue: '175005078',
-                        components: [{ value: '175005078' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'swapRefund', swap: { type: 'Standard' } },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse streaming swap', async () => {
-            const { tx } = thorchainStreamingSwap;
-            const address = 'cosmos1nz22stv03fcp29563jrgu2v56hd92l96wwystz';
-            const memo = '=:BNB.BNB:bnb1e75f8rzqlsrm3qepv4qh2ytp07ad6625at8nzg:0/1/0:te:0';
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                fee: {
-                    assetId: cosmosAssetId,
-                    value: '466',
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: 'cosmos1mkjaqql9a2la7z8xt2xg0w0m60002m579x2ycf',
-                        assetId: cosmosAssetId,
-                        totalValue: '402000000',
-                        components: [{ value: '402000000' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'swap', swap: { type: 'Streaming' } },
-                trade: { dexName: Dex.Thor, memo, type: TradeType.Swap },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse streaming swap outbound', async () => {
-            const { tx, actionsResponse } = thorchainStreamingSwapOutbound;
-            const address = 'cosmos1laznh8p3tvwu7q8ytrnn6nrntfyx0mpvvrltzl';
-            const memo = 'OUT:59DDC87BE3B99846002140031F28AB0E1A1E4F01D0DA3A2D252953D9D47C9912';
-            mocks.get.mockImplementationOnce(() => ({ data: actionsResponse }));
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: 'cosmos1eejue3dchfzd7e6pr089mkrqx7fmhghlux920v',
-                        to: address,
-                        assetId: cosmosAssetId,
-                        totalValue: '237608436',
-                        components: [{ value: '237608436' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'swapOut', swap: { type: 'Streaming' } },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse streaming swap refund', async () => {
-            const { tx, actionsResponse } = thorchainStreamingSwapRefund;
-            const address = 'cosmos1s9t9jkqvwcwh66c4nya5vxnsntew3wrcald960';
-            const memo = 'REFUND:CFD82073CB432FDFFA4BB75FE0838A1C28FD966F91E91AD9A421F128AFDC97C2';
-            mocks.get.mockImplementationOnce(() => ({ data: actionsResponse }));
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: 'cosmos1kfj43sgxqcglc2ydk0v34re523ent6qhmaj4l5',
-                        to: address,
-                        assetId: cosmosAssetId,
-                        totalValue: '125995651',
-                        components: [{ value: '125995651' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'swapRefund', swap: { type: 'Streaming' } },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse savers deposit', async () => {
-            const { tx } = thorchainSaversDeposit;
-            const address = 'cosmos12ddmphvtnv2raa3pla7afypt85kffnjlg5mt85';
-            const memo = '+:GAIA/ATOM::ss:0';
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                fee: {
-                    assetId: cosmosAssetId,
-                    value: '10000',
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: 'cosmos1g7a7l9zp4h0vma5tqe5xnmvps3wyzumwel2j95',
-                        assetId: cosmosAssetId,
-                        totalValue: '4681875',
-                        components: [{ value: '4681875' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'deposit', liquidity: { type: 'Savers' } },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse savers withdraw', async () => {
-            const { tx } = thorchainSaversWithdraw;
-            const address = 'cosmos1g7ufueqz24luzcj0d5h8u3452vv4l4d9fz0fdn';
-            const memo = '-:GAIA/ATOM:10000';
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                fee: {
-                    assetId: cosmosAssetId,
-                    value: '3000',
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: 'cosmos17hvcftcmc772t8e46cm4s2gv2r0m9pnszjcqpy',
-                        assetId: cosmosAssetId,
-                        totalValue: '100',
-                        components: [{ value: '100' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'withdraw', liquidity: { type: 'Savers' } },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse savers outbound', async () => {
-            const { tx, actionsResponse } = thorchainSaversOutbound;
-            const address = 'cosmos1g7ufueqz24luzcj0d5h8u3452vv4l4d9fz0fdn';
-            const memo = 'OUT:860B73A29EA69D7FB24B4B17893CF7CDB3B66C2BB9DD91872B140A2F325294D8';
-            mocks.get.mockImplementationOnce(() => ({ data: actionsResponse }));
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: 'cosmos1eejue3dchfzd7e6pr089mkrqx7fmhghlux920v',
-                        to: address,
-                        assetId: cosmosAssetId,
-                        totalValue: '9066156',
-                        components: [{ value: '9066156' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'withdrawOut', liquidity: { type: 'Savers' } },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse savers refund', async () => {
-            const { tx, actionsResponse } = thorchainSaversRefund;
-            const address = 'cosmos1yt49rwszuelyh0k9hl6kkq4kdn66aeqwxez6sc';
-            const memo = 'REFUND:44BC762D4D5A1BD3ED8D06EFADDD905CC05CB48FB233D88119EBC0FE7DF7A8F1';
-            mocks.get.mockImplementationOnce(() => ({ data: actionsResponse }));
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: 'cosmos19ksklulcdweea750pr3dw70v0gulj6s5xwdlpp',
-                        to: address,
-                        assetId: cosmosAssetId,
-                        totalValue: '885148',
-                        components: [{ value: '885148' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'depositRefund', liquidity: { type: 'Savers' } },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse lp deposit', async () => {
-            const { tx } = thorchainLpDeposit;
-            const address = 'cosmos1a8l3srqyk5krvzhkt7cyzy52yxcght6322w2qy';
-            const memo = '+:GAIA.ATOM::ss:29';
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                fee: {
-                    assetId: cosmosAssetId,
-                    value: '10000',
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: 'cosmos1ujd8p9lu265k982fq32j7ww2dndgeccvu6etfs',
-                        assetId: cosmosAssetId,
-                        totalValue: '100000',
-                        components: [{ value: '100000' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'deposit', liquidity: { type: 'LP' } },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse lp withdraw', async () => {
-            const { tx } = thorchainLpWithdraw;
-            const address = 'cosmos18377m4dkzz9exa6yctph0fu9ygsexgjvfy893w';
-            const memo = '-:GAIA.ATOM:10000';
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                fee: {
-                    assetId: cosmosAssetId,
-                    value: '2491',
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: 'cosmos1g7a7l9zp4h0vma5tqe5xnmvps3wyzumwel2j95',
-                        assetId: cosmosAssetId,
-                        totalValue: '1',
-                        components: [{ value: '1' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'withdraw', liquidity: { type: 'LP' } },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse lp outbound', async () => {
-            const { tx, actionsResponse } = thorchainLpOutbound;
-            const address = 'cosmos18377m4dkzz9exa6yctph0fu9ygsexgjvfy893w';
-            const memo = 'OUT:E8C9E5708C60F1C17AB106851EB19B0BF8A888A5FA0E079B7DFC7DBDB8B2E21D';
-            mocks.get.mockImplementationOnce(() => ({ data: actionsResponse }));
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: 'cosmos12sdwha358f7rdpn6t77aqjmmzcz03x0gs9hmls',
-                        to: address,
-                        assetId: cosmosAssetId,
-                        totalValue: '48123192',
-                        components: [{ value: '48123192' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'withdrawOut', liquidity: { type: 'LP' } },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse lp refund', async () => {
-            const { tx, actionsResponse } = thorchainLpRefund;
-            const address = 'cosmos1x04c87s4kyfr3ktrvkd47h43jlz35gys0rjfn0';
-            const memo = 'REFUND:70D66FC759772014C0273EB84691A2A4BFFCD0EFA6ED3A4E5A9A021C1FF53338';
-            mocks.get.mockImplementationOnce(() => ({ data: actionsResponse }));
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: 'cosmos1h7cjvuc3gtt3r4afm0zqvhvrpkfw0ahx4nszv3',
-                        to: address,
-                        assetId: cosmosAssetId,
-                        totalValue: '5678021',
-                        components: [{ value: '5678021' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'depositRefund', liquidity: { type: 'LP' } },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse loan open outbound', async () => {
-            const { tx, actionsResponse } = thorchainLoanOpenOutbound;
-            const address = 'cosmos173xmmmzpalc9h7ynwtn6fl76h78n57e8kp7cp6';
-            const memo = 'OUT:C8ECD3A1C72473C294A63428E6284B2CEEC972BFA7372DF475F381777168D486';
-            mocks.get.mockImplementationOnce(() => ({ data: actionsResponse }));
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: 'cosmos1vkakp7qxx2sjxnp3hyw592h2yxd530yvkng95e',
-                        to: address,
-                        assetId: cosmosAssetId,
-                        totalValue: '70370080',
-                        components: [{ value: '70370080' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'loanOpenOut' },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse loan repayment', async () => {
-            const { tx } = thorchainLoanRepayment;
-            const address = 'cosmos1csjuyfe8tnyn5q5sgm3wxetfqkt9053at78n69';
-            const memo = '$-:BTC.BTC:bc1q7s6r03k7e7x2gthzmjk2fptx32ags78jk57cu4';
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                fee: {
-                    assetId: cosmosAssetId,
-                    value: '2281',
-                },
-                transfers: [
-                    {
-                        type: TransferType.Send,
-                        from: address,
-                        to: 'cosmos1lwktkpjh3tvmlftfkaz9xukw7xzksh059eslkf',
-                        assetId: cosmosAssetId,
-                        totalValue: '45633513',
-                        components: [{ value: '45633513' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'loanRepayment' },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-        it('should be able to parse loan repayment refund', async () => {
-            const { tx, actionsResponse } = thorchainLoanRepaymentRefund;
-            const address = 'cosmos1vvtcw3cvje0kthxca6w5q2nz5kxr9cnckrutgc';
-            const memo = 'REFUND:4EAC7774DD66B1AC08C9FE36ABC324875CF64B31E591649E5E410898F1603AD1';
-            mocks.get.mockImplementationOnce(() => ({ data: actionsResponse }));
-            const expected = {
-                txid: tx.txid,
-                blockHash: tx.blockHash,
-                blockHeight: tx.blockHeight,
-                blockTime: tx.timestamp,
-                confirmations: tx.confirmations,
-                status: TxStatus.Confirmed,
-                address,
-                chainId: cosmosChainId,
-                transfers: [
-                    {
-                        type: TransferType.Receive,
-                        from: 'cosmos1fpsa38rmg2v829umggnvj09acurtzycjnhgnt4',
-                        to: address,
-                        assetId: cosmosAssetId,
-                        totalValue: '201974667',
-                        components: [{ value: '201974667' }],
-                    },
-                ],
-                data: { parser: 'thorchain', memo, method: 'loanRepaymentRefund' },
-            };
-            const actual = await txParser.parse(tx, address);
-            expect(actual).toEqual(expected);
-        });
-    });
-});