@shapeshiftoss/swapper 17.8.0 → 19.0.0

package/dist/esm/swappers/CowSwapper/getCowSwapTradeQuote/getCowSwapTradeQuote.js

@@ -1,134 +1,44 @@
-import { fromAssetId } from '@shapeshiftoss/caip';
-import { OrderKind } from '@shapeshiftoss/types';
-import { bn } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { zeroAddress } from 'viem';
-import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
-import { getAffiliateAppDataFragmentByChainId, getCowNetwork, getFullAppData, } from '../../../cowswap-utils/index.js';
-import { COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS, COW_SWAP_VAULT_RELAYER_ADDRESS, SUPPORTED_CHAIN_IDS, } from '../../../cowswap-utils/constants.js';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
-import { cowService } from '../utils/cowService.js';
-import { assertValidTrade, getNowPlusThirtyMinutesTimestamp, getValuesFromQuoteResponse, } from '../utils/helpers/helpers.js';
-export async function getCowSwapTradeQuote(input, config) {
-    const { sellAsset, buyAsset, accountNumber, chainId, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps, } = input;
-    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
-        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.CowSwap);
-    const assertion = assertValidTrade({
-        buyAsset,
-        sellAsset,
-        supportedChainIds: SUPPORTED_CHAIN_IDS,
-    });
-    if (assertion.isErr())
-        return Err(assertion.unwrapErr());
-    const buyToken = !isNativeEvmAsset(buyAsset.assetId)
-        ? fromAssetId(buyAsset.assetId).assetReference
-        : COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS;
-    const maybeNetwork = getCowNetwork(chainId);
-    if (!maybeNetwork)
-        return Err(makeSwapErrorRight({
-            message: `[CowSwap: getCowSwapTradeQuote] - Unsupported chainId`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { chainId },
-        }));
-    const network = maybeNetwork;
-    const affiliateAppDataFragment = getAffiliateAppDataFragmentByChainId({
-        affiliateBps,
-        chainId: sellAsset.chainId,
-    });
-    const { appData, appDataHash } = await getFullAppData(slippageTolerancePercentageDecimal, affiliateAppDataFragment, 'market');
-    // https://api.cow.fi/docs/#/default/post_api_v1_quote
-    const maybeQuoteResponse = await cowService.post(`${config.VITE_COWSWAP_BASE_URL}/${network}/api/v1/quote`, {
-        sellToken: fromAssetId(sellAsset.assetId).assetReference,
-        buyToken,
-        receiver: receiveAddress,
-        validTo: getNowPlusThirtyMinutesTimestamp(),
-        appData,
-        appDataHash,
-        partiallyFillable: false,
-        from: receiveAddress ?? zeroAddress,
-        kind: OrderKind.SELL,
-        sellAmountBeforeFee: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-    });
-    if (maybeQuoteResponse.isErr()) {
-        const err = maybeQuoteResponse.unwrapErr();
-        const errData = err.cause?.response?.data;
-        if (err.cause?.isAxiosError &&
-            errData?.errorType === 'SellAmountDoesNotCoverFee') {
-            return Err(createTradeAmountTooSmallErr({
-                assetId: sellAsset.assetId,
-                minAmountCryptoBaseUnit: bn((errData?.data).fee_amount ?? '0x0', 16).toFixed(),
-            }));
-        }
-        return Err(maybeQuoteResponse.unwrapErr());
-    }
-    const { data: cowswapQuoteResponse } = maybeQuoteResponse.unwrap();
-    const { feeAmount: feeAmountInSellTokenCryptoBaseUnit } = cowswapQuoteResponse.quote;
-    const { buyAmountAfterFeesCryptoBaseUnit, buyAmountBeforeFeesCryptoBaseUnit } = getValuesFromQuoteResponse({
-        buyAsset,
-        sellAsset,
-        response: cowswapQuoteResponse,
-        affiliateBps,
-        slippageTolerancePercentageDecimal,
+import { assertQuoteAddresses } from '../../../utils/index.js';
+import { getCowSwapStepData } from '../utils/getCowSwapStepData.js';
+import { getCowSwapTradeContext } from '../utils/getCowSwapTradeContext.js';
+export const getCowSwapTradeQuote = async (input, deps) => {
+    const { accountNumber } = input;
+    const maybeAddresses = assertQuoteAddresses(input);
+    if (maybeAddresses.isErr())
+        return Err(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    const maybeContext = await getCowSwapTradeContext({
+        input,
+        deps,
+        senderAddress: sendAddress,
+        receiveAddress,
     });
-    const rate = getInputOutputRate({
-        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-        sellAsset,
-        buyAsset,
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = getCowSwapStepData({
+        ...stepDataArgs,
+        type: 'quote',
+        input,
+        from: sendAddress,
     });
-    const id = cowswapQuoteResponse.id?.toString();
-    if (!id) {
-        return Err(makeSwapErrorRight({
-            message: `[CowSwap: getCowSwapTradeQuote] - missing quote ID`,
-            code: TradeQuoteError.InvalidResponse,
-        }));
-    }
-    const quote = {
-        id,
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
         quoteOrRate: 'quote',
+        deadline: stepDataArgs.cowswapQuoteResponse.quote.validTo * 1000,
         receiveAddress,
-        affiliateBps,
-        rate,
-        slippageTolerancePercentageDecimal,
-        swapperName: SwapperName.CowSwap,
         steps: [
             {
-                estimatedExecutionTimeMs: undefined,
-                allowanceContract: COW_SWAP_VAULT_RELAYER_ADDRESS,
-                rate,
-                feeData: {
-                    networkFeeCryptoBaseUnit: '0',
-                    protocolFees: {
-                        [sellAsset.assetId]: {
-                            amountCryptoBaseUnit: feeAmountInSellTokenCryptoBaseUnit,
-                            // Technically does, but we deduct it off the sell amount
-                            requiresBalance: false,
-                            asset: sellAsset,
-                        },
-                    },
-                },
-                sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                buyAmountBeforeFeesCryptoBaseUnit,
-                buyAmountAfterFeesCryptoBaseUnit,
-                source: SwapperName.CowSwap,
-                affiliateFee: buildAffiliateFee({
-                    strategy: 'buy_asset',
-                    affiliateBps,
-                    sellAsset,
-                    buyAsset,
-                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-                    isEstimate: true,
-                }),
-                buyAsset,
-                sellAsset,
+                ...stepCommon,
                 accountNumber,
-                cowswapQuoteResponse,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+                transactionData,
             },
         ],
     };
-    return Ok(quote);
-}
+    return Ok([tradeQuote]);
+};

package/dist/esm/swappers/CowSwapper/getCowSwapTradeRate/getCowSwapTradeRate.d.ts

@@ -1,3 +1,4 @@
 import type { Result } from '@sniptt/monads';
-import type { GetEvmTradeRateInput, SwapErrorRight, SwapperConfig, TradeRate } from '../../../types.js';
-export declare function getCowSwapTradeRate(input: GetEvmTradeRateInput, config: SwapperConfig): Promise<Result<TradeRate, SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+import type { CowSwapTradeRateInput } from '../types.js';
+export declare const getCowSwapTradeRate: (input: CowSwapTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

package/dist/esm/swappers/CowSwapper/getCowSwapTradeRate/getCowSwapTradeRate.js

@@ -1,132 +1,34 @@
-import { fromAssetId } from '@shapeshiftoss/caip';
-import { OrderKind } from '@shapeshiftoss/types';
-import { bn } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { zeroAddress } from 'viem';
-import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
-import { getAffiliateAppDataFragmentByChainId, getCowNetwork, getFullAppData, } from '../../../cowswap-utils/index.js';
-import { COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS, COW_SWAP_VAULT_RELAYER_ADDRESS, SUPPORTED_CHAIN_IDS, } from '../../../cowswap-utils/constants.js';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
-import { cowService } from '../utils/cowService.js';
-import { assertValidTrade, getNowPlusThirtyMinutesTimestamp, getValuesFromQuoteResponse, } from '../utils/helpers/helpers.js';
-export async function getCowSwapTradeRate(input, config) {
-    const { sellAsset, buyAsset, accountNumber, chainId, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps, } = input;
-    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
-        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.CowSwap);
-    const assertion = assertValidTrade({
-        buyAsset,
-        sellAsset,
-        supportedChainIds: SUPPORTED_CHAIN_IDS,
-    });
-    if (assertion.isErr())
-        return Err(assertion.unwrapErr());
-    const buyToken = !isNativeEvmAsset(buyAsset.assetId)
-        ? fromAssetId(buyAsset.assetId).assetReference
-        : COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS;
-    const maybeNetwork = getCowNetwork(chainId);
-    if (!maybeNetwork)
-        return Err(makeSwapErrorRight({
-            message: `[CowSwap: getCowSwapTradeRate] - Unsupported chainId`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { chainId },
-        }));
-    const network = maybeNetwork;
-    const affiliateAppDataFragment = getAffiliateAppDataFragmentByChainId({
-        affiliateBps,
-        chainId: sellAsset.chainId,
-    });
-    const { appData, appDataHash } = await getFullAppData(slippageTolerancePercentageDecimal, affiliateAppDataFragment, 'market');
-    // https://api.cow.fi/docs/#/default/post_api_v1_quote
-    const maybeQuoteResponse = await cowService.post(`${config.VITE_COWSWAP_BASE_URL}/${network}/api/v1/quote`, {
-        sellToken: fromAssetId(sellAsset.assetId).assetReference,
-        buyToken,
-        receiver: receiveAddress,
-        validTo: getNowPlusThirtyMinutesTimestamp(),
-        appData,
-        appDataHash,
-        partiallyFillable: false,
-        from: zeroAddress,
-        kind: OrderKind.SELL,
-        sellAmountBeforeFee: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-    });
-    if (maybeQuoteResponse.isErr()) {
-        const err = maybeQuoteResponse.unwrapErr();
-        const errData = err.cause?.response?.data;
-        if (err.cause?.isAxiosError &&
-            errData?.errorType === 'SellAmountDoesNotCoverFee') {
-            return Err(createTradeAmountTooSmallErr({
-                assetId: sellAsset.assetId,
-                minAmountCryptoBaseUnit: bn((errData?.data).fee_amount ?? '0x0', 16).toFixed(),
-            }));
-        }
-        return Err(maybeQuoteResponse.unwrapErr());
-    }
-    const { data: cowswapQuoteResponse } = maybeQuoteResponse.unwrap();
-    const { feeAmount: feeAmountInSellTokenCryptoBaseUnit } = cowswapQuoteResponse.quote;
-    const { buyAmountAfterFeesCryptoBaseUnit, buyAmountBeforeFeesCryptoBaseUnit } = getValuesFromQuoteResponse({
-        buyAsset,
-        sellAsset,
-        response: cowswapQuoteResponse,
-        affiliateBps,
-        slippageTolerancePercentageDecimal,
-    });
-    const rate = getInputOutputRate({
-        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-        sellAsset,
-        buyAsset,
+import { getCowSwapStepData } from '../utils/getCowSwapStepData.js';
+import { getCowSwapTradeContext } from '../utils/getCowSwapTradeContext.js';
+export const getCowSwapTradeRate = async (input, deps) => {
+    const { accountNumber, receiveAddress } = input;
+    const maybeContext = await getCowSwapTradeContext({
+        input,
+        deps,
+        // The signer is only known at execution - the CoW quote is simulated from the zero address
+        senderAddress: zeroAddress,
+        receiveAddress,
     });
-    const id = cowswapQuoteResponse.id?.toString();
-    if (!id) {
-        return Err(makeSwapErrorRight({
-            message: `[CowSwap: getCowSwapTradeRate] - missing quote ID`,
-            code: TradeQuoteError.InvalidResponse,
-        }));
-    }
-    const quote = {
-        id,
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = getCowSwapStepData({ ...stepDataArgs, type: 'rate', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
         quoteOrRate: 'rate',
         receiveAddress,
-        affiliateBps,
-        rate,
-        slippageTolerancePercentageDecimal,
-        swapperName: SwapperName.CowSwap,
         steps: [
             {
-                estimatedExecutionTimeMs: undefined,
-                allowanceContract: COW_SWAP_VAULT_RELAYER_ADDRESS,
-                rate,
-                feeData: {
-                    networkFeeCryptoBaseUnit: '0',
-                    protocolFees: {
-                        [sellAsset.assetId]: {
-                            amountCryptoBaseUnit: feeAmountInSellTokenCryptoBaseUnit,
-                            // Technically does, but we deduct it off the sell amount
-                            requiresBalance: false,
-                            asset: sellAsset,
-                        },
-                    },
-                },
-                sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                buyAmountBeforeFeesCryptoBaseUnit,
-                buyAmountAfterFeesCryptoBaseUnit,
-                source: SwapperName.CowSwap,
-                affiliateFee: buildAffiliateFee({
-                    strategy: 'buy_asset',
-                    affiliateBps,
-                    sellAsset,
-                    buyAsset,
-                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-                }),
-                buyAsset,
-                sellAsset,
+                ...stepCommon,
                 accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
             },
         ],
     };
-    return Ok(quote);
-}
+    return Ok([tradeRate]);
+};

package/dist/esm/swappers/CowSwapper/index.d.ts

@@ -1 +1,3 @@
 export * from './types.js';
+export { cowApi } from './endpoints.js';
+export { cowSwapper } from './CowSwapper.js';

package/dist/esm/swappers/CowSwapper/index.js

@@ -1 +1,3 @@
 export * from './types.js';
+export { cowApi } from './endpoints.js';
+export { cowSwapper } from './CowSwapper.js';

package/dist/esm/swappers/CowSwapper/types.d.ts

@@ -1,5 +1,8 @@
 import type { ChainId } from '@shapeshiftoss/caip';
 import type { OrderCreation } from '@shapeshiftoss/types';
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput } from '../../types.js';
+export type CowSwapTradeQuoteInput = GetEvmTradeQuoteInput;
+export type CowSwapTradeRateInput = GetEvmTradeRateInput;
 export type CowSwapGetTradesResponse = {
     txHash: string;
 }[];

package/dist/esm/swappers/CowSwapper/utils/cowService.js

@@ -1,4 +1,4 @@
-import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils/index.js';
 const maxAge = 5 * 1000; // 5 seconds
 const cachedUrls = ['/mainnet/api/v1/quote', '/xdai/api/v1/quote'];
 const axiosConfig = {

package/dist/esm/swappers/CowSwapper/utils/getCowSwapStepData.d.ts

@@ -0,0 +1,23 @@
+import type { OrderQuoteResponse } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
+type CowSwapStepDataBase = {
+    cowswapQuoteResponse: OrderQuoteResponse;
+    appDataHash: string;
+    buyAmountAfterFeesCryptoBaseUnit: string;
+};
+export type GetCowSwapStepDataArgs = StepDataArgs<CowSwapStepDataBase>;
+type CowSwapRateStepData = {
+    networkFeeCryptoBaseUnit: string;
+};
+type CowSwapQuoteStepData = {
+    transactionData: TxBuildData;
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getCowSwapStepData(args: Extract<GetCowSwapStepDataArgs, {
+    type: 'rate';
+}>): Result<CowSwapRateStepData, SwapErrorRight>;
+export declare function getCowSwapStepData(args: Extract<GetCowSwapStepDataArgs, {
+    type: 'quote';
+}>): Result<CowSwapQuoteStepData, SwapErrorRight>;
+export {};

package/dist/esm/swappers/CowSwapper/utils/getCowSwapStepData.js

@@ -0,0 +1,34 @@
+import { BuyTokenDestination, SellTokenSource, SigningScheme } from '@shapeshiftoss/types';
+import { bn } from '@shapeshiftoss/utils';
+import { Ok } from '@sniptt/monads';
+export function getCowSwapStepData(args) {
+    // CowSwap is gasless - the solver pays execution, so there is no miner fee on either arm
+    if (args.type === 'rate') {
+        const stepData = { networkFeeCryptoBaseUnit: '0' };
+        return Ok(stepData);
+    }
+    const { sellAsset, cowswapQuoteResponse, appDataHash, buyAmountAfterFeesCryptoBaseUnit } = args;
+    const { id, quote } = cowswapQuoteResponse;
+    // The signed order deducts slippage and fees off buyAmount and folds protocol fees back into sellAmount -
+    // this matches CoW's own minimum for the quote, else orders may take forever to fill or never fill
+    const sellAmountPlusProtocolFees = bn(quote.sellAmount).plus(quote.feeAmount);
+    const orderToSign = {
+        ...quote,
+        // CoW returns a quote with fees, but they must be zeroed out when sending the order
+        feeAmount: '0',
+        buyAmount: buyAmountAfterFeesCryptoBaseUnit,
+        sellAmount: sellAmountPlusProtocolFees.toFixed(0),
+        sellTokenBalance: SellTokenSource.ERC20,
+        buyTokenBalance: BuyTokenDestination.ERC20,
+        quoteId: id,
+        appDataHash,
+        signingScheme: SigningScheme.EIP712,
+    };
+    const transactionData = {
+        type: 'cowswap',
+        chainId: sellAsset.chainId,
+        orderToSign,
+    };
+    const stepData = { transactionData, networkFeeCryptoBaseUnit: '0' };
+    return Ok(stepData);
+}

package/dist/esm/swappers/CowSwapper/utils/getCowSwapStepData.test.js

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest';
+import { FOX_MAINNET } from '../../../utils/test-data/assets.js';
+import { getCowSwapStepData } from './getCowSwapStepData.js';
+const cowswapQuoteResponse = {
+    quote: {
+        sellToken: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+        buyToken: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+        receiver: '0x90a48d5cf7343b08da12e067680b4c6dbfe551be',
+        sellAmount: '9755648144619063874259',
+        buyAmount: '289305614806369753',
+        validTo: 1712259433,
+        appData: '{"appCode":"shapeshift","metadata":{"orderClass":{"orderClass":"market"},"quote":{"slippageBips":50}},"version":"1.3.0"}',
+        appDataHash: '0x41fffc0127f56060cc551652721d84c336f87649a20c51fcff5b8841dfeabe5b',
+        feeAmount: '184116879335769833472',
+        kind: 'sell',
+        partiallyFillable: false,
+        sellTokenBalance: 'erc20',
+        buyTokenBalance: 'erc20',
+        signingScheme: 'eip712',
+    },
+    from: '0x90a48d5cf7343b08da12e067680b4c6dbfe551be',
+    expiration: '2024-04-04T19:09:12.792412370Z',
+    id: 474006349,
+    verified: false,
+};
+const commonArgs = {
+    deps: {},
+    sellAsset: FOX_MAINNET,
+    cowswapQuoteResponse,
+    appDataHash: '0x41fffc0127f56060cc551652721d84c336f87649a20c51fcff5b8841dfeabe5b',
+    // quoted buyAmount less 0.5% slippage, as returned by getValuesFromQuoteResponse
+    buyAmountAfterFeesCryptoBaseUnit: '287859086732337904',
+};
+describe('getCowSwapStepData', () => {
+    describe('quote', () => {
+        it('should return the order to sign', () => {
+            const args = {
+                ...commonArgs,
+                type: 'quote',
+                input: {},
+                from: '0x90a48d5cf7343b08da12e067680b4c6dbfe551be',
+            };
+            const actual = getCowSwapStepData(args).unwrap();
+            expect(actual).toEqual({
+                networkFeeCryptoBaseUnit: '0',
+                transactionData: {
+                    type: 'cowswap',
+                    chainId: 'eip155:1',
+                    orderToSign: {
+                        sellToken: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                        buyToken: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+                        receiver: '0x90a48d5cf7343b08da12e067680b4c6dbfe551be',
+                        sellAmount: '9939765023954833707731',
+                        buyAmount: '287859086732337904',
+                        validTo: 1712259433,
+                        appData: '{"appCode":"shapeshift","metadata":{"orderClass":{"orderClass":"market"},"quote":{"slippageBips":50}},"version":"1.3.0"}',
+                        appDataHash: '0x41fffc0127f56060cc551652721d84c336f87649a20c51fcff5b8841dfeabe5b',
+                        feeAmount: '0',
+                        kind: 'sell',
+                        partiallyFillable: false,
+                        sellTokenBalance: 'erc20',
+                        buyTokenBalance: 'erc20',
+                        signingScheme: 'eip712',
+                        quoteId: 474006349,
+                    },
+                },
+            });
+        });
+    });
+    describe('rate', () => {
+        it('should return a zero network fee and no transaction data', () => {
+            const args = {
+                ...commonArgs,
+                type: 'rate',
+                input: {},
+            };
+            const actual = getCowSwapStepData(args).unwrap();
+            expect(actual).toEqual({ networkFeeCryptoBaseUnit: '0' });
+        });
+    });
+});

package/dist/esm/swappers/CowSwapper/utils/getCowSwapTradeContext.d.ts

@@ -0,0 +1,17 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { CowSwapTradeQuoteInput, CowSwapTradeRateInput } from '../types.js';
+import type { GetCowSwapStepDataArgs } from './getCowSwapStepData.js';
+type CowSwapTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: Omit<GetCowSwapStepDataArgs, 'type' | 'input' | 'from'>;
+};
+export declare const getCowSwapTradeContext: ({ input, deps, senderAddress, receiveAddress, }: {
+    input: CowSwapTradeQuoteInput | CowSwapTradeRateInput;
+    deps: SwapperDeps;
+    senderAddress: string;
+    receiveAddress: string | undefined;
+}) => Promise<Result<CowSwapTradeContext, SwapErrorRight>>;
+export {};

package/dist/esm/swappers/CowSwapper/utils/getCowSwapTradeContext.js

@@ -0,0 +1,134 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { OrderKind, PriceQuality } from '@shapeshiftoss/types';
+import { bn } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { getAffiliateAppDataFragmentByChainId, getCowNetwork, getFullAppData, } from '../../../utils/cowswap/index.js';
+import { COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS, COW_SWAP_VAULT_RELAYER_ADDRESS, SUPPORTED_CHAIN_IDS, } from '../../../utils/cowswap/constants.js';
+import { isNativeEvmAsset } from '../../../utils/helpers.js';
+import { cowService } from '../utils/cowService.js';
+import { assertValidTrade, getNowPlusThirtyMinutesTimestamp, getValuesFromQuoteResponse, } from '../utils/helpers.js';
+export const getCowSwapTradeContext = async ({ input, deps, senderAddress, receiveAddress, }) => {
+    const { sellAsset, buyAsset, chainId, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps, } = input;
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.CowSwap);
+    const assertion = assertValidTrade({
+        buyAsset,
+        sellAsset,
+        supportedChainIds: SUPPORTED_CHAIN_IDS,
+    });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const buyToken = !isNativeEvmAsset(buyAsset.assetId)
+        ? fromAssetId(buyAsset.assetId).assetReference
+        : COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS;
+    const network = getCowNetwork(chainId);
+    if (!network)
+        return Err(makeSwapErrorRight({
+            message: `[getCowSwapTradeContext] - Unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId },
+        }));
+    const affiliateAppDataFragment = getAffiliateAppDataFragmentByChainId({
+        affiliateBps,
+        chainId: sellAsset.chainId,
+    });
+    const { appData, appDataHash } = await getFullAppData(slippageTolerancePercentageDecimal, affiliateAppDataFragment, 'market');
+    // https://api.cow.fi/docs/#/default/post_api_v1_quote
+    const maybeQuoteResponse = await cowService.post(`${deps.config.VITE_COWSWAP_BASE_URL}/${network}/api/v1/quote`, {
+        sellToken: fromAssetId(sellAsset.assetId).assetReference,
+        buyToken,
+        receiver: receiveAddress,
+        validTo: getNowPlusThirtyMinutesTimestamp(),
+        appData,
+        appDataHash,
+        partiallyFillable: false,
+        from: senderAddress,
+        kind: OrderKind.SELL,
+        sellAmountBeforeFee: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        // Pinned so rates and quotes resolve against the same estimator set - left unset, CoW picks
+        // per-request and the fee swings enough to trip the rate-to-quote drop warning
+        priceQuality: PriceQuality.OPTIMAL,
+    });
+    if (maybeQuoteResponse.isErr()) {
+        const err = maybeQuoteResponse.unwrapErr();
+        const errData = err.cause?.response?.data;
+        if (err.cause?.isAxiosError &&
+            errData?.errorType === 'SellAmountDoesNotCoverFee') {
+            return Err(createTradeAmountTooSmallErr({
+                assetId: sellAsset.assetId,
+                minAmountCryptoBaseUnit: bn((errData?.data).fee_amount ?? '0x0', 16).toFixed(),
+            }));
+        }
+        return Err(err);
+    }
+    const { data: cowswapQuoteResponse } = maybeQuoteResponse.unwrap();
+    const { feeAmount: feeAmountInSellTokenCryptoBaseUnit } = cowswapQuoteResponse.quote;
+    const { buyAmountAfterFeesCryptoBaseUnit, buyAmountBeforeFeesCryptoBaseUnit } = getValuesFromQuoteResponse({
+        buyAsset,
+        sellAsset,
+        response: cowswapQuoteResponse,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+    });
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const id = cowswapQuoteResponse.id?.toString();
+    if (!id) {
+        return Err(makeSwapErrorRight({
+            message: `[getCowSwapTradeContext] - missing quote ID`,
+            code: TradeQuoteError.InvalidResponse,
+        }));
+    }
+    return Ok({
+        tradeCommon: {
+            id,
+            rate,
+            swapperName: SwapperName.CowSwap,
+            affiliateBps,
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            estimatedExecutionTimeMs: undefined,
+            allowanceContract: COW_SWAP_VAULT_RELAYER_ADDRESS,
+            rate,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            source: SwapperName.CowSwap,
+            buyAsset,
+            sellAsset,
+            affiliateFee: buildAffiliateFee({
+                strategy: 'buy_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                isEstimate: true,
+            }),
+        },
+        protocolFees: {
+            [sellAsset.assetId]: {
+                amountCryptoBaseUnit: feeAmountInSellTokenCryptoBaseUnit,
+                // Technically requires balance, but we deduct it off the sell amount
+                requiresBalance: false,
+                asset: sellAsset,
+            },
+        },
+        stepDataArgs: {
+            deps,
+            sellAsset,
+            cowswapQuoteResponse,
+            appDataHash,
+            buyAmountAfterFeesCryptoBaseUnit,
+        },
+    });
+};