@shapeshiftoss/swapper 7.6.0 → 7.8.0

package/dist/swappers/cow/CowSwapper.d.ts

@@ -3,10 +3,15 @@ import { ethereum } from '@shapeshiftoss/chain-adapters';
 import { Asset } from '@shapeshiftoss/types';
 import Web3 from 'web3';
 import { ApprovalNeededInput, ApprovalNeededOutput, ApproveInfiniteInput, BuildTradeInput, BuyAssetBySellIdInput, ExecuteTradeInput, GetTradeQuoteInput, Swapper, SwapperType, Trade, TradeQuote, TradeResult, TradeTxs } from '../../api';
+/**
+ * CowSwap only supports ERC-20 swaps, hence ETH is not supported
+ * In order to get rates correctly, we need WETH asset to be passed as feeAsset
+ */
 export declare type CowSwapperDeps = {
     apiUrl: string;
     adapter: ethereum.ChainAdapter;
     web3: Web3;
+    feeAsset: Asset;
 };
 export declare class CowSwapper implements Swapper<'eip155:1'> {
     static swapperName: string;

package/dist/swappers/cow/CowSwapper.js

@@ -4,6 +4,7 @@ exports.CowSwapper = void 0;
 const api_1 = require("../../api");
 const CowApprovalNeeded_1 = require("./CowApprovalNeeded/CowApprovalNeeded");
 const CowApproveInfinite_1 = require("./CowApproveInfinite/CowApproveInfinite");
+const getCowSwapTradeQuote_1 = require("./getCowSwapTradeQuote/getCowSwapTradeQuote");
 const blacklist_1 = require("./utils/blacklist");
 const helpers_1 = require("./utils/helpers/helpers");
 class CowSwapper {
@@ -20,8 +21,7 @@ class CowSwapper {
         throw new Error('CowSwapper: buildTrade unimplemented');
     }
     async getTradeQuote(input) {
-        console.info(input);
-        throw new Error('CowSwapper: getTradeQuote unimplemented');
+        return (0, getCowSwapTradeQuote_1.getCowSwapTradeQuote)(this.deps, input);
     }
     async getUsdRate(input) {
         return (0, helpers_1.getUsdRate)(this.deps, input);

package/dist/swappers/cow/getCowSwapMinMax/getCowSwapMinMax.js

@@ -12,7 +12,7 @@ const getCowSwapMinMax = async (deps, sellAsset, buyAsset) => {
             throw new api_1.SwapError('[getCowSwapMinMax]', { code: api_1.SwapErrorTypes.UNSUPPORTED_PAIR });
         }
         const usdRate = await (0, helpers_1.getUsdRate)(deps, sellAsset);
-        const minimum = (0, bignumber_1.bn)(1).dividedBy((0, bignumber_1.bnOrZero)(usdRate)).toString(); // $1 worth of the sell token.
+        const minimum = (0, bignumber_1.bn)(constants_1.MIN_COWSWAP_VALUE_USD).dividedBy((0, bignumber_1.bnOrZero)(usdRate)).toString(); // $10 worth of the sell token.
         const maximum = constants_1.MAX_COWSWAP_TRADE; // Arbitrarily large value. 10e+28 here.
         return {
             minimum,

package/dist/swappers/cow/getCowSwapTradeQuote/getCowSwapTradeQuote.d.ts

@@ -0,0 +1,14 @@
+import { GetTradeQuoteInput, TradeQuote } from '../../../api';
+import { CowSwapperDeps } from '../CowSwapper';
+export declare type CowSwapQuoteApiInput = {
+    appData: string;
+    buyToken: string;
+    from: string;
+    kind: string;
+    partiallyFillable: boolean;
+    receiver: string;
+    sellAmountBeforeFee: string;
+    sellToken: string;
+    validTo: number;
+};
+export declare function getCowSwapTradeQuote(deps: CowSwapperDeps, input: GetTradeQuoteInput): Promise<TradeQuote<'eip155:1'>>;

package/dist/swappers/cow/getCowSwapTradeQuote/getCowSwapTradeQuote.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCowSwapTradeQuote = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const api_1 = require("../../../api");
+const bignumber_1 = require("../../utils/bignumber");
+const constants_1 = require("../../utils/constants");
+const helpers_1 = require("../../utils/helpers/helpers");
+const getCowSwapMinMax_1 = require("../getCowSwapMinMax/getCowSwapMinMax");
+const constants_2 = require("../utils/constants");
+const cowService_1 = require("../utils/cowService");
+const helpers_2 = require("../utils/helpers/helpers");
+async function getCowSwapTradeQuote(deps, input) {
+    try {
+        const { sellAsset, buyAsset, sellAmount, sellAssetAccountNumber, wallet } = input;
+        const { adapter, feeAsset } = deps;
+        const { assetReference: sellAssetErc20Address, assetNamespace: sellAssetNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+        const { assetReference: buyAssetErc20Address, assetNamespace: buyAssetNamespace } = (0, caip_1.fromAssetId)(buyAsset.assetId);
+        if (buyAssetNamespace !== 'erc20' || sellAssetNamespace !== 'erc20') {
+            throw new api_1.SwapError('[getCowSwapTradeQuote] - Both assets need to be ERC-20 to use CowSwap', {
+                code: api_1.SwapErrorTypes.UNSUPPORTED_PAIR,
+                details: { buyAssetNamespace, sellAssetNamespace }
+            });
+        }
+        const { minimum, maximum } = await (0, getCowSwapMinMax_1.getCowSwapMinMax)(deps, sellAsset, buyAsset);
+        const minQuoteSellAmount = (0, bignumber_1.bnOrZero)(minimum).times((0, bignumber_1.bn)(10).exponentiatedBy(sellAsset.precision));
+        // making sure we do not have decimals for cowswap api (can happen at least from minQuoteSellAmount)
+        const normalizedSellAmount = (0, helpers_1.normalizeIntegerAmount)((0, bignumber_1.bnOrZero)(sellAmount).lt(minQuoteSellAmount) ? minQuoteSellAmount : sellAmount);
+        const apiInput = {
+            sellToken: sellAssetErc20Address,
+            buyToken: buyAssetErc20Address,
+            receiver: constants_2.DEFAULT_ADDRESS,
+            validTo: constants_2.DEFAULT_VALIDTO_TIMESTAMP,
+            appData: constants_2.DEFAULT_APP_DATA,
+            partiallyFillable: false,
+            from: constants_2.DEFAULT_ADDRESS,
+            kind: constants_2.ORDER_KIND_SELL,
+            sellAmountBeforeFee: normalizedSellAmount
+        };
+        /**
+         * /v1/quote
+         * params: {
+         * sellToken: contract address of token to sell
+         * buyToken: contractAddress of token to buy
+         * receiver: receiver address can be defaulted to "0x0000000000000000000000000000000000000000"
+         * validTo: time duration during which quote is valid (eg : 1654851610 as timestamp)
+         * appData: appData for the CowSwap quote that can be used later, can be defaulted to "0x0000000000000000000000000000000000000000000000000000000000000000"
+         * partiallyFillable: false
+         * from: sender address can be defaulted to "0x0000000000000000000000000000000000000000"
+         * kind: "sell" or "buy"
+         * sellAmountBeforeFee / buyAmountAfterFee: amount in base unit
+         * }
+         */
+        const quoteResponse = await cowService_1.cowService.post(`${deps.apiUrl}/v1/quote/`, apiInput);
+        const { data: { quote } } = quoteResponse;
+        const rate = (0, bignumber_1.bn)(quote.buyAmount)
+            .div(quote.sellAmount)
+            .times((0, bignumber_1.bn)(10).exponentiatedBy(sellAsset.precision - buyAsset.precision))
+            .toString();
+        const receiveAddress = wallet ? await adapter.getAddress({ wallet }) : constants_2.DEFAULT_ADDRESS;
+        const [feeDataOptions, wethUsdRate, usdRateSellAsset] = await Promise.all([
+            adapter.getFeeData({
+                to: constants_2.COW_SWAP_VAULT_RELAYER_ADDRESS,
+                value: '0',
+                chainSpecific: { from: receiveAddress, contractAddress: sellAssetErc20Address }
+            }),
+            (0, helpers_2.getUsdRate)(deps, feeAsset),
+            (0, helpers_2.getUsdRate)(deps, sellAsset)
+        ]);
+        const feeData = feeDataOptions['fast'];
+        const fee = (0, bignumber_1.bnOrZero)(quote.feeAmount)
+            .multipliedBy((0, bignumber_1.bnOrZero)(usdRateSellAsset))
+            .div((0, bignumber_1.bnOrZero)(wethUsdRate))
+            .div((0, bignumber_1.bn)(10).exponentiatedBy(sellAsset.precision - feeAsset.precision))
+            .toString();
+        return {
+            rate,
+            minimum,
+            maximum,
+            feeData: {
+                fee,
+                chainSpecific: {
+                    estimatedGas: feeData.chainSpecific.gasLimit,
+                    gasPrice: feeData.chainSpecific.gasPrice,
+                    approvalFee: (0, bignumber_1.bnOrZero)(constants_1.APPROVAL_GAS_LIMIT)
+                        .multipliedBy((0, bignumber_1.bnOrZero)(feeData.chainSpecific.gasPrice))
+                        .toString()
+                },
+                tradeFee: '0'
+            },
+            sellAmount: quote.sellAmount,
+            buyAmount: quote.buyAmount,
+            sources: constants_2.DEFAULT_SOURCE,
+            allowanceContract: '',
+            buyAsset,
+            sellAsset,
+            sellAssetAccountNumber
+        };
+    }
+    catch (e) {
+        if (e instanceof api_1.SwapError)
+            throw e;
+        throw new api_1.SwapError('[getCowSwapTradeQuote]', {
+            cause: e,
+            code: api_1.SwapErrorTypes.TRADE_QUOTE_FAILED
+        });
+    }
+}
+exports.getCowSwapTradeQuote = getCowSwapTradeQuote;

package/dist/swappers/cow/types.d.ts

@@ -2,3 +2,19 @@ export declare type CowSwapPriceResponse = {
     amount: string;
     token: string;
 };
+export declare type CowSwapQuoteResponse = {
+    quote: {
+        sellToken: string;
+        buyToken: string;
+        receiver: string;
+        sellAmount: string;
+        buyAmount: string;
+        validTo: number;
+        appData: string;
+        feeAmount: string;
+        kind: string;
+        partiallyFillable: boolean;
+    };
+    from: string;
+    expiration: string;
+};

package/dist/swappers/cow/utils/constants.d.ts

@@ -1,2 +1,12 @@
 export declare const MAX_ALLOWANCE = "100000000000000000000000000";
 export declare const MAX_COWSWAP_TRADE = "100000000000000000000000000";
+export declare const MIN_COWSWAP_VALUE_USD = 10;
+export declare const DEFAULT_SOURCE: {
+    name: string;
+    proportion: string;
+}[];
+export declare const DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const DEFAULT_APP_DATA = "0x0000000000000000000000000000000000000000000000000000000000000000";
+export declare const COW_SWAP_VAULT_RELAYER_ADDRESS = "0xc92e8bdf79f0507f65a392b0ab4667716bfe0110";
+export declare const DEFAULT_VALIDTO_TIMESTAMP = 4294967295;
+export declare const ORDER_KIND_SELL = "sell";

package/dist/swappers/cow/utils/constants.js

@@ -1,4 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_COWSWAP_TRADE = void 0;
+exports.ORDER_KIND_SELL = exports.DEFAULT_VALIDTO_TIMESTAMP = exports.COW_SWAP_VAULT_RELAYER_ADDRESS = exports.DEFAULT_APP_DATA = exports.DEFAULT_ADDRESS = exports.DEFAULT_SOURCE = exports.MIN_COWSWAP_VALUE_USD = exports.MAX_COWSWAP_TRADE = void 0;
 exports.MAX_COWSWAP_TRADE = '100000000000000000000000000';
+exports.MIN_COWSWAP_VALUE_USD = 10;
+exports.DEFAULT_SOURCE = [{ name: 'CowSwap', proportion: '1' }];
+exports.DEFAULT_ADDRESS = '0x0000000000000000000000000000000000000000';
+exports.DEFAULT_APP_DATA = '0x0000000000000000000000000000000000000000000000000000000000000000';
+exports.COW_SWAP_VAULT_RELAYER_ADDRESS = '0xc92e8bdf79f0507f65a392b0ab4667716bfe0110';
+// CowSwap API requires validTo field which specifies a limit date for the order to be valid
+// This is the default value being used by CowSwap exchange, corresponding to a date in year 2106
+exports.DEFAULT_VALIDTO_TIMESTAMP = 4294967295;
+exports.ORDER_KIND_SELL = 'sell';

package/dist/swappers/cow/utils/helpers/helpers.d.ts

@@ -1,3 +1,3 @@
 import { Asset } from '@shapeshiftoss/types';
 import { CowSwapperDeps } from '../../CowSwapper';
-export declare const getUsdRate: ({ apiUrl }: CowSwapperDeps, input: Asset) => Promise<string>;
+export declare const getUsdRate: ({ apiUrl, feeAsset }: CowSwapperDeps, input: Asset) => Promise<string>;

package/dist/swappers/cow/utils/helpers/helpers.js

@@ -7,8 +7,9 @@ const bignumber_1 = require("../../../utils/bignumber");
 const cowService_1 = require("../cowService");
 const USDC_CONTRACT_ADDRESS = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48';
 const USDC_ASSET_PRECISION = 6;
-const getUsdRate = async ({ apiUrl }, input) => {
-    const asset = input;
+const getUsdRate = async ({ apiUrl, feeAsset }, input) => {
+    // Replacing ETH by WETH specifically for CowSwap in order to get an usd rate when called with ETH as feeAsset
+    const asset = input.assetId !== caip_1.ethAssetId ? input : feeAsset;
     const { assetReference: erc20Address, assetNamespace } = (0, caip_1.fromAssetId)(asset.assetId);
     if (assetNamespace !== 'erc20') {
         throw new api_1.SwapError('[getUsdRate] - unsupported asset namespace', {

package/dist/swappers/thorchain/ThorchainSwapper.d.ts

@@ -1,6 +1,6 @@
 import { AssetId, ChainId } from '@shapeshiftoss/caip';
 import type { Asset } from '@shapeshiftoss/types';
-import { ApprovalNeededInput, ApprovalNeededOutput, BuyAssetBySellIdInput, ExecuteTradeInput, GetTradeQuoteInput, Swapper, SwapperType, Trade, TradeQuote, TradeResult, TradeTxs } from '../../api';
+import { ApprovalNeededInput, ApprovalNeededOutput, ApproveInfiniteInput, BuyAssetBySellIdInput, ExecuteTradeInput, GetTradeQuoteInput, Swapper, SwapperType, Trade, TradeQuote, TradeResult, TradeTxs } from '../../api';
 import { ThorchainSwapperDeps } from './types';
 export declare class ThorchainSwapper implements Swapper<ChainId> {
     private swapSupportedChainIds;
@@ -11,7 +11,7 @@ export declare class ThorchainSwapper implements Swapper<ChainId> {
     getType(): SwapperType;
     getUsdRate(input: Pick<Asset, 'symbol' | 'assetId'>): Promise<string>;
     approvalNeeded(input: ApprovalNeededInput<'eip155:1'>): Promise<ApprovalNeededOutput>;
-    approveInfinite(): Promise<string>;
+    approveInfinite(input: ApproveInfiniteInput<'eip155:1'>): Promise<string>;
     filterBuyAssetsBySellAssetId(args: BuyAssetBySellIdInput): AssetId[];
     filterAssetIdsBySellable(): AssetId[];
     buildTrade(): Promise<Trade<ChainId>>;

package/dist/swappers/thorchain/ThorchainSwapper.js

@@ -5,6 +5,7 @@ const caip_1 = require("@shapeshiftoss/caip");
 const api_1 = require("../../api");
 const getTradeQuote_1 = require("./getThorTradeQuote/getTradeQuote");
 const thorTradeApprovalNeeded_1 = require("./thorTradeApprovalNeeded/thorTradeApprovalNeeded");
+const thorTradeApproveInfinite_1 = require("./thorTradeApproveInfinite/thorTradeApproveInfinite");
 const getUsdRate_1 = require("./utils/getUsdRate/getUsdRate");
 const thorService_1 = require("./utils/thorService");
 class ThorchainSwapper {
@@ -44,8 +45,8 @@ class ThorchainSwapper {
     async approvalNeeded(input) {
         return (0, thorTradeApprovalNeeded_1.thorTradeApprovalNeeded)({ deps: this.deps, input });
     }
-    async approveInfinite() {
-        throw new Error('ThorchainSwapper: approveInfinite unimplemented');
+    async approveInfinite(input) {
+        return (0, thorTradeApproveInfinite_1.thorTradeApproveInfinite)({ deps: this.deps, input });
     }
     filterBuyAssetsBySellAssetId(args) {
         const { assetIds = [], sellAssetId } = args;

package/dist/swappers/thorchain/thorTradeApproveInfinite/thorTradeApproveInfinite.d.ts

@@ -0,0 +1,6 @@
+import { ApproveInfiniteInput } from '../../../api';
+import { ThorchainSwapperDeps } from '../types';
+export declare const thorTradeApproveInfinite: ({ deps, input }: {
+    deps: ThorchainSwapperDeps;
+    input: ApproveInfiniteInput<'eip155:1'>;
+}) => Promise<string>;

package/dist/swappers/thorchain/thorTradeApproveInfinite/thorTradeApproveInfinite.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thorTradeApproveInfinite = void 0;
+const types_1 = require("@shapeshiftoss/types");
+const api_1 = require("../../../api");
+const erc20_abi_1 = require("../../utils/abi/erc20-abi");
+const helpers_1 = require("../../utils/helpers/helpers");
+const constants_1 = require("../utils/constants");
+const thorTradeApproveInfinite = async ({ deps, input }) => {
+    try {
+        const { adapterManager, web3 } = deps;
+        const { quote, wallet } = input;
+        const sellAssetChainId = quote.sellAsset.chainId;
+        const adapter = adapterManager.get(types_1.KnownChainIds.EthereumMainnet);
+        if (!adapter)
+            throw new api_1.SwapError(`[thorTradeApproveInfinite] - No chain adapter found for ${sellAssetChainId}.`, {
+                code: api_1.SwapErrorTypes.UNSUPPORTED_CHAIN,
+                details: { sellAssetChainId }
+            });
+        const allowanceGrantRequired = await (0, helpers_1.grantAllowance)({
+            quote: {
+                ...quote,
+                sellAmount: constants_1.MAX_ALLOWANCE
+            },
+            wallet,
+            adapter,
+            erc20Abi: erc20_abi_1.erc20Abi,
+            web3
+        });
+        return allowanceGrantRequired;
+    }
+    catch (e) {
+        if (e instanceof api_1.SwapError)
+            throw e;
+        throw new api_1.SwapError('[ZrxApproveInfinite]', {
+            cause: e,
+            code: api_1.SwapErrorTypes.APPROVE_INFINITE_FAILED
+        });
+    }
+};
+exports.thorTradeApproveInfinite = thorTradeApproveInfinite;

package/dist/swappers/thorchain/utils/constants.d.ts

@@ -1 +1,2 @@
 export declare const MAX_THORCHAIN_TRADE = "100000000000000000000000000";
+export declare const MAX_ALLOWANCE = "100000000000000000000000000";

package/dist/swappers/thorchain/utils/constants.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_THORCHAIN_TRADE = void 0;
+exports.MAX_ALLOWANCE = exports.MAX_THORCHAIN_TRADE = void 0;
 exports.MAX_THORCHAIN_TRADE = '100000000000000000000000000';
+exports.MAX_ALLOWANCE = '100000000000000000000000000';

package/dist/swappers/thorchain/utils/txFeeHelpers/ethTxFees/getEthTxFees.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEthTxFees = void 0;
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
 const types_1 = require("@shapeshiftoss/types");
 const api_1 = require("../../../../../api");
 const bignumber_1 = require("../../../../utils/bignumber");
@@ -9,17 +10,36 @@ const estimateTradeFee_1 = require("../../estimateTradeFee/estimateTradeFee");
 const getEthTxFees = async ({ deps, data, router, buyAsset, sellAmount, adapterManager, receiveAddress, sellAssetReference }) => {
     try {
         const adapter = adapterManager.get(types_1.KnownChainIds.EthereumMainnet);
-        if (!adapter)
+        if (!adapter) {
             throw new api_1.SwapError(`[getThorTxInfo] - No chain adapter found for ${types_1.KnownChainIds.EthereumMainnet}.`, {
                 code: api_1.SwapErrorTypes.UNSUPPORTED_CHAIN,
                 details: { chainId: types_1.KnownChainIds.EthereumMainnet }
             });
-        // TODO(ryankk): add falling back on hard coded gas Limit * new chain adapter method if it fails
-        const feeDataOptions = await adapter.getFeeData({
-            to: router,
-            value: sellAmount,
-            chainSpecific: { from: receiveAddress, contractData: data }
-        });
+        }
+        let feeDataOptions;
+        try {
+            feeDataOptions = await adapter.getFeeData({
+                to: router,
+                value: sellAmount,
+                chainSpecific: { from: receiveAddress, contractData: data }
+            });
+        }
+        catch (e) {
+            // Fallback to fixed fee amount in case of failure so that quote will not fail
+            // eslint-disable-next-line no-console
+            console.debug('[ThorSwapper:getEthTxFees] precise gas estimate failed, falling back on hard coded limit');
+            const gasFeeData = await adapter.getGasFeeData();
+            const gasLimit = '100000'; // good value to cover all thortrades out of eth/erc20
+            feeDataOptions = {
+                fast: {
+                    txFee: (0, bignumber_1.bn)(gasLimit).times(gasFeeData[chain_adapters_1.FeeDataKey.Fast].gasPrice).toString(),
+                    chainSpecific: {
+                        gasPrice: gasFeeData[chain_adapters_1.FeeDataKey.Fast].gasPrice,
+                        gasLimit
+                    }
+                }
+            };
+        }
         const feeData = feeDataOptions['fast'];
         const tradeFee = await (0, estimateTradeFee_1.estimateTradeFee)(deps, buyAsset.assetId);
         return {

package/dist/swappers/utils/helpers/helpers.d.ts

@@ -37,4 +37,5 @@ export declare const grantAllowance: ({ quote, wallet, adapter, erc20Abi, web3 }
  * @param amount
  */
 export declare const normalizeAmount: (amount: string | number | BN) => string;
+export declare const normalizeIntegerAmount: (amount: string | number | BN) => string;
 export {};

package/dist/swappers/utils/helpers/helpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeAmount = exports.grantAllowance = exports.getAllowanceRequired = exports.getERC20Allowance = void 0;
+exports.normalizeIntegerAmount = exports.normalizeAmount = exports.grantAllowance = exports.getAllowanceRequired = exports.getERC20Allowance = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
 const web3_utils_1 = require("web3-utils");
 const api_1 = require("../../../api");
@@ -108,3 +108,10 @@ const normalizeAmount = (amount) => {
     return (0, bignumber_1.bnOrZero)(amount).toNumber().toLocaleString('fullwide', { useGrouping: false });
 };
 exports.normalizeAmount = normalizeAmount;
+const normalizeIntegerAmount = (amount) => {
+    return (0, bignumber_1.bnOrZero)(amount)
+        .integerValue()
+        .toNumber()
+        .toLocaleString('fullwide', { useGrouping: false });
+};
+exports.normalizeIntegerAmount = normalizeIntegerAmount;

package/dist/swappers/utils/test-data/setupDeps.d.ts

@@ -3,4 +3,5 @@ import Web3 from 'web3';
 export declare const setupDeps: () => {
     web3: Web3;
     adapter: ethereum.ChainAdapter;
+    feeAsset: import("@shapeshiftoss/types").Asset;
 };

package/dist/swappers/utils/test-data/setupDeps.js

@@ -30,6 +30,7 @@ exports.setupDeps = void 0;
 const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
 const unchained = __importStar(require("@shapeshiftoss/unchained-client"));
 const web3_1 = __importDefault(require("web3"));
+const assets_1 = require("./assets");
 jest.mock('@shapeshiftoss/chain-adapters');
 jest.mock('web3');
 const setupDeps = () => {
@@ -44,6 +45,6 @@ const setupDeps = () => {
     });
     const ethNodeUrl = 'http://localhost:1000';
     const web3Provider = new web3_1.default.providers.HttpProvider(ethNodeUrl);
-    return { web3: new web3_1.default(web3Provider), adapter: ethChainAdapter };
+    return { web3: new web3_1.default(web3Provider), adapter: ethChainAdapter, feeAsset: assets_1.WETH };
 };
 exports.setupDeps = setupDeps;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshiftoss/swapper",
-  "version": "7.6.0",
+  "version": "7.8.0",
   "description": "An interface and implementations to trade coins via various protocols",
   "repository": "https://github.com/shapeshift/lib",
   "license": "MIT",