@shapeshiftoss/swapper 17.6.3 → 17.6.5

package/dist/cjs/swappers/ChainflipSwapper/utils/getQuoteOrRate.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQuoteOrRate = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const uuid_1 = require("uuid");
+const constants_1 = require("../../../constants");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const constants_2 = require("../constants");
+const chainflipService_1 = require("./chainflipService");
+const getEvmTxFees_1 = require("./getEvmTxFees");
+const getUtxoTxFees_1 = require("./getUtxoTxFees");
+const helpers_1 = require("./helpers");
+const getQuoteOrRate = async (input, deps) => {
+    const { accountNumber, receiveAddress, sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps: commissionBps, quoteOrRate, } = input;
+    if (!(0, helpers_1.isSupportedChainId)(sellAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!(0, helpers_1.isSupportedChainId)(buyAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!(0, helpers_1.isSupportedAssetId)(sellAsset.chainId, sellAsset.assetId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `asset '${sellAsset.name}' on chainId '${sellAsset.chainId}' not supported`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+            details: { chainId: sellAsset.chainId, assetId: sellAsset.assetId },
+        }));
+    }
+    if (!(0, helpers_1.isSupportedAssetId)(buyAsset.chainId, buyAsset.assetId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `asset '${buyAsset.name}' on chainId '${buyAsset.chainId}' not supported`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+            details: { chainId: buyAsset.chainId, assetId: buyAsset.assetId },
+        }));
+    }
+    const brokerUrl = deps.config.VITE_CHAINFLIP_API_URL;
+    const apiKey = deps.config.VITE_CHAINFLIP_API_KEY;
+    const maybeSourceAsset = await (0, helpers_1.getChainFlipIdFromAssetId)({
+        assetId: sellAsset.assetId,
+        brokerUrl,
+    });
+    const maybeDestinationAsset = await (0, helpers_1.getChainFlipIdFromAssetId)({
+        assetId: buyAsset.assetId,
+        brokerUrl,
+    });
+    if (maybeSourceAsset.isErr())
+        return (0, monads_1.Err)(maybeSourceAsset.unwrapErr());
+    if (maybeDestinationAsset.isErr())
+        return (0, monads_1.Err)(maybeDestinationAsset.unwrapErr());
+    const sourceAsset = maybeSourceAsset.unwrap();
+    const destinationAsset = maybeDestinationAsset.unwrap();
+    const serviceCommission = parseInt(commissionBps);
+    const maybeQuoteResponse = await chainflipService_1.chainflipService.get(`${brokerUrl}/quotes-native` +
+        `?apiKey=${apiKey}` +
+        `&sourceAsset=${sourceAsset}` +
+        `&destinationAsset=${destinationAsset}` +
+        `&amount=${sellAmountIncludingProtocolFeesCryptoBaseUnit}` +
+        `&commissionBps=${serviceCommission}`);
+    if (maybeQuoteResponse.isErr()) {
+        const error = maybeQuoteResponse.unwrapErr();
+        const cause = error.cause;
+        if (cause.message.includes('code 400') &&
+            cause.response?.data.detail.includes('Amount outside asset bounds')) {
+            return (0, monads_1.Err)((0, utils_2.createTradeAmountTooSmallErr)({
+                assetId: sellAsset.assetId,
+                minAmountCryptoBaseUnit: cause.response?.data.errors.minimalAmountNative[0],
+            }));
+        }
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Quote request failed',
+            code: types_1.TradeQuoteError.NoRouteFound,
+        }));
+    }
+    const { data: quoteResponse } = maybeQuoteResponse.unwrap();
+    const getFeeData = async () => {
+        const { chainNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+        switch (chainNamespace) {
+            case caip_1.CHAIN_NAMESPACE.Evm: {
+                const sellAdapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+                const networkFeeCryptoBaseUnit = await (0, getEvmTxFees_1.getEvmTxFees)({
+                    adapter: sellAdapter,
+                    supportsEIP1559: input.supportsEIP1559,
+                    sendAsset: sourceAsset,
+                });
+                return { networkFeeCryptoBaseUnit };
+            }
+            case caip_1.CHAIN_NAMESPACE.Utxo: {
+                const sellAdapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
+                const pubKey = input.xpub;
+                return await (0, getUtxoTxFees_1.getUtxoTxFees)({
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    sellAdapter,
+                    pubKey,
+                });
+            }
+            case caip_1.CHAIN_NAMESPACE.Solana: {
+                if (!input.sendAddress)
+                    return { networkFeeCryptoBaseUnit: undefined };
+                const sellAdapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+                const getFeeDataInput = {
+                    // Simulates a self-send, since we don't know the 'to' just yet at this stage
+                    to: input.sendAddress,
+                    value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    chainSpecific: {
+                        from: input.sendAddress,
+                        tokenId: sellAsset.assetId === caip_1.solAssetId
+                            ? undefined
+                            : (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference,
+                    },
+                };
+                const { fast } = await sellAdapter.getFeeData(getFeeDataInput);
+                return { networkFeeCryptoBaseUnit: fast.txFee };
+            }
+            default:
+                throw new Error('Unsupported chainNamespace');
+        }
+    };
+    const getFeeAsset = (fee) => {
+        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 constants_2.usdcAsset;
+        if (fee.type === 'network')
+            return constants_2.usdcAsset;
+    };
+    const getProtocolFees = (singleQuoteResponse) => {
+        const protocolFees = {};
+        for (const fee of singleQuoteResponse.includedFees ?? []) {
+            if (fee.type === 'broker')
+                continue;
+            const asset = getFeeAsset(fee);
+            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;
+    };
+    const getChainflipQuoteRate = (sellAmountCryptoBaseUnit, buyAmountCryptoBaseUnit) => {
+        return (0, utils_2.getInputOutputRate)({
+            sellAmountCryptoBaseUnit,
+            buyAmountCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+    };
+    const getSwapSource = (swapType, isBoosted) => {
+        if (swapType === constants_2.CHAINFLIP_REGULAR_QUOTE) {
+            return isBoosted ? constants_2.CHAINFLIP_BOOST_SWAP_SOURCE : constants_2.CHAINFLIP_SWAP_SOURCE;
+        }
+        if (swapType === constants_2.CHAINFLIP_DCA_QUOTE) {
+            return isBoosted ? constants_2.CHAINFLIP_DCA_BOOST_SWAP_SOURCE : constants_2.CHAINFLIP_DCA_SWAP_SOURCE;
+        }
+        return (0, utils_1.assertUnreachable)(swapType);
+    };
+    const getMaxBoostFee = () => {
+        const { chainNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+        switch (chainNamespace) {
+            case caip_1.CHAIN_NAMESPACE.Evm:
+                return 0;
+            case caip_1.CHAIN_NAMESPACE.Utxo:
+                return 10;
+            case caip_1.CHAIN_NAMESPACE.Solana:
+                return 0;
+            default:
+                throw new Error('Unsupported chainNamespace');
+        }
+    };
+    const ratesOrQuotes = [];
+    for (const singleQuoteResponse of quoteResponse) {
+        const isStreaming = singleQuoteResponse.type === constants_2.CHAINFLIP_DCA_QUOTE;
+        if (isStreaming && !deps.config.VITE_FEATURE_CHAINFLIP_SWAP_DCA)
+            continue;
+        const feeData = await getFeeData();
+        if (!singleQuoteResponse.type)
+            throw new Error('Missing quote type');
+        if (singleQuoteResponse.boostQuote &&
+            singleQuoteResponse.boostQuote.ingressAmountNative &&
+            singleQuoteResponse.boostQuote.egressAmountNative) {
+            const boostRate = getChainflipQuoteRate(singleQuoteResponse.boostQuote.ingressAmountNative, singleQuoteResponse.boostQuote.egressAmountNative);
+            // This is not really a buyAmount before fees but rather an input/output calculation to get the sell amount
+            // prorated to the buy asset price to determine price impact
+            const buyAmountBeforeFeesCryptoBaseUnit = (0, utils_1.toBaseUnit)((0, utils_1.bnOrZero)(singleQuoteResponse.boostQuote.ingressAmount).times((0, utils_1.bnOrZero)(singleQuoteResponse.estimatedPrice)), buyAsset.precision);
+            const boostTradeRateOrQuote = {
+                id: (0, uuid_1.v4)(),
+                rate: boostRate,
+                receiveAddress,
+                quoteOrRate,
+                affiliateBps: commissionBps,
+                isStreaming,
+                slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal ??
+                    (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.Chainflip),
+                swapperName: types_1.SwapperName.Chainflip,
+                steps: [
+                    {
+                        buyAmountBeforeFeesCryptoBaseUnit,
+                        buyAmountAfterFeesCryptoBaseUnit: singleQuoteResponse.boostQuote.egressAmountNative,
+                        sellAmountIncludingProtocolFeesCryptoBaseUnit: singleQuoteResponse.boostQuote.ingressAmountNative,
+                        feeData: {
+                            protocolFees: getProtocolFees(singleQuoteResponse.boostQuote),
+                            ...feeData,
+                        },
+                        rate: boostRate,
+                        source: getSwapSource(singleQuoteResponse.type, true),
+                        buyAsset,
+                        sellAsset,
+                        accountNumber,
+                        allowanceContract: '0x0',
+                        estimatedExecutionTimeMs: (singleQuoteResponse.boostQuote.estimatedDurationsSeconds?.deposit ?? 0) +
+                            (singleQuoteResponse.boostQuote.estimatedDurationsSeconds?.swap ?? 0) * 1000,
+                        chainflipSpecific: {
+                            chainflipNumberOfChunks: isStreaming
+                                ? singleQuoteResponse.boostQuote.numberOfChunks ?? undefined
+                                : undefined,
+                            chainflipChunkIntervalBlocks: isStreaming
+                                ? singleQuoteResponse.boostQuote.chunkIntervalBlocks ?? undefined
+                                : undefined,
+                            chainflipMaxBoostFee: getMaxBoostFee(),
+                        },
+                    },
+                ],
+            };
+            ratesOrQuotes.push(boostTradeRateOrQuote);
+        }
+        const rate = singleQuoteResponse.ingressAmountNative && singleQuoteResponse.egressAmountNative
+            ? getChainflipQuoteRate(singleQuoteResponse.ingressAmountNative, singleQuoteResponse.egressAmountNative)
+            : '0';
+        // This is not really a buyAmount before fees but rather an input/output calculation to get the sell amount
+        // prorated to the buy asset price to determine price impact
+        const buyAmountBeforeFeesCryptoBaseUnit = (0, utils_1.toBaseUnit)((0, utils_1.bnOrZero)(singleQuoteResponse.ingressAmount).times((0, utils_1.bnOrZero)(singleQuoteResponse.estimatedPrice)), buyAsset.precision);
+        const tradeRateOrQuote = {
+            id: (0, uuid_1.v4)(),
+            rate,
+            receiveAddress,
+            quoteOrRate,
+            affiliateBps: commissionBps,
+            isStreaming,
+            slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal ??
+                (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.Chainflip),
+            swapperName: types_1.SwapperName.Chainflip,
+            steps: [
+                {
+                    buyAmountBeforeFeesCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit: singleQuoteResponse.egressAmountNative,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: singleQuoteResponse.ingressAmountNative,
+                    feeData: {
+                        protocolFees: getProtocolFees(singleQuoteResponse),
+                        ...feeData,
+                    },
+                    rate,
+                    source: getSwapSource(singleQuoteResponse.type, false),
+                    buyAsset,
+                    sellAsset,
+                    accountNumber,
+                    allowanceContract: '0x0',
+                    estimatedExecutionTimeMs: ((singleQuoteResponse.estimatedDurationsSeconds?.deposit ?? 0) +
+                        (singleQuoteResponse.estimatedDurationsSeconds?.swap ?? 0)) *
+                        1000,
+                    chainflipSpecific: {
+                        chainflipNumberOfChunks: isStreaming
+                            ? singleQuoteResponse.numberOfChunks ?? undefined
+                            : undefined,
+                        chainflipChunkIntervalBlocks: isStreaming
+                            ? singleQuoteResponse.chunkIntervalBlocks ?? undefined
+                            : undefined,
+                        chainflipMaxBoostFee: 0,
+                    },
+                },
+            ],
+        };
+        ratesOrQuotes.push(tradeRateOrQuote);
+    }
+    return (0, monads_1.Ok)(ratesOrQuotes);
+};
+exports.getQuoteOrRate = getQuoteOrRate;

package/dist/cjs/swappers/ChainflipSwapper/utils/getUtxoTxFees.d.ts

@@ -0,0 +1,9 @@
+import type { UtxoChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { QuoteFeeData } from '../../../types';
+type GetUtxoTxFeesInput = {
+    sellAmountCryptoBaseUnit: string;
+    sellAdapter: UtxoChainAdapter;
+    pubKey: string | undefined;
+};
+export declare const getUtxoTxFees: ({ sellAmountCryptoBaseUnit, sellAdapter, pubKey, }: GetUtxoTxFeesInput) => Promise<Omit<QuoteFeeData, 'protocolFees'>>;
+export {};

package/dist/cjs/swappers/ChainflipSwapper/utils/getUtxoTxFees.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUtxoTxFees = void 0;
+const getUtxoTxFees = async ({ sellAmountCryptoBaseUnit, sellAdapter, pubKey, }) => {
+    // Can't do coinselect simulation without a pubkey
+    if (!pubKey)
+        return {
+            networkFeeCryptoBaseUnit: undefined,
+        };
+    const getFeeDataInput = {
+        // One of many vault addresses - just used as a placeholder for the sake of loosely estimating fees - we *need* a *to* address for simulation or this will throw
+        to: 'bc1pfh5x55a3v92klcrdy5yv6yrt7fzr0g929klkdtapp3njfyu4qsyq8qacyf',
+        value: sellAmountCryptoBaseUnit,
+        chainSpecific: { pubkey: pubKey },
+    };
+    const feeDataOptions = await sellAdapter.getFeeData(getFeeDataInput);
+    const feeData = feeDataOptions['fast'];
+    return {
+        networkFeeCryptoBaseUnit: feeData.txFee,
+        chainSpecific: {
+            satsPerByte: feeData.chainSpecific.satoshiPerByte,
+        },
+    };
+};
+exports.getUtxoTxFees = getUtxoTxFees;

package/dist/cjs/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';
+import type { ChainflipBaasSwapDepositAddress } from '../models';
+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/cjs/swappers/ChainflipSwapper/utils/helpers.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChainFlipIdFromAssetId = exports.getChainFlipSwap = exports.calculateChainflipMinPrice = exports.isSupportedAssetId = exports.isSupportedChainId = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const constants_1 = require("../constants");
+const chainflipService_1 = require("./chainflipService");
+const isSupportedChainId = (chainId) => {
+    return constants_1.ChainflipSupportedChainIds.includes(chainId);
+};
+exports.isSupportedChainId = isSupportedChainId;
+const isSupportedAssetId = (chainId, assetId) => {
+    const supportedAssetIds = constants_1.ChainflipSupportedAssetIdsByChainId[chainId];
+    if (!supportedAssetIds)
+        return false;
+    return supportedAssetIds.includes(assetId);
+};
+exports.isSupportedAssetId = isSupportedAssetId;
+const calculateChainflipMinPrice = ({ sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAmountAfterFeesCryptoBaseUnit, slippageTolerancePercentageDecimal, sellAsset, buyAsset, }) => {
+    const sellAmountCryptoPrecision = (0, utils_1.fromBaseUnit)(sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset.precision);
+    const buyAmountCryptoPrecision = (0, utils_1.fromBaseUnit)(buyAmountAfterFeesCryptoBaseUnit, buyAsset.precision);
+    const estimatedPrice = (0, utils_1.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((0, utils_1.bn)(1).minus((0, utils_1.bnOrZero)(slippageTolerancePercentageDecimal)))
+        .toFixed(buyAsset.precision);
+    return minimumRate;
+};
+exports.calculateChainflipMinPrice = calculateChainflipMinPrice;
+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_1.chainflipService.get(swapUrl);
+};
+exports.getChainFlipSwap = getChainFlipSwap;
+const fetchChainFlipAssets = async ({ brokerUrl, }) => {
+    const result = await chainflipService_1.chainflipService.get(`${brokerUrl}/assets`);
+    return result.map(({ data }) => data.assets);
+};
+const getChainFlipIdFromAssetId = async ({ assetId, brokerUrl, }) => {
+    const maybeChainflipAssets = await fetchChainFlipAssets({
+        brokerUrl,
+    });
+    const { assetReference, chainId } = (0, caip_1.fromAssetId)(assetId);
+    const _isToken = (0, utils_1.isToken)(assetId);
+    if (maybeChainflipAssets.isErr()) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Error fetching Chainflip assets`,
+            code: types_1.TradeQuoteError.QueryFailed,
+        }));
+    }
+    const chainflipAssets = maybeChainflipAssets.unwrap();
+    const chainflipAsset = chainflipAssets.find(asset => {
+        const isCorrectNetwork = asset.network === constants_1.chainIdToChainflipNetwork[chainId];
+        if (!isCorrectNetwork)
+            return false;
+        if (_isToken) {
+            return asset.contractAddress?.toLowerCase() === assetReference.toLowerCase();
+        }
+        return !asset.contractAddress;
+    });
+    if (!chainflipAsset)
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Asset not supported by Chainflip`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    return (0, monads_1.Ok)(chainflipAsset.id);
+};
+exports.getChainFlipIdFromAssetId = getChainFlipIdFromAssetId;

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

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

package/dist/cjs/swappers/CowSwapper/CowSwapper.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cowSwapper = void 0;
+const types_1 = require("@shapeshiftoss/types");
+const cowswap_utils_1 = require("../../cowswap-utils");
+const cowService_1 = require("./utils/cowService");
+exports.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 (0, cowswap_utils_1.signCowOrder)(orderToSign, chainId, signMessage);
+        const network = (0, cowswap_utils_1.assertGetCowNetwork)(chainId);
+        const maybeOrdersResponse = await cowService_1.cowService.post(`${config.VITE_COWSWAP_BASE_URL}/${network}/api/v1/orders/`, {
+            ...orderToSign,
+            signingScheme: types_1.SigningScheme.EIP712,
+            signature,
+            appData,
+            appDataHash,
+        });
+        if (maybeOrdersResponse.isErr())
+            throw maybeOrdersResponse.unwrapErr();
+        const { data: orderUid } = maybeOrdersResponse.unwrap();
+        return orderUid;
+    },
+};

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

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