@shapeshiftoss/swapper 8.0.1 → 8.3.0

package/dist/api.d.ts

@@ -63,7 +63,8 @@ declare type CommonTradeInput = {
     sellAmount: string;
     sendMax: boolean;
     sellAssetAccountNumber: number;
-    wallet?: HDWallet;
+    wallet: HDWallet;
+    receiveAddress: string;
 };
 export declare type EvmSupportedChainIds = KnownChainIds.EthereumMainnet | KnownChainIds.AvalancheMainnet;
 export declare type EvmSupportedChainAdapters = ethereum.ChainAdapter | avalanche.ChainAdapter;
@@ -160,6 +161,8 @@ export declare enum SwapErrorTypes {
     POOL_NOT_FOUND = "POOL_NOT_FOUND"
 }
 export interface Swapper<T extends ChainId> {
+    /** Human readable swapper name */
+    readonly name: string;
     /** perform any necessary async initialization */
     initialize?(): Promise<void>;
     /** Returns the swapper type */

package/dist/swappercli.js

@@ -114,7 +114,9 @@ const main = async () => {
             buyAsset,
             sellAmount: sellAmountBase,
             sellAssetAccountNumber: 0,
-            sendMax: false
+            sendMax: false,
+            receiveAddress: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+            wallet
         });
     }
     catch (e) {
@@ -135,7 +137,8 @@ const main = async () => {
             sellAmount: sellAmountBase,
             sellAsset,
             sellAssetAccountNumber: 0,
-            buyAssetAccountNumber: 0
+            buyAssetAccountNumber: 0,
+            receiveAddress: '0xc770eefad204b5180df6a14ee197d99d808ee52d'
         });
         const txid = await swapper.executeTrade({ trade, wallet });
         console.info('broadcast tx with id: ', txid);

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

@@ -14,7 +14,7 @@ export declare type CowSwapperDeps = {
     feeAsset: Asset;
 };
 export declare class CowSwapper implements Swapper<KnownChainIds.EthereumMainnet> {
-    static swapperName: string;
+    readonly name = "CowSwap";
     deps: CowSwapperDeps;
     constructor(deps: CowSwapperDeps);
     getType(): SwapperType;

package/dist/swappers/cow/CowSwapper.js

@@ -4,19 +4,20 @@ exports.CowSwapper = void 0;
 const api_1 = require("../../api");
 const cowApprovalNeeded_1 = require("./cowApprovalNeeded/cowApprovalNeeded");
 const cowApproveInfinite_1 = require("./cowApproveInfinite/cowApproveInfinite");
+const cowBuildTrade_1 = require("./cowBuildTrade/cowBuildTrade");
 const getCowSwapTradeQuote_1 = require("./getCowSwapTradeQuote/getCowSwapTradeQuote");
 const blacklist_1 = require("./utils/blacklist");
 const helpers_1 = require("./utils/helpers/helpers");
 class CowSwapper {
     constructor(deps) {
+        this.name = 'CowSwap';
         this.deps = deps;
     }
     getType() {
         return api_1.SwapperType.CowSwap;
     }
     async buildTrade(args) {
-        console.info(args);
-        throw new Error('CowSwapper: buildTrade unimplemented');
+        return (0, cowBuildTrade_1.cowBuildTrade)(this.deps, args);
     }
     async getTradeQuote(input) {
         return (0, getCowSwapTradeQuote_1.getCowSwapTradeQuote)(this.deps, input);
@@ -51,4 +52,3 @@ class CowSwapper {
     }
 }
 exports.CowSwapper = CowSwapper;
-CowSwapper.swapperName = 'CowSwapper';

package/dist/swappers/cow/cowApprovalNeeded/cowApprovalNeeded.js

@@ -6,7 +6,7 @@ const api_1 = require("../../../api");
 const erc20Allowance_abi_1 = require("../../utils/abi/erc20Allowance-abi");
 const bignumber_1 = require("../../utils/bignumber");
 const helpers_1 = require("../../utils/helpers/helpers");
-const COW_SWAP_VAULT_RELAYER_ADDRESS = '0xc92e8bdf79f0507f65a392b0ab4667716bfe0110';
+const constants_1 = require("../utils/constants");
 async function cowApprovalNeeded({ adapter, web3 }, { quote, wallet }) {
     const { sellAsset } = quote;
     const { assetReference: sellAssetErc20Address, assetNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
@@ -22,7 +22,7 @@ async function cowApprovalNeeded({ adapter, web3 }, { quote, wallet }) {
             web3,
             erc20AllowanceAbi: erc20Allowance_abi_1.erc20AllowanceAbi,
             sellAssetErc20Address,
-            spenderAddress: COW_SWAP_VAULT_RELAYER_ADDRESS,
+            spenderAddress: constants_1.COW_SWAP_VAULT_RELAYER_ADDRESS,
             ownerAddress: receiveAddress
         });
         const allowanceOnChain = (0, bignumber_1.bnOrZero)(allowanceResult);

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

@@ -0,0 +1,4 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { BuildTradeInput, Trade } from '../../../api';
+import { CowSwapperDeps } from '../CowSwapper';
+export declare function cowBuildTrade(deps: CowSwapperDeps, input: BuildTradeInput): Promise<Trade<KnownChainIds.EthereumMainnet>>;

package/dist/swappers/cow/cowBuildTrade/cowBuildTrade.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cowBuildTrade = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const api_1 = require("../../../api");
+const erc20Allowance_abi_1 = require("../../utils/abi/erc20Allowance-abi");
+const bignumber_1 = require("../../utils/bignumber");
+const helpers_1 = require("../../utils/helpers/helpers");
+const constants_1 = require("../utils/constants");
+const cowService_1 = require("../utils/cowService");
+const helpers_2 = require("../utils/helpers/helpers");
+async function cowBuildTrade(deps, input) {
+    try {
+        const { sellAsset, buyAsset, sellAmount, sellAssetAccountNumber, wallet } = input;
+        const { adapter, feeAsset, web3 } = 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('[cowBuildTrade] - Both assets need to be ERC-20 to use CowSwap', {
+                code: api_1.SwapErrorTypes.UNSUPPORTED_PAIR,
+                details: { buyAssetNamespace, sellAssetNamespace }
+            });
+        }
+        const receiveAddress = await adapter.getAddress({ wallet });
+        const normalizedSellAmount = (0, helpers_1.normalizeAmount)(sellAmount);
+        /**
+         * /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/`, {
+            sellToken: sellAssetErc20Address,
+            buyToken: buyAssetErc20Address,
+            receiver: receiveAddress,
+            validTo: (0, helpers_2.getNowPlusThirtyMinutesTimestamp)(),
+            appData: constants_1.DEFAULT_APP_DATA,
+            partiallyFillable: false,
+            from: receiveAddress,
+            kind: constants_1.ORDER_KIND_SELL,
+            sellAmountBeforeFee: normalizedSellAmount
+        });
+        const { data: { quote } } = quoteResponse;
+        const buyCryptoAmount = (0, bignumber_1.bn)(quote.buyAmount).div((0, bignumber_1.bn)(10).exponentiatedBy(buyAsset.precision));
+        const sellCryptoAmount = (0, bignumber_1.bn)(quote.sellAmount).div((0, bignumber_1.bn)(10).exponentiatedBy(sellAsset.precision));
+        const rate = buyCryptoAmount.div(sellCryptoAmount).toString();
+        const data = (0, helpers_1.getApproveContractData)({
+            web3,
+            spenderAddress: constants_1.COW_SWAP_VAULT_RELAYER_ADDRESS,
+            contractAddress: sellAssetErc20Address
+        });
+        const [feeDataOptions, feeAssetUsdRate, sellAssetUsdRate] = await Promise.all([
+            adapter.getFeeData({
+                to: sellAssetErc20Address,
+                value: '0',
+                chainSpecific: { from: receiveAddress, contractData: data }
+            }),
+            (0, helpers_2.getUsdRate)(deps, feeAsset),
+            (0, helpers_2.getUsdRate)(deps, sellAsset)
+        ]);
+        const feeData = feeDataOptions['fast'];
+        // quote.feeAmount is expressed in sellAsset token
+        // We need fee to be expressed in feeAsset token
+        // feeInFeeAsset * feeAssetUsdRate = feeInSellAsset * sellAssetUsdRate
+        // hence feeInFeeAsset = feeInSellAsset * sellAssetUsdRate / feeAssetUsdRate
+        const feeInSellAsset = (0, bignumber_1.bnOrZero)(quote.feeAmount).div((0, bignumber_1.bn)(10).exponentiatedBy(sellAsset.precision));
+        // feeInFeeAsset = feeInSellAsset * sellAssetUsdRate / feeAssetUsdRate
+        const feeInFeeAsset = feeInSellAsset
+            .multipliedBy((0, bignumber_1.bnOrZero)(sellAssetUsdRate))
+            .div((0, bignumber_1.bnOrZero)(feeAssetUsdRate));
+        // taking precision into account
+        const fee = feeInFeeAsset.multipliedBy((0, bignumber_1.bn)(10).exponentiatedBy(feeAsset.precision)).toString();
+        const trade = {
+            rate,
+            feeData: {
+                fee,
+                chainSpecific: {
+                    estimatedGas: feeData.chainSpecific.gasLimit,
+                    gasPrice: feeData.chainSpecific.gasPrice
+                },
+                tradeFee: '0'
+            },
+            sellAmount: normalizedSellAmount,
+            buyAmount: quote.buyAmount,
+            sources: constants_1.DEFAULT_SOURCE,
+            buyAsset,
+            sellAsset,
+            sellAssetAccountNumber,
+            receiveAddress
+        };
+        const allowanceRequired = await (0, helpers_1.getAllowanceRequired)({
+            adapter,
+            sellAsset,
+            allowanceContract: constants_1.COW_SWAP_VAULT_RELAYER_ADDRESS,
+            receiveAddress,
+            sellAmount: quote.sellAmount,
+            web3: deps.web3,
+            erc20AllowanceAbi: erc20Allowance_abi_1.erc20AllowanceAbi
+        });
+        if (!allowanceRequired.isZero()) {
+            trade.feeData.chainSpecific.approvalFee = (0, bignumber_1.bnOrZero)(feeData.chainSpecific.gasLimit)
+                .multipliedBy((0, bignumber_1.bnOrZero)(feeData.chainSpecific.gasPrice))
+                .toString();
+        }
+        return trade;
+    }
+    catch (e) {
+        if (e instanceof api_1.SwapError)
+            throw e;
+        throw new api_1.SwapError('[cowBuildTrade]', {
+            cause: e,
+            code: api_1.SwapErrorTypes.TRADE_QUOTE_FAILED
+        });
+    }
+}
+exports.cowBuildTrade = cowBuildTrade;

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

@@ -1,15 +1,4 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
 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<KnownChainIds.EthereumMainnet>>;

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

@@ -4,16 +4,15 @@ 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 constants_1 = 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 { adapter, feeAsset, web3 } = 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') {
@@ -29,12 +28,12 @@ async function getCowSwapTradeQuote(deps, input) {
         const apiInput = {
             sellToken: sellAssetErc20Address,
             buyToken: buyAssetErc20Address,
-            receiver: constants_2.DEFAULT_ADDRESS,
-            validTo: constants_2.DEFAULT_VALIDTO_TIMESTAMP,
-            appData: constants_2.DEFAULT_APP_DATA,
+            receiver: constants_1.DEFAULT_ADDRESS,
+            validTo: (0, helpers_2.getNowPlusThirtyMinutesTimestamp)(),
+            appData: constants_1.DEFAULT_APP_DATA,
             partiallyFillable: false,
-            from: constants_2.DEFAULT_ADDRESS,
-            kind: constants_2.ORDER_KIND_SELL,
+            from: constants_1.DEFAULT_ADDRESS,
+            kind: constants_1.ORDER_KIND_SELL,
             sellAmountBeforeFee: normalizedSellAmount
         };
         /**
@@ -53,26 +52,36 @@ async function getCowSwapTradeQuote(deps, input) {
          */
         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([
+        const buyCryptoAmount = (0, bignumber_1.bn)(quote.buyAmount).div((0, bignumber_1.bn)(10).exponentiatedBy(buyAsset.precision));
+        const sellCryptoAmount = (0, bignumber_1.bn)(quote.sellAmount).div((0, bignumber_1.bn)(10).exponentiatedBy(sellAsset.precision));
+        const rate = buyCryptoAmount.div(sellCryptoAmount).toString();
+        const receiveAddress = wallet ? await adapter.getAddress({ wallet }) : constants_1.DEFAULT_ADDRESS;
+        const data = (0, helpers_1.getApproveContractData)({
+            web3,
+            spenderAddress: constants_1.COW_SWAP_VAULT_RELAYER_ADDRESS,
+            contractAddress: sellAssetErc20Address
+        });
+        const [feeDataOptions, feeAssetUsdRate, sellAssetUsdRate] = await Promise.all([
             adapter.getFeeData({
-                to: constants_2.COW_SWAP_VAULT_RELAYER_ADDRESS,
+                to: sellAssetErc20Address,
                 value: '0',
-                chainSpecific: { from: receiveAddress, contractAddress: sellAssetErc20Address }
+                chainSpecific: { from: receiveAddress, contractData: data }
             }),
             (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();
+        // quote.feeAmount is expressed in sellAsset token
+        // We need fee to be expressed in feeAsset token
+        // feeInFeeAsset * feeAssetUsdRate = feeInSellAsset * sellAssetUsdRate
+        // hence feeInFeeAsset = feeInSellAsset * sellAssetUsdRate / feeAssetUsdRate
+        const feeInSellAsset = (0, bignumber_1.bnOrZero)(quote.feeAmount).div((0, bignumber_1.bn)(10).exponentiatedBy(sellAsset.precision));
+        // feeInFeeAsset = feeInSellAsset * sellAssetUsdRate / feeAssetUsdRate
+        const feeInFeeAsset = feeInSellAsset
+            .multipliedBy((0, bignumber_1.bnOrZero)(sellAssetUsdRate))
+            .div((0, bignumber_1.bnOrZero)(feeAssetUsdRate));
+        // taking precision into account
+        const fee = feeInFeeAsset.multipliedBy((0, bignumber_1.bn)(10).exponentiatedBy(feeAsset.precision)).toString();
         return {
             rate,
             minimum,
@@ -82,16 +91,16 @@ async function getCowSwapTradeQuote(deps, input) {
                 chainSpecific: {
                     estimatedGas: feeData.chainSpecific.gasLimit,
                     gasPrice: feeData.chainSpecific.gasPrice,
-                    approvalFee: (0, bignumber_1.bnOrZero)(constants_1.APPROVAL_GAS_LIMIT)
+                    approvalFee: (0, bignumber_1.bnOrZero)(feeData.chainSpecific.gasLimit)
                         .multipliedBy((0, bignumber_1.bnOrZero)(feeData.chainSpecific.gasPrice))
                         .toString()
                 },
                 tradeFee: '0'
             },
-            sellAmount: quote.sellAmount,
+            sellAmount: normalizedSellAmount,
             buyAmount: quote.buyAmount,
-            sources: constants_2.DEFAULT_SOURCE,
-            allowanceContract: '',
+            sources: constants_1.DEFAULT_SOURCE,
+            allowanceContract: constants_1.COW_SWAP_VAULT_RELAYER_ADDRESS,
             buyAsset,
             sellAsset,
             sellAssetAccountNumber

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

@@ -8,5 +8,4 @@ export declare const DEFAULT_SOURCE: {
 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,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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.ORDER_KIND_SELL = 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 = exports.MAX_ALLOWANCE = void 0;
+const constants_1 = require("@ethersproject/constants");
+exports.MAX_ALLOWANCE = '100000000000000000000000000';
 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.DEFAULT_ADDRESS = constants_1.AddressZero;
+exports.DEFAULT_APP_DATA = constants_1.HashZero;
 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,15 @@
 import { Asset } from '@shapeshiftoss/types';
 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 const getUsdRate: ({ apiUrl, feeAsset }: CowSwapperDeps, input: Asset) => Promise<string>;
+export declare const getNowPlusThirtyMinutesTimestamp: () => number;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUsdRate = void 0;
+exports.getNowPlusThirtyMinutesTimestamp = exports.getUsdRate = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
 const api_1 = require("../../../../api");
 const bignumber_1 = require("../../../utils/bignumber");
@@ -17,6 +17,9 @@ const getUsdRate = async ({ apiUrl, feeAsset }, input) => {
             details: { assetNamespace }
         });
     }
+    if (erc20Address === USDC_CONTRACT_ADDRESS) {
+        return '1';
+    }
     const buyAmountInDollars = 1000;
     const buyAmount = (0, bignumber_1.bn)(buyAmountInDollars).times((0, bignumber_1.bn)(10).exponentiatedBy(USDC_ASSET_PRECISION));
     try {
@@ -42,3 +45,9 @@ const getUsdRate = async ({ apiUrl, feeAsset }, input) => {
     }
 };
 exports.getUsdRate = getUsdRate;
+const getNowPlusThirtyMinutesTimestamp = () => {
+    const ts = new Date();
+    ts.setMinutes(ts.getMinutes() + 30);
+    return Math.round(ts.getTime() / 1000);
+};
+exports.getNowPlusThirtyMinutesTimestamp = getNowPlusThirtyMinutesTimestamp;

package/dist/swappers/test/TestSwapper.d.ts

@@ -6,6 +6,7 @@ import { ApprovalNeededOutput, BuyAssetBySellIdInput, Swapper, SwapperType, Trad
  * Meant for local testing only
  */
 export declare class TestSwapper implements Swapper<ChainId> {
+    readonly name = "Test";
     supportAssets: string[];
     initialize(): Promise<void>;
     getType(): SwapperType;

package/dist/swappers/test/TestSwapper.js

@@ -8,6 +8,7 @@ const api_1 = require("../../api");
  */
 class TestSwapper {
     constructor() {
+        this.name = 'Test';
         this.supportAssets = [
             'bip122:000000000019d6689c085ae165831e93/slip44:0',
             'cosmos:cosmoshub-4/slip44:118',

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

@@ -4,6 +4,7 @@ import { KnownChainIds } from '@shapeshiftoss/types';
 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> {
+    readonly name = "Thorchain";
     private swapSupportedChainIds;
     private supportedAssetIds;
     deps: ThorchainSwapperDeps;

package/dist/swappers/thorchain/ThorchainSwapper.js

@@ -11,6 +11,7 @@ const getUsdRate_1 = require("./utils/getUsdRate/getUsdRate");
 const thorService_1 = require("./utils/thorService");
 class ThorchainSwapper {
     constructor(deps) {
+        this.name = 'Thorchain';
         this.swapSupportedChainIds = {
             'eip155:1': true,
             'bip122:000000000019d6689c085ae165831e93': true

package/dist/swappers/thorchain/getThorTradeQuote/getTradeQuote.d.ts

@@ -1,7 +1,11 @@
 import { ChainId } from '@shapeshiftoss/caip';
 import { GetTradeQuoteInput, TradeQuote } from '../../../api';
 import { ThorchainSwapperDeps } from '../types';
-export declare const getThorTradeQuote: ({ deps, input }: {
+declare type GetThorTradeQuoteInput = {
     deps: ThorchainSwapperDeps;
     input: GetTradeQuoteInput;
-}) => Promise<TradeQuote<ChainId>>;
+};
+declare type GetThorTradeQuoteReturn = Promise<TradeQuote<ChainId>>;
+declare type GetThorTradeQuote = (args: GetThorTradeQuoteInput) => GetThorTradeQuoteReturn;
+export declare const getThorTradeQuote: GetThorTradeQuote;
+export {};

package/dist/swappers/thorchain/getThorTradeQuote/getTradeQuote.js

@@ -2,61 +2,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getThorTradeQuote = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
+const types_1 = require("@shapeshiftoss/types");
 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 getThorTxData_1 = require("../utils/bitcoin/utils/getThorTxData");
 const constants_2 = require("../utils/constants");
-const getThorTxData_1 = require("../utils/ethereum/utils/getThorTxData");
+const estimateTradeFee_1 = require("../utils/estimateTradeFee/estimateTradeFee");
+const getThorTxData_2 = require("../utils/ethereum/utils/getThorTxData");
 const getPriceRatio_1 = require("../utils/getPriceRatio/getPriceRatio");
+const getBtcTxFees_1 = require("../utils/txFeeHelpers/btcTxFees/getBtcTxFees");
 const getEthTxFees_1 = require("../utils/txFeeHelpers/ethTxFees/getEthTxFees");
 const getThorTradeQuote = async ({ deps, input }) => {
-    const { sellAsset, buyAsset, sellAmount, sellAssetAccountNumber, wallet } = input;
+    const { sellAsset, buyAsset, sellAmount, sellAssetAccountNumber, wallet, chainId, receiveAddress } = input;
     if (!wallet)
         throw new api_1.SwapError('[getTradeQuote] - wallet is required', {
             code: api_1.SwapErrorTypes.VALIDATION_FAILED
         });
     try {
-        const { assetReference: sellAssetErc20Address, chainReference, chainNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
-        const isErc20Trade = sellAssetErc20Address.startsWith('0x');
-        const sellAssetChainId = (0, caip_1.toChainId)({ chainReference, chainNamespace });
-        const adapter = deps.adapterManager.get(sellAssetChainId);
+        const { assetReference: sellAssetErc20Address } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+        const adapter = deps.adapterManager.get(chainId);
         if (!adapter)
-            throw new api_1.SwapError(`[getThorTradeQuote] - No chain adapter found for ${sellAssetChainId}.`, {
+            throw new api_1.SwapError(`[getThorTradeQuote] - No chain adapter found for ${chainId}.`, {
                 code: api_1.SwapErrorTypes.UNSUPPORTED_CHAIN,
-                details: { sellAssetChainId }
+                details: { chainId }
             });
-        const bip44Params = adapter.buildBIP44Params({ accountNumber: Number(sellAssetAccountNumber) });
-        const receiveAddress = await adapter.getAddress({ wallet, bip44Params });
-        const { data, router } = await (0, getThorTxData_1.getThorTxInfo)({
-            deps,
-            sellAsset,
-            buyAsset,
-            sellAmount,
-            slippageTolerance: constants_1.DEFAULT_SLIPPAGE,
-            destinationAddress: receiveAddress,
-            isErc20Trade
-        });
-        const feeData = await (async () => {
-            switch (sellAssetChainId) {
-                case 'eip155:1':
-                    return await (0, getEthTxFees_1.getEthTxFees)({
-                        deps,
-                        data,
-                        router,
-                        buyAsset,
-                        sellAmount,
-                        adapterManager: deps.adapterManager,
-                        receiveAddress,
-                        sellAssetReference: sellAssetErc20Address
-                    });
-                default:
-                    throw new api_1.SwapError('[getThorTradeQuote] - Asset chainId is not supported.', {
-                        code: api_1.SwapErrorTypes.UNSUPPORTED_CHAIN,
-                        details: { sellAssetChainId }
-                    });
-            }
-        })();
         const sellAssetId = sellAsset.assetId;
         const buyAssetId = buyAsset.assetId;
         const feeAssetId = (0, caip_1.getFeeAssetIdFromAssetId)(buyAssetId);
@@ -69,22 +40,82 @@ const getThorTradeQuote = async ({ deps, input }) => {
         const priceRatio = await (0, getPriceRatio_1.getPriceRatio)(deps, { sellAssetId, buyAssetId });
         const rate = (0, bignumber_1.bnOrZero)(1).div(priceRatio).toString();
         const buyAmount = (0, helpers_1.normalizeAmount)((0, bignumber_1.bnOrZero)(sellAmount).times(rate));
-        const sellAssetTradeFee = (0, bignumber_1.bnOrZero)(feeData.tradeFee).times((0, bignumber_1.bnOrZero)(feeAssetRatio));
+        const tradeFee = await (0, estimateTradeFee_1.estimateTradeFee)(deps, buyAsset.assetId);
+        const sellAssetTradeFee = (0, bignumber_1.bnOrZero)(tradeFee).times((0, bignumber_1.bnOrZero)(feeAssetRatio));
         // padding minimum by 1.5 the trade fee to avoid thorchain "not enough to cover fee" errors.
         const minimum = (0, bignumber_1.fromBaseUnit)(sellAssetTradeFee.times(1.5).toString(), sellAsset.precision);
-        return {
+        const commonQuoteFields = {
             rate,
-            minimum,
             maximum: constants_2.MAX_THORCHAIN_TRADE,
-            feeData,
             sellAmount,
             buyAmount,
             sources: [{ name: 'thorchain', proportion: '1' }],
-            allowanceContract: router,
             buyAsset,
             sellAsset,
-            sellAssetAccountNumber
+            sellAssetAccountNumber,
+            minimum
         };
+        switch (chainId) {
+            case types_1.KnownChainIds.EthereumMainnet:
+                return (async () => {
+                    const { data, router } = await (0, getThorTxData_2.getThorTxInfo)({
+                        deps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmount,
+                        slippageTolerance: constants_1.DEFAULT_SLIPPAGE,
+                        destinationAddress: receiveAddress
+                    });
+                    const feeData = await (0, getEthTxFees_1.getEthTxFees)({
+                        deps,
+                        data,
+                        router,
+                        buyAsset,
+                        sellAmount,
+                        adapterManager: deps.adapterManager,
+                        receiveAddress,
+                        sellAssetReference: sellAssetErc20Address
+                    });
+                    return {
+                        ...commonQuoteFields,
+                        allowanceContract: router,
+                        feeData
+                    };
+                })();
+            case types_1.KnownChainIds.BitcoinMainnet:
+                return (async () => {
+                    const { vault, opReturnData, pubkey } = await (0, getThorTxData_1.getThorTxInfo)({
+                        deps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmount,
+                        slippageTolerance: constants_1.DEFAULT_SLIPPAGE,
+                        destinationAddress: receiveAddress,
+                        wallet,
+                        bip44Params: input.bip44Params,
+                        accountType: input.accountType
+                    });
+                    const feeData = await (0, getBtcTxFees_1.getBtcTxFees)({
+                        deps,
+                        buyAsset,
+                        sellAmount,
+                        vault,
+                        opReturnData,
+                        pubkey,
+                        adapterManager: deps.adapterManager
+                    });
+                    return {
+                        ...commonQuoteFields,
+                        allowanceContract: '0x0',
+                        feeData
+                    };
+                })();
+            default:
+                throw new api_1.SwapError('[getThorTradeQuote] - Asset chainId is not supported.', {
+                    code: api_1.SwapErrorTypes.UNSUPPORTED_CHAIN,
+                    details: { chainId }
+                });
+        }
     }
     catch (e) {
         if (e instanceof api_1.SwapError)

package/dist/swappers/thorchain/utils/bitcoin/utils/getThorTxData.d.ts

@@ -0,0 +1,22 @@
+import { HDWallet } from '@shapeshiftoss/hdwallet-core';
+import { Asset, BIP44Params, UtxoAccountType } from '@shapeshiftoss/types';
+import { ThorchainSwapperDeps } from '../../../types';
+declare type GetBtcThorTxInfoArgs = {
+    deps: ThorchainSwapperDeps;
+    sellAsset: Asset;
+    buyAsset: Asset;
+    sellAmount: string;
+    slippageTolerance: string;
+    destinationAddress: string;
+    wallet: HDWallet;
+    bip44Params: BIP44Params;
+    accountType: UtxoAccountType;
+};
+declare type GetBtcThorTxInfoReturn = Promise<{
+    opReturnData: string;
+    vault: string;
+    pubkey: string;
+}>;
+declare type GetBtcThorTxInfo = (args: GetBtcThorTxInfoArgs) => GetBtcThorTxInfoReturn;
+export declare const getThorTxInfo: GetBtcThorTxInfo;
+export {};

package/dist/swappers/thorchain/utils/bitcoin/utils/getThorTxData.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThorTxInfo = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const api_1 = require("../../../../../api");
+const bignumber_1 = require("../../../../utils/bignumber");
+const getPriceRatio_1 = require("../../getPriceRatio/getPriceRatio");
+const makeSwapMemo_1 = require("../../makeSwapMemo/makeSwapMemo");
+const thorService_1 = require("../../thorService");
+const getThorTxInfo = async ({ deps, sellAsset, buyAsset, sellAmount, slippageTolerance, destinationAddress, wallet, bip44Params, accountType }) => {
+    try {
+        const { data: inboundAddresses } = await thorService_1.thorService.get(`${deps.midgardUrl}/thorchain/inbound_addresses`);
+        const btcInboundAddresses = inboundAddresses.find((inbound) => inbound.chain === 'BTC');
+        const vault = btcInboundAddresses === null || btcInboundAddresses === void 0 ? void 0 : btcInboundAddresses.address;
+        if (!vault)
+            throw new api_1.SwapError(`[getThorTxInfo]: vault not found for BTC`, {
+                code: api_1.SwapErrorTypes.RESPONSE_ERROR,
+                details: { inboundAddresses }
+            });
+        const priceRatio = await (0, getPriceRatio_1.getPriceRatio)(deps, {
+            buyAssetId: buyAsset.assetId,
+            sellAssetId: sellAsset.assetId
+        });
+        const expectedBuyAmount = (0, bignumber_1.toBaseUnit)((0, bignumber_1.fromBaseUnit)((0, bignumber_1.bnOrZero)(sellAmount).dividedBy(priceRatio), sellAsset.precision), buyAsset.precision);
+        const isValidSlippageRange = (0, bignumber_1.bnOrZero)(slippageTolerance).gte(0) && (0, bignumber_1.bnOrZero)(slippageTolerance).lte(1);
+        if ((0, bignumber_1.bnOrZero)(expectedBuyAmount).lt(0) || !isValidSlippageRange)
+            throw new api_1.SwapError('[getThorTxInfo]: bad expected buy amount or bad slippage tolerance', {
+                code: api_1.SwapErrorTypes.BUILD_TRADE_FAILED,
+                details: { expectedBuyAmount, slippageTolerance }
+            });
+        const limit = (0, bignumber_1.bnOrZero)(expectedBuyAmount)
+            .times((0, bignumber_1.bn)(1).minus(slippageTolerance))
+            .decimalPlaces(0)
+            .toString();
+        const memo = (0, makeSwapMemo_1.makeSwapMemo)({
+            buyAssetId: buyAsset.assetId,
+            destinationAddress,
+            limit
+        });
+        const adapter = deps.adapterManager.get(caip_1.btcChainId);
+        const pubkey = await adapter.getPublicKey(wallet, bip44Params, accountType);
+        return {
+            opReturnData: memo,
+            vault,
+            pubkey: pubkey.xpub
+        };
+    }
+    catch (e) {
+        if (e instanceof api_1.SwapError)
+            throw e;
+        throw new api_1.SwapError('[getThorTxInfo]', { cause: e, code: api_1.SwapErrorTypes.TRADE_QUOTE_FAILED });
+    }
+};
+exports.getThorTxInfo = getThorTxInfo;

package/dist/swappers/thorchain/utils/ethereum/makeTradeTx.js

@@ -14,8 +14,7 @@ const makeTradeTx = async ({ wallet, bip44Params, sellAmount, buyAsset, sellAsse
             buyAsset,
             sellAmount,
             slippageTolerance,
-            destinationAddress,
-            isErc20Trade
+            destinationAddress
         });
         return adapter.buildCustomTx({
             wallet,

package/dist/swappers/thorchain/utils/ethereum/utils/getThorTxData.d.ts

@@ -1,15 +1,18 @@
 import { Asset } from '@shapeshiftoss/types';
 import { ThorchainSwapperDeps } from '../../../types';
-export declare const getThorTxInfo: ({ deps, sellAsset, buyAsset, sellAmount, slippageTolerance, destinationAddress, isErc20Trade }: {
+declare type GetBtcThorTxInfoArgs = {
     deps: ThorchainSwapperDeps;
     sellAsset: Asset;
     buyAsset: Asset;
     sellAmount: string;
     slippageTolerance: string;
     destinationAddress: string;
-    isErc20Trade: boolean;
-}) => Promise<{
-    data: any;
+};
+declare type GetBtcThorTxInfoReturn = Promise<{
+    data: string;
     memo: string;
     router: string;
 }>;
+declare type GetBtcThorTxInfo = (args: GetBtcThorTxInfoArgs) => GetBtcThorTxInfoReturn;
+export declare const getThorTxInfo: GetBtcThorTxInfo;
+export {};

package/dist/swappers/thorchain/utils/ethereum/utils/getThorTxData.js

@@ -8,9 +8,10 @@ const getPriceRatio_1 = require("../../getPriceRatio/getPriceRatio");
 const makeSwapMemo_1 = require("../../makeSwapMemo/makeSwapMemo");
 const thorService_1 = require("../../thorService");
 const routerCalldata_1 = require("../routerCalldata");
-const getThorTxInfo = async ({ deps, sellAsset, buyAsset, sellAmount, slippageTolerance, destinationAddress, isErc20Trade }) => {
+const getThorTxInfo = async ({ deps, sellAsset, buyAsset, sellAmount, slippageTolerance, destinationAddress }) => {
     try {
-        const { assetReference } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+        const { assetReference, assetNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+        const isErc20Trade = assetNamespace === 'erc20';
         const { data: inboundAddresses } = await thorService_1.thorService.get(`${deps.midgardUrl}/thorchain/inbound_addresses`);
         const ethInboundAddresses = inboundAddresses.find((inbound) => inbound.chain === 'ETH');
         const vault = ethInboundAddresses === null || ethInboundAddresses === void 0 ? void 0 : ethInboundAddresses.address;
@@ -25,10 +26,11 @@ const getThorTxInfo = async ({ deps, sellAsset, buyAsset, sellAmount, slippageTo
             sellAssetId: sellAsset.assetId
         });
         const expectedBuyAmount = (0, bignumber_1.toBaseUnit)((0, bignumber_1.fromBaseUnit)((0, bignumber_1.bnOrZero)(sellAmount).dividedBy(priceRatio), sellAsset.precision), buyAsset.precision);
-        if (!(0, bignumber_1.bnOrZero)(expectedBuyAmount).gte(0) ||
-            !((0, bignumber_1.bnOrZero)(slippageTolerance).gte(0) && (0, bignumber_1.bnOrZero)(slippageTolerance).lte(1)))
+        const isValidSlippageRange = (0, bignumber_1.bnOrZero)(slippageTolerance).gte(0) && (0, bignumber_1.bnOrZero)(slippageTolerance).lte(1);
+        if ((0, bignumber_1.bnOrZero)(expectedBuyAmount).lt(0) || !isValidSlippageRange)
             throw new api_1.SwapError('[makeTradeTx]: bad expected buy amount or bad slippage tolerance', {
-                code: api_1.SwapErrorTypes.BUILD_TRADE_FAILED
+                code: api_1.SwapErrorTypes.BUILD_TRADE_FAILED,
+                details: { expectedBuyAmount, slippageTolerance }
             });
         const limit = (0, bignumber_1.bnOrZero)(expectedBuyAmount)
             .times((0, bignumber_1.bn)(1).minus(slippageTolerance))

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

@@ -21,6 +21,11 @@ export declare type GetERC20AllowanceArgs = {
     ownerAddress: string;
     spenderAddress: string;
 };
+export declare type GetApproveContractDataArgs = {
+    web3: Web3;
+    spenderAddress: string;
+    contractAddress: string;
+};
 declare type GrantAllowanceArgs<T extends EvmSupportedChainIds> = {
     quote: TradeQuote<T>;
     wallet: HDWallet;
@@ -38,4 +43,5 @@ export declare const grantAllowance: <T extends EvmSupportedChainIds>({ quote, w
  */
 export declare const normalizeAmount: (amount: string | number | BN) => string;
 export declare const normalizeIntegerAmount: (amount: string | number | BN) => string;
+export declare const getApproveContractData: ({ web3, spenderAddress, contractAddress }: GetApproveContractDataArgs) => string;
 export {};

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

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeIntegerAmount = exports.normalizeAmount = exports.grantAllowance = exports.getAllowanceRequired = exports.getERC20Allowance = void 0;
+exports.getApproveContractData = 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");
+const constants_1 = require("../../cow/utils/constants");
+const erc20_abi_1 = require("../abi/erc20-abi");
 const bignumber_1 = require("../bignumber");
 const getERC20Allowance = async ({ erc20AllowanceAbi, web3, sellAssetErc20Address, ownerAddress, spenderAddress }) => {
     const erc20Contract = new web3.eth.Contract(erc20AllowanceAbi, sellAssetErc20Address);
@@ -115,3 +117,8 @@ const normalizeIntegerAmount = (amount) => {
         .toLocaleString('fullwide', { useGrouping: false });
 };
 exports.normalizeIntegerAmount = normalizeIntegerAmount;
+const getApproveContractData = ({ web3, spenderAddress, contractAddress }) => {
+    const contract = new web3.eth.Contract(erc20_abi_1.erc20Abi, contractAddress);
+    return contract.methods.approve(spenderAddress, constants_1.MAX_ALLOWANCE).encodeABI();
+};
+exports.getApproveContractData = getApproveContractData;

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

@@ -5,3 +5,4 @@ export declare const FOX: Asset;
 export declare const WBTC: Asset;
 export declare const ETH: Asset;
 export declare const UNSUPPORTED: Asset;
+export declare const USDC: Asset;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UNSUPPORTED = exports.ETH = exports.WBTC = exports.FOX = exports.WETH = exports.BTC = void 0;
+exports.USDC = exports.UNSUPPORTED = exports.ETH = exports.WBTC = exports.FOX = exports.WETH = exports.BTC = void 0;
 exports.BTC = {
     assetId: 'bip122:000000000019d6689c085ae165831e93/slip44:0',
     chainId: 'bip122:000000000019d6689c085ae165831e93',
@@ -73,3 +73,15 @@ exports.UNSUPPORTED = {
     explorerTxLink: 'https://etherscan.io/tx/',
     explorerAddressLink: 'https://etherscan.io/address/'
 };
+exports.USDC = {
+    assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    chainId: 'eip155:1',
+    symbol: 'USDC',
+    name: 'USD Coin',
+    precision: 6,
+    color: '#2373CB',
+    icon: 'https://rawcdn.githack.com/trustwallet/assets/master/blockchains/ethereum/assets/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48/logo.png',
+    explorer: 'https://etherscan.io',
+    explorerAddressLink: 'https://etherscan.io/address/',
+    explorerTxLink: 'https://etherscan.io/tx/'
+};

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

@@ -1,3 +1,4 @@
+import { HDWallet } from '@shapeshiftoss/hdwallet-core';
 import { Asset, KnownChainIds } from '@shapeshiftoss/types';
 import { TradeQuote } from '../../../api';
 export declare const setupQuote: () => {
@@ -6,3 +7,22 @@ export declare const setupQuote: () => {
     buyAsset: Asset;
     sellAsset: Asset;
 };
+export declare const setupBuildTrade: () => {
+    buildTradeInput: {
+        sellAsset: Asset;
+        buyAsset: Asset;
+        sellAmount: string;
+        sendMax: boolean;
+        sellAssetAccountNumber: number;
+        wallet: HDWallet;
+        receiveAddress: string;
+    } & {
+        chainId: import("../../../api").EvmSupportedChainIds;
+    } & {
+        buyAssetAccountNumber: number;
+        slippage?: string | undefined;
+        wallet: HDWallet;
+    };
+    buyAsset: Asset;
+    sellAsset: Asset;
+};

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupQuote = void 0;
+exports.setupBuildTrade = exports.setupQuote = void 0;
 const types_1 = require("@shapeshiftoss/types");
 const assets_1 = require("./assets");
 const setupQuote = () => {
@@ -25,8 +25,27 @@ const setupQuote = () => {
         sellAsset,
         buyAsset,
         sellAssetAccountNumber: 0,
-        sendMax: false
+        sendMax: false,
+        receiveAddress: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+        wallet: {}
     };
     return { quoteInput, tradeQuote, buyAsset, sellAsset };
 };
 exports.setupQuote = setupQuote;
+const setupBuildTrade = () => {
+    const sellAsset = { ...assets_1.FOX };
+    const buyAsset = { ...assets_1.WETH };
+    const buildTradeInput = {
+        chainId: types_1.KnownChainIds.EthereumMainnet,
+        sellAmount: '1000000000000000000',
+        buyAsset,
+        sendMax: false,
+        sellAssetAccountNumber: 0,
+        buyAssetAccountNumber: 0,
+        sellAsset,
+        wallet: {},
+        receiveAddress: ''
+    };
+    return { buildTradeInput, buyAsset, sellAsset };
+};
+exports.setupBuildTrade = setupBuildTrade;

package/dist/swappers/zrx/ZrxSwapper.d.ts

@@ -3,7 +3,7 @@ import { Asset } from '@shapeshiftoss/types';
 import { ApprovalNeededInput, ApprovalNeededOutput, ApproveInfiniteInput, BuildTradeInput, BuyAssetBySellIdInput, EvmSupportedChainIds, GetEvmTradeQuoteInput, Swapper, SwapperType, TradeQuote, TradeResult, TradeTxs } from '../../api';
 import { ZrxExecuteTradeInput, ZrxSwapperDeps, ZrxTrade } from './types';
 export declare class ZrxSwapper<T extends EvmSupportedChainIds> implements Swapper<T> {
-    static swapperName: string;
+    readonly name = "0x";
     deps: ZrxSwapperDeps;
     chainId: ChainId;
     constructor(deps: ZrxSwapperDeps);

package/dist/swappers/zrx/ZrxSwapper.js

@@ -12,6 +12,7 @@ const zrxBuildTrade_1 = require("./zrxBuildTrade/zrxBuildTrade");
 const zrxExecuteTrade_1 = require("./zrxExecuteTrade/zrxExecuteTrade");
 class ZrxSwapper {
     constructor(deps) {
+        this.name = '0x';
         this.deps = deps;
         this.chainId = deps.adapter.getChainId();
     }
@@ -62,4 +63,3 @@ class ZrxSwapper {
     }
 }
 exports.ZrxSwapper = ZrxSwapper;
-ZrxSwapper.swapperName = 'ZrxSwapper';

package/dist/swappers/zrx/utils/test-data/setupZrxSwapQuote.d.ts

@@ -1,4 +1,3 @@
-import { HDWallet } from '@shapeshiftoss/hdwallet-core';
 import { Asset } from '@shapeshiftoss/types';
 import { ZrxQuoteResponse } from '../../types';
 export declare const setupZrxTradeQuoteResponse: () => {
@@ -6,24 +5,6 @@ export declare const setupZrxTradeQuoteResponse: () => {
     buyAsset: Asset;
     sellAsset: Asset;
 };
-export declare const setupBuildTrade: () => {
-    buildTradeInput: {
-        sellAsset: Asset;
-        buyAsset: Asset;
-        sellAmount: string;
-        sendMax: boolean;
-        sellAssetAccountNumber: number;
-        wallet?: HDWallet | undefined;
-    } & {
-        chainId: import("../../../../api").EvmSupportedChainIds;
-    } & {
-        buyAssetAccountNumber: number;
-        slippage?: string | undefined;
-        wallet: HDWallet;
-    };
-    buyAsset: Asset;
-    sellAsset: Asset;
-};
 export declare const setupExecuteTrade: () => {
     executeTradeInput: {
         sellAmount: string;

package/dist/swappers/zrx/utils/test-data/setupZrxSwapQuote.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupExecuteTrade = exports.setupBuildTrade = exports.setupZrxTradeQuoteResponse = void 0;
-const types_1 = require("@shapeshiftoss/types");
+exports.setupExecuteTrade = exports.setupZrxTradeQuoteResponse = void 0;
 const assets_1 = require("../../../utils/test-data/assets");
 const setupZrxTradeQuoteResponse = () => {
     const sellAsset = { ...assets_1.FOX };
@@ -20,22 +19,6 @@ const setupZrxTradeQuoteResponse = () => {
     return { quoteResponse, buyAsset, sellAsset };
 };
 exports.setupZrxTradeQuoteResponse = setupZrxTradeQuoteResponse;
-const setupBuildTrade = () => {
-    const sellAsset = { ...assets_1.FOX };
-    const buyAsset = { ...assets_1.WETH };
-    const buildTradeInput = {
-        chainId: types_1.KnownChainIds.EthereumMainnet,
-        sellAmount: '1000000000000000000',
-        buyAsset,
-        sendMax: false,
-        sellAssetAccountNumber: 0,
-        buyAssetAccountNumber: 0,
-        sellAsset,
-        wallet: {}
-    };
-    return { buildTradeInput, buyAsset, sellAsset };
-};
-exports.setupBuildTrade = setupBuildTrade;
 const setupExecuteTrade = () => {
     const sellAsset = { ...assets_1.FOX };
     const buyAsset = { ...assets_1.WETH };

package/package.json

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