@shapeshiftoss/swapper 17.7.3 → 18.1.0

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

@@ -1,144 +1,43 @@
-import { getQuotes } from '@avnu/avnu-sdk';
-import { starknetChainId } from '@shapeshiftoss/caip';
-import { bn } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { validateAndParseAddress } from 'starknet';
-import { v4 as uuid } from 'uuid';
-import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
-import { AVNU_SUPPORTED_CHAIN_IDS } from '../utils/constants.js';
-import { getTokenAddress } from '../utils/helpers.js';
+import { TradeQuoteError } from '../../../types.js';
+import { assertQuoteAddresses, makeSwapErrorRight } from '../../../utils/index.js';
+import { getAvnuTradeContext } from '../utils/getAvnuTradeContext.js';
 export const getTradeQuote = async (input, deps) => {
-    const { sellAsset, buyAsset, accountNumber, sendAddress, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, slippageTolerancePercentageDecimal, affiliateBps, } = input;
-    if (!AVNU_SUPPORTED_CHAIN_IDS.includes(sellAsset.chainId)) {
-        return Err(makeSwapErrorRight({
-            message: `Chain ${sellAsset.chainId} is not supported by AVNU`,
-            code: TradeQuoteError.UnsupportedChain,
-        }));
-    }
-    if (!AVNU_SUPPORTED_CHAIN_IDS.includes(buyAsset.chainId)) {
-        return Err(makeSwapErrorRight({
-            message: `Chain ${buyAsset.chainId} is not supported by AVNU`,
-            code: TradeQuoteError.UnsupportedChain,
-        }));
-    }
-    if (accountNumber === undefined) {
-        return Err(makeSwapErrorRight({
-            message: `accountNumber is required`,
-            code: TradeQuoteError.UnknownError,
-        }));
-    }
-    if (sendAddress === undefined) {
-        return Err(makeSwapErrorRight({
-            message: `sendAddress is required`,
-            code: TradeQuoteError.UnknownError,
-        }));
-    }
-    if (receiveAddress === undefined) {
-        return Err(makeSwapErrorRight({
-            message: `receiveAddress is required`,
-            code: TradeQuoteError.UnknownError,
-        }));
-    }
+    const { sellAsset, accountNumber } = input;
+    const maybeAddresses = assertQuoteAddresses(input);
+    if (maybeAddresses.isErr())
+        return Err(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
     try {
-        const sellTokenAddress = getTokenAddress(sellAsset);
-        const buyTokenAddress = getTokenAddress(buyAsset);
-        // Normalize addresses to ensure consistent format across quote and execution
-        // Starknet addresses can have different representations (with/without leading zeros)
+        // Starknet addresses can have different representations (with/without leading zeros) - normalize
+        // to keep the quote and execution consistent
         const normalizedSendAddress = validateAndParseAddress(sendAddress);
         const normalizedReceiveAddress = validateAndParseAddress(receiveAddress);
-        const quotes = await getQuotes({
-            sellTokenAddress,
-            buyTokenAddress,
-            sellAmount: BigInt(sellAmount),
-            takerAddress: normalizedSendAddress,
-            size: 1,
-            integratorFees: affiliateBps ? BigInt(affiliateBps) : undefined,
-            integratorFeeRecipient: getTreasuryAddressFromChainId(starknetChainId),
-            integratorName: 'shapeshift',
-        });
-        if (!quotes || quotes.length === 0) {
-            return Err(makeSwapErrorRight({
-                message: 'No quotes available for this trade pair',
-                code: TradeQuoteError.NoRouteFound,
-            }));
-        }
-        const bestQuote = quotes[0];
-        if (!bestQuote) {
-            return Err(makeSwapErrorRight({
-                message: 'No valid quote returned from AVNU',
-                code: TradeQuoteError.QueryFailed,
-            }));
-        }
-        const buyAmountAfterFeesCryptoBaseUnit = bestQuote.buyAmount.toString();
-        const sellAdapter = deps.assertGetStarknetChainAdapter(sellAsset.chainId);
-        const feeData = await sellAdapter.getFeeData({
+        const maybeContext = await getAvnuTradeContext({ input, takerAddress: normalizedSendAddress });
+        if (maybeContext.isErr())
+            return Err(maybeContext.unwrapErr());
+        const { tradeCommon, stepCommon, protocolFees, quoteId, sellTokenAddress } = maybeContext.unwrap();
+        const adapter = deps.assertGetStarknetChainAdapter(sellAsset.chainId);
+        const feeData = await adapter.getFeeData({
             to: normalizedReceiveAddress,
-            value: sellAmount,
+            value: stepCommon.sellAmountIncludingProtocolFeesCryptoBaseUnit,
             chainSpecific: {
                 from: normalizedSendAddress,
                 tokenContractAddress: sellTokenAddress,
             },
             sendMax: false,
         });
-        const rate = getInputOutputRate({
-            sellAmountCryptoBaseUnit: sellAmount,
-            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-            sellAsset,
-            buyAsset,
-        });
-        const protocolFees = affiliateBps
-            ? {
-                [buyAsset.assetId]: {
-                    amountCryptoBaseUnit: bn(buyAmountAfterFeesCryptoBaseUnit)
-                        .times(affiliateBps)
-                        .div(10000)
-                        .toFixed(0),
-                    requiresBalance: false,
-                    asset: buyAsset,
-                },
-            }
-            : {};
         const tradeQuote = {
-            id: uuid(),
+            ...tradeCommon,
             receiveAddress: normalizedReceiveAddress,
-            affiliateBps,
-            rate,
-            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??
-                getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Avnu),
             quoteOrRate: 'quote',
-            swapperName: SwapperName.Avnu,
             steps: [
                 {
+                    ...stepCommon,
                     accountNumber,
-                    allowanceContract: '0x0',
-                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-                    buyAmountAfterFeesCryptoBaseUnit,
-                    buyAsset,
-                    feeData: {
-                        protocolFees,
-                        networkFeeCryptoBaseUnit: feeData.fast.txFee,
-                    },
-                    rate,
-                    sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
-                    sellAsset,
-                    source: SwapperName.Avnu,
-                    estimatedExecutionTimeMs: undefined,
-                    avnuSpecific: {
-                        quoteId: bestQuote.quoteId,
-                        routes: bestQuote.routes,
-                    },
-                    affiliateFee: buildAffiliateFee({
-                        strategy: 'buy_asset',
-                        affiliateBps,
-                        sellAsset,
-                        buyAsset,
-                        sellAmountCryptoBaseUnit: sellAmount,
-                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-                    }),
+                    feeData: { protocolFees, networkFeeCryptoBaseUnit: feeData.fast.txFee },
+                    swapperMetadata: { name: 'avnu', quoteId },
                 },
             ],
         };

package/dist/esm/swappers/AvnuSwapper/swapperApi/getTradeRate.d.ts

@@ -1,3 +1,4 @@
 import type { Result } from '@sniptt/monads';
-import type { GetTradeRateInput, SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
-export declare const getTradeRate: (input: GetTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+import type { AvnuTradeRateInput } from '../types.js';
+export declare const getTradeRate: (input: AvnuTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

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

@@ -1,129 +1,48 @@
-import { getQuotes } from '@avnu/avnu-sdk';
-import { bn } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { validateAndParseAddress } from 'starknet';
-import { v4 as uuid } from 'uuid';
-import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
-import { AVNU_SUPPORTED_CHAIN_IDS } from '../utils/constants.js';
-import { getTokenAddress } from '../utils/helpers.js';
+import { getAvnuTradeContext } from '../utils/getAvnuTradeContext.js';
 export const getTradeRate = async (input, deps) => {
-    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, slippageTolerancePercentageDecimal, affiliateBps, receiveAddress, } = input;
-    if (!AVNU_SUPPORTED_CHAIN_IDS.includes(sellAsset.chainId)) {
-        return Err(makeSwapErrorRight({
-            message: `Chain ${sellAsset.chainId} is not supported by AVNU`,
-            code: TradeQuoteError.UnsupportedChain,
-        }));
-    }
-    if (!AVNU_SUPPORTED_CHAIN_IDS.includes(buyAsset.chainId)) {
-        return Err(makeSwapErrorRight({
-            message: `Chain ${buyAsset.chainId} is not supported by AVNU`,
-            code: TradeQuoteError.UnsupportedChain,
-        }));
-    }
-    try {
-        const sellTokenAddress = getTokenAddress(sellAsset);
-        const buyTokenAddress = getTokenAddress(buyAsset);
-        // Normalize receive address if provided (for fee estimation)
-        // Rate quotes may not have a receive address, so this is optional
-        const normalizedReceiveAddress = receiveAddress ? validateAndParseAddress(receiveAddress) : '';
-        const quotes = await getQuotes({
-            sellTokenAddress,
-            buyTokenAddress,
-            sellAmount: BigInt(sellAmount),
-            size: 1,
-            integratorFees: affiliateBps ? BigInt(affiliateBps) : undefined,
-            integratorFeeRecipient: getTreasuryAddressFromChainId(sellAsset.chainId),
-        });
-        if (!quotes || quotes.length === 0) {
-            return Err(makeSwapErrorRight({
-                message: 'No quotes available for this trade pair',
-                code: TradeQuoteError.NoRouteFound,
-            }));
+    const { accountNumber, sellAsset, receiveAddress } = input;
+    const maybeContext = await getAvnuTradeContext({ input, takerAddress: undefined });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, sellTokenAddress } = maybeContext.unwrap();
+    // Rates may be walletless - normalize the receive address only when present, and use it as a
+    // stand-in sender for fee estimation
+    const normalizedReceiveAddress = receiveAddress
+        ? validateAndParseAddress(receiveAddress)
+        : undefined;
+    // Rates are best-effort display: without an address, or if estimation fails, degrade to a zero fee
+    const networkFeeCryptoBaseUnit = await (async () => {
+        if (!normalizedReceiveAddress)
+            return '0';
+        try {
+            const feeData = await deps.assertGetStarknetChainAdapter(sellAsset.chainId).getFeeData({
+                to: normalizedReceiveAddress,
+                value: stepCommon.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                chainSpecific: {
+                    from: normalizedReceiveAddress,
+                    tokenContractAddress: sellTokenAddress,
+                },
+                sendMax: false,
+            });
+            return feeData.fast.txFee;
         }
-        const bestQuote = quotes[0];
-        if (!bestQuote) {
-            return Err(makeSwapErrorRight({
-                message: 'No valid quote returned from AVNU',
-                code: TradeQuoteError.QueryFailed,
-            }));
+        catch {
+            return '0';
         }
-        const buyAmountAfterFeesCryptoBaseUnit = bestQuote.buyAmount.toString();
-        const sellAdapter = deps.assertGetStarknetChainAdapter(sellAsset.chainId);
-        // For rate quotes, use receiveAddress as a dummy from/to for fee estimation
-        const feeData = await sellAdapter.getFeeData({
-            to: normalizedReceiveAddress,
-            value: sellAmount,
-            chainSpecific: {
-                from: normalizedReceiveAddress,
-                tokenContractAddress: sellTokenAddress,
+    })();
+    const tradeRate = {
+        ...tradeCommon,
+        receiveAddress: normalizedReceiveAddress,
+        quoteOrRate: 'rate',
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { protocolFees, networkFeeCryptoBaseUnit },
             },
-            sendMax: false,
-        });
-        const rate = getInputOutputRate({
-            sellAmountCryptoBaseUnit: sellAmount,
-            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-            sellAsset,
-            buyAsset,
-        });
-        const protocolFees = affiliateBps
-            ? {
-                [buyAsset.assetId]: {
-                    amountCryptoBaseUnit: bn(buyAmountAfterFeesCryptoBaseUnit)
-                        .times(affiliateBps)
-                        .div(10000)
-                        .toFixed(0),
-                    requiresBalance: false,
-                    asset: buyAsset,
-                },
-            }
-            : {};
-        const tradeRate = {
-            id: uuid(),
-            receiveAddress: normalizedReceiveAddress || receiveAddress,
-            affiliateBps,
-            rate,
-            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??
-                getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Avnu),
-            quoteOrRate: 'rate',
-            swapperName: SwapperName.Avnu,
-            steps: [
-                {
-                    accountNumber: undefined,
-                    allowanceContract: '0x0',
-                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-                    buyAmountAfterFeesCryptoBaseUnit,
-                    buyAsset,
-                    feeData: {
-                        protocolFees,
-                        networkFeeCryptoBaseUnit: feeData.fast.txFee,
-                    },
-                    rate,
-                    sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
-                    sellAsset,
-                    source: SwapperName.Avnu,
-                    estimatedExecutionTimeMs: undefined,
-                    affiliateFee: buildAffiliateFee({
-                        strategy: 'buy_asset',
-                        affiliateBps,
-                        sellAsset,
-                        buyAsset,
-                        sellAmountCryptoBaseUnit: sellAmount,
-                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-                    }),
-                },
-            ],
-        };
-        return Ok([tradeRate]);
-    }
-    catch (error) {
-        return Err(makeSwapErrorRight({
-            message: error instanceof Error ? error.message : 'Unknown error getting AVNU rate',
-            code: TradeQuoteError.QueryFailed,
-            cause: error,
-        }));
-    }
+        ],
+    };
+    return Ok([tradeRate]);
 };

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

@@ -1,2 +1,9 @@
 import type { KnownChainIds } from '@shapeshiftoss/types';
+import type { GetStarknetTradeQuoteInput, GetStarknetTradeRateInput } from '../../types.js';
+export type AvnuTradeQuoteInput = GetStarknetTradeQuoteInput;
+export type AvnuTradeRateInput = GetStarknetTradeRateInput;
 export type AvnuSupportedChainId = typeof KnownChainIds.StarknetMainnet;
+export type AvnuMetadata = {
+    name: 'avnu';
+    quoteId: string;
+};

package/dist/esm/swappers/AvnuSwapper/utils/getAvnuTradeContext.d.ts

@@ -0,0 +1,14 @@
+import type { Result } from '@sniptt/monads';
+import type { GetStarknetTradeQuoteInput, GetStarknetTradeRateInput, QuoteFeeData, SwapErrorRight, TradeCommon, TradeStepCommon } from '../../../types.js';
+type AvnuTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    quoteId: string;
+    sellTokenAddress: string;
+};
+export declare const getAvnuTradeContext: ({ input, takerAddress, }: {
+    input: GetStarknetTradeQuoteInput | GetStarknetTradeRateInput;
+    takerAddress: string | undefined;
+}) => Promise<Result<AvnuTradeContext, SwapErrorRight>>;
+export {};

package/dist/esm/swappers/AvnuSwapper/utils/getAvnuTradeContext.js

@@ -0,0 +1,102 @@
+import { getQuotes } from '@avnu/avnu-sdk';
+import { starknetChainId } from '@shapeshiftoss/caip';
+import { bn } 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 { getInputOutputRate, makeSwapErrorRight } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { getTreasuryAddressFromChainId } from '../../../utils/helpers.js';
+import { assertValidTrade, getTokenAddress } from './helpers.js';
+export const getAvnuTradeContext = async ({ input, takerAddress, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, slippageTolerancePercentageDecimal, affiliateBps, } = input;
+    const assertion = assertValidTrade({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const sellTokenAddress = getTokenAddress(sellAsset);
+    const buyTokenAddress = getTokenAddress(buyAsset);
+    try {
+        const quotes = await getQuotes({
+            sellTokenAddress,
+            buyTokenAddress,
+            sellAmount: BigInt(sellAmount),
+            takerAddress,
+            size: 1,
+            integratorFees: affiliateBps ? BigInt(affiliateBps) : undefined,
+            integratorFeeRecipient: getTreasuryAddressFromChainId(starknetChainId),
+            integratorName: 'shapeshift',
+        });
+        if (!quotes || quotes.length === 0) {
+            return Err(makeSwapErrorRight({
+                message: 'No quotes available for this trade pair',
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const bestQuote = quotes[0];
+        if (!bestQuote) {
+            return Err(makeSwapErrorRight({
+                message: 'No valid quote returned from AVNU',
+                code: TradeQuoteError.QueryFailed,
+            }));
+        }
+        const buyAmountAfterFeesCryptoBaseUnit = bestQuote.buyAmount.toString();
+        const rate = getInputOutputRate({
+            sellAmountCryptoBaseUnit: sellAmount,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const protocolFees = affiliateBps
+            ? {
+                [buyAsset.assetId]: {
+                    amountCryptoBaseUnit: bn(buyAmountAfterFeesCryptoBaseUnit)
+                        .times(affiliateBps)
+                        .div(10000)
+                        .toFixed(0),
+                    requiresBalance: false,
+                    asset: buyAsset,
+                },
+            }
+            : {};
+        return Ok({
+            tradeCommon: {
+                id: uuid(),
+                rate,
+                affiliateBps,
+                slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??
+                    getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Avnu),
+                swapperName: SwapperName.Avnu,
+            },
+            stepCommon: {
+                allowanceContract: '',
+                buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit,
+                buyAsset,
+                rate,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
+                sellAsset,
+                source: SwapperName.Avnu,
+                estimatedExecutionTimeMs: undefined,
+                affiliateFee: buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmount,
+                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                }),
+            },
+            protocolFees,
+            quoteId: bestQuote.quoteId,
+            sellTokenAddress,
+        });
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: error instanceof Error ? error.message : 'Unknown error getting AVNU quote',
+            code: TradeQuoteError.QueryFailed,
+            cause: error,
+        }));
+    }
+};

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

@@ -1,7 +1,18 @@
 import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
 /**
  * Get the token address for AVNU swaps
  * For native STRK token (slip44 namespace), returns the STRK contract address
  * For other tokens, returns the token contract address from assetReference
  */
 export declare const getTokenAddress: (asset: Asset) => string;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<void, SwapErrorRight>;
+/**
+ * Normalize a value to hex format for Starknet RPC
+ * Handles various input types: decimal strings, hex strings (with/without 0x), numbers, BigInts
+ */
+export declare const toHexString: (value: unknown) => string;

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

@@ -1,4 +1,9 @@
 import { fromAssetId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { num } from 'starknet';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { AVNU_SUPPORTED_CHAIN_IDS } from './constants.js';
 // STRK native token contract address on Starknet
 const AVNU_STRK_NATIVE_ADDRESS = '0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d';
 /**
@@ -15,3 +20,42 @@ export const getTokenAddress = (asset) => {
     // For other tokens, the assetReference should be the token contract address
     return assetReference;
 };
+export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (!AVNU_SUPPORTED_CHAIN_IDS.includes(sellAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `Chain ${sellAsset.chainId} is not supported by AVNU`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (!AVNU_SUPPORTED_CHAIN_IDS.includes(buyAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `Chain ${buyAsset.chainId} is not supported by AVNU`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    return Ok(undefined);
+};
+/**
+ * Normalize a value to hex format for Starknet RPC
+ * Handles various input types: decimal strings, hex strings (with/without 0x), numbers, BigInts
+ */
+export const toHexString = (value) => {
+    const strValue = String(value);
+    // Already a proper hex string with 0x prefix
+    if (strValue.startsWith('0x')) {
+        return strValue;
+    }
+    // Check if it looks like a hex string without 0x prefix (contains a-f characters)
+    // Starknet addresses and felts often come as hex without 0x prefix
+    if (/^[0-9a-fA-F]+$/.test(strValue) && /[a-fA-F]/.test(strValue)) {
+        return `0x${strValue}`;
+    }
+    // Otherwise treat as decimal and convert to hex
+    try {
+        return num.toHex(strValue);
+    }
+    catch {
+        // If conversion fails, assume it's already hex and add prefix
+        return `0x${strValue}`;
+    }
+};

package/dist/esm/swappers/BebopSwapper/BebopSwapper.js

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

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

@@ -1,80 +1,39 @@
 import { solanaChainId } from '@shapeshiftoss/caip';
-import { evm } from '@shapeshiftoss/chain-adapters';
-import BigNumber from 'bignumber.js';
-import { fromHex } from 'viem';
-import { checkEvmSwapStatus, checkSolanaSwapStatus, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
+import { checkEvmSwapStatus, checkSolanaSwapStatus, getExecutableTradeStep, getSwapMetadata, isExecutableTradeQuote, } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
 import { getBebopSolanaTradeQuote } from './getBebopSolanaTradeQuote/getBebopSolanaTradeQuote.js';
 import { getBebopSolanaTradeRate } from './getBebopSolanaTradeRate/getBebopSolanaTradeRate.js';
 import { getBebopTradeQuote } from './getBebopTradeQuote/getBebopTradeQuote.js';
 import { getBebopTradeRate } from './getBebopTradeRate/getBebopTradeRate.js';
-import { isSolanaChainId } from './utils/helpers/helpers.js';
 export const bebopApi = {
-    getTradeQuote: async (input, { assertGetEvmChainAdapter, assetsById, config }) => {
-        if (isSolanaChainId(input.sellAsset.chainId)) {
-            const tradeQuoteResult = await getBebopSolanaTradeQuote(input, assetsById, config.VITE_BEBOP_API_KEY);
-            return tradeQuoteResult.map(tradeQuote => [tradeQuote]);
-        }
-        const tradeQuoteResult = await getBebopTradeQuote(input, assertGetEvmChainAdapter, assetsById, config.VITE_BEBOP_API_KEY);
-        return tradeQuoteResult.map(tradeQuote => [tradeQuote]);
-    },
-    getTradeRate: async (input, { assertGetEvmChainAdapter, assetsById, config }) => {
-        if (isSolanaChainId(input.sellAsset.chainId)) {
-            const tradeRateResult = await getBebopSolanaTradeRate(input, assetsById, config.VITE_BEBOP_API_KEY);
-            return tradeRateResult.map(tradeRate => [tradeRate]);
-        }
-        const tradeRateResult = await getBebopTradeRate(input, assertGetEvmChainAdapter, assetsById, config.VITE_BEBOP_API_KEY);
-        return tradeRateResult.map(tradeRate => [tradeRate]);
+    getTradeQuote: (input, deps) => {
+        const quoteInput = input;
+        return 'supportsEIP1559' in quoteInput
+            ? getBebopTradeQuote(quoteInput, deps)
+            : getBebopSolanaTradeQuote(quoteInput, deps);
     },
-    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, sellAsset, bebopTransactionMetadata } = step;
-        if (!bebopTransactionMetadata)
-            throw new Error('Transaction metadata is required');
-        const { value: hexValue, to, data, gas } = bebopTransactionMetadata;
-        const value = fromHex(hexValue, 'bigint').toString();
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-        if (!gas) {
-            throw new Error('Bebop API did not provide gas estimate - cannot execute trade safely');
-        }
-        return adapter.buildCustomApiTx({
-            accountNumber,
-            data,
-            from,
-            to,
-            value,
-            ...feeData,
-            gasLimit: BigNumber.max(feeData.gasLimit, gas).toFixed(),
-        });
+    getTradeRate: (input, deps) => {
+        const rateInput = input;
+        return 'supportsEIP1559' in rateInput
+            ? getBebopTradeRate(rateInput, deps)
+            : getBebopSolanaTradeRate(rateInput, deps);
     },
+    getUnsignedEvmTransaction,
+    getEvmTransactionFees,
     getUnsignedSolanaMessage: ({ tradeQuote, stepIndex }) => {
         if (!isExecutableTradeQuote(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');
         const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { bebopSolanaSerializedTx, bebopQuoteId } = step;
-        if (!bebopSolanaSerializedTx || !bebopQuoteId) {
-            throw new Error('Bebop Solana transaction metadata is required');
+        const { transactionData } = step;
+        const { quoteId } = getSwapMetadata(step.swapperMetadata, 'bebop');
+        if (transactionData?.type !== 'solana_serialized_tx' || !quoteId) {
+            throw new Error('Bebop Solana transaction data is required');
         }
         return Promise.resolve({
-            serializedTx: bebopSolanaSerializedTx,
-            quoteId: bebopQuoteId,
+            serializedTx: transactionData.serializedTx,
+            quoteId,
         });
     },
-    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { sellAsset, bebopTransactionMetadata } = step;
-        if (!bebopTransactionMetadata)
-            throw new Error('Transaction metadata is required');
-        const { value: hexValue, to, data } = bebopTransactionMetadata;
-        const value = fromHex(hexValue, 'bigint').toString();
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-        return feeData.networkFeeCryptoBaseUnit;
-    },
     checkTradeStatus: input => {
         if (input.chainId === solanaChainId) {
             return checkSolanaSwapStatus({