@shapeshiftoss/unchained-client 10.14.3 → 10.14.5

package/dist/esm/utxo/dogecoin/parser/__tests__/dogecoin.test.js

@@ -0,0 +1,213 @@
+import { dogeAssetId, dogeChainId } from '@shapeshiftoss/caip';
+import { describe, expect, it, vi } from 'vitest';
+import { TransferType, TxStatus } from '../../../../types.js';
+import { TransactionParser } from '../index.js';
+import standardNoChange from './mockData/standardNoChange.js';
+import standardWithChange from './mockData/standardWithChange.js';
+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: dogeChainId,
+    assetId: dogeAssetId,
+    midgardUrl: '',
+});
+describe('parseTx', () => {
+    describe('standard', () => {
+        it('should be able to parse standard send with no change mempool', async () => {
+            const { txMempool } = standardNoChange;
+            const address = 'D7N7452tBhydYh9ecEfFpQgw8yXXapxRCP';
+            const expected = {
+                txid: txMempool.txid,
+                blockHeight: txMempool.blockHeight,
+                blockTime: txMempool.timestamp,
+                confirmations: txMempool.confirmations,
+                status: TxStatus.Pending,
+                address,
+                chainId: dogeChainId,
+                fee: {
+                    assetId: dogeAssetId,
+                    value: '12050688',
+                },
+                transfers: [
+                    {
+                        type: TransferType.Send,
+                        from: 'D7N7452tBhydYh9ecEfFpQgw8yXXapxRCP',
+                        to: 'DQZkYpyV2YzkyqnZDqekbKuSD6VGq6CqHb',
+                        assetId: dogeAssetId,
+                        totalValue: '750000000',
+                        components: [{ value: '750000000' }],
+                    },
+                ],
+            };
+            const actual = await txParser.parse(txMempool, address);
+            expect(expected).toEqual(actual);
+        });
+        it('should be able to parse standard send with no change', async () => {
+            const { tx } = standardNoChange;
+            const address = 'D7N7452tBhydYh9ecEfFpQgw8yXXapxRCP';
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: TxStatus.Confirmed,
+                address,
+                chainId: dogeChainId,
+                fee: {
+                    assetId: dogeAssetId,
+                    value: '12050688',
+                },
+                transfers: [
+                    {
+                        type: TransferType.Send,
+                        from: 'D7N7452tBhydYh9ecEfFpQgw8yXXapxRCP',
+                        to: 'DQZkYpyV2YzkyqnZDqekbKuSD6VGq6CqHb',
+                        assetId: dogeAssetId,
+                        totalValue: '750000000',
+                        components: [{ value: '750000000' }],
+                    },
+                ],
+            };
+            const actual = await txParser.parse(tx, address);
+            expect(expected).toEqual(actual);
+        });
+        it('should be able to parse standard receive no change mempool', async () => {
+            const { txMempool } = standardNoChange;
+            const address = 'DQZkYpyV2YzkyqnZDqekbKuSD6VGq6CqHb';
+            const expected = {
+                txid: txMempool.txid,
+                blockHeight: txMempool.blockHeight,
+                blockTime: txMempool.timestamp,
+                confirmations: txMempool.confirmations,
+                status: TxStatus.Pending,
+                address,
+                chainId: dogeChainId,
+                transfers: [
+                    {
+                        type: TransferType.Receive,
+                        from: 'D7N7452tBhydYh9ecEfFpQgw8yXXapxRCP',
+                        to: 'DQZkYpyV2YzkyqnZDqekbKuSD6VGq6CqHb',
+                        assetId: dogeAssetId,
+                        totalValue: '737949312',
+                        components: [{ value: '737949312' }],
+                    },
+                ],
+            };
+            const actual = await txParser.parse(txMempool, address);
+            expect(expected).toEqual(actual);
+        });
+        it('should be able to parse standard receive no change', async () => {
+            const { tx } = standardNoChange;
+            const address = 'DQZkYpyV2YzkyqnZDqekbKuSD6VGq6CqHb';
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: TxStatus.Confirmed,
+                address,
+                chainId: dogeChainId,
+                transfers: [
+                    {
+                        type: TransferType.Receive,
+                        from: 'D7N7452tBhydYh9ecEfFpQgw8yXXapxRCP',
+                        to: 'DQZkYpyV2YzkyqnZDqekbKuSD6VGq6CqHb',
+                        assetId: dogeAssetId,
+                        totalValue: '737949312',
+                        components: [{ value: '737949312' }],
+                    },
+                ],
+            };
+            const actual = await txParser.parse(tx, address);
+            expect(expected).toEqual(actual);
+        });
+        it('should be able to parse standard send with change mempool', async () => {
+            const { txMempool } = standardWithChange;
+            const address = 'DDUoTGov76gcqAEBXXpUHzSuSQkPYKze9N';
+            const expected = {
+                txid: txMempool.txid,
+                blockHeight: txMempool.blockHeight,
+                blockTime: txMempool.timestamp,
+                confirmations: txMempool.confirmations,
+                status: TxStatus.Pending,
+                address,
+                chainId: dogeChainId,
+                fee: {
+                    assetId: dogeAssetId,
+                    value: '125900000',
+                },
+                transfers: [
+                    {
+                        type: TransferType.Send,
+                        to: 'DHfvk82f2sCqsoUXzTyQSDUoF5YZVYoE1Y',
+                        from: 'DDUoTGov76gcqAEBXXpUHzSuSQkPYKze9N',
+                        assetId: dogeAssetId,
+                        totalValue: '70370021036118',
+                        components: [{ value: '70370021036118' }],
+                    },
+                    {
+                        type: TransferType.Receive,
+                        to: 'DDUoTGov76gcqAEBXXpUHzSuSQkPYKze9N',
+                        from: 'DDUoTGov76gcqAEBXXpUHzSuSQkPYKze9N',
+                        assetId: dogeAssetId,
+                        totalValue: '70223692253218',
+                        components: [{ value: '70223692253218' }],
+                    },
+                ],
+            };
+            const actual = await txParser.parse(txMempool, address);
+            expect(expected).toEqual(actual);
+        });
+        it('should be able to parse standard send with change', async () => {
+            const { tx } = standardWithChange;
+            const address = 'DDUoTGov76gcqAEBXXpUHzSuSQkPYKze9N';
+            const expected = {
+                txid: tx.txid,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                blockHash: tx.blockHash,
+                confirmations: tx.confirmations,
+                status: TxStatus.Confirmed,
+                address,
+                chainId: dogeChainId,
+                fee: {
+                    assetId: dogeAssetId,
+                    value: '125900000',
+                },
+                transfers: [
+                    {
+                        type: TransferType.Send,
+                        to: 'DHfvk82f2sCqsoUXzTyQSDUoF5YZVYoE1Y',
+                        from: 'DDUoTGov76gcqAEBXXpUHzSuSQkPYKze9N',
+                        assetId: dogeAssetId,
+                        totalValue: '70370021036118',
+                        components: [{ value: '70370021036118' }],
+                    },
+                    {
+                        type: TransferType.Receive,
+                        to: 'DDUoTGov76gcqAEBXXpUHzSuSQkPYKze9N',
+                        from: 'DDUoTGov76gcqAEBXXpUHzSuSQkPYKze9N',
+                        assetId: dogeAssetId,
+                        totalValue: '70223692253218',
+                        components: [{ value: '70223692253218' }],
+                    },
+                ],
+            };
+            const actual = await txParser.parse(tx, address);
+            expect(expected).toEqual(actual);
+        });
+    });
+});

package/dist/esm/utxo/dogecoin/parser/__tests__/mockData/standardNoChange.d.ts

@@ -0,0 +1,6 @@
+import type { Tx } from '../../../../../generated/dogecoin/index.js';
+declare const _default: {
+    tx: Tx;
+    txMempool: Tx;
+};
+export default _default;

package/dist/esm/utxo/dogecoin/parser/__tests__/mockData/standardWithChange.d.ts

@@ -0,0 +1,6 @@
+import type { Tx } from '../../../../../generated/dogecoin/index.js';
+declare const _default: {
+    tx: Tx;
+    txMempool: Tx;
+};
+export default _default;

package/dist/esm/utxo/dogecoin/parser/index.d.ts

@@ -0,0 +1,9 @@
+import type { Tx } from '../../../generated/dogecoin/index.js';
+import type { BaseTransactionParserArgs } from '../../parser/index.js';
+import { BaseTransactionParser } from '../../parser/index.js';
+export interface TransactionParserArgs extends BaseTransactionParserArgs {
+    midgardUrl: string;
+}
+export declare class TransactionParser extends BaseTransactionParser<Tx> {
+    constructor(args: TransactionParserArgs);
+}

package/dist/esm/utxo/dogecoin/parser/index.js

@@ -0,0 +1,8 @@
+import { BaseTransactionParser } from '../../parser/index.js';
+import * as thorchain from '../../parser/thorchain.js';
+export class TransactionParser extends BaseTransactionParser {
+    constructor(args) {
+        super(args);
+        this.registerParsers([new thorchain.Parser({ midgardUrl: args.midgardUrl })]);
+    }
+}

package/dist/esm/utxo/index.d.ts

@@ -0,0 +1,6 @@
+export type { utxo as types } from '@shapeshiftoss/common-api';
+export * from './parser/index.js';
+export * as bitcoin from './bitcoin/index.js';
+export * as bitcoincash from './bitcoincash/index.js';
+export * as dogecoin from './dogecoin/index.js';
+export * as litecoin from './litecoin/index.js';

package/dist/esm/utxo/index.js

@@ -0,0 +1,5 @@
+export * from './parser/index.js';
+export * as bitcoin from './bitcoin/index.js';
+export * as bitcoincash from './bitcoincash/index.js';
+export * as dogecoin from './dogecoin/index.js';
+export * as litecoin from './litecoin/index.js';

package/dist/esm/utxo/litecoin/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../../generated/litecoin/index.js';
+export * from './parser/index.js';

package/dist/esm/utxo/litecoin/index.js

@@ -0,0 +1,2 @@
+export * from '../../generated/litecoin/index.js';
+export * from './parser/index.js';

package/dist/esm/utxo/litecoin/parser/__tests__/litecoin.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/utxo/litecoin/parser/__tests__/litecoin.test.js

@@ -0,0 +1,209 @@
+import { ltcAssetId, ltcChainId } from '@shapeshiftoss/caip';
+import { describe, expect, it, vi } from 'vitest';
+import { TransferType, TxStatus } from '../../../../types.js';
+import { TransactionParser } from '../index.js';
+import standardNoChange from './mockData/standardNoChange.js';
+import standardWithChange from './mockData/standardWithChange.js';
+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: ltcChainId, assetId: ltcAssetId, midgardUrl: '' });
+describe('parseTx', () => {
+    describe('standard', () => {
+        it('should be able to parse standard send with no change mempool', async () => {
+            const { txMempool } = standardNoChange;
+            const address = 'LZSEtkn8TLr5EpremqDq49CSUS1xGnkbX9';
+            const expected = {
+                txid: txMempool.txid,
+                blockHeight: txMempool.blockHeight,
+                blockTime: txMempool.timestamp,
+                confirmations: txMempool.confirmations,
+                status: TxStatus.Pending,
+                address,
+                chainId: ltcChainId,
+                fee: {
+                    assetId: ltcAssetId,
+                    value: '100000',
+                },
+                transfers: [
+                    {
+                        type: TransferType.Send,
+                        from: 'LZSEtkn8TLr5EpremqDq49CSUS1xGnkbX9',
+                        to: 'MVZSZBDqUsvzDZSvupJyPun2fb8UZKhSi7',
+                        assetId: ltcAssetId,
+                        totalValue: '340524408',
+                        components: [{ value: '340524408' }],
+                    },
+                ],
+            };
+            const actual = await txParser.parse(txMempool, address);
+            expect(expected).toEqual(actual);
+        });
+        it('should be able to parse standard send with no change', async () => {
+            const { tx } = standardNoChange;
+            const address = 'LZSEtkn8TLr5EpremqDq49CSUS1xGnkbX9';
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: TxStatus.Confirmed,
+                address,
+                chainId: ltcChainId,
+                fee: {
+                    assetId: ltcAssetId,
+                    value: '100000',
+                },
+                transfers: [
+                    {
+                        type: TransferType.Send,
+                        from: 'LZSEtkn8TLr5EpremqDq49CSUS1xGnkbX9',
+                        to: 'MVZSZBDqUsvzDZSvupJyPun2fb8UZKhSi7',
+                        assetId: ltcAssetId,
+                        totalValue: '340524408',
+                        components: [{ value: '340524408' }],
+                    },
+                ],
+            };
+            const actual = await txParser.parse(tx, address);
+            expect(expected).toEqual(actual);
+        });
+        it('should be able to parse standard receive with no change mempool', async () => {
+            const { txMempool } = standardNoChange;
+            const address = 'MVZSZBDqUsvzDZSvupJyPun2fb8UZKhSi7';
+            const expected = {
+                txid: txMempool.txid,
+                blockHeight: txMempool.blockHeight,
+                blockTime: txMempool.timestamp,
+                confirmations: txMempool.confirmations,
+                status: TxStatus.Pending,
+                address,
+                chainId: ltcChainId,
+                transfers: [
+                    {
+                        type: TransferType.Receive,
+                        from: 'LZSEtkn8TLr5EpremqDq49CSUS1xGnkbX9',
+                        to: 'MVZSZBDqUsvzDZSvupJyPun2fb8UZKhSi7',
+                        assetId: ltcAssetId,
+                        totalValue: '340424408',
+                        components: [{ value: '340424408' }],
+                    },
+                ],
+            };
+            const actual = await txParser.parse(txMempool, address);
+            expect(expected).toEqual(actual);
+        });
+        it('should be able to parse standard receive with no change', async () => {
+            const { tx } = standardNoChange;
+            const address = 'MVZSZBDqUsvzDZSvupJyPun2fb8UZKhSi7';
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: TxStatus.Confirmed,
+                address,
+                chainId: ltcChainId,
+                transfers: [
+                    {
+                        type: TransferType.Receive,
+                        from: 'LZSEtkn8TLr5EpremqDq49CSUS1xGnkbX9',
+                        to: 'MVZSZBDqUsvzDZSvupJyPun2fb8UZKhSi7',
+                        assetId: ltcAssetId,
+                        totalValue: '340424408',
+                        components: [{ value: '340424408' }],
+                    },
+                ],
+            };
+            const actual = await txParser.parse(tx, address);
+            expect(expected).toEqual(actual);
+        });
+        it('should be able to parse standard send with change mempool', async () => {
+            const { txMempool } = standardWithChange;
+            const address = 'LWvWQ3XMoipFsAqE1EZPQFUovLea7DC1ef';
+            const expected = {
+                txid: txMempool.txid,
+                blockHeight: txMempool.blockHeight,
+                blockTime: txMempool.timestamp,
+                confirmations: txMempool.confirmations,
+                status: TxStatus.Pending,
+                address,
+                chainId: ltcChainId,
+                fee: {
+                    assetId: ltcAssetId,
+                    value: '100000',
+                },
+                transfers: [
+                    {
+                        type: TransferType.Send,
+                        to: 'LXPf92CJycUi5JogY3NXEgYqZygTkEXrsy',
+                        from: 'LWvWQ3XMoipFsAqE1EZPQFUovLea7DC1ef',
+                        assetId: ltcAssetId,
+                        totalValue: '147680075',
+                        components: [{ value: '147680075' }],
+                    },
+                    {
+                        type: TransferType.Receive,
+                        to: 'LWvWQ3XMoipFsAqE1EZPQFUovLea7DC1ef',
+                        from: 'LWvWQ3XMoipFsAqE1EZPQFUovLea7DC1ef',
+                        assetId: ltcAssetId,
+                        totalValue: '31465800',
+                        components: [{ value: '31465800' }],
+                    },
+                ],
+            };
+            const actual = await txParser.parse(txMempool, address);
+            expect(expected).toEqual(actual);
+        });
+        it('should be able to parse standard send with change', async () => {
+            const { tx } = standardWithChange;
+            const address = 'LWvWQ3XMoipFsAqE1EZPQFUovLea7DC1ef';
+            const expected = {
+                txid: tx.txid,
+                blockHash: tx.blockHash,
+                blockHeight: tx.blockHeight,
+                blockTime: tx.timestamp,
+                confirmations: tx.confirmations,
+                status: TxStatus.Confirmed,
+                address,
+                chainId: ltcChainId,
+                fee: {
+                    assetId: ltcAssetId,
+                    value: '100000',
+                },
+                transfers: [
+                    {
+                        type: TransferType.Send,
+                        to: 'LXPf92CJycUi5JogY3NXEgYqZygTkEXrsy',
+                        from: 'LWvWQ3XMoipFsAqE1EZPQFUovLea7DC1ef',
+                        assetId: ltcAssetId,
+                        totalValue: '147680075',
+                        components: [{ value: '147680075' }],
+                    },
+                    {
+                        type: TransferType.Receive,
+                        to: 'LWvWQ3XMoipFsAqE1EZPQFUovLea7DC1ef',
+                        from: 'LWvWQ3XMoipFsAqE1EZPQFUovLea7DC1ef',
+                        assetId: ltcAssetId,
+                        totalValue: '31465800',
+                        components: [{ value: '31465800' }],
+                    },
+                ],
+            };
+            const actual = await txParser.parse(tx, address);
+            expect(expected).toEqual(actual);
+        });
+    });
+});

package/dist/esm/utxo/litecoin/parser/__tests__/mockData/standardNoChange.d.ts

@@ -0,0 +1,6 @@
+import type { Tx } from '../../../../../generated/litecoin/index.js';
+declare const _default: {
+    tx: Tx;
+    txMempool: Tx;
+};
+export default _default;

package/dist/esm/utxo/litecoin/parser/__tests__/mockData/standardWithChange.d.ts

@@ -0,0 +1,6 @@
+import type { Tx } from '../../../../../generated/litecoin/index.js';
+declare const _default: {
+    tx: Tx;
+    txMempool: Tx;
+};
+export default _default;

package/dist/esm/utxo/litecoin/parser/index.d.ts

@@ -0,0 +1,9 @@
+import type { Tx } from '../../../generated/litecoin/index.js';
+import type { BaseTransactionParserArgs } from '../../parser/index.js';
+import { BaseTransactionParser } from '../../parser/index.js';
+export interface TransactionParserArgs extends BaseTransactionParserArgs {
+    midgardUrl: string;
+}
+export declare class TransactionParser extends BaseTransactionParser<Tx> {
+    constructor(args: TransactionParserArgs);
+}

package/dist/esm/utxo/litecoin/parser/index.js

@@ -0,0 +1,8 @@
+import { BaseTransactionParser } from '../../parser/index.js';
+import * as thorchain from '../../parser/thorchain.js';
+export class TransactionParser extends BaseTransactionParser {
+    constructor(args) {
+        super(args);
+        this.registerParsers([new thorchain.Parser({ midgardUrl: args.midgardUrl })]);
+    }
+}

package/dist/esm/utxo/parser/index.d.ts

@@ -0,0 +1,23 @@
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+import type { utxo } from '@shapeshiftoss/common-api';
+import type { ParsedTx } from '../parser/index.js';
+import type { SubParser } from './types.js';
+export * from './types.js';
+export interface BaseTransactionParserArgs {
+    chainId: ChainId;
+    assetId: AssetId;
+}
+export declare class BaseTransactionParser<T extends utxo.Tx> {
+    chainId: ChainId;
+    assetId: AssetId;
+    private parsers;
+    constructor(args: BaseTransactionParserArgs);
+    /**
+     * Register custom transaction sub parser to parse custom op return data
+     *
+     * _parsers should be registered from most generic first to most specific last_
+     */
+    registerParser(parser: SubParser<T>): void;
+    protected registerParsers(parsers: SubParser<T>[]): void;
+    parse(tx: T, address: string): Promise<ParsedTx>;
+}

package/dist/esm/utxo/parser/index.js

@@ -0,0 +1,84 @@
+import { BigNumber } from 'bignumber.js';
+import { TransferType, TxStatus } from '../../types.js';
+import { aggregateTransfer } from '../../utils.js';
+export * from './types.js';
+export class BaseTransactionParser {
+    chainId;
+    assetId;
+    parsers = [];
+    constructor(args) {
+        this.chainId = args.chainId;
+        this.assetId = args.assetId;
+    }
+    /**
+     * Register custom transaction sub parser to parse custom op return data
+     *
+     * _parsers should be registered from most generic first to most specific last_
+     */
+    registerParser(parser) {
+        this.parsers.unshift(parser);
+    }
+    registerParsers(parsers) {
+        parsers.forEach(parser => this.registerParser(parser));
+    }
+    async parse(tx, address) {
+        const parserResults = await (async () => {
+            for (const parser of this.parsers) {
+                const result = await parser.parse(tx, address);
+                if (result)
+                    return result;
+            }
+        })();
+        const parsedTx = {
+            address,
+            blockHash: tx.blockHash,
+            blockHeight: tx.blockHeight,
+            blockTime: tx.timestamp,
+            chainId: this.chainId,
+            confirmations: tx.confirmations,
+            status: tx.confirmations > 0 ? TxStatus.Confirmed : TxStatus.Pending,
+            transfers: parserResults?.transfers ?? [],
+            txid: tx.txid,
+            trade: parserResults?.trade,
+            data: parserResults?.data,
+        };
+        tx.vin.forEach(vin => {
+            if (vin.addresses?.includes(address)) {
+                // send amount
+                const sendValue = new BigNumber(vin.value ?? 0);
+                if (sendValue.gt(0)) {
+                    parsedTx.transfers = aggregateTransfer({
+                        assetId: this.assetId,
+                        from: vin.addresses?.[0] ?? '',
+                        to: tx.vout[0].addresses?.[0] ?? '',
+                        transfers: parsedTx.transfers,
+                        type: TransferType.Send,
+                        value: sendValue.toString(10),
+                    });
+                }
+                // network fee
+                const fees = new BigNumber(tx.fee ?? 0);
+                if (fees.gt(0)) {
+                    parsedTx.fee = { assetId: this.assetId, value: fees.toString(10) };
+                }
+            }
+        });
+        tx.vout.forEach(vout => {
+            if (vout.addresses?.includes(address)) {
+                // receive amount
+                const receiveValue = new BigNumber(vout.value ?? 0);
+                if (receiveValue.gt(0)) {
+                    parsedTx.transfers = aggregateTransfer({
+                        assetId: this.assetId,
+                        from: tx.vin[0].addresses?.[0] ?? '',
+                        to: vout.addresses?.[0] ?? '',
+                        transfers: parsedTx.transfers,
+                        type: TransferType.Receive,
+                        value: receiveValue.toString(10),
+                    });
+                }
+            }
+        });
+        return Promise.resolve(parsedTx);
+    }
+}

package/dist/esm/utxo/parser/mayachain.d.ts

@@ -0,0 +1,9 @@
+import type { SubParser, Tx, TxSpecific } from '../parser/index.js';
+export interface ParserArgs {
+    midgardUrl: string;
+}
+export declare class Parser implements SubParser<Tx> {
+    private readonly parser;
+    constructor(args: ParserArgs);
+    parse(tx: Tx): Promise<TxSpecific | undefined>;
+}

package/dist/esm/utxo/parser/mayachain.js

@@ -0,0 +1,17 @@
+import * as mayachain from '../../parser/mayachain.js';
+const opReturnRegex = /OP_RETURN \((?<memo>[^)]+)\)/;
+export class Parser {
+    parser;
+    constructor(args) {
+        this.parser = new mayachain.Parser({ midgardUrl: args.midgardUrl });
+    }
+    async parse(tx) {
+        const opReturn = tx.vout.find(vout => vout.opReturn)?.opReturn;
+        if (!opReturn)
+            return;
+        const memo = opReturn.match(opReturnRegex)?.groups?.memo;
+        if (!memo)
+            return;
+        return await this.parser.parse(memo, tx.txid);
+    }
+}

package/dist/esm/utxo/parser/thorchain.d.ts

@@ -0,0 +1,9 @@
+import type { SubParser, Tx, TxSpecific } from '../parser/index.js';
+export interface ParserArgs {
+    midgardUrl: string;
+}
+export declare class Parser implements SubParser<Tx> {
+    private readonly parser;
+    constructor(args: ParserArgs);
+    parse(tx: Tx): Promise<TxSpecific | undefined>;
+}