@shapeshiftoss/swapper 8.5.1 → 8.6.0

package/dist/api.d.ts

@@ -164,7 +164,8 @@ export declare enum SwapErrorTypes {
     VALIDATION_FAILED = "VALIDATION_FAILED",
     MAKE_MEMO_FAILED = "MAKE_MEMO_FAILED",
     PRICE_RATIO_FAILED = "PRICE_RATIO_FAILED",
-    POOL_NOT_FOUND = "POOL_NOT_FOUND"
+    POOL_NOT_FOUND = "POOL_NOT_FOUND",
+    GET_TRADE_TXS_FAILED = "GET_TRADE_TXS_FAILED"
 }
 export interface Swapper<T extends ChainId> {
     /** Human readable swapper name */

package/dist/api.js

@@ -36,4 +36,5 @@ var SwapErrorTypes;
     SwapErrorTypes["MAKE_MEMO_FAILED"] = "MAKE_MEMO_FAILED";
     SwapErrorTypes["PRICE_RATIO_FAILED"] = "PRICE_RATIO_FAILED";
     SwapErrorTypes["POOL_NOT_FOUND"] = "POOL_NOT_FOUND";
+    SwapErrorTypes["GET_TRADE_TXS_FAILED"] = "GET_TRADE_TXS_FAILED";
 })(SwapErrorTypes = exports.SwapErrorTypes || (exports.SwapErrorTypes = {}));

package/dist/manager/SwapperManager.js

@@ -25,12 +25,6 @@ class SwapperManager {
     addSwapper(swapperInstance) {
         validateSwapper(swapperInstance);
         const swapperType = swapperInstance.getType();
-        const swapper = this.swappers.get(swapperType);
-        if (swapper)
-            throw new api_1.SwapError('[addSwapper] - swapper already exists', {
-                code: api_1.SwapErrorTypes.MANAGER_ERROR,
-                details: { swapperType }
-            });
         this.swappers.set(swapperType, swapperInstance);
         return this;
     }

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

@@ -2,7 +2,8 @@ import { AssetId } from '@shapeshiftoss/caip';
 import { ethereum } from '@shapeshiftoss/chain-adapters';
 import { Asset, KnownChainIds } from '@shapeshiftoss/types';
 import Web3 from 'web3';
-import { ApprovalNeededInput, ApprovalNeededOutput, ApproveInfiniteInput, BuildTradeInput, BuyAssetBySellIdInput, ExecuteTradeInput, GetTradeQuoteInput, Swapper, SwapperType, Trade, TradeQuote, TradeResult, TradeTxs } from '../../api';
+import { ApprovalNeededInput, ApprovalNeededOutput, ApproveInfiniteInput, BuildTradeInput, BuyAssetBySellIdInput, ExecuteTradeInput, GetTradeQuoteInput, Swapper, SwapperType, TradeQuote, TradeResult, TradeTxs } from '../../api';
+import { CowTrade } from './types';
 /**
  * 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
@@ -18,7 +19,7 @@ export declare class CowSwapper implements Swapper<KnownChainIds.EthereumMainnet
     deps: CowSwapperDeps;
     constructor(deps: CowSwapperDeps);
     getType(): SwapperType;
-    buildTrade(args: BuildTradeInput): Promise<Trade<KnownChainIds.EthereumMainnet>>;
+    buildTrade(args: BuildTradeInput): Promise<CowTrade<KnownChainIds.EthereumMainnet>>;
     getTradeQuote(input: GetTradeQuoteInput): Promise<TradeQuote<KnownChainIds.EthereumMainnet>>;
     getUsdRate(input: Asset): Promise<string>;
     executeTrade(args: ExecuteTradeInput<KnownChainIds.EthereumMainnet>): Promise<TradeResult>;
@@ -26,5 +27,5 @@ export declare class CowSwapper implements Swapper<KnownChainIds.EthereumMainnet
     approveInfinite(args: ApproveInfiniteInput<KnownChainIds.EthereumMainnet>): Promise<string>;
     filterBuyAssetsBySellAssetId(args: BuyAssetBySellIdInput): AssetId[];
     filterAssetIdsBySellable(assetIds: AssetId[]): AssetId[];
-    getTradeTxs(): Promise<TradeTxs>;
+    getTradeTxs(args: TradeResult): Promise<TradeTxs>;
 }

package/dist/swappers/cow/CowSwapper.js

@@ -5,6 +5,8 @@ const api_1 = require("../../api");
 const cowApprovalNeeded_1 = require("./cowApprovalNeeded/cowApprovalNeeded");
 const cowApproveInfinite_1 = require("./cowApproveInfinite/cowApproveInfinite");
 const cowBuildTrade_1 = require("./cowBuildTrade/cowBuildTrade");
+const cowExecuteTrade_1 = require("./cowExecuteTrade/cowExecuteTrade");
+const cowGetTradeTxs_1 = require("./cowGetTradeTxs/cowGetTradeTxs");
 const getCowSwapTradeQuote_1 = require("./getCowSwapTradeQuote/getCowSwapTradeQuote");
 const blacklist_1 = require("./utils/blacklist");
 const helpers_1 = require("./utils/helpers/helpers");
@@ -26,8 +28,7 @@ class CowSwapper {
         return (0, helpers_1.getUsdRate)(this.deps, input);
     }
     async executeTrade(args) {
-        console.info(args);
-        throw new Error('CowSwapper: executeTrade unimplemented');
+        return (0, cowExecuteTrade_1.cowExecuteTrade)(this.deps, args);
     }
     async approvalNeeded(args) {
         return (0, cowApprovalNeeded_1.cowApprovalNeeded)(this.deps, args);
@@ -47,8 +48,8 @@ class CowSwapper {
     filterAssetIdsBySellable(assetIds) {
         return assetIds.filter((id) => id.startsWith('eip155:1/erc20') && !blacklist_1.COWSWAP_UNSUPPORTED_ASSETS.includes(id));
     }
-    async getTradeTxs() {
-        throw new Error('CowSwapper: executeTrade unimplemented');
+    async getTradeTxs(args) {
+        return (0, cowGetTradeTxs_1.cowGetTradeTxs)(this.deps, args);
     }
 }
 exports.CowSwapper = CowSwapper;

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

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

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

@@ -12,7 +12,7 @@ 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 { adapter, 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') {
@@ -57,36 +57,29 @@ async function cowBuildTrade(deps, input) {
             spenderAddress: constants_1.COW_SWAP_VAULT_RELAYER_ADDRESS,
             contractAddress: sellAssetErc20Address
         });
-        const [feeDataOptions, feeAssetUsdRate, sellAssetUsdRate] = await Promise.all([
+        const [feeDataOptions, 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
+        // calculating trade fee in USD
+        const tradeFeeFiat = (0, bignumber_1.bnOrZero)(quote.feeAmount)
+            .div((0, bignumber_1.bn)(10).exponentiatedBy(sellAsset.precision))
             .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();
+            .toString();
         const trade = {
             rate,
             feeData: {
-                fee,
+                fee: '0',
                 chainSpecific: {
                     estimatedGas: feeData.chainSpecific.gasLimit,
                     gasPrice: feeData.chainSpecific.gasPrice
                 },
-                tradeFee: '0'
+                tradeFee: tradeFeeFiat
             },
             sellAmount: normalizedSellAmount,
             buyAmount: quote.buyAmount,
@@ -94,7 +87,9 @@ async function cowBuildTrade(deps, input) {
             buyAsset,
             sellAsset,
             sellAssetAccountNumber,
-            receiveAddress
+            receiveAddress,
+            feeAmountInSellToken: quote.feeAmount,
+            sellAmountWithoutFee: quote.sellAmount
         };
         const allowanceRequired = await (0, helpers_1.getAllowanceRequired)({
             adapter,

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

@@ -0,0 +1,4 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { ExecuteTradeInput, TradeResult } from '../../../api';
+import { CowSwapperDeps } from '../CowSwapper';
+export declare function cowExecuteTrade({ apiUrl, adapter }: CowSwapperDeps, { trade, wallet }: ExecuteTradeInput<KnownChainIds.EthereumMainnet>): Promise<TradeResult>;

package/dist/swappers/cow/cowExecuteTrade/cowExecuteTrade.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cowExecuteTrade = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const hdwallet_core_1 = require("@shapeshiftoss/hdwallet-core");
+const ethers_1 = require("ethers");
+const api_1 = require("../../../api");
+const constants_1 = require("../utils/constants");
+const cowService_1 = require("../utils/cowService");
+const helpers_1 = require("../utils/helpers/helpers");
+async function cowExecuteTrade({ apiUrl, adapter }, { trade, wallet }) {
+    const cowTrade = trade;
+    const { sellAsset, buyAsset, feeAmountInSellToken, sellAmountWithoutFee } = cowTrade;
+    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('[cowExecuteTrade] - Both assets need to be ERC-20 to use CowSwap', {
+            code: api_1.SwapErrorTypes.UNSUPPORTED_PAIR,
+            details: { buyAssetNamespace, sellAssetNamespace }
+        });
+    }
+    try {
+        const orderToSign = {
+            sellToken: sellAssetErc20Address,
+            buyToken: buyAssetErc20Address,
+            sellAmount: sellAmountWithoutFee,
+            buyAmount: trade.buyAmount,
+            validTo: (0, helpers_1.getNowPlusThirtyMinutesTimestamp)(),
+            appData: constants_1.DEFAULT_APP_DATA,
+            feeAmount: feeAmountInSellToken,
+            kind: constants_1.ORDER_KIND_SELL,
+            partiallyFillable: false,
+            receiver: trade.receiveAddress,
+            sellTokenBalance: constants_1.ERC20_TOKEN_BALANCE,
+            buyTokenBalance: constants_1.ERC20_TOKEN_BALANCE
+        };
+        // We need to construct orderDigest, sign it and send it to cowSwap API, in order to submit a trade
+        // Some context about this : https://docs.cow.fi/tutorials/how-to-submit-orders-via-the-api/4.-signing-the-order
+        // For more info, check hashOrder method implementation
+        const orderDigest = (0, helpers_1.hashOrder)((0, helpers_1.domain)(1, constants_1.COW_SWAP_SETTLEMENT_ADDRESS), orderToSign);
+        const bip44Params = chain_adapters_1.ethereum.ChainAdapter.defaultBIP44Params;
+        const message = {
+            messageToSign: {
+                addressNList: (0, hdwallet_core_1.bip32ToAddressNList)((0, chain_adapters_1.toRootDerivationPath)(bip44Params)),
+                message: ethers_1.ethers.utils.arrayify(orderDigest)
+            },
+            wallet
+        };
+        const signatureOrderDigest = await adapter.signMessage(message);
+        // Passing the signature through split/join to normalize the `v` byte.
+        // Some wallets do not pad it with `27`, which causes a signature failure
+        // `splitSignature` pads it if needed, and `joinSignature` simply puts it back together
+        const signature = ethers_1.ethers.utils.joinSignature(ethers_1.ethers.utils.splitSignature(signatureOrderDigest));
+        /**
+         * /v1/orders
+         * params: {
+         * sellToken: contract address of token to sell
+         * buyToken: contractAddress of token to buy
+         * receiver: receiver address
+         * validTo: time duration during which order is valid (putting current timestamp + 30 minutes for real order)
+         * appData: appData that can be used later, can be defaulted to "0x0000000000000000000000000000000000000000000000000000000000000000"
+         * partiallyFillable: false
+         * from: sender address
+         * kind: "sell" or "buy"
+         * feeAmount: amount of fee in sellToken base
+         * sellTokenBalance: "erc20" string,
+         * buyTokenBalance: "erc20" string,
+         * signingScheme: the signing scheme used for the signature
+         * signature: a signed message specific to cowswap for this order
+         * from: same as receiver address in our case
+         * }
+         */
+        const ordersResponse = await cowService_1.cowService.post(`${apiUrl}/v1/orders/`, {
+            ...orderToSign,
+            signingScheme: constants_1.SIGNING_SCHEME,
+            signature,
+            from: trade.receiveAddress
+        });
+        return { tradeId: ordersResponse.data };
+    }
+    catch (e) {
+        if (e instanceof api_1.SwapError)
+            throw e;
+        throw new api_1.SwapError('[cowExecuteTrade]', {
+            cause: e,
+            code: api_1.SwapErrorTypes.EXECUTE_TRADE_FAILED
+        });
+    }
+}
+exports.cowExecuteTrade = cowExecuteTrade;

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

@@ -0,0 +1,3 @@
+import { TradeResult, TradeTxs } from '../../../api';
+import { CowSwapperDeps } from '../CowSwapper';
+export declare function cowGetTradeTxs(deps: CowSwapperDeps, input: TradeResult): Promise<TradeTxs>;

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

@@ -0,0 +1,31 @@
+"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: '',
+            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.SwapErrorTypes.GET_TRADE_TXS_FAILED
+        });
+    }
+}
+exports.cowGetTradeTxs = cowGetTradeTxs;

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

@@ -12,7 +12,7 @@ const helpers_2 = require("../utils/helpers/helpers");
 async function getCowSwapTradeQuote(deps, input) {
     try {
         const { sellAsset, buyAsset, sellAmount, sellAssetAccountNumber, wallet } = input;
-        const { adapter, feeAsset, web3 } = deps;
+        const { adapter, 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') {
@@ -61,33 +61,26 @@ async function getCowSwapTradeQuote(deps, input) {
             spenderAddress: constants_1.COW_SWAP_VAULT_RELAYER_ADDRESS,
             contractAddress: sellAssetErc20Address
         });
-        const [feeDataOptions, feeAssetUsdRate, sellAssetUsdRate] = await Promise.all([
+        const [feeDataOptions, 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
+        // calculating trade fee in USD
+        const tradeFeeFiat = (0, bignumber_1.bnOrZero)(quote.feeAmount)
+            .div((0, bignumber_1.bn)(10).exponentiatedBy(sellAsset.precision))
             .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();
+            .toString();
         return {
             rate,
             minimum,
             maximum,
             feeData: {
-                fee,
+                fee: '0',
                 chainSpecific: {
                     estimatedGas: feeData.chainSpecific.gasLimit,
                     gasPrice: feeData.chainSpecific.gasPrice,
@@ -95,7 +88,7 @@ async function getCowSwapTradeQuote(deps, input) {
                         .multipliedBy((0, bignumber_1.bnOrZero)(feeData.chainSpecific.gasPrice))
                         .toString()
                 },
-                tradeFee: '0'
+                tradeFee: tradeFeeFiat
             },
             sellAmount: normalizedSellAmount,
             buyAmount: quote.buyAmount,

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

@@ -1,3 +1,5 @@
+import { ChainId } from '@shapeshiftoss/caip';
+import { Trade } from '../../api';
 export declare type CowSwapPriceResponse = {
     amount: string;
     token: string;
@@ -18,3 +20,14 @@ export declare type CowSwapQuoteResponse = {
     from: string;
     expiration: string;
 };
+export declare type CowSwapGetOrdersResponse = {
+    status: string;
+};
+export declare type CowSwapGetTradesElement = {
+    txHash: string;
+};
+export declare type CowSwapGetTradesResponse = Array<CowSwapGetTradesElement>;
+export interface CowTrade<C extends ChainId> extends Trade<C> {
+    feeAmountInSellToken: string;
+    sellAmountWithoutFee: string;
+}

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

@@ -8,4 +8,8 @@ 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 COW_SWAP_SETTLEMENT_ADDRESS = "0x9008D19f58AAbD9eD0D60971565AA8510560ab41";
 export declare const ORDER_KIND_SELL = "sell";
+export declare const SIGNING_SCHEME = "ethsign";
+export declare const ERC20_TOKEN_BALANCE = "erc20";
+export declare const ORDER_STATUS_FULFILLED = "fulfilled";

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+exports.ORDER_STATUS_FULFILLED = exports.ERC20_TOKEN_BALANCE = exports.SIGNING_SCHEME = exports.ORDER_KIND_SELL = 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");
 exports.MAX_ALLOWANCE = '100000000000000000000000000';
 exports.MAX_COWSWAP_TRADE = '100000000000000000000000000';
@@ -9,4 +9,8 @@ exports.DEFAULT_SOURCE = [{ name: 'CowSwap', proportion: '1' }];
 exports.DEFAULT_ADDRESS = constants_1.AddressZero;
 exports.DEFAULT_APP_DATA = constants_1.HashZero;
 exports.COW_SWAP_VAULT_RELAYER_ADDRESS = '0xc92e8bdf79f0507f65a392b0ab4667716bfe0110';
+exports.COW_SWAP_SETTLEMENT_ADDRESS = '0x9008D19f58AAbD9eD0D60971565AA8510560ab41';
 exports.ORDER_KIND_SELL = 'sell';
+exports.SIGNING_SCHEME = 'ethsign';
+exports.ERC20_TOKEN_BALANCE = 'erc20';
+exports.ORDER_STATUS_FULFILLED = 'fulfilled';

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

@@ -1,5 +1,28 @@
+import { TypedDataDomain, TypedDataField } from '@ethersproject/abstract-signer';
 import { Asset } from '@shapeshiftoss/types';
 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, Array<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 CowSwapQuoteApiInput = {
     appData: string;
     buyToken: string;
@@ -13,3 +36,17 @@ export declare type CowSwapQuoteApiInput = {
 };
 export declare const getUsdRate: ({ apiUrl, feeAsset }: CowSwapperDeps, input: Asset) => Promise<string>;
 export declare const getNowPlusThirtyMinutesTimestamp: () => number;
+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,12 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNowPlusThirtyMinutesTimestamp = exports.getUsdRate = void 0;
+exports.domain = exports.hashOrder = exports.hashTypedData = exports.getNowPlusThirtyMinutesTimestamp = exports.getUsdRate = exports.ORDER_TYPE_FIELDS = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
+const ethers_1 = require("ethers");
 const api_1 = require("../../../../api");
 const bignumber_1 = require("../../../utils/bignumber");
 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 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;
@@ -51,3 +66,31 @@ const getNowPlusThirtyMinutesTimestamp = () => {
     return Math.round(ts.getTime() / 1000);
 };
 exports.getNowPlusThirtyMinutesTimestamp = getNowPlusThirtyMinutesTimestamp;
+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/osmosis/OsmosisSwapper.d.ts

@@ -4,7 +4,7 @@ import { ApprovalNeededOutput, BuildTradeInput, BuyAssetBySellIdInput, ExecuteTr
 import { OsmoSwapperDeps } from './utils/types';
 export declare class OsmosisSwapper implements Swapper<ChainId> {
     readonly name = "Osmosis";
-    supportAssets: string[];
+    supportedAssetIds: string[];
     deps: OsmoSwapperDeps;
     getType(): SwapperType;
     constructor(deps: OsmoSwapperDeps);

package/dist/swappers/osmosis/OsmosisSwapper.js

@@ -10,7 +10,7 @@ class OsmosisSwapper {
     constructor(deps) {
         this.name = 'Osmosis';
         this.deps = deps;
-        this.supportAssets = [caip_1.cosmosAssetId, caip_1.osmosisAssetId];
+        this.supportedAssetIds = [caip_1.cosmosAssetId, caip_1.osmosisAssetId];
     }
     getType() {
         return api_1.SwapperType.Osmosis;
@@ -52,13 +52,13 @@ class OsmosisSwapper {
         });
     }
     filterBuyAssetsBySellAssetId(args) {
-        const { sellAssetId } = args;
-        if (!this.supportAssets.includes(sellAssetId))
+        const { assetIds = [], sellAssetId } = args;
+        if (!this.supportedAssetIds.includes(sellAssetId))
             return [];
-        return this.supportAssets;
+        return assetIds.filter((assetId) => this.supportedAssetIds.includes(assetId) && assetId !== sellAssetId);
     }
     filterAssetIdsBySellable() {
-        return this.supportAssets;
+        return this.supportedAssetIds;
     }
     async buildTrade(args) {
         const { sellAsset, buyAsset, sellAmount, receiveAddress } = args;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshiftoss/swapper",
-  "version": "8.5.1",
+  "version": "8.6.0",
   "description": "An interface and implementations to trade coins via various protocols",
   "repository": "https://github.com/shapeshift/lib",
   "license": "MIT",
@@ -34,7 +34,7 @@
     "@shapeshiftoss/caip": "^6.2.0",
     "@shapeshiftoss/chain-adapters": "^7.2.0",
     "@shapeshiftoss/errors": "^1.1.2",
-    "@shapeshiftoss/hdwallet-core": "^1.23.0",
+    "@shapeshiftoss/hdwallet-core": "^1.27.0",
     "@shapeshiftoss/types": "^7.0.0"
   },
   "devDependencies": {
@@ -42,7 +42,7 @@
     "@shapeshiftoss/caip": "^6.2.0",
     "@shapeshiftoss/chain-adapters": "^7.2.0",
     "@shapeshiftoss/errors": "^1.1.2",
-    "@shapeshiftoss/hdwallet-core": "^1.23.0",
+    "@shapeshiftoss/hdwallet-core": "^1.27.0",
     "@shapeshiftoss/types": "^7.0.0",
     "@types/readline-sync": "^1.4.4",
     "readline-sync": "^1.4.10",