@shapeshiftoss/swapper 17.8.0 → 18.1.0

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

@@ -2,8 +2,9 @@ import type { AssetId, ChainId } from '@shapeshiftoss/caip';
 import type { Asset } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads';
 import type { AxiosResponse } from 'axios';
-import type { SwapErrorRight } from '../../../types.js';
-import type { ChainflipBaasSwapDepositAddress } from '../models/index.js';
+import type { ProtocolFee, SwapErrorRight, SwapSource } from '../../../types.js';
+import { CHAINFLIP_DCA_QUOTE, CHAINFLIP_REGULAR_QUOTE } from '../constants.js';
+import type { ChainflipBaasQuoteQuote, ChainflipBaasSwapDepositAddress } from '../models/index.js';
 type ChainFlipBrokerBaseArgs = {
     brokerUrl: string;
     apiKey: string;
@@ -22,6 +23,10 @@ type GetChainFlipSwapArgs = ChainFlipBrokerBaseArgs & {
 };
 export declare const isSupportedChainId: (chainId: ChainId) => chainId is import("@shapeshiftoss/types").KnownChainIds.EthereumMainnet | import("@shapeshiftoss/types").KnownChainIds.ArbitrumMainnet | import("@shapeshiftoss/types").KnownChainIds.BitcoinMainnet | import("@shapeshiftoss/types").KnownChainIds.SolanaMainnet | import("@shapeshiftoss/types").KnownChainIds.TronMainnet;
 export declare const isSupportedAssetId: (chainId: ChainId, assetId: AssetId) => chainId is import("@shapeshiftoss/types").KnownChainIds.EthereumMainnet | import("@shapeshiftoss/types").KnownChainIds.ArbitrumMainnet | import("@shapeshiftoss/types").KnownChainIds.BitcoinMainnet | import("@shapeshiftoss/types").KnownChainIds.SolanaMainnet | import("@shapeshiftoss/types").KnownChainIds.TronMainnet;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<boolean, SwapErrorRight>;
 export declare const calculateChainflipMinPrice: ({ sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAmountAfterFeesCryptoBaseUnit, slippageTolerancePercentageDecimal, sellAsset, buyAsset, }: {
     sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
     buyAmountAfterFeesCryptoBaseUnit: string;
@@ -33,4 +38,19 @@ export declare const getChainFlipSwap: ({ brokerUrl, apiKey, sourceAsset, destin
 export declare const getChainFlipIdFromAssetId: ({ assetId, brokerUrl, }: Omit<ChainFlipBrokerBaseArgs, "apiKey"> & {
     assetId: AssetId;
 }) => Promise<Result<string, SwapErrorRight>>;
+export declare const getChainflipRate: ({ sellAmountCryptoBaseUnit, buyAmountCryptoBaseUnit, sellAsset, buyAsset, }: {
+    sellAmountCryptoBaseUnit: string | null | undefined;
+    buyAmountCryptoBaseUnit: string | null | undefined;
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => string;
+export declare const getSwapSource: (swapType: typeof CHAINFLIP_REGULAR_QUOTE | typeof CHAINFLIP_DCA_QUOTE, isBoosted: boolean) => SwapSource;
+export declare const getMaxBoostFee: (assetId: AssetId) => number;
+export declare const getProtocolFees: ({ quote, sellAsset, buyAsset, sourceAsset, destinationAsset, }: {
+    quote: ChainflipBaasQuoteQuote;
+    sellAsset: Asset;
+    buyAsset: Asset;
+    sourceAsset: string;
+    destinationAsset: string;
+}) => Record<AssetId, ProtocolFee>;
 export {};

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

@@ -1,9 +1,9 @@
-import { fromAssetId } from '@shapeshiftoss/caip';
-import { BigAmount, bn, bnOrZero, isToken } from '@shapeshiftoss/utils';
+import { CHAIN_NAMESPACE, fromAssetId } from '@shapeshiftoss/caip';
+import { assertUnreachable, BigAmount, bn, bnOrZero, isToken } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { TradeQuoteError } from '../../../types.js';
-import { makeSwapErrorRight } from '../../../utils.js';
-import { ChainflipSupportedAssetIdsByChainId, ChainflipSupportedChainIds, chainIdToChainflipNetwork, } from '../constants.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils/index.js';
+import { CHAINFLIP_BOOST_SWAP_SOURCE, CHAINFLIP_DCA_BOOST_SWAP_SOURCE, CHAINFLIP_DCA_QUOTE, CHAINFLIP_DCA_SWAP_SOURCE, CHAINFLIP_REGULAR_QUOTE, CHAINFLIP_SWAP_SOURCE, ChainflipSupportedAssetIdsByChainId, ChainflipSupportedChainIds, chainIdToChainflipNetwork, usdcAsset, } from '../constants.js';
 import { chainflipService } from './chainflipService.js';
 export const isSupportedChainId = (chainId) => {
     return ChainflipSupportedChainIds.includes(chainId);
@@ -14,6 +14,37 @@ export const isSupportedAssetId = (chainId, assetId) => {
         return false;
     return supportedAssetIds.includes(assetId);
 };
+export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (!isSupportedChainId(sellAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!isSupportedChainId(buyAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    if (!isSupportedAssetId(sellAsset.chainId, sellAsset.assetId)) {
+        return Err(makeSwapErrorRight({
+            message: `asset '${sellAsset.name}' on chainId '${sellAsset.chainId}' not supported`,
+            code: TradeQuoteError.UnsupportedTradePair,
+            details: { chainId: sellAsset.chainId, assetId: sellAsset.assetId },
+        }));
+    }
+    if (!isSupportedAssetId(buyAsset.chainId, buyAsset.assetId)) {
+        return Err(makeSwapErrorRight({
+            message: `asset '${buyAsset.name}' on chainId '${buyAsset.chainId}' not supported`,
+            code: TradeQuoteError.UnsupportedTradePair,
+            details: { chainId: buyAsset.chainId, assetId: buyAsset.assetId },
+        }));
+    }
+    return Ok(true);
+};
 export const calculateChainflipMinPrice = ({ sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAmountAfterFeesCryptoBaseUnit, slippageTolerancePercentageDecimal, sellAsset, buyAsset, }) => {
     const sellAmountCryptoPrecision = BigAmount.fromBaseUnit({
         value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
@@ -81,3 +112,67 @@ export const getChainFlipIdFromAssetId = async ({ assetId, brokerUrl, }) => {
         }));
     return Ok(chainflipAsset.id);
 };
+export const getChainflipRate = ({ sellAmountCryptoBaseUnit, buyAmountCryptoBaseUnit, sellAsset, buyAsset, }) => {
+    if (!sellAmountCryptoBaseUnit || !buyAmountCryptoBaseUnit)
+        return '0';
+    return getInputOutputRate({
+        sellAmountCryptoBaseUnit,
+        buyAmountCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+};
+export const getSwapSource = (swapType, isBoosted) => {
+    if (swapType === CHAINFLIP_REGULAR_QUOTE) {
+        return isBoosted ? CHAINFLIP_BOOST_SWAP_SOURCE : CHAINFLIP_SWAP_SOURCE;
+    }
+    if (swapType === CHAINFLIP_DCA_QUOTE) {
+        return isBoosted ? CHAINFLIP_DCA_BOOST_SWAP_SOURCE : CHAINFLIP_DCA_SWAP_SOURCE;
+    }
+    return assertUnreachable(swapType);
+};
+export const getMaxBoostFee = (assetId) => {
+    const { chainNamespace } = fromAssetId(assetId);
+    switch (chainNamespace) {
+        case CHAIN_NAMESPACE.Utxo:
+            return 10;
+        case CHAIN_NAMESPACE.Evm:
+        case CHAIN_NAMESPACE.Solana:
+        case CHAIN_NAMESPACE.Tron:
+            return 0;
+        default:
+            throw new Error('Unsupported chainNamespace');
+    }
+};
+export const getProtocolFees = ({ quote, sellAsset, buyAsset, sourceAsset, destinationAsset, }) => {
+    const protocolFees = {};
+    for (const fee of quote.includedFees ?? []) {
+        if (fee.type === 'broker')
+            continue;
+        const asset = (() => {
+            if (fee.type === 'ingress' || fee.type === 'boost')
+                return sellAsset;
+            if (fee.type === 'egress')
+                return buyAsset;
+            if (fee.type === 'liquidity' && fee.asset === sourceAsset)
+                return sellAsset;
+            if (fee.type === 'liquidity' && fee.asset === destinationAsset)
+                return buyAsset;
+            if (fee.type === 'liquidity' && fee.asset === 'usdc.eth')
+                return usdcAsset;
+            if (fee.type === 'network')
+                return usdcAsset;
+        })();
+        if (!asset)
+            continue;
+        if (!(asset.assetId in protocolFees)) {
+            protocolFees[asset.assetId] = {
+                amountCryptoBaseUnit: '0',
+                requiresBalance: false,
+                asset,
+            };
+        }
+        protocolFees[asset.assetId].amountCryptoBaseUnit = (BigInt(protocolFees[asset.assetId].amountCryptoBaseUnit) + BigInt(fee.amountNative ?? '0')).toString();
+    }
+    return protocolFees;
+};

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

@@ -1,5 +1,5 @@
 import { SigningScheme } from '@shapeshiftoss/types';
-import { assertGetCowNetwork, signCowOrder } from '../../cowswap-utils/index.js';
+import { assertGetCowNetwork, signCowOrder } from '../../utils/cowswap/index.js';
 import { cowService } from './utils/cowService.js';
 export const cowSwapper = {
     executeEvmMessage: async ({ chainId, orderToSign }, { signMessage }, config) => {

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

@@ -1,86 +1,21 @@
-import { BuyTokenDestination, SellTokenSource, SigningScheme } from '@shapeshiftoss/types';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
-import { bn } from '@shapeshiftoss/utils';
-import { v4 as uuid } from 'uuid';
-import { getDefaultSlippageDecimalPercentageForSwapper } from '../../constants.js';
-import { assertGetCowNetwork, getAffiliateAppDataFragmentByChainId, getFullAppData, } from '../../cowswap-utils/index.js';
-import { SwapperName } from '../../types.js';
-import { checkSafeTransactionStatus, getExecutableTradeStep, getHopByIndex, isExecutableTradeQuote, } from '../../utils.js';
+import { checkSafeTransactionStatus, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils/index.js';
+import { assertGetCowNetwork } from '../../utils/cowswap/index.js';
 import { CowStatusMessage } from './constants.js';
 import { getCowSwapTradeQuote } from './getCowSwapTradeQuote/getCowSwapTradeQuote.js';
 import { getCowSwapTradeRate } from './getCowSwapTradeRate/getCowSwapTradeRate.js';
 import { cowService } from './utils/cowService.js';
-import { getValuesFromQuoteResponse } from './utils/helpers/helpers.js';
-const tradeQuoteMetadata = new Map();
 export const cowApi = {
-    getTradeQuote: async (input, { config }) => {
-        const tradeQuoteResult = await getCowSwapTradeQuote(input, config);
-        return tradeQuoteResult.map(tradeQuote => {
-            // A quote always has a first step
-            const firstStep = getHopByIndex(tradeQuote, 0);
-            const id = uuid();
-            tradeQuoteMetadata.set(id, { chainId: firstStep?.sellAsset.chainId });
-            return [tradeQuote];
-        });
-    },
-    getTradeRate: async (input, { config }) => {
-        const tradeRateResult = await getCowSwapTradeRate(input, config);
-        return tradeRateResult.map(tradeRate => {
-            // A rate always has a first step
-            const firstStep = getHopByIndex(tradeRate, 0);
-            const id = uuid();
-            tradeQuoteMetadata.set(id, { chainId: firstStep?.sellAsset.chainId });
-            return [tradeRate];
-        });
-    },
-    getUnsignedEvmMessage: async ({ tradeQuote, stepIndex }) => {
+    getTradeQuote: (input, deps) => getCowSwapTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getCowSwapTradeRate(input, deps),
+    getUnsignedEvmMessage: ({ tradeQuote, stepIndex }) => {
         if (!isExecutableTradeQuote(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { cowswapQuoteResponse, sellAsset, buyAsset } = step;
-        if (!cowswapQuoteResponse)
-            throw new Error('CowSwap quote data is required');
-        const { slippageTolerancePercentageDecimal = getDefaultSlippageDecimalPercentageForSwapper(SwapperName.CowSwap), } = tradeQuote;
-        // Check the chainId is supported for paranoia
-        assertGetCowNetwork(sellAsset.chainId);
-        const affiliateAppDataFragment = getAffiliateAppDataFragmentByChainId({
-            affiliateBps: tradeQuote.affiliateBps,
-            chainId: sellAsset.chainId,
-        });
-        const { appDataHash } = await getFullAppData(slippageTolerancePercentageDecimal, affiliateAppDataFragment, 'market');
-        const { id, quote } = cowswapQuoteResponse;
-        // Note: While CowSwap returns us a quote, and we have slippageBips and `partnerFee.bps` in the appData, this isn't enough.
-        // For the min out to actually to be reliable, the final message to be signed needs to have slippage and fee bps deducted.
-        // This actually matches what CoW uses as a minimum for a given quote - failure to do so means orders may take forever to be filled, or never be filled at all.
-        const { buyAmountAfterFeesCryptoBaseUnit } = getValuesFromQuoteResponse({
-            buyAsset,
-            sellAsset,
-            response: cowswapQuoteResponse,
-            affiliateBps: tradeQuote.affiliateBps,
-            slippageTolerancePercentageDecimal,
-        });
-        // CoW API and flow is weird - same idea as the mutation above, we need to incorporate protocol fees into the order
-        // This was previously working as-is with fees being deducted from the sell amount at protocol-level, but we now we need to add them into the order
-        // In other words, this means what was previously CoW being "feeless" as far as we're concerned
-        // i.e no additional fees to account for when doing balance checks, no longer holds true
-        //
-        // This also makes CoW the first and currently *only* swapper where max token swaps aren't full balance
-        const sellAmountPlusProtocolFees = bn(quote.sellAmount).plus(quote.feeAmount);
-        const orderToSign = {
-            ...quote,
-            // Another mutation from the original quote to go around the fact that CoW API flow is weird
-            // they return us a quote with fees, but we have to zero them out when sending the order
-            feeAmount: '0',
-            buyAmount: buyAmountAfterFeesCryptoBaseUnit,
-            sellAmount: sellAmountPlusProtocolFees.toFixed(0),
-            // from,
-            sellTokenBalance: SellTokenSource.ERC20,
-            buyTokenBalance: BuyTokenDestination.ERC20,
-            quoteId: id,
-            appDataHash,
-            signingScheme: SigningScheme.EIP712,
-        };
-        return { chainId: sellAsset.chainId, orderToSign };
+        const { transactionData } = getExecutableTradeStep(tradeQuote, stepIndex);
+        if (transactionData?.type !== 'cowswap')
+            throw new Error('CowSwap order data is required');
+        const { chainId, orderToSign } = transactionData;
+        return Promise.resolve({ chainId, orderToSign });
     },
     getEvmTransactionFees: () => {
         // No transaction fees for CoW
@@ -98,6 +33,9 @@ export const cowApi = {
         if (maybeSafeTransactionStatus)
             return maybeSafeTransactionStatus;
         const network = assertGetCowNetwork(chainId);
+        // txHash is the order uid - the cow explorer order page is the swap's tracker
+        const swapperTxId = txHash;
+        const swapperTxLink = `https://explorer.cow.fi/orders/${txHash}`;
         // with cow we aren't able to get the tx hash until it's already completed, so we must use the
         // order uid to fetch the trades and use their existence as indicating "complete"
         // https://docs.cow.fi/tutorials/how-to-submit-orders-via-the-api/6.-checking-order-status
@@ -111,6 +49,8 @@ export const cowApi = {
                 return {
                     status: TxStatus.Confirmed,
                     buyTxHash,
+                    swapperTxId,
+                    swapperTxLink,
                     message: CowStatusMessage.Fulfilled,
                 };
             }
@@ -125,12 +65,16 @@ export const cowApi = {
                     return {
                         status: TxStatus.Failed,
                         buyTxHash: undefined,
+                        swapperTxId,
+                        swapperTxLink,
                         message: CowStatusMessage.Cancelled,
                     };
                 case 'expired':
                     return {
                         status: TxStatus.Failed,
                         buyTxHash: undefined,
+                        swapperTxId,
+                        swapperTxLink,
                         message: CowStatusMessage.Expired,
                     };
                 default:
@@ -139,6 +83,8 @@ export const cowApi = {
         return {
             status: TxStatus.Pending,
             buyTxHash: undefined,
+            swapperTxId,
+            swapperTxLink,
             message: CowStatusMessage.Open,
         };
     },

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

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

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

@@ -1,134 +1,43 @@
-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',
         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]);
+};