@shapeshiftoss/swapper 17.8.0 → 19.0.0

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

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChainflipStepData = exports.CHAINFLIP_SOLANA_COMPUTE_BUDGET = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const evm_1 = require("../../../utils/evm");
+const helpers_1 = require("../../../utils/helpers");
+const solana_1 = require("../../../utils/solana");
+const utxo_1 = require("../../../utils/utxo");
+// Deposits are plain transfers - 21k intrinsic for natives, tokens measured ~50-65k to a fresh
+// deposit address across the supported set (usdc/usdt/flip)
+const SAFE_NATIVE_TRANSFER_GAS_LIMIT = '21000';
+const SAFE_TOKEN_TRANSFER_GAS_LIMIT = '65000';
+// Deposits are plain (token) transfers with constant measured compute consumption (max 15394 CU
+// with ata creation), so the margin is safety only; the floor guarantees the limit covers full
+// ata recreation if the deposit ata is closed between simulation and landing (a no-op create
+// simulates ~3x cheaper than a real one)
+exports.CHAINFLIP_SOLANA_COMPUTE_BUDGET = {
+    marginMultiplier: 1.1,
+    minComputeUnits: 20_000,
+};
+async function getChainflipStepData(args) {
+    const { deps, type, input, sellAsset, sellAmountCryptoBaseUnit, depositAddress, from } = args;
+    const { chainNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+    switch (chainNamespace) {
+        case caip_1.CHAIN_NAMESPACE.Evm: {
+            const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+            const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+            if (type === 'rate') {
+                try {
+                    const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                        adapter,
+                        supportsEIP1559,
+                        gasLimit: (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId)
+                            ? SAFE_NATIVE_TRANSFER_GAS_LIMIT
+                            : SAFE_TOKEN_TRANSFER_GAS_LIMIT,
+                    });
+                    const stepData = { networkFeeCryptoBaseUnit };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                catch (error) {
+                    return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getChainflipStepData', error));
+                }
+            }
+            const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+            const data = chain_adapters_1.evm.getErc20Data(depositAddress, sellAmountCryptoBaseUnit, contractAddress);
+            const transactionData = {
+                type: 'evm',
+                chainId: Number((0, caip_1.fromChainId)(sellAsset.chainId).chainReference),
+                to: contractAddress ?? depositAddress,
+                data: data || '0x',
+                value: (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) ? sellAmountCryptoBaseUnit : '0',
+            };
+            try {
+                // The deposit is a plain (token) transfer with no approval involved, but estimation
+                // still reverts for an unfunded sender - override the missing balance only
+                const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    transactionData,
+                    from,
+                    supportsEIP1559,
+                    stateOverride: { sellAsset, sellAmountCryptoBaseUnit },
+                });
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return (0, monads_1.Ok)(stepData);
+            }
+            catch (error) {
+                return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getChainflipStepData', error));
+            }
+        }
+        case caip_1.CHAIN_NAMESPACE.Utxo: {
+            const adapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
+            try {
+                const { networkFeeCryptoBaseUnit } = await (0, utxo_1.getUtxoNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    pubkey: 'xpub' in input ? input.xpub : undefined,
+                    to: depositAddress ?? utxo_1.UTXO_PLACEHOLDER_ADDRESS,
+                    value: sellAmountCryptoBaseUnit,
+                });
+                if (type === 'rate') {
+                    const stepData = { networkFeeCryptoBaseUnit };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                const transactionData = {
+                    type: 'utxo',
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                };
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return (0, monads_1.Ok)(stepData);
+            }
+            catch (error) {
+                return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getChainflipStepData', error));
+            }
+        }
+        case caip_1.CHAIN_NAMESPACE.Solana: {
+            const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+            const tokenId = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+            try {
+                if (type === 'rate') {
+                    // No deposit channel yet - estimate via a self transfer (placeholder sender when walletless),
+                    // plus static ATA rent for token sells since the transfer omits the deposit ATA creation
+                    const address = from ?? solana_1.SOLANA_PLACEHOLDER_ADDRESS;
+                    const instructions = await adapter.buildTransferInstructions({
+                        from: address,
+                        to: address,
+                        tokenId: from ? tokenId : undefined,
+                        value: from ? sellAmountCryptoBaseUnit : '1',
+                    });
+                    const { networkFeeCryptoBaseUnit } = await (0, solana_1.getSolanaNetworkFeeCryptoBaseUnit)({
+                        adapter,
+                        from: address,
+                        instructions,
+                        tokenId,
+                    });
+                    const stepData = {
+                        networkFeeCryptoBaseUnit: (0, utils_1.bn)(networkFeeCryptoBaseUnit)
+                            .plus(tokenId ? solana_1.ATA_RENT_LAMPORTS : 0)
+                            .toString(),
+                    };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                const instructions = await adapter.buildTransferInstructions({
+                    from,
+                    to: depositAddress,
+                    tokenId,
+                    value: sellAmountCryptoBaseUnit,
+                });
+                const { networkFeeCryptoBaseUnit, feeData, includeComputeBudget } = await (0, solana_1.getSolanaNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    from,
+                    instructions,
+                    tokenId,
+                });
+                const transactionData = {
+                    type: 'solana_instructions',
+                    instructions: (0, solana_1.withComputeUnitLimit)({
+                        instructions,
+                        computeUnits: feeData.chainSpecific.computeUnits,
+                        includeComputeBudget,
+                        computeBudget: exports.CHAINFLIP_SOLANA_COMPUTE_BUDGET,
+                    }),
+                    addressLookupTableAddresses: [],
+                };
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return (0, monads_1.Ok)(stepData);
+            }
+            catch (error) {
+                return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getChainflipStepData', error));
+            }
+        }
+        // Un-migrated - exec builds its tx from chainflipSpecific.depositAddress, so no transactionData is carried
+        case caip_1.CHAIN_NAMESPACE.Tron: {
+            const to = depositAddress ?? from;
+            if (!to || !from) {
+                const stepData = { networkFeeCryptoBaseUnit: undefined };
+                return (0, monads_1.Ok)(stepData);
+            }
+            try {
+                const { fast } = await deps.assertGetTronChainAdapter(sellAsset.chainId).getFeeData({
+                    to,
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: {
+                        from,
+                        contractAddress: (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId),
+                    },
+                });
+                const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                return (0, monads_1.Ok)(stepData);
+            }
+            catch (error) {
+                return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getChainflipStepData', error));
+            }
+        }
+        default:
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `[getChainflipStepData] unsupported chainNamespace: ${chainNamespace}`,
+                code: types_1.TradeQuoteError.UnsupportedChain,
+            }));
+    }
+}
+exports.getChainflipStepData = getChainflipStepData;

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

@@ -0,0 +1,19 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types';
+import type { ChainflipTradeQuoteInput, ChainflipTradeRateInput } from '../types';
+import type { GetChainflipStepDataArgs } from './getChainflipStepData';
+export type ChainflipTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: Omit<GetChainflipStepDataArgs, 'type' | 'input' | 'depositAddress' | 'from'>;
+    channelParams: {
+        sourceAsset: string;
+        destinationAsset: string;
+        maxBoostFee: number;
+        numberOfChunks: number | undefined;
+        chunkIntervalBlocks: number | undefined;
+        buyAmountAfterFeesCryptoBaseUnit: string;
+    };
+};
+export declare const getChainflipTradeContexts: (input: ChainflipTradeQuoteInput | ChainflipTradeRateInput, deps: SwapperDeps) => Promise<Result<ChainflipTradeContext[], SwapErrorRight>>;

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

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChainflipTradeContexts = void 0;
+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 affiliateFee_1 = require("../../../utils/affiliateFee");
+const constants_2 = require("../constants");
+const chainflipService_1 = require("./chainflipService");
+const helpers_1 = require("./helpers");
+const getChainflipTradeContexts = async (input, deps) => {
+    const brokerUrl = deps.config.VITE_CHAINFLIP_API_URL;
+    const apiKey = deps.config.VITE_CHAINFLIP_API_KEY;
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const assertion = (0, helpers_1.assertValidTrade)({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    const maybeSourceAsset = await (0, helpers_1.getChainFlipIdFromAssetId)({
+        assetId: sellAsset.assetId,
+        brokerUrl,
+    });
+    if (maybeSourceAsset.isErr())
+        return (0, monads_1.Err)(maybeSourceAsset.unwrapErr());
+    const sourceAsset = maybeSourceAsset.unwrap();
+    const maybeDestinationAsset = await (0, helpers_1.getChainFlipIdFromAssetId)({
+        assetId: buyAsset.assetId,
+        brokerUrl,
+    });
+    if (maybeDestinationAsset.isErr())
+        return (0, monads_1.Err)(maybeDestinationAsset.unwrapErr());
+    const destinationAsset = maybeDestinationAsset.unwrap();
+    const maybeQuoteResponse = await chainflipService_1.chainflipService.get(`${brokerUrl}/quotes-native` +
+        `?apiKey=${apiKey}` +
+        `&sourceAsset=${sourceAsset}` +
+        `&destinationAsset=${destinationAsset}` +
+        `&amount=${sellAmountIncludingProtocolFeesCryptoBaseUnit}` +
+        `&commissionBps=${parseInt(affiliateBps)}`);
+    if (maybeQuoteResponse.isErr()) {
+        const error = maybeQuoteResponse.unwrapErr();
+        const cause = error.cause;
+        const minAmountCryptoBaseUnit = cause?.response?.data?.errors?.minimalAmountNative?.[0];
+        if (cause?.response?.status === 400 && minAmountCryptoBaseUnit !== undefined) {
+            return (0, monads_1.Err)((0, utils_2.createTradeAmountTooSmallErr)({ assetId: sellAsset.assetId, minAmountCryptoBaseUnit }));
+        }
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({ message: 'Quote request failed', code: types_1.TradeQuoteError.NoRouteFound }));
+    }
+    const { data: quotes } = maybeQuoteResponse.unwrap();
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.Chainflip);
+    const tradeContexts = [];
+    for (const quote of quotes) {
+        if (!quote.type) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: '[getChainflipTradeContext] Missing quote type',
+                code: types_1.TradeQuoteError.InvalidResponse,
+            }));
+        }
+        const quoteType = quote.type;
+        const isStreaming = quoteType === constants_2.CHAINFLIP_DCA_QUOTE;
+        if (isStreaming && !deps.config.VITE_FEATURE_CHAINFLIP_SWAP_DCA)
+            continue;
+        // estimatedPrice and type only exist on the parent quote, not the boost variant
+        const buildTradeContext = (variantQuote, isBoosted) => {
+            const rate = (0, helpers_1.getChainflipRate)({
+                sellAmountCryptoBaseUnit: variantQuote.ingressAmountNative,
+                buyAmountCryptoBaseUnit: variantQuote.egressAmountNative,
+                sellAsset,
+                buyAsset,
+            });
+            const buyAmountAfterFeesCryptoBaseUnit = variantQuote.egressAmountNative ?? '0';
+            const variantSellAmountCryptoBaseUnit = variantQuote.ingressAmountNative ?? '0';
+            const streamingChunkValue = (value) => isStreaming ? value ?? undefined : undefined;
+            const protocolFees = (0, helpers_1.getProtocolFees)({
+                quote: variantQuote,
+                sellAsset,
+                buyAsset,
+                sourceAsset,
+                destinationAsset,
+            });
+            return {
+                tradeCommon: {
+                    id: (0, uuid_1.v4)(),
+                    rate,
+                    affiliateBps,
+                    isStreaming,
+                    slippageTolerancePercentageDecimal,
+                    swapperName: types_1.SwapperName.Chainflip,
+                },
+                stepCommon: {
+                    // Not a real pre-fee amount, but an input/output calc prorated to the buy asset price to determine price impact
+                    buyAmountBeforeFeesCryptoBaseUnit: utils_1.BigAmount.fromPrecision({
+                        value: (0, utils_1.bnOrZero)(variantQuote.ingressAmount).times((0, utils_1.bnOrZero)(quote.estimatedPrice)),
+                        precision: buyAsset.precision,
+                    }).toBaseUnit(),
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: variantSellAmountCryptoBaseUnit,
+                    rate,
+                    source: (0, helpers_1.getSwapSource)(quoteType, isBoosted),
+                    buyAsset,
+                    sellAsset,
+                    allowanceContract: '',
+                    estimatedExecutionTimeMs: ((variantQuote.estimatedDurationsSeconds?.deposit ?? 0) +
+                        (variantQuote.estimatedDurationsSeconds?.swap ?? 0)) *
+                        1000,
+                    affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: variantSellAmountCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    }),
+                },
+                protocolFees,
+                stepDataArgs: {
+                    deps,
+                    sellAsset,
+                    sellAmountCryptoBaseUnit: variantSellAmountCryptoBaseUnit,
+                },
+                channelParams: {
+                    sourceAsset,
+                    destinationAsset,
+                    maxBoostFee: isBoosted ? (0, helpers_1.getMaxBoostFee)(sellAsset.assetId) : 0,
+                    numberOfChunks: streamingChunkValue(variantQuote.numberOfChunks),
+                    chunkIntervalBlocks: streamingChunkValue(variantQuote.chunkIntervalBlocks),
+                    buyAmountAfterFeesCryptoBaseUnit,
+                },
+            };
+        };
+        const { boostQuote } = quote;
+        if (boostQuote && boostQuote.ingressAmountNative && boostQuote.egressAmountNative) {
+            tradeContexts.push(buildTradeContext(boostQuote, true));
+        }
+        tradeContexts.push(buildTradeContext(quote, false));
+    }
+    return (0, monads_1.Ok)(tradeContexts);
+};
+exports.getChainflipTradeContexts = getChainflipTradeContexts;

package/dist/cjs/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';
-import type { ChainflipBaasSwapDepositAddress } from '../models';
+import type { ProtocolFee, SwapErrorRight, SwapSource } from '../../../types';
+import { CHAINFLIP_DCA_QUOTE, CHAINFLIP_REGULAR_QUOTE } from '../constants';
+import type { ChainflipBaasQuoteQuote, ChainflipBaasSwapDepositAddress } from '../models';
 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/cjs/swappers/ChainflipSwapper/utils/helpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getChainFlipIdFromAssetId = exports.getChainFlipSwap = exports.calculateChainflipMinPrice = exports.isSupportedAssetId = exports.isSupportedChainId = void 0;
+exports.getProtocolFees = exports.getMaxBoostFee = exports.getSwapSource = exports.getChainflipRate = exports.getChainFlipIdFromAssetId = exports.getChainFlipSwap = exports.calculateChainflipMinPrice = exports.assertValidTrade = exports.isSupportedAssetId = exports.isSupportedChainId = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
 const utils_1 = require("@shapeshiftoss/utils");
 const monads_1 = require("@sniptt/monads");
@@ -19,6 +19,38 @@ const isSupportedAssetId = (chainId, assetId) => {
     return supportedAssetIds.includes(assetId);
 };
 exports.isSupportedAssetId = isSupportedAssetId;
+const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (!(0, exports.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, exports.isSupportedChainId)(buyAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    if (!(0, exports.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, exports.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 },
+        }));
+    }
+    return (0, monads_1.Ok)(true);
+};
+exports.assertValidTrade = assertValidTrade;
 const calculateChainflipMinPrice = ({ sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAmountAfterFeesCryptoBaseUnit, slippageTolerancePercentageDecimal, sellAsset, buyAsset, }) => {
     const sellAmountCryptoPrecision = utils_1.BigAmount.fromBaseUnit({
         value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
@@ -89,3 +121,71 @@ const getChainFlipIdFromAssetId = async ({ assetId, brokerUrl, }) => {
     return (0, monads_1.Ok)(chainflipAsset.id);
 };
 exports.getChainFlipIdFromAssetId = getChainFlipIdFromAssetId;
+const getChainflipRate = ({ sellAmountCryptoBaseUnit, buyAmountCryptoBaseUnit, sellAsset, buyAsset, }) => {
+    if (!sellAmountCryptoBaseUnit || !buyAmountCryptoBaseUnit)
+        return '0';
+    return (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit,
+        buyAmountCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+};
+exports.getChainflipRate = getChainflipRate;
+const getSwapSource = (swapType, isBoosted) => {
+    if (swapType === constants_1.CHAINFLIP_REGULAR_QUOTE) {
+        return isBoosted ? constants_1.CHAINFLIP_BOOST_SWAP_SOURCE : constants_1.CHAINFLIP_SWAP_SOURCE;
+    }
+    if (swapType === constants_1.CHAINFLIP_DCA_QUOTE) {
+        return isBoosted ? constants_1.CHAINFLIP_DCA_BOOST_SWAP_SOURCE : constants_1.CHAINFLIP_DCA_SWAP_SOURCE;
+    }
+    return (0, utils_1.assertUnreachable)(swapType);
+};
+exports.getSwapSource = getSwapSource;
+const getMaxBoostFee = (assetId) => {
+    const { chainNamespace } = (0, caip_1.fromAssetId)(assetId);
+    switch (chainNamespace) {
+        case caip_1.CHAIN_NAMESPACE.Utxo:
+            return 10;
+        case caip_1.CHAIN_NAMESPACE.Evm:
+        case caip_1.CHAIN_NAMESPACE.Solana:
+        case caip_1.CHAIN_NAMESPACE.Tron:
+            return 0;
+        default:
+            throw new Error('Unsupported chainNamespace');
+    }
+};
+exports.getMaxBoostFee = getMaxBoostFee;
+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 constants_1.usdcAsset;
+            if (fee.type === 'network')
+                return constants_1.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;
+};
+exports.getProtocolFees = getProtocolFees;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cowSwapper = void 0;
 const types_1 = require("@shapeshiftoss/types");
-const cowswap_utils_1 = require("../../cowswap-utils");
+const cowswap_1 = require("../../utils/cowswap");
 const cowService_1 = require("./utils/cowService");
 exports.cowSwapper = {
     executeEvmMessage: async ({ chainId, orderToSign }, { signMessage }, config) => {
@@ -10,8 +10,8 @@ exports.cowSwapper = {
         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 signature = await (0, cowswap_1.signCowOrder)(orderToSign, chainId, signMessage);
+        const network = (0, cowswap_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,