@shapeshiftoss/swapper 17.6.3 → 17.6.5

package/dist/swappers/cow/cowGetTradeTxs/cowGetTradeTxs.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cowGetTradeTxs = void 0;
-const api_1 = require("../../../api");
-const constants_1 = require("../utils/constants");
-const cowService_1 = require("../utils/cowService");
-async function cowGetTradeTxs(deps, input) {
-    try {
-        const getOrdersResponse = await cowService_1.cowService.get(`${deps.apiUrl}/v1/orders/${input.tradeId}`);
-        const { data: { status }, } = getOrdersResponse;
-        if (status !== constants_1.ORDER_STATUS_FULFILLED) {
-            return {
-                sellTxid: '',
-            };
-        }
-        const getTradesResponse = await cowService_1.cowService.get(`${deps.apiUrl}/v1/trades/?orderUid=${input.tradeId}`);
-        return {
-            sellTxid: input.tradeId,
-            buyTxid: getTradesResponse.data[0].txHash,
-        };
-    }
-    catch (e) {
-        if (e instanceof api_1.SwapError)
-            throw e;
-        throw new api_1.SwapError('[cowGetTradeTxs]', {
-            cause: e,
-            code: api_1.SwapErrorType.GET_TRADE_TXS_FAILED,
-        });
-    }
-}
-exports.cowGetTradeTxs = cowGetTradeTxs;

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

@@ -1,4 +0,0 @@
-import { Asset } from '@shapeshiftoss/asset-service';
-import { MinMaxOutput } from '../../../api';
-import { CowSwapperDeps } from '../CowSwapper';
-export declare const getCowSwapMinMax: (deps: CowSwapperDeps, sellAsset: Asset, buyAsset: Asset) => Promise<MinMaxOutput>;

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

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCowSwapMinMax = 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 getCowSwapMinMax = async (deps, sellAsset, buyAsset) => {
-    try {
-        const { assetNamespace: sellAssetNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
-        const { chainId: buyAssetChainId } = (0, caip_1.fromAssetId)(buyAsset.assetId);
-        if (sellAssetNamespace !== 'erc20' || buyAssetChainId !== types_1.KnownChainIds.EthereumMainnet) {
-            throw new api_1.SwapError('[getCowSwapMinMax]', { code: api_1.SwapErrorType.UNSUPPORTED_PAIR });
-        }
-        const usdRate = await (0, helpers_1.getUsdRate)(deps, sellAsset);
-        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,
-            maximum,
-        };
-    }
-    catch (e) {
-        if (e instanceof api_1.SwapError)
-            throw e;
-        throw new api_1.SwapError('[getCowSwapMinMax]', { cause: e, code: api_1.SwapErrorType.MIN_MAX_FAILED });
-    }
-};
-exports.getCowSwapMinMax = getCowSwapMinMax;

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

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

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

@@ -1,145 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCowSwapTradeQuote = void 0;
-const caip_1 = require("@shapeshiftoss/caip");
-const types_1 = require("@shapeshiftoss/types");
-const axios_1 = __importDefault(require("axios"));
-const api_1 = require("../../../api");
-const bignumber_1 = require("../../utils/bignumber");
-const helpers_1 = require("../../utils/helpers/helpers");
-const getCowSwapMinMax_1 = require("../getCowSwapMinMax/getCowSwapMinMax");
-const constants_1 = require("../utils/constants");
-const cowService_1 = require("../utils/cowService");
-const helpers_2 = require("../utils/helpers/helpers");
-async function getCowSwapTradeQuote(deps, input) {
-    var _a, _b;
-    try {
-        const { sellAsset, buyAsset, sellAmountBeforeFeesCryptoBaseUnit, accountNumber, receiveAddress, } = input;
-        const { adapter, web3 } = deps;
-        const { assetReference: sellAssetErc20Address, assetNamespace: sellAssetNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
-        const { assetReference: buyAssetErc20Address, chainId: buyAssetChainId } = (0, caip_1.fromAssetId)(buyAsset.assetId);
-        if (sellAssetNamespace !== 'erc20') {
-            throw new api_1.SwapError('[getCowSwapTradeQuote] - Sell asset needs to be ERC-20 to use CowSwap', {
-                code: api_1.SwapErrorType.UNSUPPORTED_PAIR,
-                details: { sellAssetNamespace },
-            });
-        }
-        if (buyAssetChainId !== types_1.KnownChainIds.EthereumMainnet) {
-            throw new api_1.SwapError('[getCowSwapTradeQuote] - Buy asset needs to be on ETH mainnet to use CowSwap', {
-                code: api_1.SwapErrorType.UNSUPPORTED_PAIR,
-                details: { buyAssetChainId },
-            });
-        }
-        const buyToken = buyAsset.assetId !== caip_1.ethAssetId ? buyAssetErc20Address : constants_1.COW_SWAP_ETH_MARKER_ADDRESS;
-        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));
-        const isSellAmountBelowMinimum = (0, bignumber_1.bnOrZero)(sellAmountBeforeFeesCryptoBaseUnit).lt(minQuoteSellAmount);
-        // making sure we do not have decimals for cowswap api (can happen at least from minQuoteSellAmount)
-        const normalizedSellAmountCryptoBaseUnit = (0, helpers_1.normalizeIntegerAmount)(isSellAmountBelowMinimum ? minQuoteSellAmount : sellAmountBeforeFeesCryptoBaseUnit);
-        const apiInput = {
-            sellToken: sellAssetErc20Address,
-            buyToken,
-            receiver: constants_1.DEFAULT_ADDRESS,
-            validTo: (0, helpers_2.getNowPlusThirtyMinutesTimestamp)(),
-            appData: constants_1.DEFAULT_APP_DATA,
-            partiallyFillable: false,
-            from: constants_1.DEFAULT_ADDRESS,
-            kind: constants_1.ORDER_KIND_SELL,
-            sellAmountBeforeFee: normalizedSellAmountCryptoBaseUnit,
-        };
-        /**
-         * /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: { buyAmount: buyAmountCryptoBaseUnit, sellAmount: sellAmountCryptoBaseUnit, feeAmount: feeAmountInSellTokenCryptoBaseUnit, }, }, } = quoteResponse;
-        const quoteSellAmountPlusFeesCryptoBaseUnit = (0, bignumber_1.bnOrZero)(sellAmountCryptoBaseUnit).plus(feeAmountInSellTokenCryptoBaseUnit);
-        const buyCryptoAmount = (0, bignumber_1.bn)(buyAmountCryptoBaseUnit).div((0, bignumber_1.bn)(10).exponentiatedBy(buyAsset.precision));
-        const sellCryptoAmount = (0, bignumber_1.bn)(sellAmountCryptoBaseUnit).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, sellAssetUsdRate] = await Promise.all([
-            adapter.getFeeData({
-                to: sellAssetErc20Address,
-                value: '0',
-                chainSpecific: { from: receiveAddress, contractData: data },
-            }),
-            (0, helpers_2.getUsdRate)(deps, sellAsset),
-        ]);
-        const sellAssetTradeFeeUsd = (0, bignumber_1.bnOrZero)(feeAmountInSellTokenCryptoBaseUnit)
-            .div((0, bignumber_1.bn)(10).exponentiatedBy(sellAsset.precision))
-            .multipliedBy((0, bignumber_1.bnOrZero)(sellAssetUsdRate))
-            .toString();
-        const feeData = feeDataOptions['fast'];
-        const isQuoteSellAmountBelowMinimum = (0, bignumber_1.bnOrZero)(quoteSellAmountPlusFeesCryptoBaseUnit).lt(minQuoteSellAmount);
-        // If isQuoteSellAmountBelowMinimum we don't want to replace it with normalizedSellAmount
-        // The purpose of this was to get a quote from CowSwap even with small amounts
-        const quoteSellAmountCryptoBaseUnit = isQuoteSellAmountBelowMinimum
-            ? sellAmountBeforeFeesCryptoBaseUnit
-            : normalizedSellAmountCryptoBaseUnit;
-        // Similarly, if isQuoteSellAmountBelowMinimum we can't use the buy amount from the quote
-        // because we aren't actually selling the minimum amount (we are attempting to sell an amount less than it)
-        const quoteBuyAmountCryptoBaseUnit = isQuoteSellAmountBelowMinimum
-            ? '0'
-            : buyAmountCryptoBaseUnit;
-        return {
-            rate,
-            minimumCryptoHuman: minimum,
-            maximum,
-            feeData: {
-                networkFeeCryptoBaseUnit: '0',
-                chainSpecific: {
-                    estimatedGas: feeData.chainSpecific.gasLimit,
-                    gasPriceCryptoBaseUnit: feeData.chainSpecific.gasPrice,
-                    approvalFeeCryptoBaseUnit: (0, bignumber_1.bnOrZero)(feeData.chainSpecific.gasLimit)
-                        .multipliedBy((0, bignumber_1.bnOrZero)(feeData.chainSpecific.gasPrice))
-                        .toString(),
-                },
-                buyAssetTradeFeeUsd: '0',
-                sellAssetTradeFeeUsd,
-            },
-            sellAmountBeforeFeesCryptoBaseUnit: quoteSellAmountCryptoBaseUnit,
-            buyAmountCryptoBaseUnit: quoteBuyAmountCryptoBaseUnit,
-            sources: constants_1.DEFAULT_SOURCE,
-            allowanceContract: constants_1.COW_SWAP_VAULT_RELAYER_ADDRESS,
-            buyAsset,
-            sellAsset,
-            accountNumber,
-        };
-    }
-    catch (e) {
-        if (axios_1.default.isAxiosError(e) &&
-            ((_a = e.response) === null || _a === void 0 ? void 0 : _a.status) === 400 &&
-            ((_b = e.response) === null || _b === void 0 ? void 0 : _b.data.errorType) ===
-                'SellAmountDoesNotCoverFee') {
-            throw new api_1.SwapError('[getCowSwapTradeQuote]', {
-                cause: e,
-                code: api_1.SwapErrorType.TRADE_QUOTE_INPUT_LOWER_THAN_FEES,
-            });
-        }
-        if (e instanceof api_1.SwapError)
-            throw e;
-        throw new api_1.SwapError('[getCowSwapTradeQuote]', {
-            cause: e,
-            code: api_1.SwapErrorType.TRADE_QUOTE_FAILED,
-        });
-    }
-}
-exports.getCowSwapTradeQuote = getCowSwapTradeQuote;

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

@@ -1,29 +0,0 @@
-import { ChainId } from '@shapeshiftoss/caip';
-import { Trade } from '../../api';
-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;
-};
-export declare type CowSwapGetOrdersResponse = {
-    status: string;
-};
-export declare type CowSwapGetTradesElement = {
-    txHash: string;
-};
-export declare type CowSwapGetTradesResponse = CowSwapGetTradesElement[];
-export interface CowTrade<C extends ChainId> extends Trade<C> {
-    feeAmountInSellTokenCryptoBaseUnit: string;
-    sellAmountDeductFeeCryptoBaseUnit: string;
-}

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

@@ -1,19 +0,0 @@
-import { SwapperName } from '../../../api';
-export declare const MAX_ALLOWANCE = "100000000000000000000000000";
-export declare const MAX_COWSWAP_TRADE = "100000000000000000000000000";
-export declare const MIN_COWSWAP_VALUE_USD = 20;
-export declare const DEFAULT_SOURCE: {
-    name: SwapperName;
-    proportion: string;
-}[];
-export declare const DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
-export declare const DEFAULT_APP_DATA = "0x68a7b5781dfe48bd5d7aeb11261c17517f5c587da682e4fade9b6a00a59b8970";
-export declare const COW_SWAP_VAULT_RELAYER_ADDRESS = "0xc92e8bdf79f0507f65a392b0ab4667716bfe0110";
-export declare const COW_SWAP_SETTLEMENT_ADDRESS = "0x9008D19f58AAbD9eD0D60971565AA8510560ab41";
-export declare const WETH_ASSET_ID = "eip155:1/erc20:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
-export declare const ORDER_KIND_SELL = "sell";
-export declare const ORDER_KIND_BUY = "buy";
-export declare const SIGNING_SCHEME = "ethsign";
-export declare const ERC20_TOKEN_BALANCE = "erc20";
-export declare const ORDER_STATUS_FULFILLED = "fulfilled";
-export declare const COW_SWAP_ETH_MARKER_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";

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

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.COW_SWAP_ETH_MARKER_ADDRESS = exports.ORDER_STATUS_FULFILLED = exports.ERC20_TOKEN_BALANCE = exports.SIGNING_SCHEME = exports.ORDER_KIND_BUY = exports.ORDER_KIND_SELL = exports.WETH_ASSET_ID = exports.COW_SWAP_SETTLEMENT_ADDRESS = 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");
-const api_1 = require("../../../api");
-exports.MAX_ALLOWANCE = '100000000000000000000000000';
-exports.MAX_COWSWAP_TRADE = '100000000000000000000000000';
-exports.MIN_COWSWAP_VALUE_USD = 20;
-exports.DEFAULT_SOURCE = [{ name: api_1.SwapperName.CowSwap, proportion: '1' }];
-exports.DEFAULT_ADDRESS = constants_1.AddressZero;
-exports.DEFAULT_APP_DATA = '0x68a7b5781dfe48bd5d7aeb11261c17517f5c587da682e4fade9b6a00a59b8970';
-exports.COW_SWAP_VAULT_RELAYER_ADDRESS = '0xc92e8bdf79f0507f65a392b0ab4667716bfe0110';
-exports.COW_SWAP_SETTLEMENT_ADDRESS = '0x9008D19f58AAbD9eD0D60971565AA8510560ab41';
-exports.WETH_ASSET_ID = 'eip155:1/erc20:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2';
-exports.ORDER_KIND_SELL = 'sell';
-exports.ORDER_KIND_BUY = 'buy';
-exports.SIGNING_SCHEME = 'ethsign';
-exports.ERC20_TOKEN_BALANCE = 'erc20';
-exports.ORDER_STATUS_FULFILLED = 'fulfilled';
-// Address used by CowSwap to buy ETH
-// See https://github.com/gnosis/gp-v2-contracts/commit/821b5a8da213297b0f7f1d8b17c893c5627020af#diff-12bbbe13cd5cf42d639e34a39d8795021ba40d3ee1e1a8282df652eb161a11d6R13
-exports.COW_SWAP_ETH_MARKER_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';

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

@@ -1 +0,0 @@
-export declare const cowService: import("axios").AxiosInstance;

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

@@ -1,20 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cowService = void 0;
-const axios_1 = __importDefault(require("axios"));
-const utils_1 = require("../../../utils");
-const maxAge = 5 * 1000; // 5 seconds
-const cachedUrls = ['/mainnet/api/v1/quote'];
-const cache = (0, utils_1.createCache)(maxAge, cachedUrls);
-const axiosConfig = {
-    timeout: 10000,
-    headers: {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-    },
-    adapter: cache.adapter,
-};
-exports.cowService = axios_1.default.create(axiosConfig);

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

@@ -1,57 +0,0 @@
-import { TypedDataDomain, TypedDataField } from '@ethersproject/abstract-signer';
-import { Asset } from '@shapeshiftoss/asset-service';
-import { CowSwapperDeps } from '../../CowSwapper';
-export declare const ORDER_TYPE_FIELDS: {
-    name: string;
-    type: string;
-}[];
-/**
- * EIP-712 typed data type definitions.
- */
-export declare type TypedDataTypes = Record<string, TypedDataField[]>;
-export declare type CowSwapOrder = {
-    sellToken: string;
-    buyToken: string;
-    sellAmount: string;
-    buyAmount: string;
-    validTo: number;
-    appData: string;
-    feeAmount: string;
-    kind: string;
-    partiallyFillable: boolean;
-    receiver: string;
-    sellTokenBalance: string;
-    buyTokenBalance: string;
-};
-export declare type CowSwapQuoteApiInputBase = {
-    appData: string;
-    buyToken: string;
-    from: string;
-    kind: string;
-    partiallyFillable: boolean;
-    receiver: string;
-    sellToken: string;
-    validTo: number;
-};
-export declare type CowSwapSellQuoteApiInput = CowSwapQuoteApiInputBase & {
-    sellAmountBeforeFee: string;
-};
-export declare type CowSwapBuyQuoteApiInput = CowSwapQuoteApiInputBase & {
-    buyAmountAfterFee: string;
-};
-export declare const getNowPlusThirtyMinutesTimestamp: () => number;
-export declare const getUsdRate: ({ apiUrl }: CowSwapperDeps, input: Asset) => Promise<string>;
-export declare const hashTypedData: (domain: TypedDataDomain, types: TypedDataTypes, data: Record<string, unknown>) => string;
-/**
- * Compute the 32-byte signing hash for the specified order.
- * Implementation is following https://github.com/cowprotocol/contracts/blob/main/src/ts/order.ts
- * Some more ressources that can be useful :
- * https://docs.cow.fi/tutorials/how-to-submit-orders-via-the-api/4.-signing-the-order
- * https://docs.cow.fi/smart-contracts/settlement-contract/signature-schemes
- *
- * @param domain The EIP-712 domain separator to compute the hash for.
- * @param order The order to compute the digest for.
- * @return Hex-encoded 32-byte order digest.
- */
-export declare const hashOrder: (domain: TypedDataDomain, order: CowSwapOrder) => string;
-export declare const domain: (chainId: number, verifyingContract: string) => TypedDataDomain;

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

@@ -1,124 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.domain = exports.hashOrder = exports.hashTypedData = exports.getUsdRate = exports.getNowPlusThirtyMinutesTimestamp = exports.ORDER_TYPE_FIELDS = void 0;
-const asset_service_1 = require("@shapeshiftoss/asset-service");
-const caip_1 = require("@shapeshiftoss/caip");
-const ethers_1 = require("ethers");
-const api_1 = require("../../../../api");
-const bignumber_1 = require("../../../utils/bignumber");
-const constants_1 = require("../constants");
-const cowService_1 = require("../cowService");
-const USDC_CONTRACT_ADDRESS = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48';
-const USDC_ASSET_PRECISION = 6;
-exports.ORDER_TYPE_FIELDS = [
-    { name: 'sellToken', type: 'address' },
-    { name: 'buyToken', type: 'address' },
-    { name: 'receiver', type: 'address' },
-    { name: 'sellAmount', type: 'uint256' },
-    { name: 'buyAmount', type: 'uint256' },
-    { name: 'validTo', type: 'uint32' },
-    { name: 'appData', type: 'bytes32' },
-    { name: 'feeAmount', type: 'uint256' },
-    { name: 'kind', type: 'string' },
-    { name: 'partiallyFillable', type: 'bool' },
-    { name: 'sellTokenBalance', type: 'string' },
-    { name: 'buyTokenBalance', type: 'string' },
-];
-const getNowPlusThirtyMinutesTimestamp = () => {
-    const ts = new Date();
-    ts.setMinutes(ts.getMinutes() + 30);
-    return Math.round(ts.getTime() / 1000);
-};
-exports.getNowPlusThirtyMinutesTimestamp = getNowPlusThirtyMinutesTimestamp;
-const getUsdRate = async ({ apiUrl }, 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 : new asset_service_1.AssetService().getAll()[constants_1.WETH_ASSET_ID];
-    const { assetReference: erc20Address, assetNamespace } = (0, caip_1.fromAssetId)(asset.assetId);
-    if (assetNamespace !== 'erc20') {
-        throw new api_1.SwapError('[getUsdRate] - unsupported asset namespace', {
-            code: api_1.SwapErrorType.USD_RATE_FAILED,
-            details: { assetNamespace },
-        });
-    }
-    if (erc20Address === USDC_CONTRACT_ADDRESS) {
-        return '1';
-    }
-    // rate is imprecise for low $ values, hence asking for $1000
-    const buyAmountInDollars = 1000;
-    const buyAmount = (0, bignumber_1.bn)(buyAmountInDollars)
-        .times((0, bignumber_1.bn)(10).exponentiatedBy(USDC_ASSET_PRECISION))
-        .toString();
-    try {
-        const apiInput = {
-            sellToken: erc20Address,
-            buyToken: USDC_CONTRACT_ADDRESS,
-            receiver: constants_1.DEFAULT_ADDRESS,
-            validTo: (0, exports.getNowPlusThirtyMinutesTimestamp)(),
-            appData: constants_1.DEFAULT_APP_DATA,
-            partiallyFillable: false,
-            from: constants_1.DEFAULT_ADDRESS,
-            kind: constants_1.ORDER_KIND_BUY,
-            buyAmountAfterFee: buyAmount,
-        };
-        /**
-         * /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(`${apiUrl}/v1/quote/`, apiInput);
-        const { data: { quote: { sellAmount: sellAmountCryptoBaseUnit }, }, } = quoteResponse;
-        const sellAmountCryptoPrecision = (0, bignumber_1.bn)(sellAmountCryptoBaseUnit).div((0, bignumber_1.bn)(10).exponentiatedBy(asset.precision));
-        if (!sellAmountCryptoPrecision.gt(0))
-            throw new api_1.SwapError('[getUsdRate] - Failed to get sell token amount', {
-                code: api_1.SwapErrorType.RESPONSE_ERROR,
-            });
-        // dividing $1000 by amount of sell token received
-        return (0, bignumber_1.bn)(buyAmountInDollars).div(sellAmountCryptoPrecision).toString();
-    }
-    catch (e) {
-        if (e instanceof api_1.SwapError)
-            throw e;
-        throw new api_1.SwapError('[getUsdRate]', {
-            cause: e,
-            code: api_1.SwapErrorType.USD_RATE_FAILED,
-        });
-    }
-};
-exports.getUsdRate = getUsdRate;
-const hashTypedData = (domain, types, data) => {
-    return ethers_1.ethers.utils._TypedDataEncoder.hash(domain, types, data);
-};
-exports.hashTypedData = hashTypedData;
-/**
- * Compute the 32-byte signing hash for the specified order.
- * Implementation is following https://github.com/cowprotocol/contracts/blob/main/src/ts/order.ts
- * Some more ressources that can be useful :
- * https://docs.cow.fi/tutorials/how-to-submit-orders-via-the-api/4.-signing-the-order
- * https://docs.cow.fi/smart-contracts/settlement-contract/signature-schemes
- *
- * @param domain The EIP-712 domain separator to compute the hash for.
- * @param order The order to compute the digest for.
- * @return Hex-encoded 32-byte order digest.
- */
-const hashOrder = (domain, order) => {
-    return (0, exports.hashTypedData)(domain, { Order: exports.ORDER_TYPE_FIELDS }, order);
-};
-exports.hashOrder = hashOrder;
-const domain = (chainId, verifyingContract) => {
-    return {
-        name: 'Gnosis Protocol',
-        version: 'v2',
-        chainId,
-        verifyingContract,
-    };
-};
-exports.domain = domain;

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

@@ -1,4 +0,0 @@
-import { ChainId } from '@shapeshiftoss/caip';
-import { Trade } from '../../api';
-import { CowTrade } from './types';
-export declare const isCowTrade: <C extends ChainId>(trade: CowTrade<C> | Trade<C>) => trade is CowTrade<C>;

package/dist/swappers/cow/utils.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCowTrade = void 0;
-const isCowTrade = (trade) => Boolean(trade.feeAmountInSellTokenCryptoBaseUnit);
-exports.isCowTrade = isCowTrade;

package/dist/swappers/index.d.ts

@@ -1,7 +0,0 @@
-export * from './zrx/ZrxSwapper';
-export * from './thorchain/ThorchainSwapper';
-export { getInboundAddressDataForChain } from './thorchain/utils/getInboundAddressDataForChain';
-export * from './test/TestSwapper';
-export * from './osmosis/OsmosisSwapper';
-export * from './cow/CowSwapper';
-export { isRune } from './thorchain/utils/isRune/isRune';

package/dist/swappers/index.js

@@ -1,26 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRune = exports.getInboundAddressDataForChain = void 0;
-__exportStar(require("./zrx/ZrxSwapper"), exports);
-__exportStar(require("./thorchain/ThorchainSwapper"), exports);
-var getInboundAddressDataForChain_1 = require("./thorchain/utils/getInboundAddressDataForChain");
-Object.defineProperty(exports, "getInboundAddressDataForChain", { enumerable: true, get: function () { return getInboundAddressDataForChain_1.getInboundAddressDataForChain; } });
-__exportStar(require("./test/TestSwapper"), exports);
-__exportStar(require("./osmosis/OsmosisSwapper"), exports);
-__exportStar(require("./cow/CowSwapper"), exports);
-var isRune_1 = require("./thorchain/utils/isRune/isRune");
-Object.defineProperty(exports, "isRune", { enumerable: true, get: function () { return isRune_1.isRune; } });

package/dist/swappers/osmosis/OsmosisSwapper.d.ts

@@ -1,28 +0,0 @@
-import { Asset } from '@shapeshiftoss/asset-service';
-import { AssetId, ChainId } from '@shapeshiftoss/caip';
-import { cosmos, osmosis } from '@shapeshiftoss/chain-adapters';
-import { KnownChainIds } from '@shapeshiftoss/types';
-import { ApprovalNeededOutput, BuildTradeInput, BuyAssetBySellIdInput, ExecuteTradeInput, GetTradeQuoteInput, MinMaxOutput, Swapper, SwapperName, SwapperType, Trade, TradeQuote, TradeTxs } from '../../api';
-import { OsmosisTradeResult, OsmoSwapperDeps } from './utils/types';
-export declare type OsmosisSupportedChainId = KnownChainIds.CosmosMainnet | KnownChainIds.OsmosisMainnet;
-export declare type OsmosisSupportedChainAdapter = cosmos.ChainAdapter | osmosis.ChainAdapter;
-export declare class OsmosisSwapper implements Swapper<ChainId> {
-    readonly name = SwapperName.Osmosis;
-    supportedAssetIds: string[];
-    deps: OsmoSwapperDeps;
-    getType(): SwapperType;
-    constructor(deps: OsmoSwapperDeps);
-    getTradeTxs(tradeResult: OsmosisTradeResult): Promise<TradeTxs>;
-    getUsdRate(input: Pick<Asset, 'symbol' | 'assetId'>): Promise<string>;
-    getMinMax(input: {
-        sellAsset: Asset;
-    }): Promise<MinMaxOutput>;
-    approvalNeeded(): Promise<ApprovalNeededOutput>;
-    approveInfinite(): Promise<string>;
-    approveAmount(): Promise<string>;
-    filterBuyAssetsBySellAssetId(args: BuyAssetBySellIdInput): string[];
-    filterAssetIdsBySellable(): AssetId[];
-    buildTrade(args: BuildTradeInput): Promise<Trade<ChainId>>;
-    getTradeQuote(input: GetTradeQuoteInput): Promise<TradeQuote<ChainId>>;
-    executeTrade({ trade, wallet }: ExecuteTradeInput<ChainId>): Promise<OsmosisTradeResult>;
-}