@shapeshiftoss/swapper 17.6.3 → 17.6.5

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 {};