@shapeshiftoss/unchained-client 10.14.0 → 10.14.3

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

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

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

@@ -1,42 +1,13 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionParser = exports.ZRX_OPTIMISM_PROXY_CONTRACT = void 0;
-const caip_1 = require("@shapeshiftoss/caip");
-const parser_1 = require("../../parser");
-const erc20 = __importStar(require("../../parser/erc20"));
-const zrx = __importStar(require("../../parser/zrx"));
-exports.ZRX_OPTIMISM_PROXY_CONTRACT = '0xDEF1ABE32c034e558Cdd535791643C58a13aCC10';
-class TransactionParser extends parser_1.BaseTransactionParser {
+import { ZRX_OPTIMISM_PROXY_CONTRACT } from '@shapeshiftoss/contracts';
+import { BaseTransactionParser } from '../../parser';
+import * as erc20 from '../../parser/erc20';
+import * as zrx from '../../parser/zrx';
+export class TransactionParser extends BaseTransactionParser {
     constructor(args) {
         super(args);
-        this.assetId = caip_1.optimismAssetId;
         this.registerParsers([
             new erc20.Parser({ chainId: this.chainId, provider: this.provider }),
-            new zrx.Parser({ proxyContract: exports.ZRX_OPTIMISM_PROXY_CONTRACT }),
+            new zrx.Parser({ proxyContract: ZRX_OPTIMISM_PROXY_CONTRACT }),
         ]);
     }
 }
-exports.TransactionParser = TransactionParser;

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

@@ -0,0 +1,27 @@
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+import { ethers } from 'ethers';
+import type { BaseTxMetadata } from '../../types';
+import type { SubParser, TxSpecific } from '.';
+import type { Tx } from './types';
+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/evm/parser/arbitrumBridge.js

@@ -0,0 +1,114 @@
+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 '.';
+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/evm/parser/erc20.d.ts

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

package/dist/evm/parser/erc20.js

@@ -1,34 +1,34 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Parser = void 0;
-const caip_1 = require("@shapeshiftoss/caip");
-const ethers_1 = require("ethers");
-const erc20_1 = __importDefault(require("./abi/erc20"));
-const utils_1 = require("./utils");
-class Parser {
+import { toAssetId } from '@shapeshiftoss/caip';
+import { ethers } from 'ethers';
+import { erc20Abi } from 'viem';
+import { getSigHash } from './utils';
+export class Parser {
+    provider;
+    chainId;
+    abiInterface = new ethers.Interface(erc20Abi);
+    supportedFunctions;
     constructor(args) {
-        this.abiInterface = new ethers_1.ethers.utils.Interface(erc20_1.default);
-        this.supportedFunctions = {
-            approveSigHash: this.abiInterface.getSighash('approve'),
-        };
         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 = (0, utils_1.getSigHash)(tx.inputData);
-        if (!Object.values(this.supportedFunctions).some((hash) => hash === txSigHash))
+        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: (0, caip_1.toAssetId)({
+            assetId: toAssetId({
                 chainId: this.chainId,
                 assetNamespace: 'erc20',
                 assetReference: tx.to,
@@ -38,14 +38,15 @@ class Parser {
         };
         switch (txSigHash) {
             case this.supportedFunctions.approveSigHash: {
-                const value = decoded.args.amount;
-                if (value.isZero())
-                    return { data: { ...data, method: 'revoke', value: value.toString() } };
-                return { data: { ...data, value: value.toString() } };
+                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 { data };
+                return await Promise.resolve({ data });
         }
     }
 }
-exports.Parser = Parser;

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

@@ -1,18 +1,22 @@
-import { AssetId, ChainId } from '@shapeshiftoss/caip';
-import { ethers } from 'ethers';
-import { ParsedTx, SubParser, Tx } from './types';
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+import { JsonRpcProvider } from 'ethers';
+import type { Api } from '..';
+import type { ParsedTx, SubParser, Tx } from './types';
 export * from './types';
 export * from './utils';
-export interface TransactionParserArgs {
+export interface BaseTransactionParserArgs {
     chainId: ChainId;
+    assetId: AssetId;
+    api: Api;
     rpcUrl: string;
 }
 export declare class BaseTransactionParser<T extends Tx> {
     chainId: ChainId;
     assetId: AssetId;
-    protected readonly provider: ethers.providers.JsonRpcProvider;
+    protected readonly api: Api;
+    protected readonly provider: JsonRpcProvider;
     private parsers;
-    constructor(args: TransactionParserArgs);
+    constructor(args: BaseTransactionParserArgs);
     /**
      * Register custom transaction sub parser to extract contract specific data
      *

package/dist/evm/parser/index.js

@@ -1,37 +1,22 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseTransactionParser = void 0;
-const caip_1 = require("@shapeshiftoss/caip");
-const logger_1 = require("@shapeshiftoss/logger");
-const bignumber_js_1 = require("bignumber.js");
-const ethers_1 = require("ethers");
-const types_1 = require("../../types");
-const utils_1 = require("../../utils");
-__exportStar(require("./types"), exports);
-__exportStar(require("./utils"), exports);
-const logger = new logger_1.Logger({
-    namespace: ['unchained-client', 'evm', 'parser'],
-    level: process.env.LOG_LEVEL,
-});
-class BaseTransactionParser {
+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';
+import { aggregateTransfer, findAsyncSequential } from '../../utils';
+import { getTxStatus } from './utils';
+export * from './types';
+export * from './utils';
+export class BaseTransactionParser {
+    chainId;
+    assetId;
+    api;
+    provider;
+    parsers = [];
     constructor(args) {
-        this.parsers = [];
         this.chainId = args.chainId;
-        this.provider = new ethers_1.ethers.providers.JsonRpcProvider(args.rpcUrl);
+        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
@@ -42,13 +27,12 @@ class BaseTransactionParser {
         this.parsers.unshift(parser);
     }
     registerParsers(parsers) {
-        parsers.forEach((parser) => this.registerParser(parser));
+        parsers.forEach(parser => this.registerParser(parser));
     }
     async parse(tx, address) {
-        var _a;
-        address = ethers_1.ethers.utils.getAddress(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 (0, utils_1.findAsyncSequential)(this.parsers, async (parser) => await parser.parse(tx));
+        const contractParserResult = await findAsyncSequential(this.parsers, async (parser) => await parser.parse(tx, address));
         const parsedTx = {
             address,
             blockHash: tx.blockHash,
@@ -57,47 +41,53 @@ class BaseTransactionParser {
             chainId: this.chainId,
             confirmations: tx.confirmations,
             status: this.getStatus(tx),
-            trade: contractParserResult === null || contractParserResult === void 0 ? void 0 : contractParserResult.trade,
-            transfers: (_a = contractParserResult === null || contractParserResult === void 0 ? void 0 : contractParserResult.transfers) !== null && _a !== void 0 ? _a : [],
+            trade: contractParserResult?.trade,
+            transfers: contractParserResult?.transfers ?? [],
             txid: tx.txid,
-            data: contractParserResult === null || contractParserResult === void 0 ? void 0 : contractParserResult.data,
+            data: contractParserResult?.data,
         };
         return this.getParsedTxWithTransfers(tx, parsedTx, address);
     }
     getStatus(tx) {
-        const status = tx.status;
-        if (status === -1 && tx.confirmations <= 0)
-            return types_1.TxStatus.Pending;
-        if (status === 1 && tx.confirmations > 0)
-            return types_1.TxStatus.Confirmed;
-        if (status === 0)
-            return types_1.TxStatus.Failed;
-        return types_1.TxStatus.Unknown;
+        return getTxStatus(tx);
     }
     getParsedTxWithTransfers(tx, parsedTx, address) {
-        var _a, _b;
         if (address === tx.from) {
             // send amount
-            const sendValue = new bignumber_js_1.BigNumber(tx.value);
+            const sendValue = new BigNumber(tx.value);
             if (sendValue.gt(0)) {
-                parsedTx.transfers = (0, utils_1.aggregateTransfer)(parsedTx.transfers, types_1.TransferType.Send, this.assetId, tx.from, tx.to, sendValue.toString(10));
+                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_js_1.BigNumber(tx.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_js_1.BigNumber(tx.value);
+            const receiveValue = new BigNumber(tx.value);
             if (receiveValue.gt(0)) {
-                parsedTx.transfers = (0, utils_1.aggregateTransfer)(parsedTx.transfers, types_1.TransferType.Receive, this.assetId, tx.from, tx.to, receiveValue.toString(10));
+                parsedTx.transfers = aggregateTransfer({
+                    assetId: this.assetId,
+                    from: tx.from,
+                    to: tx.to,
+                    transfers: parsedTx.transfers,
+                    type: TransferType.Receive,
+                    value: receiveValue.toString(10),
+                });
             }
         }
-        (_a = tx.tokenTransfers) === null || _a === void 0 ? void 0 : _a.forEach((transfer) => {
+        tx.tokenTransfers?.forEach(transfer => {
             // FTX Token (FTT) name and symbol was set backwards on the ERC20 contract (Ethereum Mainnet)
-            if (this.chainId === caip_1.ethChainId &&
+            if (this.chainId === ethChainId &&
                 transfer.contract === '0x50D1c9771902476076eCFc8B2A83Ad6b9355a4c9') {
                 transfer.name = transfer.symbol;
                 transfer.symbol = transfer.name;
@@ -109,61 +99,89 @@ class BaseTransactionParser {
                 symbol: transfer.symbol,
             };
             const assetId = (() => {
-                // alias ether token on optimism to native asset as they are the same
-                if (transfer.contract === '0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000') {
-                    return (0, caip_1.toAssetId)({
+                // 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: caip_1.ASSET_REFERENCE.Optimism,
+                        assetReference: ASSET_REFERENCE.Polygon,
                     });
                 }
                 const assetNamespace = (() => {
                     switch (transfer.type) {
                         case 'ERC20':
-                            return caip_1.ASSET_NAMESPACE.erc20;
+                            return ASSET_NAMESPACE.erc20;
                         case 'ERC721':
-                            return caip_1.ASSET_NAMESPACE.erc721;
+                            return ASSET_NAMESPACE.erc721;
+                        case 'ERC1155':
+                            return ASSET_NAMESPACE.erc1155;
                         case 'BEP20':
-                            return caip_1.ASSET_NAMESPACE.bep20;
+                            return ASSET_NAMESPACE.bep20;
                         case 'BEP721':
-                            return caip_1.ASSET_NAMESPACE.bep721;
+                            return ASSET_NAMESPACE.bep721;
+                        case 'BEP1155':
+                            return ASSET_NAMESPACE.bep1155;
                         default:
-                            logger.warn(`unsupported asset namespace: ${transfer.type}`);
                             return;
                     }
                 })();
                 if (!assetNamespace)
                     return;
-                return (0, caip_1.toAssetId)({
+                return toAssetId({
                     chainId: this.chainId,
                     assetNamespace,
-                    assetReference: transfer.contract,
+                    assetReference: transfer.id ? `${transfer.contract}/${transfer.id}` : transfer.contract,
                 });
             })();
             if (!assetId)
                 return;
-            const transferArgs = [assetId, transfer.from, transfer.to, transfer.value, token];
+            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 = (0, utils_1.aggregateTransfer)(parsedTx.transfers, types_1.TransferType.Send, ...transferArgs);
+                parsedTx.transfers = aggregateTransfer(makeTokenTransferArgs(TransferType.Send));
             }
             // token receive amount
             if (address === transfer.to) {
-                parsedTx.transfers = (0, utils_1.aggregateTransfer)(parsedTx.transfers, types_1.TransferType.Receive, ...transferArgs);
+                parsedTx.transfers = aggregateTransfer(makeTokenTransferArgs(TransferType.Receive));
             }
         });
-        (_b = tx.internalTxs) === null || _b === void 0 ? void 0 : _b.forEach((internalTx) => {
-            const transferArgs = [this.assetId, internalTx.from, internalTx.to, internalTx.value];
+        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 = (0, utils_1.aggregateTransfer)(parsedTx.transfers, types_1.TransferType.Send, ...transferArgs);
+                parsedTx.transfers = aggregateTransfer(makeInternalTransferArgs(TransferType.Send));
             }
             // internal eth receive
             if (address === internalTx.to) {
-                parsedTx.transfers = (0, utils_1.aggregateTransfer)(parsedTx.transfers, types_1.TransferType.Receive, ...transferArgs);
+                parsedTx.transfers = aggregateTransfer(makeInternalTransferArgs(TransferType.Receive));
             }
         });
         return parsedTx;
     }
 }
-exports.BaseTransactionParser = BaseTransactionParser;

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

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

package/dist/evm/parser/mayachain.js

@@ -0,0 +1,8 @@
+import { Parser as MayachainParser } from '../../parser/mayachain';
+import { Parser as ThorchainParser } from './thorchain';
+export class Parser extends ThorchainParser {
+    constructor(args) {
+        super(args);
+        this.parser = new MayachainParser({ midgardUrl: args.midgardUrl });
+    }
+}

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

@@ -0,0 +1,25 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import { ethers } from 'ethers';
+import type { BaseTxMetadata } from '../../types';
+import type { SubParser, TxSpecific } from '.';
+import type { Tx } from './types';
+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>;
+}