@shapeshiftoss/swapper 17.6.9 → 17.6.11

package/dist/esm/swappers/ButterSwap/xhr.js

@@ -1,4 +1,4 @@
-import { fromAssetId, solanaChainId } from '@shapeshiftoss/caip';
+import { fromAssetId, solanaChainId, tronChainId } from '@shapeshiftoss/caip';
 import { chainIdToFeeAssetId } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { zeroAddress } from 'viem';
@@ -20,7 +20,8 @@ export var ButterSwapErrorCode;
     ButterSwapErrorCode[ButterSwapErrorCode["InvalidAddress"] = 2007] = "InvalidAddress";
 })(ButterSwapErrorCode || (ButterSwapErrorCode = {}));
 const SOLANA_NATIVE_ADDRESS = 'So11111111111111111111111111111111111111112';
-export const getButterRoute = async ({ sellAsset, buyAsset, sellAmountCryptoBaseUnit, slippage, affiliate, }) => {
+const TRON_NATIVE_ADDRESS = 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb';
+export const getButterRoute = async ({ sellAsset, buyAsset, sellAmountCryptoPrecision, slippage, affiliate, }) => {
     const butterFromChainId = chainIdToButterSwapChainId(sellAsset.chainId);
     const butterToChainId = chainIdToButterSwapChainId(buyAsset.chainId);
     if (!butterFromChainId || !butterToChainId) {
@@ -37,6 +38,8 @@ export const getButterRoute = async ({ sellAsset, buyAsset, sellAmountCryptoBase
     const sellAssetAddress = (() => {
         if (sellAsset.chainId === solanaChainId && sellAssetIsNative)
             return SOLANA_NATIVE_ADDRESS;
+        if (sellAsset.chainId === tronChainId && sellAssetIsNative)
+            return TRON_NATIVE_ADDRESS;
         if (sellAssetIsNative)
             return zeroAddress;
         return sellAssetAddressRaw;
@@ -44,6 +47,8 @@ export const getButterRoute = async ({ sellAsset, buyAsset, sellAmountCryptoBase
     const buyAssetAddress = (() => {
         if (buyAsset.chainId === solanaChainId && buyAssetIsNative)
             return SOLANA_NATIVE_ADDRESS;
+        if (buyAsset.chainId === tronChainId && buyAssetIsNative)
+            return TRON_NATIVE_ADDRESS;
         if (buyAssetIsNative)
             return zeroAddress;
         return buyAssetAddressRaw;
@@ -54,7 +59,7 @@ export const getButterRoute = async ({ sellAsset, buyAsset, sellAmountCryptoBase
         tokenInAddress: sellAssetAddress,
         toChainId: butterToChainId,
         tokenOutAddress: buyAssetAddress,
-        amount: sellAmountCryptoBaseUnit,
+        amount: sellAmountCryptoPrecision,
         type: 'exactIn',
         slippage,
         entrance: 'shapeshift',

package/dist/esm/swappers/CetusSwapper/endpoints.js

@@ -1,5 +1,6 @@
 import { getProvidersExcluding } from '@cetusprotocol/aggregator-sdk';
-import { Transaction } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/transactions';
+import { Transaction } from '@mysten/sui/transactions';
+import { toAddressNList } from '@shapeshiftoss/chain-adapters';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
 import { bnOrZero } from '@shapeshiftoss/utils';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../constants.js';
@@ -51,13 +52,7 @@ export const cetusApi = {
         intentMessage[2] = 0;
         intentMessage.set(transactionBytes, 3);
         const bip44Params = adapter.getBip44Params({ accountNumber });
-        const addressNList = [
-            bip44Params.purpose,
-            bip44Params.coinType,
-            bip44Params.accountNumber,
-            ...(bip44Params.isChange !== undefined ? [bip44Params.isChange ? 1 : 0] : []),
-            ...(bip44Params.addressIndex !== undefined ? [bip44Params.addressIndex] : []),
-        ];
+        const addressNList = toAddressNList(bip44Params);
         return {
             addressNList,
             intentMessageBytes: intentMessage,

package/dist/esm/swappers/CetusSwapper/swapperApi/getTradeQuote.js

@@ -1,10 +1,11 @@
-import { Transaction } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/transactions';
+import { Transaction } from '@mysten/sui/transactions';
 import { bnOrZero } from '@shapeshiftoss/utils';
 import { Err } from '@sniptt/monads';
 import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { getAggregatorClient, getSuiClient } from '../utils/helpers.js';
 import { getCetusTradeData } from './getCetusTradeData.js';
 export const getTradeQuote = async (input, deps) => {
@@ -78,6 +79,15 @@ export const getTradeQuote = async (input, deps) => {
                     sellAsset,
                     allowanceContract: '0x0',
                     estimatedExecutionTimeMs: undefined,
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmount,
+                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
                 },
             ],
         };

package/dist/esm/swappers/CetusSwapper/swapperApi/getTradeRate.js

@@ -1,10 +1,11 @@
-import { Transaction } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/transactions';
+import { Transaction } from '@mysten/sui/transactions';
 import { bnOrZero } from '@shapeshiftoss/utils';
 import { Err } from '@sniptt/monads';
 import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { getAggregatorClient, getSuiClient } from '../utils/helpers.js';
 import { getCetusTradeData } from './getCetusTradeData.js';
 export const getTradeRate = async (input, deps) => {
@@ -76,6 +77,15 @@ export const getTradeRate = async (input, deps) => {
                     sellAsset,
                     allowanceContract: '0x0',
                     estimatedExecutionTimeMs: undefined,
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmount,
+                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
                 },
             ],
         };

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

@@ -1,6 +1,6 @@
 import type { RouterDataV3 } from '@cetusprotocol/aggregator-sdk';
 import { AggregatorClient } from '@cetusprotocol/aggregator-sdk';
-import { SuiClient } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/client';
+import { SuiClient } from '@mysten/sui/client';
 import type { Asset } from '@shapeshiftoss/types';
 export declare const getAggregatorClient: (rpcUrl: string) => AggregatorClient;
 export declare const getSuiClient: (rpcUrl: string) => SuiClient;

package/dist/esm/swappers/CetusSwapper/utils/helpers.js

@@ -1,5 +1,5 @@
 import { AggregatorClient, Env } from '@cetusprotocol/aggregator-sdk';
-import { SuiClient } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/client';
+import { SuiClient } from '@mysten/sui/client';
 import { fromAssetId } from '@shapeshiftoss/caip';
 let suiClientInstance;
 let aggregatorClientInstance;

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

@@ -1,4 +1,4 @@
-import { arbitrumAssetId, btcAssetId, ethAssetId, flipAssetId, solAssetId, usdcAssetId, usdcOnArbitrumOneAssetId, usdcOnSolanaAssetId, usdtAssetId, } from '@shapeshiftoss/caip';
+import { arbitrumAssetId, btcAssetId, ethAssetId, flipAssetId, solAssetId, usdcAssetId, usdcOnArbitrumOneAssetId, usdcOnSolanaAssetId, usdtAssetId, usdtOnArbitrumOneAssetId, usdtOnSolanaAssetId, wbtcAssetId, } from '@shapeshiftoss/caip';
 import { KnownChainIds } from '@shapeshiftoss/types';
 import { SwapperName } from '../../types.js';
 import { ChainflipNetwork } from './types.js';
@@ -11,10 +11,14 @@ export const ChainflipSupportedChainIds = [
     KnownChainIds.SolanaMainnet,
 ];
 export const ChainflipSupportedAssetIdsByChainId = {
-    [KnownChainIds.EthereumMainnet]: [ethAssetId, flipAssetId, usdcAssetId, usdtAssetId],
-    [KnownChainIds.ArbitrumMainnet]: [arbitrumAssetId, usdcOnArbitrumOneAssetId],
+    [KnownChainIds.EthereumMainnet]: [ethAssetId, flipAssetId, usdcAssetId, usdtAssetId, wbtcAssetId],
+    [KnownChainIds.ArbitrumMainnet]: [
+        arbitrumAssetId,
+        usdcOnArbitrumOneAssetId,
+        usdtOnArbitrumOneAssetId,
+    ],
     [KnownChainIds.BitcoinMainnet]: [btcAssetId],
-    [KnownChainIds.SolanaMainnet]: [solAssetId, usdcOnSolanaAssetId],
+    [KnownChainIds.SolanaMainnet]: [solAssetId, usdcOnSolanaAssetId, usdtOnSolanaAssetId],
 };
 export const chainIdToChainflipNetwork = {
     [KnownChainIds.EthereumMainnet]: ChainflipNetwork.Ethereum,

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

@@ -1,10 +1,11 @@
 import { CHAIN_NAMESPACE, fromAssetId, solAssetId } from '@shapeshiftoss/caip';
-import { assertUnreachable, bnOrZero, toBaseUnit } from '@shapeshiftoss/utils';
+import { assertUnreachable, BigAmount, bnOrZero } 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 { buildAffiliateFee } from '../../utils/affiliateFee.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';
@@ -66,11 +67,11 @@ export const getQuoteOrRate = async (input, deps) => {
     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')) {
+        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],
+                minAmountCryptoBaseUnit: cause.response?.data?.errors?.minimalAmountNative?.[0],
             }));
         }
         return Err(makeSwapErrorRight({
@@ -199,7 +200,10 @@ export const getQuoteOrRate = async (input, deps) => {
             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 buyAmountBeforeFeesCryptoBaseUnit = BigAmount.fromPrecision({
+                value: bnOrZero(singleQuoteResponse.boostQuote.ingressAmount).times(bnOrZero(singleQuoteResponse.estimatedPrice)),
+                precision: buyAsset.precision,
+            }).toBaseUnit();
             const boostTradeRateOrQuote = {
                 id: uuid(),
                 rate: boostRate,
@@ -236,6 +240,14 @@ export const getQuoteOrRate = async (input, deps) => {
                                 : undefined,
                             chainflipMaxBoostFee: getMaxBoostFee(),
                         },
+                        affiliateFee: buildAffiliateFee({
+                            strategy: 'buy_asset',
+                            affiliateBps: commissionBps,
+                            sellAsset,
+                            buyAsset,
+                            sellAmountCryptoBaseUnit: singleQuoteResponse.boostQuote.ingressAmountNative,
+                            buyAmountCryptoBaseUnit: singleQuoteResponse.boostQuote.egressAmountNative,
+                        }),
                     },
                 ],
             };
@@ -246,7 +258,10 @@ export const getQuoteOrRate = async (input, deps) => {
             : '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 buyAmountBeforeFeesCryptoBaseUnit = BigAmount.fromPrecision({
+            value: bnOrZero(singleQuoteResponse.ingressAmount).times(bnOrZero(singleQuoteResponse.estimatedPrice)),
+            precision: buyAsset.precision,
+        }).toBaseUnit();
         const tradeRateOrQuote = {
             id: uuid(),
             rate,
@@ -284,6 +299,14 @@ export const getQuoteOrRate = async (input, deps) => {
                             : undefined,
                         chainflipMaxBoostFee: 0,
                     },
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps: commissionBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: singleQuoteResponse.ingressAmountNative ?? '0',
+                        buyAmountCryptoBaseUnit: singleQuoteResponse.egressAmountNative ?? '0',
+                    }),
                 },
             ],
         };

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

@@ -1,5 +1,5 @@
 import { fromAssetId } from '@shapeshiftoss/caip';
-import { bn, bnOrZero, fromBaseUnit, isToken } from '@shapeshiftoss/utils';
+import { BigAmount, bn, bnOrZero, isToken } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils.js';
@@ -15,8 +15,14 @@ export const isSupportedAssetId = (chainId, assetId) => {
     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 sellAmountCryptoPrecision = BigAmount.fromBaseUnit({
+        value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        precision: sellAsset.precision,
+    }).toPrecision();
+    const buyAmountCryptoPrecision = BigAmount.fromBaseUnit({
+        value: buyAmountAfterFeesCryptoBaseUnit,
+        precision: buyAsset.precision,
+    }).toPrecision();
     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

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

@@ -9,7 +9,7 @@ export const cowSwapper = {
             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/`, {
+        const maybeOrdersResponse = await cowService.post(`${config.VITE_COWSWAP_BASE_URL}/${network}/api/v1/orders`, {
             ...orderToSign,
             signingScheme: SigningScheme.EIP712,
             signature,

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

@@ -8,6 +8,7 @@ import { getAffiliateAppDataFragmentByChainId, getCowNetwork, getFullAppData, }
 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 { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { cowService } from '../utils/cowService.js';
 import { assertValidTrade, getNowPlusThirtyMinutesTimestamp, getValuesFromQuoteResponse, } from '../utils/helpers/helpers.js';
@@ -39,7 +40,7 @@ export async function getCowSwapTradeQuote(input, config) {
     });
     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/`, {
+    const maybeQuoteResponse = await cowService.post(`${config.VITE_COWSWAP_BASE_URL}/${network}/api/v1/quote`, {
         sellToken: fromAssetId(sellAsset.assetId).assetReference,
         buyToken,
         receiver: receiveAddress,
@@ -113,6 +114,15 @@ export async function getCowSwapTradeQuote(input, config) {
                 buyAmountBeforeFeesCryptoBaseUnit,
                 buyAmountAfterFeesCryptoBaseUnit,
                 source: SwapperName.CowSwap,
+                affiliateFee: buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    isEstimate: true,
+                }),
                 buyAsset,
                 sellAsset,
                 accountNumber,

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

@@ -383,7 +383,7 @@ describe('getCowSwapTradeQuote', () => {
         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);
+        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 = {
@@ -416,7 +416,7 @@ describe('getCowSwapTradeQuote', () => {
         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);
+        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 = {
@@ -449,7 +449,7 @@ describe('getCowSwapTradeQuote', () => {
         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);
+        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 = {
@@ -482,7 +482,7 @@ describe('getCowSwapTradeQuote', () => {
         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);
+        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 = {
@@ -515,6 +515,6 @@ describe('getCowSwapTradeQuote', () => {
         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);
+        expect(cowService.post).toHaveBeenCalledWith('https://api.cow.fi/mainnet/api/v1/quote', expectedApiInputSmallAmountWethToFox);
     });
 });

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

@@ -8,6 +8,7 @@ import { getAffiliateAppDataFragmentByChainId, getCowNetwork, getFullAppData, }
 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 { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { cowService } from '../utils/cowService.js';
 import { assertValidTrade, getNowPlusThirtyMinutesTimestamp, getValuesFromQuoteResponse, } from '../utils/helpers/helpers.js';
@@ -39,7 +40,7 @@ export async function getCowSwapTradeRate(input, config) {
     });
     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/`, {
+    const maybeQuoteResponse = await cowService.post(`${config.VITE_COWSWAP_BASE_URL}/${network}/api/v1/quote`, {
         sellToken: fromAssetId(sellAsset.assetId).assetReference,
         buyToken,
         receiver: receiveAddress,
@@ -113,6 +114,14 @@ export async function getCowSwapTradeRate(input, config) {
                 buyAmountBeforeFeesCryptoBaseUnit,
                 buyAmountAfterFeesCryptoBaseUnit,
                 source: SwapperName.CowSwap,
+                affiliateFee: buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                }),
                 buyAsset,
                 sellAsset,
                 accountNumber,

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

@@ -1,5 +1,5 @@
 import { fromAssetId } from '@shapeshiftoss/caip';
-import { bn, bnOrZero, convertBasisPointsToDecimalPercentage, convertPrecision, fromBaseUnit, } from '@shapeshiftoss/utils';
+import { BigAmount, bn, bnOrZero, convertBasisPointsToDecimalPercentage, convertPrecision, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { TradeQuoteError } from '../../../../types.js';
 import { makeSwapErrorRight } from '../../../../utils.js';
@@ -56,8 +56,14 @@ export const getValuesFromQuoteResponse = ({ buyAsset, sellAsset, response, affi
         amount: buyAmountAfterAffiliateFeesCryptoBaseUnit,
         slippageTolerancePercentageDecimal,
     });
-    const buyAmountAfterAffiliateFeesCryptoPrecision = fromBaseUnit(buyAmountAfterAffiliateFeesCryptoBaseUnit, buyAsset.precision);
-    const sellAmountCryptoPrecision = fromBaseUnit(sellAmountAfterFeesCryptoBaseUnit, sellAsset.precision);
+    const buyAmountAfterAffiliateFeesCryptoPrecision = BigAmount.fromBaseUnit({
+        value: buyAmountAfterAffiliateFeesCryptoBaseUnit,
+        precision: buyAsset.precision,
+    }).toPrecision();
+    const sellAmountCryptoPrecision = BigAmount.fromBaseUnit({
+        value: sellAmountAfterFeesCryptoBaseUnit,
+        precision: sellAsset.precision,
+    }).toPrecision();
     const rate = bnOrZero(buyAmountAfterAffiliateFeesCryptoPrecision)
         .div(sellAmountCryptoPrecision)
         .toString();

package/dist/esm/swappers/DebridgeSwapper/DebridgeSwapper.d.ts

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

package/dist/esm/swappers/DebridgeSwapper/DebridgeSwapper.js

@@ -0,0 +1,4 @@
+import { executeEvmTransaction } from '../../utils.js';
+export const debridgeSwapper = {
+    executeEvmTransaction,
+};

package/dist/esm/swappers/DebridgeSwapper/constant.d.ts

@@ -0,0 +1,5 @@
+export declare const chainIdToDebridgeChainId: Record<string, number>;
+export declare const debridgeChainIdToChainId: import("lodash").Dictionary<string>;
+export declare const DEBRIDGE_SUPPORTED_CHAIN_IDS: string[];
+export declare const DEFAULT_DEBRIDGE_TOKEN_ADDRESS: "0x0000000000000000000000000000000000000000";
+export declare const DEFAULT_DEBRIDGE_USER_ADDRESS = "0x000000000000000000000000000000000000dead";

package/dist/esm/swappers/DebridgeSwapper/constant.js

@@ -0,0 +1,30 @@
+import { arbitrumChainId, avalancheChainId, baseChainId, berachainChainId, bobChainId, bscChainId, cronosChainId, ethChainId, flowEvmChainId, gnosisChainId, hyperEvmChainId, lineaChainId, mantleChainId, megaethChainId, monadChainId, optimismChainId, plasmaChainId, polygonChainId, seiChainId, sonicChainId, storyChainId, } from '@shapeshiftoss/caip';
+import invert from 'lodash/invert';
+import { zeroAddress } from 'viem';
+export const chainIdToDebridgeChainId = {
+    [ethChainId]: 1,
+    [optimismChainId]: 10,
+    [bscChainId]: 56,
+    [gnosisChainId]: 100000002,
+    [polygonChainId]: 137,
+    [monadChainId]: 100000030,
+    [hyperEvmChainId]: 100000022,
+    [seiChainId]: 100000027,
+    [baseChainId]: 8453,
+    [plasmaChainId]: 100000028,
+    [arbitrumChainId]: 42161,
+    [avalancheChainId]: 43114,
+    [mantleChainId]: 100000023,
+    [cronosChainId]: 100000019,
+    [berachainChainId]: 100000020,
+    [lineaChainId]: 59144,
+    [bobChainId]: 100000021,
+    [sonicChainId]: 100000014,
+    [storyChainId]: 100000013,
+    [flowEvmChainId]: 100000009,
+    [megaethChainId]: 100000031,
+};
+export const debridgeChainIdToChainId = invert(chainIdToDebridgeChainId);
+export const DEBRIDGE_SUPPORTED_CHAIN_IDS = Object.keys(chainIdToDebridgeChainId);
+export const DEFAULT_DEBRIDGE_TOKEN_ADDRESS = zeroAddress;
+export const DEFAULT_DEBRIDGE_USER_ADDRESS = '0x000000000000000000000000000000000000dead';

package/dist/esm/swappers/DebridgeSwapper/endpoints.d.ts

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