@shapeshiftoss/swapper 17.6.6-alpha.1 → 17.6.6

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

@@ -1,293 +0,0 @@
-import { CHAIN_NAMESPACE, fromAssetId, solAssetId } from '@shapeshiftoss/caip';
-import { assertUnreachable, bnOrZero, toBaseUnit } from '@shapeshiftoss/utils';
-import { Err, Ok } from '@sniptt/monads';
-import { v4 as uuid } from 'uuid';
-import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils.js';
-import { CHAINFLIP_BOOST_SWAP_SOURCE, CHAINFLIP_DCA_BOOST_SWAP_SOURCE, CHAINFLIP_DCA_QUOTE, CHAINFLIP_DCA_SWAP_SOURCE, CHAINFLIP_REGULAR_QUOTE, CHAINFLIP_SWAP_SOURCE, usdcAsset, } from '../constants.js';
-import { chainflipService } from './chainflipService.js';
-import { getEvmTxFees } from './getEvmTxFees.js';
-import { getUtxoTxFees } from './getUtxoTxFees.js';
-import { getChainFlipIdFromAssetId, isSupportedAssetId, isSupportedChainId } from './helpers.js';
-export const getQuoteOrRate = async (input, deps) => {
-    const { accountNumber, receiveAddress, sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps: commissionBps, quoteOrRate, } = input;
-    if (!isSupportedChainId(sellAsset.chainId)) {
-        return Err(makeSwapErrorRight({
-            message: `unsupported chainId`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { chainId: sellAsset.chainId },
-        }));
-    }
-    if (!isSupportedChainId(buyAsset.chainId)) {
-        return Err(makeSwapErrorRight({
-            message: `unsupported chainId`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { chainId: sellAsset.chainId },
-        }));
-    }
-    if (!isSupportedAssetId(sellAsset.chainId, sellAsset.assetId)) {
-        return Err(makeSwapErrorRight({
-            message: `asset '${sellAsset.name}' on chainId '${sellAsset.chainId}' not supported`,
-            code: TradeQuoteError.UnsupportedTradePair,
-            details: { chainId: sellAsset.chainId, assetId: sellAsset.assetId },
-        }));
-    }
-    if (!isSupportedAssetId(buyAsset.chainId, buyAsset.assetId)) {
-        return Err(makeSwapErrorRight({
-            message: `asset '${buyAsset.name}' on chainId '${buyAsset.chainId}' not supported`,
-            code: TradeQuoteError.UnsupportedTradePair,
-            details: { chainId: buyAsset.chainId, assetId: buyAsset.assetId },
-        }));
-    }
-    const brokerUrl = deps.config.VITE_CHAINFLIP_API_URL;
-    const apiKey = deps.config.VITE_CHAINFLIP_API_KEY;
-    const maybeSourceAsset = await getChainFlipIdFromAssetId({
-        assetId: sellAsset.assetId,
-        brokerUrl,
-    });
-    const maybeDestinationAsset = await getChainFlipIdFromAssetId({
-        assetId: buyAsset.assetId,
-        brokerUrl,
-    });
-    if (maybeSourceAsset.isErr())
-        return Err(maybeSourceAsset.unwrapErr());
-    if (maybeDestinationAsset.isErr())
-        return Err(maybeDestinationAsset.unwrapErr());
-    const sourceAsset = maybeSourceAsset.unwrap();
-    const destinationAsset = maybeDestinationAsset.unwrap();
-    const serviceCommission = parseInt(commissionBps);
-    const maybeQuoteResponse = await 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 Err(createTradeAmountTooSmallErr({
-                assetId: sellAsset.assetId,
-                minAmountCryptoBaseUnit: cause.response?.data.errors.minimalAmountNative[0],
-            }));
-        }
-        return Err(makeSwapErrorRight({
-            message: 'Quote request failed',
-            code: TradeQuoteError.NoRouteFound,
-        }));
-    }
-    const { data: quoteResponse } = maybeQuoteResponse.unwrap();
-    const getFeeData = async () => {
-        const { chainNamespace } = fromAssetId(sellAsset.assetId);
-        switch (chainNamespace) {
-            case CHAIN_NAMESPACE.Evm: {
-                const sellAdapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
-                const networkFeeCryptoBaseUnit = await getEvmTxFees({
-                    adapter: sellAdapter,
-                    supportsEIP1559: input.supportsEIP1559,
-                    sendAsset: sourceAsset,
-                });
-                return { networkFeeCryptoBaseUnit };
-            }
-            case CHAIN_NAMESPACE.Utxo: {
-                const sellAdapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
-                const pubKey = input.xpub;
-                return await getUtxoTxFees({
-                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    sellAdapter,
-                    pubKey,
-                });
-            }
-            case 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 === solAssetId
-                            ? undefined
-                            : 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 usdcAsset;
-        if (fee.type === 'network')
-            return 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 getInputOutputRate({
-            sellAmountCryptoBaseUnit,
-            buyAmountCryptoBaseUnit,
-            sellAsset,
-            buyAsset,
-        });
-    };
-    const getSwapSource = (swapType, isBoosted) => {
-        if (swapType === CHAINFLIP_REGULAR_QUOTE) {
-            return isBoosted ? CHAINFLIP_BOOST_SWAP_SOURCE : CHAINFLIP_SWAP_SOURCE;
-        }
-        if (swapType === CHAINFLIP_DCA_QUOTE) {
-            return isBoosted ? CHAINFLIP_DCA_BOOST_SWAP_SOURCE : CHAINFLIP_DCA_SWAP_SOURCE;
-        }
-        return assertUnreachable(swapType);
-    };
-    const getMaxBoostFee = () => {
-        const { chainNamespace } = fromAssetId(sellAsset.assetId);
-        switch (chainNamespace) {
-            case CHAIN_NAMESPACE.Evm:
-                return 0;
-            case CHAIN_NAMESPACE.Utxo:
-                return 10;
-            case CHAIN_NAMESPACE.Solana:
-                return 0;
-            default:
-                throw new Error('Unsupported chainNamespace');
-        }
-    };
-    const ratesOrQuotes = [];
-    for (const singleQuoteResponse of quoteResponse) {
-        const isStreaming = singleQuoteResponse.type === 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 = toBaseUnit(bnOrZero(singleQuoteResponse.boostQuote.ingressAmount).times(bnOrZero(singleQuoteResponse.estimatedPrice)), buyAsset.precision);
-            const boostTradeRateOrQuote = {
-                id: uuid(),
-                rate: boostRate,
-                receiveAddress,
-                quoteOrRate,
-                affiliateBps: commissionBps,
-                isStreaming,
-                slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal ??
-                    getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Chainflip),
-                swapperName: 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 = toBaseUnit(bnOrZero(singleQuoteResponse.ingressAmount).times(bnOrZero(singleQuoteResponse.estimatedPrice)), buyAsset.precision);
-        const tradeRateOrQuote = {
-            id: uuid(),
-            rate,
-            receiveAddress,
-            quoteOrRate,
-            affiliateBps: commissionBps,
-            isStreaming,
-            slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal ??
-                getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Chainflip),
-            swapperName: 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 Ok(ratesOrQuotes);
-};

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

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

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

@@ -1,21 +0,0 @@
-export 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,
-        },
-    };
-};

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

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

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

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

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

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

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

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

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

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

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

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