@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

@@ -0,0 +1,36 @@
+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';
+type ChainFlipBrokerBaseArgs = {
+    brokerUrl: string;
+    apiKey: string;
+};
+type GetChainFlipSwapArgs = ChainFlipBrokerBaseArgs & {
+    sourceAsset: string;
+    destinationAsset: string;
+    destinationAddress: string;
+    maxBoostFee?: number;
+    minimumPrice: string;
+    refundAddress: string;
+    retryDurationInBlocks?: number;
+    commissionBps: number;
+    numberOfChunks?: number;
+    chunkIntervalBlocks?: number;
+};
+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;
+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;
+export declare const calculateChainflipMinPrice: ({ sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAmountAfterFeesCryptoBaseUnit, slippageTolerancePercentageDecimal, sellAsset, buyAsset, }: {
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    buyAmountAfterFeesCryptoBaseUnit: string;
+    slippageTolerancePercentageDecimal: string | undefined;
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => string;
+export declare const getChainFlipSwap: ({ brokerUrl, apiKey, sourceAsset, destinationAsset, destinationAddress, maxBoostFee, minimumPrice, refundAddress, retryDurationInBlocks, commissionBps, numberOfChunks, chunkIntervalBlocks, }: GetChainFlipSwapArgs) => Promise<Result<AxiosResponse<ChainflipBaasSwapDepositAddress, any>, SwapErrorRight>>;
+export declare const getChainFlipIdFromAssetId: ({ assetId, brokerUrl, }: Omit<ChainFlipBrokerBaseArgs, "apiKey"> & {
+    assetId: AssetId;
+}) => Promise<Result<string, SwapErrorRight>>;
+export {};

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

@@ -0,0 +1,76 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { bn, bnOrZero, fromBaseUnit, 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 { chainflipService } from './chainflipService.js';
+export const isSupportedChainId = (chainId) => {
+    return ChainflipSupportedChainIds.includes(chainId);
+};
+export const isSupportedAssetId = (chainId, assetId) => {
+    const supportedAssetIds = ChainflipSupportedAssetIdsByChainId[chainId];
+    if (!supportedAssetIds)
+        return false;
+    return supportedAssetIds.includes(assetId);
+};
+export const calculateChainflipMinPrice = ({ sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAmountAfterFeesCryptoBaseUnit, slippageTolerancePercentageDecimal, sellAsset, buyAsset, }) => {
+    const sellAmountCryptoPrecision = fromBaseUnit(sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset.precision);
+    const buyAmountCryptoPrecision = fromBaseUnit(buyAmountAfterFeesCryptoBaseUnit, buyAsset.precision);
+    const estimatedPrice = bn(buyAmountCryptoPrecision).div(sellAmountCryptoPrecision);
+    // This is called minimumPrice upstream but this really is a rate, let's not honour confusing terminology
+    const minimumRate = estimatedPrice
+        .times(bn(1).minus(bnOrZero(slippageTolerancePercentageDecimal)))
+        .toFixed(buyAsset.precision);
+    return minimumRate;
+};
+export const getChainFlipSwap = ({ brokerUrl, apiKey, sourceAsset, destinationAsset, destinationAddress, maxBoostFee = 0, minimumPrice, refundAddress, retryDurationInBlocks = 150, commissionBps, numberOfChunks, chunkIntervalBlocks = 2, }) => {
+    let swapUrl = `${brokerUrl}/swap` +
+        `?apiKey=${apiKey}` +
+        `&sourceAsset=${sourceAsset}` +
+        `&destinationAsset=${destinationAsset}` +
+        `&destinationAddress=${destinationAddress}` +
+        `&boostFee=${maxBoostFee}` +
+        `&minimumPrice=${minimumPrice}` +
+        `&refundAddress=${refundAddress}` +
+        `&retryDurationInBlocks=${retryDurationInBlocks}` +
+        `&commissionBps=${commissionBps}`;
+    if (numberOfChunks && chunkIntervalBlocks) {
+        swapUrl += `&numberOfChunks=${numberOfChunks}`;
+        swapUrl += `&chunkIntervalBlocks=${chunkIntervalBlocks}`;
+    }
+    return chainflipService.get(swapUrl);
+};
+const fetchChainFlipAssets = async ({ brokerUrl, }) => {
+    const result = await chainflipService.get(`${brokerUrl}/assets`);
+    return result.map(({ data }) => data.assets);
+};
+export const getChainFlipIdFromAssetId = async ({ assetId, brokerUrl, }) => {
+    const maybeChainflipAssets = await fetchChainFlipAssets({
+        brokerUrl,
+    });
+    const { assetReference, chainId } = fromAssetId(assetId);
+    const _isToken = isToken(assetId);
+    if (maybeChainflipAssets.isErr()) {
+        return Err(makeSwapErrorRight({
+            message: `Error fetching Chainflip assets`,
+            code: TradeQuoteError.QueryFailed,
+        }));
+    }
+    const chainflipAssets = maybeChainflipAssets.unwrap();
+    const chainflipAsset = chainflipAssets.find(asset => {
+        const isCorrectNetwork = asset.network === chainIdToChainflipNetwork[chainId];
+        if (!isCorrectNetwork)
+            return false;
+        if (_isToken) {
+            return asset.contractAddress?.toLowerCase() === assetReference.toLowerCase();
+        }
+        return !asset.contractAddress;
+    });
+    if (!chainflipAsset)
+        return Err(makeSwapErrorRight({
+            message: `Asset not supported by Chainflip`,
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    return Ok(chainflipAsset.id);
+};

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

@@ -0,0 +1,2 @@
+import type { Swapper } from '../../types.js';
+export declare const cowSwapper: Swapper;

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

@@ -0,0 +1,24 @@
+import { SigningScheme } from '@shapeshiftoss/types';
+import { assertGetCowNetwork, signCowOrder } from '../../cowswap-utils/index.js';
+import { cowService } from './utils/cowService.js';
+export const cowSwapper = {
+    executeEvmMessage: async ({ chainId, orderToSign }, { signMessage }, config) => {
+        // Removes the types that aren't part of GpV2Order types or structured signing will fail
+        const { appDataHash, appData } = orderToSign;
+        if (!appDataHash)
+            throw Error('Missing appDataHash');
+        const signature = await signCowOrder(orderToSign, chainId, signMessage);
+        const network = assertGetCowNetwork(chainId);
+        const maybeOrdersResponse = await cowService.post(`${config.VITE_COWSWAP_BASE_URL}/${network}/api/v1/orders/`, {
+            ...orderToSign,
+            signingScheme: SigningScheme.EIP712,
+            signature,
+            appData,
+            appDataHash,
+        });
+        if (maybeOrdersResponse.isErr())
+            throw maybeOrdersResponse.unwrapErr();
+        const { data: orderUid } = maybeOrdersResponse.unwrap();
+        return orderUid;
+    },
+};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,178 @@
+import { ethChainId } from '@shapeshiftoss/caip';
+import { Ok } from '@sniptt/monads';
+import { describe, expect, it, vi } from 'vitest';
+import { cowApi } from './endpoints.js';
+import { cowService } from './utils/cowService.js';
+const mockedCowService = vi.mocked(cowService);
+const mocks = vi.hoisted(() => ({
+    get: vi.fn(),
+    post: vi.fn(),
+}));
+vi.mock('./utils/cowService', () => {
+    const mockAxios = {
+        default: {
+            create: vi.fn(() => ({
+                get: mocks.get,
+                post: mocks.post,
+            })),
+        },
+    };
+    return {
+        cowService: mockAxios.default.create(),
+    };
+});
+vi.mock('./getCowSwapTradeQuote/getCowSwapTradeQuote', () => ({
+    getCowSwapTradeQuote: vi.fn(),
+}));
+vi.mock('@/state/slices/assetsSlice/selectors', async () => {
+    const { BTC, ETH, FOX_GNOSIS, FOX_MAINNET, WBTC, WETH, XDAI, ETH_ARBITRUM, USDC_ARBITRUM, } = require('@/lib/swapper/swappers/utils/test-data/assets');
+    const actual = await vi.importActual('@/state/slices/assetsSlice/selectors');
+    return {
+        ...actual,
+        selectAssets: vi.fn(() => ({
+            [BTC.assetId]: BTC,
+            [ETH.assetId]: ETH,
+            [FOX_GNOSIS.assetId]: FOX_GNOSIS,
+            [FOX_MAINNET.assetId]: FOX_MAINNET,
+            [WBTC.assetId]: WBTC,
+            [WETH.assetId]: WETH,
+            [XDAI.assetId]: XDAI,
+            [ETH_ARBITRUM.assetId]: ETH_ARBITRUM,
+            [USDC_ARBITRUM.assetId]: USDC_ARBITRUM,
+        })),
+    };
+});
+const MOCK_COWSWAP_CONFIG = {
+    VITE_COWSWAP_BASE_URL: 'https://api.cow.fi',
+};
+describe('cowApi', () => {
+    describe('getUnsignedEvmMessage', () => {
+        it('should return the correct unsigned message', async () => {
+            const from = '0x90a48d5cf7343b08da12e067680b4c6dbfe551be';
+            const stepIndex = 0;
+            const chainId = ethChainId;
+            const slippageTolerancePercentageDecimal = '0.005'; // 0.5%
+            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 tradeQuote = {
+                id: '474004127',
+                quoteOrRate: 'quote',
+                receiveAddress: '0x90a48d5cf7343b08da12e067680b4c6dbfe551be',
+                affiliateBps: '0',
+                rate: '0.00002965519158928897',
+                slippageTolerancePercentageDecimal: '0.005',
+                steps: [
+                    {
+                        allowanceContract: '0xc92e8bdf79f0507f65a392b0ab4667716bfe0110',
+                        rate: '0.00002965519158928897',
+                        feeData: {
+                            networkFeeCryptoBaseUnit: '0',
+                            protocolFees: {
+                                'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d': {
+                                    amountCryptoBaseUnit: '291070363839288541184',
+                                    requiresBalance: true,
+                                    asset: {
+                                        assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                                        chainId: 'eip155:1',
+                                        name: 'FOX',
+                                        precision: 18,
+                                        color: '#3761F9',
+                                        icon: '/fox-token-logo.png',
+                                        symbol: 'FOX',
+                                        explorer: 'https://etherscan.io',
+                                        explorerAddressLink: 'https://etherscan.io/address/',
+                                        explorerTxLink: 'https://etherscan.io/tx/',
+                                        relatedAssetKey: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                                    },
+                                },
+                            },
+                        },
+                        sellAmountIncludingProtocolFeesCryptoBaseUnit: '9939765023954833707731',
+                        buyAmountBeforeFeesCryptoBaseUnit: '294765636137894062',
+                        buyAmountAfterFeesCryptoBaseUnit: '286133888732275878',
+                        source: 'CoW Swap',
+                        buyAsset: {
+                            assetId: 'eip155:1/slip44:60',
+                            chainId: 'eip155:1',
+                            symbol: 'ETH',
+                            name: 'Ethereum',
+                            networkName: 'Ethereum',
+                            precision: 18,
+                            color: '#5C6BC0',
+                            icon: 'https://rawcdn.githack.com/trustwallet/assets/32e51d582a890b3dd3135fe3ee7c20c2fd699a6d/blockchains/ethereum/info/logo.png',
+                            explorer: 'https://etherscan.io',
+                            explorerAddressLink: 'https://etherscan.io/address/',
+                            explorerTxLink: 'https://etherscan.io/tx/',
+                            relatedAssetKey: 'eip155:1/slip44:60',
+                        },
+                        sellAsset: {
+                            assetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                            chainId: 'eip155:1',
+                            name: 'FOX',
+                            precision: 18,
+                            color: '#3761F9',
+                            icon: '/fox-token-logo.png',
+                            symbol: 'FOX',
+                            explorer: 'https://etherscan.io',
+                            explorerAddressLink: 'https://etherscan.io/address/',
+                            explorerTxLink: 'https://etherscan.io/tx/',
+                            relatedAssetKey: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                        },
+                        accountNumber: 0,
+                        cowswapQuoteResponse,
+                    },
+                ],
+            };
+            mockedCowService.post.mockReturnValue(Promise.resolve(Ok({ data: cowswapQuoteResponse })));
+            const actual = await cowApi.getUnsignedEvmMessage?.({
+                from,
+                slippageTolerancePercentageDecimal,
+                tradeQuote,
+                stepIndex,
+                chainId,
+                config: MOCK_COWSWAP_CONFIG,
+            });
+            const expected = {
+                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,
+                },
+            };
+            expect(actual).toEqual(expected);
+        });
+    });
+});

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

@@ -0,0 +1,6 @@
+export declare enum CowStatusMessage {
+    Open = "Order Placed",
+    Fulfilled = "Order Fulfilled",
+    Cancelled = "Order Cancelled",
+    Expired = "Order Expired"
+}

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

@@ -0,0 +1,7 @@
+export var CowStatusMessage;
+(function (CowStatusMessage) {
+    CowStatusMessage["Open"] = "Order Placed";
+    CowStatusMessage["Fulfilled"] = "Order Fulfilled";
+    CowStatusMessage["Cancelled"] = "Order Cancelled";
+    CowStatusMessage["Expired"] = "Order Expired";
+})(CowStatusMessage || (CowStatusMessage = {}));

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

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types.js';
+export declare const cowApi: SwapperApi;

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

@@ -0,0 +1,145 @@
+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 { 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 }) => {
+        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 };
+    },
+    getEvmTransactionFees: () => {
+        // No transaction fees for CoW
+        return Promise.resolve('0');
+    },
+    checkTradeStatus: async ({ txHash, // TODO: this is not a tx hash, its an ID
+    chainId, address, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, config, }) => {
+        const maybeSafeTransactionStatus = await checkSafeTransactionStatus({
+            txHash,
+            chainId,
+            assertGetEvmChainAdapter,
+            fetchIsSmartContractAddressQuery,
+            address,
+        });
+        if (maybeSafeTransactionStatus)
+            return maybeSafeTransactionStatus;
+        const network = assertGetCowNetwork(chainId);
+        // 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
+        const tradesResponse = await cowService.get(`${config.VITE_COWSWAP_BASE_URL}/${network}/api/v1/trades`, { params: { orderUid: txHash } });
+        if (tradesResponse.isErr())
+            throw tradesResponse.unwrapErr();
+        const { data: trades } = tradesResponse.unwrap();
+        if (trades.length) {
+            const buyTxHash = trades[0]?.txHash;
+            if (buyTxHash) {
+                return {
+                    status: TxStatus.Confirmed,
+                    buyTxHash,
+                    message: CowStatusMessage.Fulfilled,
+                };
+            }
+        }
+        else {
+            const ordersResponse = await cowService.get(`${config.VITE_COWSWAP_BASE_URL}/${network}/api/v1/orders/${txHash}`);
+            if (ordersResponse.isErr())
+                throw ordersResponse.unwrapErr();
+            const { data: order } = ordersResponse.unwrap();
+            switch (order.status) {
+                case 'cancelled':
+                    return {
+                        status: TxStatus.Failed,
+                        buyTxHash: undefined,
+                        message: CowStatusMessage.Cancelled,
+                    };
+                case 'expired':
+                    return {
+                        status: TxStatus.Failed,
+                        buyTxHash: undefined,
+                        message: CowStatusMessage.Expired,
+                    };
+                default:
+            }
+        }
+        return {
+            status: TxStatus.Pending,
+            buyTxHash: undefined,
+            message: CowStatusMessage.Open,
+        };
+    },
+};

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

@@ -0,0 +1,3 @@
+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>>;

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

@@ -0,0 +1,124 @@
+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 { 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,
+    });
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const id = cowswapQuoteResponse.id?.toString();
+    if (!id) {
+        return Err(makeSwapErrorRight({
+            message: `[CowSwap: getCowSwapTradeQuote] - missing quote ID`,
+            code: TradeQuoteError.InvalidResponse,
+        }));
+    }
+    const quote = {
+        id,
+        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,
+                buyAsset,
+                sellAsset,
+                accountNumber,
+                cowswapQuoteResponse,
+            },
+        ],
+    };
+    return Ok(quote);
+}

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

@@ -0,0 +1 @@
+export {};