@shapeshiftoss/unchained-client 10.14.0 → 10.14.3

package/dist/evm/ethereum/parser/__tests__/mockData/zrxTradeTetherToKishu.js

@@ -0,0 +1,50 @@
+export default {
+    tx: {
+        txid: '0x7ae99994cc2630db20646cc3454cb8c84397862db0f9f67735cf8a2053c7a144',
+        blockHash: '0x80ac91bfae14c398043d421d3585f27fba1f6b62153a81b8879b99cdf52adfab',
+        blockHeight: 12408996,
+        timestamp: 1620680747,
+        status: 1,
+        from: '0xb8b19c048296E086DaF69F54d48dE2Da444dB047',
+        to: '0xDef1C0ded9bec7F1a1670819833240f027b25EfF',
+        confirmations: 2404349,
+        value: '0',
+        fee: '78183644000000000',
+        gasLimit: '284175',
+        gasUsed: '249788',
+        gasPrice: '313000000000',
+        inputData: '0xd9627aa400000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000a7a3582000000000000000000000000000000000000000000000001f67ff0e4228bacf32e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2000000000000000000000000a2b4c0af19cc16a6cfacce81f192b024d625817d869584cd0000000000000000000000007cba0eb7a94068324583be7771c5ecda25e4c4d10000000000000000000000000000000000000000000000c325e3478e6099a027',
+        tokenTransfers: [
+            {
+                contract: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+                decimals: 6,
+                name: 'Tether USD',
+                symbol: 'USDT',
+                type: 'ERC20',
+                from: '0xb8b19c048296E086DaF69F54d48dE2Da444dB047',
+                to: '0x0d4a11d5EEaaC28EC3F61d100daF4d40471f1852',
+                value: '45000000000',
+            },
+            {
+                contract: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+                decimals: 18,
+                name: 'Wrapped Ether',
+                symbol: 'WETH',
+                type: 'ERC20',
+                from: '0x0d4a11d5EEaaC28EC3F61d100daF4d40471f1852',
+                to: '0xF82d8Ec196Fb0D56c6B82a8B1870F09502A49F88',
+                value: '11448289873732555174',
+            },
+            {
+                contract: '0xA2b4C0Af19cC16a6CfAcCe81F192B024d625817D',
+                decimals: 9,
+                name: 'Kishu Inu',
+                symbol: 'KISHU',
+                type: 'ERC20',
+                from: '0xF82d8Ec196Fb0D56c6B82a8B1870F09502A49F88',
+                to: '0xb8b19c048296E086DaF69F54d48dE2Da444dB047',
+                value: '9248567698016204727450',
+            },
+        ],
+    },
+};

package/dist/evm/ethereum/parser/__tests__/mockData/zrxTradeTribeToEth.d.ts

@@ -0,0 +1,34 @@
+declare const _default: {
+    tx: {
+        txid: string;
+        blockHash: string;
+        blockHeight: number;
+        timestamp: number;
+        status: number;
+        from: string;
+        to: string;
+        confirmations: number;
+        value: string;
+        fee: string;
+        gasLimit: string;
+        gasUsed: string;
+        gasPrice: string;
+        inputData: string;
+        tokenTransfers: {
+            contract: string;
+            decimals: number;
+            name: string;
+            symbol: string;
+            type: string;
+            from: string;
+            to: string;
+            value: string;
+        }[];
+        internalTxs: {
+            from: string;
+            to: string;
+            value: string;
+        }[];
+    };
+};
+export default _default;

package/dist/evm/ethereum/parser/__tests__/mockData/zrxTradeTribeToEth.js

@@ -0,0 +1,52 @@
+export default {
+    tx: {
+        txid: '0xcb4c224c9843289957c95519811225ab6ada773c9e1faafb30ace0193ff6e3f9',
+        blockHash: '0xe27ff22423ca0a1e9cc5cd12599d00f51cda7a706cbb475bba15ced85091931e',
+        blockHeight: 12323213,
+        timestamp: 1619537079,
+        status: 1,
+        from: '0x5bb96c35a68Cba037D0F261C67477416db137F03',
+        to: '0xDef1C0ded9bec7F1a1670819833240f027b25EfF',
+        confirmations: 2490127,
+        value: '0',
+        fee: '8308480000000000',
+        gasLimit: '159001',
+        gasUsed: '103856',
+        gasPrice: '80000000000',
+        inputData: '0xd9627aa4000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000003635c9adc5dea000000000000000000000000000000000000000000000000000000770ca929ce9fd7500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000c7283b66eb1eb5fb86327f08e1b5816b0720212b000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee869584cd0000000000000000000000007cba0eb7a94068324583be7771c5ecda25e4c4d1000000000000000000000000000000000000000000000081466fe92460882c76',
+        tokenTransfers: [
+            {
+                contract: '0xc7283b66Eb1EB5FB86327f08e1B5816b0720212B',
+                decimals: 18,
+                name: 'Tribe',
+                symbol: 'TRIBE',
+                type: 'ERC20',
+                from: '0x5bb96c35a68Cba037D0F261C67477416db137F03',
+                to: '0x7ce01885a13c652241aE02Ea7369Ee8D466802EB',
+                value: '1000000000000000000000',
+            },
+            {
+                contract: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+                decimals: 18,
+                name: 'Wrapped Ether',
+                symbol: 'WETH',
+                type: 'ERC20',
+                from: '0x7ce01885a13c652241aE02Ea7369Ee8D466802EB',
+                to: '0xDef1C0ded9bec7F1a1670819833240f027b25EfF',
+                value: '541566754246167133',
+            },
+        ],
+        internalTxs: [
+            {
+                from: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+                to: '0xDef1C0ded9bec7F1a1670819833240f027b25EfF',
+                value: '541566754246167133',
+            },
+            {
+                from: '0xDef1C0ded9bec7F1a1670819833240f027b25EfF',
+                to: '0x5bb96c35a68Cba037D0F261C67477416db137F03',
+                value: '541566754246167133',
+            },
+        ],
+    },
+};

package/dist/evm/ethereum/parser/cowswap.d.ts

@@ -1,6 +1,6 @@
-import { Tx } from '../../../generated/ethereum';
-import { BaseTxMetadata } from '../../../types';
-import { SubParser, TxSpecific } from '../../parser';
+import type { Tx } from '../../../generated/ethereum';
+import type { BaseTxMetadata } from '../../../types';
+import type { SubParser, TxSpecific } from '../../parser';
 export interface TxMetadata extends BaseTxMetadata {
     parser: 'cowswap';
 }

package/dist/evm/ethereum/parser/cowswap.js

@@ -1,25 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Parser = void 0;
-const types_1 = require("../../../types");
-const parser_1 = require("../../parser");
-const constants_1 = require("./constants");
-class Parser {
+import { COWSWAP_SETTLEMENT_CONTRACT_MAINNET } from '@shapeshiftoss/contracts';
+import { Dex, TradeType } from '../../../types';
+import { txInteractsWithContract } from '../../parser';
+export class Parser {
     async parse(tx) {
-        if (!(0, parser_1.txInteractsWithContract)(tx, constants_1.COWSWAP_CONTRACT_MAINNET))
+        if (!txInteractsWithContract(tx, COWSWAP_SETTLEMENT_CONTRACT_MAINNET))
             return;
         if (!(tx.tokenTransfers && tx.tokenTransfers.length))
             return;
-        return {
+        return await Promise.resolve({
             trade: {
-                dexName: types_1.Dex.CowSwap,
-                type: types_1.TradeType.Trade,
+                dexName: Dex.CowSwap,
+                type: TradeType.Trade,
             },
             data: {
                 method: undefined,
                 parser: 'cowswap',
             },
-        };
+        });
     }
 }
-exports.Parser = Parser;

package/dist/evm/ethereum/parser/foxy.d.ts

@@ -1,17 +1,13 @@
 import { ethers } from 'ethers';
-import { Tx } from '../../../generated/ethereum';
-import { BaseTxMetadata } from '../../../types';
-import { SubParser, TxSpecific } from '../../parser';
+import type { Tx } from '../../../generated/ethereum';
+import type { BaseTxMetadata } from '../../../types';
+import type { SubParser, TxSpecific } from '../../parser';
 export interface TxMetadata extends BaseTxMetadata {
     parser: 'foxy';
 }
 export declare class Parser implements SubParser<Tx> {
-    readonly abiInterface: ethers.utils.Interface;
-    readonly supportedFunctions: {
-        stakeSigHash: string;
-        unstakeSigHash: string;
-        instantUnstakeSigHash: string;
-        claimWithdrawSigHash: string;
-    };
+    readonly abiInterface: ethers.Interface;
+    private readonly supportedFunctions;
+    constructor();
     parse(tx: Tx): Promise<TxSpecific | undefined>;
 }

package/dist/evm/ethereum/parser/foxy.js

@@ -1,41 +1,41 @@
-"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 ethers_1 = require("ethers");
-const parser_1 = require("../../parser");
-const foxyStaking_1 = __importDefault(require("./abi/foxyStaking"));
-const constants_1 = require("./constants");
-class Parser {
+import { FOXY_STAKING_ABI, FOXY_STAKING_CONTRACT } from '@shapeshiftoss/contracts';
+import { ethers } from 'ethers';
+import { getSigHash, txInteractsWithContract } from '../../parser';
+export class Parser {
+    abiInterface = new ethers.Interface(FOXY_STAKING_ABI);
+    supportedFunctions;
     constructor() {
-        this.abiInterface = new ethers_1.ethers.utils.Interface(foxyStaking_1.default);
+        const stakeSigHash = this.abiInterface.getFunction('stake(uint256,address)')?.selector;
+        const unstakeSigHash = this.abiInterface.getFunction('unstake')?.selector;
+        const instantUnstakeSigHash = this.abiInterface.getFunction('instantUnstake')?.selector;
+        const claimWithdrawSigHash = this.abiInterface.getFunction('claimWithdraw')?.selector;
+        if (!(stakeSigHash && unstakeSigHash && instantUnstakeSigHash && claimWithdrawSigHash)) {
+            throw new Error('Failed to get function selectors');
+        }
         this.supportedFunctions = {
-            stakeSigHash: this.abiInterface.getSighash('stake(uint256,address)'),
-            unstakeSigHash: this.abiInterface.getSighash('unstake'),
-            instantUnstakeSigHash: this.abiInterface.getSighash('instantUnstake'),
-            claimWithdrawSigHash: this.abiInterface.getSighash('claimWithdraw'),
+            stakeSigHash,
+            unstakeSigHash,
+            instantUnstakeSigHash,
+            claimWithdrawSigHash,
         };
     }
     async parse(tx) {
-        if (!(0, parser_1.txInteractsWithContract)(tx, constants_1.FOXY_STAKING_CONTRACT))
+        if (!txInteractsWithContract(tx, FOXY_STAKING_CONTRACT))
             return;
         if (!tx.inputData)
             return;
-        const txSigHash = (0, parser_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;
-        return {
+        return await Promise.resolve({
             data: {
                 method: decoded.name,
                 parser: 'foxy',
             },
-        };
+        });
     }
 }
-exports.Parser = Parser;

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

@@ -1,6 +1,10 @@
-import { Tx } from '../../../generated/ethereum';
-import { BaseTransactionParser, TransactionParserArgs } from '../../parser';
-export declare const ZRX_ETHEREUM_PROXY_CONTRACT = "0xDef1C0ded9bec7F1a1670819833240f027b25EfF";
+import type { Tx } from '../../../generated/ethereum';
+import type { BaseTransactionParserArgs } from '../../parser';
+import { BaseTransactionParser } from '../../parser';
+export interface TransactionParserArgs extends BaseTransactionParserArgs {
+    thorMidgardUrl: string;
+    mayaMidgardUrl: string;
+}
 export declare class TransactionParser extends BaseTransactionParser<Tx> {
     constructor(args: TransactionParserArgs);
 }

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

@@ -1,56 +1,36 @@
-"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_ETHEREUM_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"));
-const cowswap = __importStar(require("./cowswap"));
-const foxy = __importStar(require("./foxy"));
-const thor = __importStar(require("./thor"));
-const uniV2 = __importStar(require("./uniV2"));
-const weth = __importStar(require("./weth"));
-const yearn = __importStar(require("./yearn"));
-exports.ZRX_ETHEREUM_PROXY_CONTRACT = '0xDef1C0ded9bec7F1a1670819833240f027b25EfF';
-class TransactionParser extends parser_1.BaseTransactionParser {
+import { ZRX_ETHEREUM_PROXY_CONTRACT } from '@shapeshiftoss/contracts';
+import { BaseTransactionParser } from '../../parser';
+import * as arbitrumBridge from '../../parser/arbitrumBridge';
+import * as erc20 from '../../parser/erc20';
+import * as mayachain from '../../parser/mayachain';
+import * as thorchain from '../../parser/thorchain';
+import * as zrx from '../../parser/zrx';
+import * as cowswap from './cowswap';
+import * as foxy from './foxy';
+import * as uniV2 from './uniV2';
+import * as weth from './weth';
+export class TransactionParser extends BaseTransactionParser {
     constructor(args) {
         super(args);
-        this.assetId = caip_1.ethAssetId;
         // due to the current parser logic, order here matters (register most generic first to most specific last)
-        // weth and yearn have the same sigHash for deposit(), but the weth parser is stricter resulting in faster processing times
         this.registerParsers([
             new erc20.Parser({ chainId: this.chainId, provider: this.provider }),
-            new yearn.Parser({ chainId: this.chainId }),
             new foxy.Parser(),
             new weth.Parser({ chainId: this.chainId, provider: this.provider }),
             new uniV2.Parser({ chainId: this.chainId, provider: this.provider }),
-            new thor.Parser({ chainId: this.chainId, rpcUrl: args.rpcUrl }),
-            new zrx.Parser({ proxyContract: exports.ZRX_ETHEREUM_PROXY_CONTRACT }),
+            new mayachain.Parser({
+                chainId: this.chainId,
+                rpcUrl: args.rpcUrl,
+                midgardUrl: args.mayaMidgardUrl,
+            }),
+            new thorchain.Parser({
+                chainId: this.chainId,
+                rpcUrl: args.rpcUrl,
+                midgardUrl: args.thorMidgardUrl,
+            }),
+            new zrx.Parser({ proxyContract: ZRX_ETHEREUM_PROXY_CONTRACT }),
             new cowswap.Parser(),
+            new arbitrumBridge.Parser({ chainId: this.chainId }),
         ]);
     }
 }
-exports.TransactionParser = TransactionParser;

package/dist/evm/ethereum/parser/uniV2.d.ts

@@ -1,32 +1,27 @@
-import { ChainId } from '@shapeshiftoss/caip';
-import { ethers } from 'ethers';
-import { Tx } from '../../../generated/ethereum';
-import { BaseTxMetadata } from '../../../types';
-import { SubParser, TxSpecific } from '../../parser';
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { JsonRpcProvider } from 'ethers';
+import { Interface } from 'ethers';
+import type { Tx } from '../../../generated/ethereum';
+import type { BaseTxMetadata } from '../../../types';
+import type { SubParser, TxSpecific } from '../../parser';
 export interface TxMetadata extends BaseTxMetadata {
     parser: 'uniV2';
 }
 export interface ParserArgs {
     chainId: ChainId;
-    provider: ethers.providers.JsonRpcProvider;
+    provider: JsonRpcProvider;
 }
 export declare class Parser implements SubParser<Tx> {
-    provider: ethers.providers.JsonRpcProvider;
+    provider: JsonRpcProvider;
     readonly chainId: ChainId;
     readonly wethContract: string;
-    readonly abiInterface: ethers.utils.Interface;
-    readonly stakingRewardsInterface: ethers.utils.Interface;
-    readonly supportedFunctions: {
-        addLiquidityEthSigHash: string;
-        removeLiquidityEthSigHash: string;
-    };
-    readonly supportedStakingRewardsFunctions: {
-        stakeSigHash: string;
-        exitSigHash: string;
-    };
+    readonly abiInterface: Interface;
+    readonly stakingRewardsInterface: Interface;
+    private readonly supportedFunctions;
+    private readonly supportedStakingRewardsFunctions;
     constructor(args: ParserArgs);
     parseUniV2(tx: Tx): Promise<TxSpecific | undefined>;
-    parseStakingRewards(tx: Tx): Promise<TxSpecific | undefined>;
+    parseStakingRewards(tx: Tx): TxSpecific | undefined;
     parse(tx: Tx): Promise<TxSpecific | undefined>;
     private static pairFor;
 }

package/dist/evm/ethereum/parser/uniV2.js

@@ -1,47 +1,47 @@
-"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 types_1 = require("../../../types");
-const parser_1 = require("../../parser");
-const erc20_1 = __importDefault(require("../../parser/abi/erc20"));
-const uniV2_1 = __importDefault(require("./abi/uniV2"));
-const uniV2StakingRewards_1 = __importDefault(require("./abi/uniV2StakingRewards"));
-const constants_1 = require("./constants");
-class Parser {
+import { fromChainId, toAssetId } from '@shapeshiftoss/caip';
+import { UNI_V2_FOX_STAKING_REWARDS_CONTRACTS, UNISWAP_V2_FACTORY_CONTRACT_MAINNET, UNISWAP_V2_ROUTER_02_ABI, UNISWAP_V2_ROUTER_02_CONTRACT_MAINNET, UNIV2_STAKING_REWARDS_ABI, WETH_TOKEN_CONTRACT, } from '@shapeshiftoss/contracts';
+import assert from 'assert';
+import { Contract, getAddress, getCreate2Address, Interface, solidityPackedKeccak256 } from 'ethers';
+import { erc20Abi } from 'viem';
+import { TransferType } from '../../../types';
+import { getSigHash, txInteractsWithContract } from '../../parser';
+export class Parser {
+    provider;
+    chainId;
+    wethContract;
+    abiInterface = new Interface(UNISWAP_V2_ROUTER_02_ABI);
+    stakingRewardsInterface = new Interface(UNIV2_STAKING_REWARDS_ABI);
+    supportedFunctions;
+    supportedStakingRewardsFunctions;
     constructor(args) {
-        this.abiInterface = new ethers_1.ethers.utils.Interface(uniV2_1.default);
-        this.stakingRewardsInterface = new ethers_1.ethers.utils.Interface(uniV2StakingRewards_1.default);
+        this.chainId = args.chainId;
+        this.provider = args.provider;
+        assert(args.chainId === 'eip155:1', `chainId '${args.chainId}' is not supported`);
+        this.wethContract = WETH_TOKEN_CONTRACT;
+        const addLiquidityEthSigHash = this.abiInterface.getFunction('addLiquidityETH')?.selector;
+        const removeLiquidityEthSigHash = this.abiInterface.getFunction('removeLiquidityETH')?.selector;
+        const stakeSigHash = this.stakingRewardsInterface.getFunction('stake')?.selector;
+        const exitSigHash = this.stakingRewardsInterface.getFunction('exit')?.selector;
+        if (!(addLiquidityEthSigHash && removeLiquidityEthSigHash)) {
+            throw new Error('Failed to get function selectors');
+        }
+        if (!(stakeSigHash && exitSigHash)) {
+            throw new Error('Failed to get function selectors');
+        }
         this.supportedFunctions = {
-            addLiquidityEthSigHash: this.abiInterface.getSighash('addLiquidityETH'),
-            removeLiquidityEthSigHash: this.abiInterface.getSighash('removeLiquidityETH'),
+            addLiquidityEthSigHash,
+            removeLiquidityEthSigHash,
         };
         this.supportedStakingRewardsFunctions = {
-            stakeSigHash: this.stakingRewardsInterface.getSighash('stake'),
-            exitSigHash: this.stakingRewardsInterface.getSighash('exit'),
+            stakeSigHash,
+            exitSigHash,
         };
-        this.chainId = args.chainId;
-        this.provider = args.provider;
-        this.wethContract = (() => {
-            switch (args.chainId) {
-                case 'eip155:1':
-                    return constants_1.WETH_CONTRACT_MAINNET;
-                case 'eip155:3':
-                    return constants_1.WETH_CONTRACT_ROPSTEN;
-                default:
-                    throw new Error('chainId is not supported. (supported chainIds: eip155:1, eip155:3)');
-            }
-        })();
     }
     async parseUniV2(tx) {
         if (!tx.inputData)
             return;
-        const txSigHash = (0, parser_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
@@ -56,24 +56,24 @@ class Parser {
                     method: decoded.name,
                 },
             };
-        const tokenAddress = ethers_1.ethers.utils.getAddress(decoded.args.token.toLowerCase());
+        const tokenAddress = getAddress(decoded.args.token.toLowerCase());
         const lpTokenAddress = Parser.pairFor(tokenAddress, this.wethContract);
         const transfers = await (async () => {
-            switch ((0, parser_1.getSigHash)(tx.inputData)) {
+            switch (getSigHash(tx.inputData)) {
                 case this.supportedFunctions.addLiquidityEthSigHash: {
-                    const contract = new ethers_1.ethers.Contract(tokenAddress, erc20_1.default, this.provider);
+                    const contract = new Contract(tokenAddress, erc20Abi, this.provider);
                     const decimals = await contract.decimals();
                     const name = await contract.name();
                     const symbol = await contract.symbol();
                     const value = decoded.args.amountTokenDesired.toString();
-                    const assetId = (0, caip_1.toAssetId)({
-                        ...(0, caip_1.fromChainId)(this.chainId),
+                    const assetId = toAssetId({
+                        ...fromChainId(this.chainId),
                         assetNamespace: 'erc20',
                         assetReference: tokenAddress,
                     });
                     return [
                         {
-                            type: types_1.TransferType.Send,
+                            type: TransferType.Send,
                             from: tx.from,
                             to: lpTokenAddress,
                             assetId,
@@ -84,19 +84,19 @@ class Parser {
                     ];
                 }
                 case this.supportedFunctions.removeLiquidityEthSigHash: {
-                    const contract = new ethers_1.ethers.Contract(lpTokenAddress, erc20_1.default, this.provider);
+                    const contract = new Contract(lpTokenAddress, erc20Abi, this.provider);
                     const decimals = await contract.decimals();
                     const name = await contract.name();
                     const symbol = await contract.symbol();
                     const value = decoded.args.liquidity.toString();
-                    const assetId = (0, caip_1.toAssetId)({
-                        ...(0, caip_1.fromChainId)(this.chainId),
+                    const assetId = toAssetId({
+                        ...fromChainId(this.chainId),
                         assetNamespace: 'erc20',
                         assetReference: lpTokenAddress,
                     });
                     return [
                         {
-                            type: types_1.TransferType.Send,
+                            type: TransferType.Send,
                             from: tx.from,
                             to: lpTokenAddress,
                             assetId,
@@ -121,11 +121,11 @@ class Parser {
             },
         };
     }
-    async parseStakingRewards(tx) {
+    parseStakingRewards(tx) {
         if (!tx.inputData)
             return;
-        const txSigHash = (0, parser_1.getSigHash)(tx.inputData);
-        if (!Object.values(this.supportedStakingRewardsFunctions).some((hash) => hash === txSigHash))
+        const txSigHash = getSigHash(tx.inputData);
+        if (!Object.values(this.supportedStakingRewardsFunctions).some(hash => hash === txSigHash))
             return;
         const decoded = this.stakingRewardsInterface.parseTransaction({ data: tx.inputData });
         // failed to decode input data
@@ -139,19 +139,17 @@ class Parser {
         };
     }
     async parse(tx) {
-        if ((0, parser_1.txInteractsWithContract)(tx, constants_1.UNI_V2_ROUTER_CONTRACT))
-            return this.parseUniV2(tx);
+        if (txInteractsWithContract(tx, UNISWAP_V2_ROUTER_02_CONTRACT_MAINNET))
+            return await this.parseUniV2(tx);
         // TODO: parse any transaction that has input data that is able to be decoded using the `stakingRewardsInterface`
-        if (constants_1.UNI_V2_FOX_STAKING_REWARDS_CONTRACTS.some((contract) => (0, parser_1.txInteractsWithContract)(tx, contract)))
-            return this.parseStakingRewards(tx);
-        return;
+        const isFoxStakingRewards = UNI_V2_FOX_STAKING_REWARDS_CONTRACTS.some(contract => txInteractsWithContract(tx, contract));
+        if (isFoxStakingRewards)
+            return await Promise.resolve(this.parseStakingRewards(tx));
     }
     static pairFor(tokenA, tokenB) {
         const [token0, token1] = tokenA < tokenB ? [tokenA, tokenB] : [tokenB, tokenA];
-        const factoryContract = '0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f';
-        const salt = ethers_1.ethers.utils.solidityKeccak256(['address', 'address'], [token0, token1]);
+        const salt = solidityPackedKeccak256(['address', 'address'], [token0, token1]);
         const initCodeHash = '0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'; // https://github.com/Uniswap/v2-periphery/blob/dda62473e2da448bc9cb8f4514dadda4aeede5f4/contracts/libraries/UniswapV2Library.sol#L24
-        return ethers_1.ethers.utils.getCreate2Address(factoryContract, salt, initCodeHash);
+        return getCreate2Address(UNISWAP_V2_FACTORY_CONTRACT_MAINNET, salt, initCodeHash);
     }
 }
-exports.Parser = Parser;

package/dist/evm/ethereum/parser/weth.d.ts

@@ -1,24 +1,21 @@
-import { ChainId } from '@shapeshiftoss/caip';
+import type { ChainId } from '@shapeshiftoss/caip';
 import { ethers } from 'ethers';
-import { Tx } from '../../../generated/ethereum';
-import { BaseTxMetadata } from '../../../types';
-import { SubParser, TxSpecific } from '../../parser';
+import type { Tx } from '../../../generated/ethereum';
+import type { BaseTxMetadata } from '../../../types';
+import type { SubParser, TxSpecific } from '../../parser';
 export interface TxMetadata extends BaseTxMetadata {
     parser: 'weth';
 }
 export interface ParserArgs {
     chainId: ChainId;
-    provider: ethers.providers.JsonRpcProvider;
+    provider: ethers.JsonRpcProvider;
 }
 export declare class Parser implements SubParser<Tx> {
-    provider: ethers.providers.JsonRpcProvider;
+    provider: ethers.JsonRpcProvider;
     readonly chainId: ChainId;
     readonly wethContract: string;
-    readonly abiInterface: ethers.utils.Interface;
-    readonly supportedFunctions: {
-        depositSigHash: string;
-        withdrawalSigHash: string;
-    };
+    readonly abiInterface: ethers.Interface;
+    private readonly supportedFunctions;
     constructor(args: ParserArgs);
     parse(tx: Tx): Promise<TxSpecific | undefined>;
 }