@shapeshiftoss/swapper 17.6.6-alpha.0 → 17.6.6

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

@@ -1,520 +0,0 @@
-import { BuyTokenDestination, KnownChainIds, SellTokenSource } from '@shapeshiftoss/types';
-import { Ok } from '@sniptt/monads';
-import { describe, expect, it, vi } from 'vitest';
-import { COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS, DEFAULT_ADDRESS, } from '../../../cowswap-utils/constants.js';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { ETH, ETH_ARBITRUM, FOX_MAINNET, USDC_ARBITRUM, USDC_GNOSIS, WETH, XDAI, } from '../../utils/test-data/assets.js';
-import { cowService } from '../utils/cowService.js';
-import { getCowSwapTradeQuote } from './getCowSwapTradeQuote.js';
-vi.mock('@shapeshiftoss/chain-adapters');
-const mockedCowService = vi.mocked(cowService);
-const MOCK_COWSWAP_CONFIG = {
-    VITE_COWSWAP_BASE_URL: 'https://api.cow.fi',
-};
-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('../utils/helpers/helpers', async () => {
-    const actual = await vi.importActual('../utils/helpers/helpers');
-    return {
-        ...actual,
-        getNowPlusThirtyMinutesTimestamp: () => 1656797787,
-    };
-});
-vi.mock('../../utils/helpers/helpers', async () => {
-    const actual = await vi.importActual('../../utils/helpers/helpers');
-    return {
-        ...actual,
-        getApproveContractData: () => '0xABCDEFGH',
-    };
-});
-const expectedApiInputWethToFox = {
-    appData: '{"appCode":"shapeshift","metadata":{"orderClass":{"orderClass":"market"},"quote":{"slippageBips":50}},"version":"1.3.0"}',
-    appDataHash: '0x41fffc0127f56060cc551652721d84c336f87649a20c51fcff5b8841dfeabe5b',
-    buyToken: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
-    from: '0x0000000000000000000000000000000000000000',
-    kind: 'sell',
-    partiallyFillable: false,
-    receiver: '0x0000000000000000000000000000000000000000',
-    sellAmountBeforeFee: '1000000000000000000',
-    sellToken: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
-    validTo: 1656797787,
-};
-const expectedApiInputSmallAmountWethToFox = {
-    appData: '{"appCode":"shapeshift","metadata":{"orderClass":{"orderClass":"market"},"quote":{"slippageBips":50}},"version":"1.3.0"}',
-    appDataHash: '0x41fffc0127f56060cc551652721d84c336f87649a20c51fcff5b8841dfeabe5b',
-    buyToken: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
-    from: '0x0000000000000000000000000000000000000000',
-    kind: 'sell',
-    partiallyFillable: false,
-    receiver: '0x0000000000000000000000000000000000000000',
-    sellAmountBeforeFee: '1000000000000',
-    sellToken: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
-    validTo: 1656797787,
-};
-const expectedApiInputFoxToEth = {
-    appData: '{"appCode":"shapeshift","metadata":{"orderClass":{"orderClass":"market"},"quote":{"slippageBips":50}},"version":"1.3.0"}',
-    appDataHash: '0x41fffc0127f56060cc551652721d84c336f87649a20c51fcff5b8841dfeabe5b',
-    buyToken: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
-    from: '0x0000000000000000000000000000000000000000',
-    kind: 'sell',
-    partiallyFillable: false,
-    receiver: '0x0000000000000000000000000000000000000000',
-    sellAmountBeforeFee: '1000000000000000000000',
-    sellToken: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
-    validTo: 1656797787,
-};
-const expectedApiInputUsdcGnosisToXdai = {
-    appData: '{"appCode":"shapeshift","metadata":{"orderClass":{"orderClass":"market"},"quote":{"slippageBips":50}},"version":"1.3.0"}',
-    appDataHash: '0x41fffc0127f56060cc551652721d84c336f87649a20c51fcff5b8841dfeabe5b',
-    buyToken: COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS,
-    from: '0x0000000000000000000000000000000000000000',
-    kind: 'sell',
-    partiallyFillable: false,
-    receiver: '0x0000000000000000000000000000000000000000',
-    sellAmountBeforeFee: '20000000',
-    sellToken: '0xddafbb505ad214d7b80b1f830fccc89b60fb7a83',
-    validTo: 1656797787,
-};
-const expectedApiInputUsdcToEthArbitrum = {
-    appData: '{"appCode":"shapeshift","metadata":{"orderClass":{"orderClass":"market"},"quote":{"slippageBips":50}},"version":"1.3.0"}',
-    appDataHash: '0x41fffc0127f56060cc551652721d84c336f87649a20c51fcff5b8841dfeabe5b',
-    buyToken: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
-    from: '0x0000000000000000000000000000000000000000',
-    kind: 'sell',
-    partiallyFillable: false,
-    receiver: '0x0000000000000000000000000000000000000000',
-    sellAmountBeforeFee: '500000',
-    sellToken: '0xaf88d065e77c8cc2239327c5edb3a432268e5831',
-    validTo: 1656797787,
-};
-const expectedTradeQuoteWethToFox = {
-    quoteOrRate: 'quote',
-    id: '123',
-    receiveAddress: '0x0000000000000000000000000000000000000000',
-    affiliateBps: '0',
-    rate: '14633.996289802713696747',
-    slippageTolerancePercentageDecimal: '0.005',
-    swapperName: SwapperName.CowSwap,
-    steps: [
-        {
-            estimatedExecutionTimeMs: undefined,
-            allowanceContract: '0xc92e8bdf79f0507f65a392b0ab4667716bfe0110',
-            rate: '14633.996289802713696747',
-            feeData: {
-                protocolFees: {
-                    [WETH.assetId]: {
-                        amountCryptoBaseUnit: '14557942658757988',
-                        requiresBalance: false,
-                        asset: WETH,
-                    },
-                },
-                networkFeeCryptoBaseUnit: '0',
-            },
-            sellAmountIncludingProtocolFeesCryptoBaseUnit: '1000000000000000000',
-            buyAmountBeforeFeesCryptoBaseUnit: '14924808465433443149366',
-            buyAmountAfterFeesCryptoBaseUnit: '14633996289802713696747',
-            source: SwapperName.CowSwap,
-            buyAsset: FOX_MAINNET,
-            sellAsset: WETH,
-            accountNumber: 0,
-            cowswapQuoteResponse: {
-                id: 123,
-                quote: {
-                    ...expectedApiInputWethToFox,
-                    sellAmountBeforeFee: undefined,
-                    sellAmount: '985442057341242012',
-                    buyAmount: '14707533959600717283163',
-                    feeAmount: '14557942658757988',
-                    sellTokenBalance: SellTokenSource.ERC20,
-                    buyTokenBalance: BuyTokenDestination.ERC20,
-                },
-            },
-        },
-    ],
-};
-const expectedTradeQuoteFoxToEth = {
-    quoteOrRate: 'quote',
-    id: '123',
-    receiveAddress: '0x0000000000000000000000000000000000000000',
-    affiliateBps: '0',
-    rate: '0.00004663451553170897',
-    slippageTolerancePercentageDecimal: '0.005',
-    swapperName: SwapperName.CowSwap,
-    steps: [
-        {
-            estimatedExecutionTimeMs: undefined,
-            allowanceContract: '0xc92e8bdf79f0507f65a392b0ab4667716bfe0110',
-            rate: '0.00004663451553170897',
-            feeData: {
-                protocolFees: {
-                    [FOX_MAINNET.assetId]: {
-                        amountCryptoBaseUnit: '61804771879693983744',
-                        requiresBalance: false,
-                        asset: FOX_MAINNET,
-                    },
-                },
-                networkFeeCryptoBaseUnit: '0',
-            },
-            sellAmountIncludingProtocolFeesCryptoBaseUnit: '1000000000000000000000',
-            buyAmountBeforeFeesCryptoBaseUnit: '49956403982959960',
-            buyAmountAfterFeesCryptoBaseUnit: '46634515531708967',
-            source: SwapperName.CowSwap,
-            buyAsset: ETH,
-            sellAsset: FOX_MAINNET,
-            accountNumber: 0,
-            cowswapQuoteResponse: {
-                id: 123,
-                quote: {
-                    ...expectedApiInputFoxToEth,
-                    sellAmountBeforeFee: undefined,
-                    sellAmount: '938195228120306016256',
-                    buyAmount: '46868859830863283',
-                    feeAmount: '61804771879693983744',
-                    sellTokenBalance: SellTokenSource.ERC20,
-                    buyTokenBalance: BuyTokenDestination.ERC20,
-                },
-            },
-        },
-    ],
-};
-const expectedTradeQuoteUsdcToXdai = {
-    quoteOrRate: 'quote',
-    id: '123',
-    receiveAddress: '0x0000000000000000000000000000000000000000',
-    affiliateBps: '0',
-    rate: '1.04501702603391403555',
-    slippageTolerancePercentageDecimal: '0.005',
-    swapperName: SwapperName.CowSwap,
-    steps: [
-        {
-            allowanceContract: '0xc92e8bdf79f0507f65a392b0ab4667716bfe0110',
-            rate: '1.04501702603391403555',
-            estimatedExecutionTimeMs: undefined,
-            feeData: {
-                protocolFees: {
-                    [USDC_GNOSIS.assetId]: {
-                        amountCryptoBaseUnit: '1188',
-                        requiresBalance: false,
-                        asset: USDC_GNOSIS,
-                    },
-                },
-                networkFeeCryptoBaseUnit: '0',
-            },
-            sellAmountIncludingProtocolFeesCryptoBaseUnit: '20000000',
-            buyAmountBeforeFeesCryptoBaseUnit: '21006555728332525852',
-            buyAmountAfterFeesCryptoBaseUnit: '20900340520678280711',
-            source: SwapperName.CowSwap,
-            buyAsset: XDAI,
-            sellAsset: USDC_GNOSIS,
-            accountNumber: 0,
-            cowswapQuoteResponse: {
-                id: 123,
-                quote: {
-                    ...expectedApiInputUsdcGnosisToXdai,
-                    sellAmountBeforeFee: undefined,
-                    sellAmount: '20998812',
-                    buyAmount: '21005367357465608755',
-                    feeAmount: '1188',
-                    sellTokenBalance: SellTokenSource.ERC20,
-                    buyTokenBalance: BuyTokenDestination.ERC20,
-                },
-            },
-        },
-    ],
-};
-const expectedTradeQuoteUsdcToEthArbitrum = {
-    quoteOrRate: 'quote',
-    id: '123',
-    receiveAddress: '0x0000000000000000000000000000000000000000',
-    affiliateBps: '0',
-    rate: '0.000281881715243856',
-    slippageTolerancePercentageDecimal: '0.005',
-    swapperName: SwapperName.CowSwap,
-    steps: [
-        {
-            allowanceContract: '0xc92e8bdf79f0507f65a392b0ab4667716bfe0110',
-            rate: '0.000281881715243856',
-            estimatedExecutionTimeMs: undefined,
-            feeData: {
-                networkFeeCryptoBaseUnit: '0',
-                protocolFees: {
-                    [USDC_ARBITRUM.assetId]: {
-                        amountCryptoBaseUnit: '7944',
-                        requiresBalance: false,
-                        asset: USDC_ARBITRUM,
-                    },
-                },
-            },
-            sellAmountIncludingProtocolFeesCryptoBaseUnit: '500000',
-            buyAmountBeforeFeesCryptoBaseUnit: '143935957632481',
-            buyAmountAfterFeesCryptoBaseUnit: '140940857621928',
-            source: SwapperName.CowSwap,
-            buyAsset: ETH_ARBITRUM,
-            sellAsset: USDC_ARBITRUM,
-            accountNumber: 0,
-            cowswapQuoteResponse: {
-                id: 123,
-                quote: {
-                    ...expectedApiInputUsdcToEthArbitrum,
-                    sellAmountBeforeFee: undefined,
-                    sellAmount: '492056',
-                    buyAmount: '141649103137616',
-                    feeAmount: '7944',
-                    sellTokenBalance: SellTokenSource.ERC20,
-                    buyTokenBalance: BuyTokenDestination.ERC20,
-                },
-            },
-        },
-    ],
-};
-const expectedTradeQuoteSmallAmountWethToFox = {
-    quoteOrRate: 'quote',
-    id: '123',
-    receiveAddress: '0x0000000000000000000000000000000000000000',
-    affiliateBps: '0',
-    rate: '144293027.59156357115',
-    slippageTolerancePercentageDecimal: '0.005',
-    swapperName: SwapperName.CowSwap,
-    steps: [
-        {
-            estimatedExecutionTimeMs: undefined,
-            allowanceContract: '0xc92e8bdf79f0507f65a392b0ab4667716bfe0110',
-            rate: '144293027.59156357115',
-            feeData: {
-                protocolFees: {
-                    [WETH.assetId]: {
-                        amountCryptoBaseUnit: '1455794265875791',
-                        requiresBalance: false,
-                        asset: WETH,
-                    },
-                },
-                networkFeeCryptoBaseUnit: '0',
-            },
-            sellAmountIncludingProtocolFeesCryptoBaseUnit: '1000000000000',
-            buyAmountBeforeFeesCryptoBaseUnit: '166441655297153832879',
-            buyAmountAfterFeesCryptoBaseUnit: '144293027591563571150',
-            source: SwapperName.CowSwap,
-            buyAsset: FOX_MAINNET,
-            sellAsset: WETH,
-            accountNumber: 0,
-            cowswapQuoteResponse: {
-                id: 123,
-                quote: {
-                    ...expectedApiInputSmallAmountWethToFox,
-                    sellAmountBeforeFee: undefined,
-                    sellAmount: '9854420573412420',
-                    buyAmount: '145018118182475950905',
-                    feeAmount: '1455794265875791',
-                    sellTokenBalance: SellTokenSource.ERC20,
-                    buyTokenBalance: BuyTokenDestination.ERC20,
-                },
-            },
-        },
-    ],
-};
-describe('getCowSwapTradeQuote', () => {
-    it('should throw an exception if sell asset is not an erc20', async () => {
-        const input = {
-            chainId: KnownChainIds.EthereumMainnet,
-            sellAsset: ETH,
-            buyAsset: FOX_MAINNET,
-            sellAmountIncludingProtocolFeesCryptoBaseUnit: '11111',
-            accountNumber: 0,
-            receiveAddress: DEFAULT_ADDRESS,
-            affiliateBps: '0',
-            supportsEIP1559: false,
-            allowMultiHop: false,
-            slippageTolerancePercentageDecimal: '0.005',
-            quoteOrRate: 'quote',
-        };
-        const maybeTradeQuote = await getCowSwapTradeQuote(input, MOCK_COWSWAP_CONFIG);
-        expect(maybeTradeQuote.isErr()).toBe(true);
-        expect(maybeTradeQuote.unwrapErr()).toMatchObject({
-            cause: undefined,
-            code: TradeQuoteError.UnsupportedTradePair,
-            details: { sellAsset: ETH },
-            message: '[CowSwap: assertValidTrade] - Sell asset must be an ERC-20',
-            name: 'SwapError',
-        });
-    });
-    it('should call cowService with correct parameters, handle the fees and return the correct trade quote when selling WETH', async () => {
-        const input = {
-            chainId: KnownChainIds.EthereumMainnet,
-            sellAsset: WETH,
-            buyAsset: FOX_MAINNET,
-            sellAmountIncludingProtocolFeesCryptoBaseUnit: '1000000000000000000',
-            accountNumber: 0,
-            receiveAddress: DEFAULT_ADDRESS,
-            affiliateBps: '0',
-            supportsEIP1559: false,
-            allowMultiHop: false,
-            slippageTolerancePercentageDecimal: '0.005',
-            quoteOrRate: 'quote',
-        };
-        mockedCowService.post.mockReturnValue(Promise.resolve(Ok({
-            data: {
-                id: 123,
-                quote: {
-                    ...expectedApiInputWethToFox,
-                    sellAmountBeforeFee: undefined,
-                    sellAmount: '985442057341242012',
-                    buyAmount: '14707533959600717283163',
-                    feeAmount: '14557942658757988',
-                    sellTokenBalance: SellTokenSource.ERC20,
-                    buyTokenBalance: BuyTokenDestination.ERC20,
-                },
-            },
-        })));
-        const maybeTradeQuote = await getCowSwapTradeQuote(input, MOCK_COWSWAP_CONFIG);
-        expect(maybeTradeQuote.isOk()).toBe(true);
-        expect(maybeTradeQuote.unwrap()).toEqual(expectedTradeQuoteWethToFox);
-        expect(cowService.post).toHaveBeenCalledWith('https://api.cow.fi/mainnet/api/v1/quote/', expectedApiInputWethToFox);
-    });
-    it('should call cowService with correct parameters, handle the fees and return the correct trade quote when buying ETH', async () => {
-        const input = {
-            chainId: KnownChainIds.EthereumMainnet,
-            sellAsset: FOX_MAINNET,
-            buyAsset: ETH,
-            sellAmountIncludingProtocolFeesCryptoBaseUnit: '1000000000000000000000',
-            accountNumber: 0,
-            receiveAddress: DEFAULT_ADDRESS,
-            affiliateBps: '0',
-            supportsEIP1559: false,
-            allowMultiHop: false,
-            slippageTolerancePercentageDecimal: '0.005',
-            quoteOrRate: 'quote',
-        };
-        mockedCowService.post.mockReturnValue(Promise.resolve(Ok({
-            data: {
-                id: 123,
-                quote: {
-                    ...expectedApiInputFoxToEth,
-                    sellAmountBeforeFee: undefined,
-                    sellAmount: '938195228120306016256',
-                    buyAmount: '46868859830863283',
-                    feeAmount: '61804771879693983744',
-                    sellTokenBalance: SellTokenSource.ERC20,
-                    buyTokenBalance: BuyTokenDestination.ERC20,
-                },
-            },
-        })));
-        const maybeTradeQuote = await getCowSwapTradeQuote(input, MOCK_COWSWAP_CONFIG);
-        expect(maybeTradeQuote.isOk()).toBe(true);
-        expect(maybeTradeQuote.unwrap()).toEqual(expectedTradeQuoteFoxToEth);
-        expect(cowService.post).toHaveBeenCalledWith('https://api.cow.fi/mainnet/api/v1/quote/', expectedApiInputFoxToEth);
-    });
-    it('should call cowService with correct parameters, handle the fees and return the correct trade quote when buying XDAI', async () => {
-        const input = {
-            chainId: KnownChainIds.GnosisMainnet,
-            sellAsset: USDC_GNOSIS,
-            buyAsset: XDAI,
-            sellAmountIncludingProtocolFeesCryptoBaseUnit: '20000000',
-            accountNumber: 0,
-            receiveAddress: DEFAULT_ADDRESS,
-            affiliateBps: '0',
-            supportsEIP1559: false,
-            allowMultiHop: false,
-            slippageTolerancePercentageDecimal: '0.005',
-            quoteOrRate: 'quote',
-        };
-        mockedCowService.post.mockReturnValue(Promise.resolve(Ok({
-            data: {
-                id: 123,
-                quote: {
-                    ...expectedApiInputUsdcGnosisToXdai,
-                    sellAmountBeforeFee: undefined,
-                    sellAmount: '20998812',
-                    buyAmount: '21005367357465608755',
-                    feeAmount: '1188',
-                    sellTokenBalance: SellTokenSource.ERC20,
-                    buyTokenBalance: BuyTokenDestination.ERC20,
-                },
-            },
-        })));
-        const maybeTradeQuote = await getCowSwapTradeQuote(input, MOCK_COWSWAP_CONFIG);
-        expect(maybeTradeQuote.isOk()).toBe(true);
-        expect(maybeTradeQuote.unwrap()).toEqual(expectedTradeQuoteUsdcToXdai);
-        expect(cowService.post).toHaveBeenCalledWith('https://api.cow.fi/xdai/api/v1/quote/', expectedApiInputUsdcGnosisToXdai);
-    });
-    it('should call cowService with correct parameters, handle the fees and return the correct trade quote when buying ETH on Arbitrum', async () => {
-        const input = {
-            chainId: KnownChainIds.ArbitrumMainnet,
-            sellAsset: USDC_ARBITRUM,
-            buyAsset: ETH_ARBITRUM,
-            sellAmountIncludingProtocolFeesCryptoBaseUnit: '500000',
-            accountNumber: 0,
-            receiveAddress: DEFAULT_ADDRESS,
-            affiliateBps: '0',
-            supportsEIP1559: false,
-            allowMultiHop: false,
-            slippageTolerancePercentageDecimal: '0.005',
-            quoteOrRate: 'quote',
-        };
-        mockedCowService.post.mockReturnValue(Promise.resolve(Ok({
-            data: {
-                id: 123,
-                quote: {
-                    ...expectedApiInputUsdcToEthArbitrum,
-                    sellAmountBeforeFee: undefined,
-                    sellAmount: '492056',
-                    buyAmount: '141649103137616',
-                    feeAmount: '7944',
-                    sellTokenBalance: SellTokenSource.ERC20,
-                    buyTokenBalance: BuyTokenDestination.ERC20,
-                },
-            },
-        })));
-        const maybeTradeQuote = await getCowSwapTradeQuote(input, MOCK_COWSWAP_CONFIG);
-        expect(maybeTradeQuote.isOk()).toBe(true);
-        expect(maybeTradeQuote.unwrap()).toEqual(expectedTradeQuoteUsdcToEthArbitrum);
-        expect(cowService.post).toHaveBeenCalledWith('https://api.cow.fi/arbitrum_one/api/v1/quote/', expectedApiInputUsdcToEthArbitrum);
-    });
-    it('should call cowService with correct parameters and return quote with original sellAmount when selling a very small amount of WETH', async () => {
-        const input = {
-            chainId: KnownChainIds.EthereumMainnet,
-            sellAsset: WETH,
-            buyAsset: FOX_MAINNET,
-            sellAmountIncludingProtocolFeesCryptoBaseUnit: '1000000000000',
-            accountNumber: 0,
-            receiveAddress: DEFAULT_ADDRESS,
-            affiliateBps: '0',
-            supportsEIP1559: false,
-            allowMultiHop: false,
-            slippageTolerancePercentageDecimal: '0.005',
-            quoteOrRate: 'quote',
-        };
-        mockedCowService.post.mockReturnValue(Promise.resolve(Ok({
-            data: {
-                id: 123,
-                quote: {
-                    ...expectedApiInputSmallAmountWethToFox,
-                    sellAmountBeforeFee: undefined,
-                    sellAmount: '9854420573412420',
-                    buyAmount: '145018118182475950905',
-                    feeAmount: '1455794265875791',
-                    sellTokenBalance: SellTokenSource.ERC20,
-                    buyTokenBalance: BuyTokenDestination.ERC20,
-                },
-            },
-        })));
-        const maybeTradeQuote = await getCowSwapTradeQuote(input, MOCK_COWSWAP_CONFIG);
-        expect(maybeTradeQuote.isErr()).toBe(false);
-        expect(maybeTradeQuote.unwrap()).toEqual(expectedTradeQuoteSmallAmountWethToFox);
-        expect(cowService.post).toHaveBeenCalledWith('https://api.cow.fi/mainnet/api/v1/quote/', expectedApiInputSmallAmountWethToFox);
-    });
-});

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

@@ -1,3 +0,0 @@
-import type { Result } from '@sniptt/monads';
-import type { GetEvmTradeRateInput, SwapErrorRight, SwapperConfig, TradeRate } from '../../../types.js';
-export declare function getCowSwapTradeRate(input: GetEvmTradeRateInput, config: SwapperConfig): Promise<Result<TradeRate, SwapErrorRight>>;

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

@@ -1,123 +0,0 @@
-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 getCowSwapTradeRate(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: getCowSwapTradeRate] - 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: 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: getCowSwapTradeRate] - missing quote ID`,
-            code: TradeQuoteError.InvalidResponse,
-        }));
-    }
-    const quote = {
-        id,
-        quoteOrRate: 'rate',
-        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,
-            },
-        ],
-    };
-    return Ok(quote);
-}

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

@@ -1 +0,0 @@
-export * from './types.js';

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

@@ -1 +0,0 @@
-export * from './types.js';

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

@@ -1,18 +0,0 @@
-import type { ChainId } from '@shapeshiftoss/caip';
-import type { OrderCreation } from '@shapeshiftoss/types';
-export type CowSwapGetTradesResponse = {
-    txHash: string;
-}[];
-export type CowSwapOrdersResponse = {
-    status: 'presignaturePending' | 'open' | 'fulfilled' | 'cancelled' | 'expired';
-};
-export type AffiliateAppDataFragment = {
-    partnerFee?: {
-        bps: number;
-        recipient: string;
-    };
-};
-export type CowMessageToSign = {
-    chainId: ChainId;
-    orderToSign: Omit<OrderCreation, 'signature'>;
-};

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

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

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

@@ -1 +0,0 @@
-export declare const COWSWAP_UNSUPPORTED_ASSETS: readonly string[];