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

package/dist/esm/evm/optimism/parser/index.d.ts

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

package/dist/esm/evm/optimism/parser/index.js

@@ -1,13 +0,0 @@
-import { ZRX_OPTIMISM_PROXY_CONTRACT } from '@shapeshiftoss/contracts';
-import { BaseTransactionParser } from '../../parser/index.js';
-import * as erc20 from '../../parser/erc20.js';
-import * as zrx from '../../parser/zrx.js';
-export class TransactionParser extends BaseTransactionParser {
-    constructor(args) {
-        super(args);
-        this.registerParsers([
-            new erc20.Parser({ chainId: this.chainId, provider: this.provider }),
-            new zrx.Parser({ proxyContract: ZRX_OPTIMISM_PROXY_CONTRACT }),
-        ]);
-    }
-}

package/dist/esm/evm/parser/arbitrumBridge.d.ts

@@ -1,27 +0,0 @@
-import type { AssetId, ChainId } from '@shapeshiftoss/caip';
-import { ethers } from 'ethers';
-import type { BaseTxMetadata } from '../../types.js';
-import type { SubParser, TxSpecific } from './index.js';
-import type { Tx } from './types.js';
-export interface TxMetadata extends BaseTxMetadata {
-    parser: 'arbitrumBridge';
-    assetId?: AssetId;
-    destinationAddress?: string;
-    destinationAssetId?: AssetId;
-    value?: string;
-}
-export interface ParserArgs {
-    chainId: ChainId;
-}
-export declare class Parser implements SubParser<Tx> {
-    readonly chainId: ChainId;
-    readonly arbProxyAbi: ethers.Interface;
-    readonly arbSysAbi: ethers.Interface;
-    readonly arbOutboxAbi: ethers.Interface;
-    readonly arbRetryableTxAbi: ethers.Interface;
-    readonly l2ArbitrumGatewayAbi: ethers.Interface;
-    readonly l1OrbitCustomGatewayAbi: ethers.Interface;
-    readonly l1ArbitrumGatewayAbi: ethers.Interface;
-    constructor(args: ParserArgs);
-    parse(tx: Tx): Promise<TxSpecific | undefined>;
-}

package/dist/esm/evm/parser/arbitrumBridge.js

@@ -1,114 +0,0 @@
-import { arbitrumChainId, ethAssetId, ethChainId, toAssetId } from '@shapeshiftoss/caip';
-import { ARB_OUTBOX_ABI, ARB_OUTBOX_CONTRACT, ARB_PROXY_ABI, ARB_RETRYABLE_TX_CONTRACT, ARB_SYS_ABI, ARB_SYS_CONTRACT, ARBITRUM_L2_ERC20_GATEWAY_PROXY_CONTRACT, ARBITRUM_RETRYABLE_TX_ABI, L1_ARBITRUM_GATEWAY_ABI, L1_ARBITRUM_GATEWAY_CONTRACT, L1_ORBIT_CUSTOM_GATEWAY_ABI, L1_ORBIT_CUSTOM_GATEWAY_CONTRACT, L2_ARBITRUM_CUSTOM_GATEWAY_CONTRACT, L2_ARBITRUM_GATEWAY_ABI, L2_ARBITRUM_GATEWAY_CONTRACT, } from '@shapeshiftoss/contracts';
-import { ethers } from 'ethers';
-import { getSigHash, txInteractsWithContract } from './index.js';
-export class Parser {
-    chainId;
-    arbProxyAbi = new ethers.Interface(ARB_PROXY_ABI);
-    arbSysAbi = new ethers.Interface(ARB_SYS_ABI);
-    arbOutboxAbi = new ethers.Interface(ARB_OUTBOX_ABI);
-    arbRetryableTxAbi = new ethers.Interface(ARBITRUM_RETRYABLE_TX_ABI);
-    l2ArbitrumGatewayAbi = new ethers.Interface(L2_ARBITRUM_GATEWAY_ABI);
-    l1OrbitCustomGatewayAbi = new ethers.Interface(L1_ORBIT_CUSTOM_GATEWAY_ABI);
-    l1ArbitrumGatewayAbi = new ethers.Interface(L1_ARBITRUM_GATEWAY_ABI);
-    constructor(args) {
-        this.chainId = args.chainId;
-    }
-    async parse(tx) {
-        if (!tx.inputData)
-            return;
-        const txSigHash = getSigHash(tx.inputData);
-        const selectedAbi = (() => {
-            if (txInteractsWithContract(tx, ARB_OUTBOX_CONTRACT))
-                return this.arbOutboxAbi;
-            if (txInteractsWithContract(tx, ARB_SYS_CONTRACT))
-                return this.arbSysAbi;
-            if (txInteractsWithContract(tx, L2_ARBITRUM_GATEWAY_CONTRACT))
-                return this.l2ArbitrumGatewayAbi;
-            if (txInteractsWithContract(tx, L2_ARBITRUM_CUSTOM_GATEWAY_CONTRACT))
-                return this.l2ArbitrumGatewayAbi;
-            if (txInteractsWithContract(tx, ARBITRUM_L2_ERC20_GATEWAY_PROXY_CONTRACT))
-                return this.l2ArbitrumGatewayAbi;
-            if (txInteractsWithContract(tx, L1_ARBITRUM_GATEWAY_CONTRACT) &&
-                this.chainId === arbitrumChainId)
-                return this.arbProxyAbi;
-            if (txInteractsWithContract(tx, ARB_RETRYABLE_TX_CONTRACT))
-                return this.arbRetryableTxAbi;
-            if (txInteractsWithContract(tx, L1_ORBIT_CUSTOM_GATEWAY_CONTRACT))
-                return this.l1OrbitCustomGatewayAbi;
-            if (txInteractsWithContract(tx, L1_ARBITRUM_GATEWAY_CONTRACT))
-                return this.l1ArbitrumGatewayAbi;
-        })();
-        const decoded = selectedAbi?.parseTransaction({ data: tx.inputData });
-        // failed to decode input data
-        if (!decoded)
-            return;
-        const maybeAssetId = tx.tokenTransfers?.[0].contract
-            ? toAssetId({
-                chainId: this.chainId,
-                assetNamespace: 'erc20',
-                assetReference: tx.tokenTransfers?.[0].contract,
-            })
-            : undefined;
-        const data = {
-            assetId: maybeAssetId,
-            method: decoded.name,
-            parser: 'arbitrumBridge',
-        };
-        // On ethereum side, we wants to tag it as a deposit if it interacts with the L1 Arbitrum Gateway
-        if (txInteractsWithContract(tx, L1_ARBITRUM_GATEWAY_CONTRACT) && this.chainId === ethChainId) {
-            data.method = `${decoded.name}Deposit`;
-        }
-        switch (selectedAbi) {
-            case this.arbSysAbi:
-                switch (txSigHash) {
-                    case this.arbSysAbi.getFunction('withdrawEth')?.selector:
-                        return await Promise.resolve({
-                            data: {
-                                ...data,
-                                destinationAddress: decoded.args.destination,
-                                destinationAssetId: ethAssetId,
-                                value: tx.value,
-                            },
-                        });
-                    default:
-                        return await Promise.resolve({ data });
-                }
-            case this.l2ArbitrumGatewayAbi:
-                switch (txSigHash) {
-                    case this.l2ArbitrumGatewayAbi.getFunction('outboundTransfer(address,address,uint256,bytes)')?.selector:
-                        {
-                            const amount = decoded.args._amount;
-                            const l1Token = decoded.args._l1Token;
-                            const destinationAssetId = toAssetId({
-                                chainId: ethChainId,
-                                assetNamespace: 'erc20',
-                                assetReference: l1Token,
-                            });
-                            return await Promise.resolve({
-                                data: {
-                                    ...data,
-                                    destinationAddress: decoded.args._to,
-                                    destinationAssetId,
-                                    value: amount.toString(),
-                                },
-                            });
-                        }
-                    case this.l2ArbitrumGatewayAbi.getFunction('finalizeInboundTransfer')?.selector:
-                        return await Promise.resolve({
-                            data: {
-                                ...data,
-                                // `finalizeInboundTransfer` on the Ethereum side (i.e withdraw request) is internal to the bridge, and only releases fundus safu
-                                // https://docs.arbitrum.io/build-decentralized-apps/token-bridging/token-bridge-erc20
-                                // however, on the Arbitrum side, it's an effective deposit
-                                method: this.chainId === arbitrumChainId ? 'finalizeInboundTransferDeposit' : data.method,
-                            },
-                        });
-                    default:
-                        return await Promise.resolve({ data });
-                }
-            default:
-                return await Promise.resolve({ data });
-        }
-    }
-}

package/dist/esm/evm/parser/erc20.d.ts

@@ -1,22 +0,0 @@
-import type { ChainId } from '@shapeshiftoss/caip';
-import { ethers } from 'ethers';
-import type { BaseTxMetadata } from '../../types.js';
-import type { SubParser, Tx, TxSpecific } from './types.js';
-export interface TxMetadata extends BaseTxMetadata {
-    parser: 'erc20';
-    assetId: string;
-    value?: string;
-}
-interface ParserArgs {
-    chainId: ChainId;
-    provider: ethers.JsonRpcProvider;
-}
-export declare class Parser<T extends Tx> implements SubParser<T> {
-    provider: ethers.JsonRpcProvider;
-    readonly chainId: ChainId;
-    readonly abiInterface: ethers.Interface;
-    private readonly supportedFunctions;
-    constructor(args: ParserArgs);
-    parse(tx: T): Promise<TxSpecific | undefined>;
-}
-export {};

package/dist/esm/evm/parser/erc20.js

@@ -1,52 +0,0 @@
-import { toAssetId } from '@shapeshiftoss/caip';
-import { ethers } from 'ethers';
-import { erc20Abi } from 'viem';
-import { getSigHash } from './utils.js';
-export class Parser {
-    provider;
-    chainId;
-    abiInterface = new ethers.Interface(erc20Abi);
-    supportedFunctions;
-    constructor(args) {
-        this.provider = args.provider;
-        this.chainId = args.chainId;
-        const approveSigHash = this.abiInterface.getFunction('approve')?.selector;
-        if (!approveSigHash)
-            throw new Error('Failed to get function selectors');
-        this.supportedFunctions = {
-            approveSigHash,
-        };
-    }
-    async parse(tx) {
-        if (!tx.inputData)
-            return;
-        const txSigHash = getSigHash(tx.inputData);
-        if (!Object.values(this.supportedFunctions).some(hash => hash === txSigHash))
-            return;
-        const decoded = this.abiInterface.parseTransaction({ data: tx.inputData });
-        // failed to decode input data
-        if (!decoded)
-            return;
-        const data = {
-            assetId: toAssetId({
-                chainId: this.chainId,
-                assetNamespace: 'erc20',
-                assetReference: tx.to,
-            }),
-            method: decoded.name,
-            parser: 'erc20',
-        };
-        switch (txSigHash) {
-            case this.supportedFunctions.approveSigHash: {
-                const amount = decoded.args.amount;
-                const value = amount.toString();
-                if (amount === 0n) {
-                    return await Promise.resolve({ data: { ...data, method: 'revoke', value } });
-                }
-                return await Promise.resolve({ data: { ...data, value: value.toString() } });
-            }
-            default:
-                return await Promise.resolve({ data });
-        }
-    }
-}

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

@@ -1,30 +0,0 @@
-import type { AssetId, ChainId } from '@shapeshiftoss/caip';
-import { JsonRpcProvider } from 'ethers';
-import type { Api } from '../index.js';
-import type { ParsedTx, SubParser, Tx } from './types.js';
-export * from './types.js';
-export * from './utils.js';
-export interface BaseTransactionParserArgs {
-    chainId: ChainId;
-    assetId: AssetId;
-    api: Api;
-    rpcUrl: string;
-}
-export declare class BaseTransactionParser<T extends Tx> {
-    chainId: ChainId;
-    assetId: AssetId;
-    protected readonly api: Api;
-    protected readonly provider: JsonRpcProvider;
-    private parsers;
-    constructor(args: BaseTransactionParserArgs);
-    /**
-     * Register custom transaction sub parser to extract contract specific 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>;
-    private getStatus;
-    private getParsedTxWithTransfers;
-}

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

@@ -1,181 +0,0 @@
-import { ASSET_NAMESPACE, ASSET_REFERENCE, ethChainId, optimismChainId, polygonChainId, toAssetId, } from '@shapeshiftoss/caip';
-import { BigNumber } from 'bignumber.js';
-import { getAddress, JsonRpcProvider } from 'ethers';
-import { TransferType } from '../../types.js';
-import { aggregateTransfer, findAsyncSequential } from '../../utils.js';
-import { getTxStatus } from './utils.js';
-export * from './types.js';
-export * from './utils.js';
-export class BaseTransactionParser {
-    chainId;
-    assetId;
-    api;
-    provider;
-    parsers = [];
-    constructor(args) {
-        this.chainId = args.chainId;
-        this.assetId = args.assetId;
-        this.api = args.api;
-        this.provider = new JsonRpcProvider(args.rpcUrl, undefined, { staticNetwork: true });
-    }
-    /**
-     * Register custom transaction sub parser to extract contract specific 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) {
-        address = getAddress(address);
-        // We expect only one Parser to return a result. If multiple do, we take the first and early exit.
-        const contractParserResult = await findAsyncSequential(this.parsers, async (parser) => await parser.parse(tx, address));
-        const parsedTx = {
-            address,
-            blockHash: tx.blockHash,
-            blockHeight: tx.blockHeight,
-            blockTime: tx.timestamp,
-            chainId: this.chainId,
-            confirmations: tx.confirmations,
-            status: this.getStatus(tx),
-            trade: contractParserResult?.trade,
-            transfers: contractParserResult?.transfers ?? [],
-            txid: tx.txid,
-            data: contractParserResult?.data,
-        };
-        return this.getParsedTxWithTransfers(tx, parsedTx, address);
-    }
-    getStatus(tx) {
-        return getTxStatus(tx);
-    }
-    getParsedTxWithTransfers(tx, parsedTx, address) {
-        if (address === tx.from) {
-            // send amount
-            const sendValue = new BigNumber(tx.value);
-            if (sendValue.gt(0)) {
-                parsedTx.transfers = aggregateTransfer({
-                    assetId: this.assetId,
-                    from: tx.from,
-                    to: tx.to,
-                    transfers: parsedTx.transfers,
-                    type: TransferType.Send,
-                    value: sendValue.toString(10),
-                });
-            }
-            // network fee
-            const fees = new BigNumber(tx.fee);
-            if (fees.gt(0)) {
-                parsedTx.fee = { assetId: this.assetId, value: fees.toString(10) };
-            }
-        }
-        if (address === tx.to) {
-            // receive amount
-            const receiveValue = new BigNumber(tx.value);
-            if (receiveValue.gt(0)) {
-                parsedTx.transfers = aggregateTransfer({
-                    assetId: this.assetId,
-                    from: tx.from,
-                    to: tx.to,
-                    transfers: parsedTx.transfers,
-                    type: TransferType.Receive,
-                    value: receiveValue.toString(10),
-                });
-            }
-        }
-        tx.tokenTransfers?.forEach(transfer => {
-            // FTX Token (FTT) name and symbol was set backwards on the ERC20 contract (Ethereum Mainnet)
-            if (this.chainId === ethChainId &&
-                transfer.contract === '0x50D1c9771902476076eCFc8B2A83Ad6b9355a4c9') {
-                transfer.name = transfer.symbol;
-                transfer.symbol = transfer.name;
-            }
-            const token = {
-                contract: transfer.contract,
-                decimals: transfer.decimals,
-                name: transfer.name,
-                symbol: transfer.symbol,
-            };
-            const assetId = (() => {
-                // alias LegacyERC20ETH on optimism to native asset as they are the same (pre bedrock)
-                if (this.chainId === optimismChainId &&
-                    transfer.contract === '0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000') {
-                    return toAssetId({
-                        chainId: this.chainId,
-                        assetNamespace: 'slip44',
-                        assetReference: ASSET_REFERENCE.Optimism,
-                    });
-                }
-                // alias POL token on POLY to native asset as they are the same
-                if (this.chainId === polygonChainId &&
-                    transfer.contract === '0x0000000000000000000000000000000000001010') {
-                    return toAssetId({
-                        chainId: this.chainId,
-                        assetNamespace: 'slip44',
-                        assetReference: ASSET_REFERENCE.Polygon,
-                    });
-                }
-                const assetNamespace = (() => {
-                    switch (transfer.type) {
-                        case 'ERC20':
-                            return ASSET_NAMESPACE.erc20;
-                        case 'ERC721':
-                            return ASSET_NAMESPACE.erc721;
-                        case 'ERC1155':
-                            return ASSET_NAMESPACE.erc1155;
-                        default:
-                            return;
-                    }
-                })();
-                if (!assetNamespace)
-                    return;
-                return toAssetId({
-                    chainId: this.chainId,
-                    assetNamespace,
-                    assetReference: transfer.id ? `${transfer.contract}/${transfer.id}` : transfer.contract,
-                });
-            })();
-            if (!assetId)
-                return;
-            const makeTokenTransferArgs = (type) => ({
-                assetId,
-                from: transfer.from,
-                id: transfer.id,
-                to: transfer.to,
-                token,
-                transfers: parsedTx.transfers,
-                type,
-                value: transfer.value,
-            });
-            // token send amount
-            if (address === transfer.from) {
-                parsedTx.transfers = aggregateTransfer(makeTokenTransferArgs(TransferType.Send));
-            }
-            // token receive amount
-            if (address === transfer.to) {
-                parsedTx.transfers = aggregateTransfer(makeTokenTransferArgs(TransferType.Receive));
-            }
-        });
-        tx.internalTxs?.forEach(internalTx => {
-            const makeInternalTransferArgs = (type) => ({
-                assetId: this.assetId,
-                from: internalTx.from,
-                to: internalTx.to,
-                transfers: parsedTx.transfers,
-                type,
-                value: internalTx.value,
-            });
-            // internal eth send
-            if (address === internalTx.from) {
-                parsedTx.transfers = aggregateTransfer(makeInternalTransferArgs(TransferType.Send));
-            }
-            // internal eth receive
-            if (address === internalTx.to) {
-                parsedTx.transfers = aggregateTransfer(makeInternalTransferArgs(TransferType.Receive));
-            }
-        });
-        return parsedTx;
-    }
-}

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

@@ -1,9 +0,0 @@
-import type { ChainId } from '@shapeshiftoss/caip';
-import * as thormaya from './thormaya.js';
-export interface ParserArgs {
-    chainId: ChainId;
-    midgardUrl: string;
-}
-export declare class Parser extends thormaya.Parser {
-    constructor(args: ParserArgs);
-}

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

@@ -1,10 +0,0 @@
-import * as mayachain from '../../parser/mayachain.js';
-import * as thormaya from './thormaya.js';
-export class Parser extends thormaya.Parser {
-    constructor(args) {
-        super({
-            chainId: args.chainId,
-            parser: new mayachain.Parser({ midgardUrl: args.midgardUrl }),
-        });
-    }
-}

package/dist/esm/evm/parser/rfox.d.ts

@@ -1,25 +0,0 @@
-import type { AssetId } from '@shapeshiftoss/caip';
-import { ethers } from 'ethers';
-import type { BaseTxMetadata } from '../../types.js';
-import type { SubParser, TxSpecific } from './index.js';
-import type { Tx } from './types.js';
-export interface TxMetadata extends BaseTxMetadata {
-    parser: 'rfox';
-    type: 'evm';
-    assetId: AssetId;
-    value?: string;
-    runeAddress?: string;
-    claimIndex?: number;
-}
-export interface ParserArgs {
-    proxyContract: string;
-    stakingAssetId: AssetId;
-}
-export declare class Parser implements SubParser<Tx> {
-    private readonly proxyContract;
-    private readonly stakingAssetId;
-    private readonly supportedFunctions;
-    readonly abiInterface: ethers.Interface;
-    constructor(args: ParserArgs);
-    parse(tx: Tx): Promise<TxSpecific | undefined>;
-}

package/dist/esm/evm/parser/rfox.js

@@ -1,62 +0,0 @@
-import { RFOX_ABI } from '@shapeshiftoss/contracts';
-import { ethers } from 'ethers';
-import { getSigHash, txInteractsWithContract } from './index.js';
-export class Parser {
-    proxyContract;
-    stakingAssetId;
-    supportedFunctions;
-    abiInterface = new ethers.Interface(RFOX_ABI);
-    constructor(args) {
-        this.proxyContract = args.proxyContract;
-        this.stakingAssetId = args.stakingAssetId;
-        const stake = this.abiInterface.getFunction('stake')?.selector;
-        const unstake = this.abiInterface.getFunction('unstake')?.selector;
-        const withdrawClaim = this.abiInterface.getFunction('withdraw(uint256)')?.selector;
-        const withdraw = this.abiInterface.getFunction('withdraw()')?.selector;
-        const setRuneAddress = this.abiInterface.getFunction('setRuneAddress')?.selector;
-        if (!(stake && unstake && withdrawClaim && withdraw && setRuneAddress)) {
-            throw new Error('Failed to get function selectors');
-        }
-        this.supportedFunctions = {
-            stake,
-            unstake,
-            withdrawClaim,
-            withdraw,
-            setRuneAddress,
-        };
-    }
-    async parse(tx) {
-        if (!txInteractsWithContract(tx, this.proxyContract))
-            return;
-        if (!tx.inputData)
-            return;
-        const txSigHash = getSigHash(tx.inputData);
-        if (!Object.values(this.supportedFunctions).some(hash => hash === txSigHash))
-            return;
-        const decoded = this.abiInterface.parseTransaction({ data: tx.inputData });
-        if (!decoded)
-            return;
-        const data = {
-            method: decoded.name,
-            parser: 'rfox',
-            type: 'evm',
-            assetId: this.stakingAssetId,
-        };
-        switch (txSigHash) {
-            case this.supportedFunctions.unstake:
-                const amount = decoded.args.amount;
-                return await Promise.resolve({
-                    data: { ...data, method: `${data.method}Request`, value: amount.toString() },
-                });
-            case this.supportedFunctions.stake:
-            case this.supportedFunctions.setRuneAddress:
-                const runeAddress = decoded.args.runeAddress;
-                return await Promise.resolve({ data: { ...data, runeAddress } });
-            case this.supportedFunctions.withdrawClaim:
-                const index = decoded.args.index;
-                return await Promise.resolve({ data: { ...data, claimIndex: Number(index) } });
-            default:
-                return await Promise.resolve({ data });
-        }
-    }
-}

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

@@ -1,9 +0,0 @@
-import type { ChainId } from '@shapeshiftoss/caip';
-import * as thormaya from './thormaya.js';
-export interface ParserArgs {
-    chainId: ChainId;
-    midgardUrl: string;
-}
-export declare class Parser extends thormaya.Parser {
-    constructor(args: ParserArgs);
-}

package/dist/esm/evm/parser/thorchain.js

@@ -1,10 +0,0 @@
-import * as thorchain from '../../parser/thorchain.js';
-import * as thormaya from './thormaya.js';
-export class Parser extends thormaya.Parser {
-    constructor(args) {
-        super({
-            chainId: args.chainId,
-            parser: new thorchain.Parser({ midgardUrl: args.midgardUrl }),
-        });
-    }
-}

package/dist/esm/evm/parser/thormaya.d.ts

@@ -1,17 +0,0 @@
-import type { ChainId } from '@shapeshiftoss/caip';
-import type { Tx } from '../../generated/ethereum/index.js';
-import type * as mayachain from '../../parser/mayachain.js';
-import type * as thorchain from '../../parser/thorchain.js';
-import type { SubParser, TxSpecific } from './index.js';
-export interface ParserArgs {
-    chainId: ChainId;
-    parser: thorchain.Parser | mayachain.Parser;
-}
-export declare class Parser implements SubParser<Tx> {
-    private readonly chainId;
-    private readonly abiInterface;
-    private readonly supportedFunctions;
-    private readonly parser;
-    constructor(args: ParserArgs);
-    parse(tx: Tx): Promise<TxSpecific | undefined>;
-}

package/dist/esm/evm/parser/thormaya.js

@@ -1,69 +0,0 @@
-import { ethers } from 'ethers';
-import { getSigHash } from './index.js';
-const routerAbi = [
-    'function deposit(address vault, address asset, uint256 amount, string memo)',
-    'function depositWithExpiry(address vault, address asset, uint256 amount, string memo, uint256 expiration)',
-    'function transferOut(address to, address asset, uint256 amount, string memo)',
-    'function transferOutAndCall(address target, address finalAsset, address to, uint256 amountOutMin, string memo)',
-    'function swapIn(address tcRouter, address tcVault, string tcMemo, address token, uint256 amount, uint256 amountOutMin, uint256 deadline)',
-];
-const depositRegex = /^(add|a|\+):([^:]+)(:([^:]+)?)?(:([^:]+)?)?(:([^:]+)?)?$/;
-const withdrawRegex = /^(withdraw|wd|-):([^:]+)(:([^:]+)?)?(:([^:]+)?)?$/;
-export class Parser {
-    chainId;
-    abiInterface;
-    supportedFunctions;
-    parser;
-    constructor(args) {
-        this.abiInterface = new ethers.Interface(routerAbi);
-        const depositSigHash = this.abiInterface.getFunction('deposit')?.selector;
-        const depositWithExpirySigHash = this.abiInterface.getFunction('depositWithExpiry')?.selector;
-        const transferOutSigHash = this.abiInterface.getFunction('transferOut')?.selector;
-        const transferOutAndCallSigHash = this.abiInterface.getFunction('transferOutAndCall')?.selector;
-        const swapInSigHash = this.abiInterface.getFunction('swapIn')?.selector;
-        if (!(depositSigHash &&
-            depositWithExpirySigHash &&
-            transferOutSigHash &&
-            transferOutAndCallSigHash &&
-            swapInSigHash)) {
-            throw new Error('Failed to get function selectors');
-        }
-        this.supportedFunctions = {
-            depositSigHash,
-            depositWithExpirySigHash,
-            transferOutSigHash,
-            transferOutAndCallSigHash,
-            swapInSigHash,
-        };
-        this.parser = args.parser;
-        this.chainId = args.chainId;
-    }
-    async parse(tx) {
-        if (!tx.inputData)
-            return;
-        const txSigHash = getSigHash(tx.inputData);
-        const memo = (() => {
-            // input data is a function call
-            if (Object.values(this.supportedFunctions).some(hash => hash === txSigHash)) {
-                const decoded = this.abiInterface.parseTransaction({ data: tx.inputData });
-                // failed to decode input data
-                if (!decoded)
-                    return;
-                return decoded.args.memo || decoded.args.tcMemo;
-            }
-            // input data may be a raw thorchain memo
-            const maybeMemo = Buffer.from(tx.inputData.slice(2), 'hex').toString();
-            if ([depositRegex, withdrawRegex].some(regex => regex.test(maybeMemo.toLowerCase()))) {
-                return maybeMemo;
-            }
-        })();
-        if (!memo)
-            return;
-        try {
-            return await this.parser.parse(memo, tx.txid);
-        }
-        catch (err) {
-            console.error(`failed to parse tx: ${tx.txid} on ${this.chainId}: ${err}`);
-        }
-    }
-}