@shapeshiftoss/swapper 17.6.7 → 17.6.9

package/dist/esm/constants.js

@@ -1,6 +1,8 @@
 import { assertUnreachable } from '@shapeshiftoss/utils';
 import { arbitrumBridgeSwapper } from './swappers/ArbitrumBridgeSwapper/ArbitrumBridgeSwapper.js';
 import { arbitrumBridgeApi } from './swappers/ArbitrumBridgeSwapper/endpoints.js';
+import { avnuSwapper } from './swappers/AvnuSwapper/AvnuSwapper.js';
+import { avnuApi } from './swappers/AvnuSwapper/endpoints.js';
 import { bebopSwapper } from './swappers/BebopSwapper/BebopSwapper.js';
 import { bebopApi } from './swappers/BebopSwapper/endpoints.js';
 import { butterSwap } from './swappers/ButterSwap/ButterSwap.js';
@@ -21,6 +23,8 @@ import { portalsApi } from './swappers/PortalsSwapper/endpoints.js';
 import { portalsSwapper } from './swappers/PortalsSwapper/PortalsSwapper.js';
 import { relaySwapper } from './swappers/RelaySwapper/index.js';
 import { relayApi } from './swappers/RelaySwapper/endpoints.js';
+import { sunioApi } from './swappers/SunioSwapper/endpoints.js';
+import { sunioSwapper } from './swappers/SunioSwapper/SunioSwapper.js';
 import { thorchainApi } from './swappers/ThorchainSwapper/endpoints.js';
 import { thorchainSwapper } from './swappers/ThorchainSwapper/ThorchainSwapper.js';
 import { zrxApi } from './swappers/ZrxSwapper/endpoints.js';
@@ -87,6 +91,14 @@ export const swappers = {
         ...cetusSwapper,
         ...cetusApi,
     },
+    [SwapperName.Sunio]: {
+        ...sunioSwapper,
+        ...sunioApi,
+    },
+    [SwapperName.Avnu]: {
+        ...avnuSwapper,
+        ...avnuApi,
+    },
     [SwapperName.Test]: undefined,
 };
 // Slippage defaults. Don't export these to ensure the getDefaultSlippageDecimalPercentageForSwapper helper function is used.
@@ -100,6 +112,8 @@ const DEFAULT_ARBITRUM_BRIDGE_SLIPPAGE_DECIMAL_PERCENTAGE = '0'; // no slippage
 const DEFAULT_CHAINFLIP_SLIPPAGE_DECIMAL_PERCENTAGE = '0.02'; // 2%
 const DEFAULT_BUTTERSWAP_SLIPPAGE_DECIMAL_PERCENTAGE = '0.015'; // 1.5%
 const DEFAULT_CETUS_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005'; // .5%
+const DEFAULT_SUNIO_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005'; // .5%
+const DEFAULT_AVNU_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005'; // .5%
 export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
     if (swapperName === undefined)
         return DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE;
@@ -130,6 +144,10 @@ export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
             return DEFAULT_NEAR_INTENTS_SLIPPAGE_DECIMAL_PERCENTAGE;
         case SwapperName.Cetus:
             return DEFAULT_CETUS_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case SwapperName.Sunio:
+            return DEFAULT_SUNIO_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case SwapperName.Avnu:
+            return DEFAULT_AVNU_SLIPPAGE_DECIMAL_PERCENTAGE;
         default:
             return assertUnreachable(swapperName);
     }

package/dist/esm/cowswap-utils/constants.js

@@ -23,6 +23,7 @@ export const SUPPORTED_CHAIN_IDS = [
     KnownChainIds.BaseMainnet,
     KnownChainIds.AvalancheMainnet,
     KnownChainIds.PolygonMainnet,
+    KnownChainIds.BnbSmartChainMainnet,
 ];
 export const COW_SWAP_VAULT_RELAYER_ADDRESS = '0xc92e8bdf79f0507f65a392b0ab4667716bfe0110';
 export const COW_SWAP_SETTLEMENT_ADDRESS = '0x9008D19f58AAbD9eD0D60971565AA8510560ab41';

package/dist/esm/cowswap-utils/index.js

@@ -22,6 +22,8 @@ export const getCowNetwork = (chainId) => {
             return CowNetwork.Avalanche;
         case KnownChainIds.PolygonMainnet:
             return CowNetwork.Polygon;
+        case KnownChainIds.BnbSmartChainMainnet:
+            return CowNetwork.Bnb;
         default:
             return;
     }

package/dist/esm/index.d.ts

@@ -3,9 +3,11 @@ export * from './cowswap-utils/index.js';
 export * from './safe-utils/index.js';
 export * from './swapper.js';
 export * from './swappers/ArbitrumBridgeSwapper/index.js';
+export * from './swappers/AvnuSwapper/index.js';
 export * from './swappers/BebopSwapper/index.js';
 export * from './swappers/CetusSwapper/index.js';
 export * from './swappers/ChainflipSwapper/index.js';
+export * from './swappers/SunioSwapper/index.js';
 export * from './swappers/CowSwapper/index.js';
 export * from './swappers/JupiterSwapper/index.js';
 export * from './swappers/PortalsSwapper/index.js';

package/dist/esm/index.js

@@ -3,9 +3,11 @@ export * from './cowswap-utils/index.js';
 export * from './safe-utils/index.js';
 export * from './swapper.js';
 export * from './swappers/ArbitrumBridgeSwapper/index.js';
+export * from './swappers/AvnuSwapper/index.js';
 export * from './swappers/BebopSwapper/index.js';
 export * from './swappers/CetusSwapper/index.js';
 export * from './swappers/ChainflipSwapper/index.js';
+export * from './swappers/SunioSwapper/index.js';
 export * from './swappers/CowSwapper/index.js';
 export * from './swappers/JupiterSwapper/index.js';
 export * from './swappers/PortalsSwapper/index.js';

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

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

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

@@ -0,0 +1,4 @@
+import { executeStarknetTransaction } from '../../index.js';
+export const avnuSwapper = {
+    executeStarknetTransaction,
+};

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

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

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

@@ -0,0 +1,178 @@
+import { quoteToCalls } from '@avnu/avnu-sdk';
+import { toAddressNList } from '@shapeshiftoss/chain-adapters';
+import { CallData, hash, num } from 'starknet';
+import { checkStarknetSwapStatus, createDefaultStatusResponse, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
+import { getTradeQuote } from './swapperApi/getTradeQuote.js';
+import { getTradeRate } from './swapperApi/getTradeRate.js';
+export const avnuApi = {
+    getTradeQuote,
+    getTradeRate: (input, deps) => {
+        return getTradeRate(input, deps);
+    },
+    getUnsignedStarknetTransaction: async ({ stepIndex, tradeQuote, from, slippageTolerancePercentageDecimal, assertGetStarknetChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, sellAsset, avnuSpecific } = step;
+        if (!avnuSpecific)
+            throw new Error('avnuSpecific is required');
+        if (!avnuSpecific.quoteId)
+            throw new Error('quoteId is required in avnuSpecific');
+        const adapter = assertGetStarknetChainAdapter(sellAsset.chainId);
+        // Convert slippage from decimal percentage string to number for AVNU format (e.g., "0.01" = 1%)
+        const slippage = slippageTolerancePercentageDecimal
+            ? parseFloat(slippageTolerancePercentageDecimal)
+            : 0.01;
+        // Get the swap calls from AVNU SDK
+        const { calls: avnuCalls } = await quoteToCalls({
+            quoteId: avnuSpecific.quoteId,
+            slippage,
+            takerAddress: from,
+        });
+        // Build the full invoke transaction calldata from AVNU calls
+        // Format: [call_array_length, contract1, selector1, calldata_len1, ...calldata1, ...]
+        const fullCalldata = [avnuCalls.length.toString()];
+        for (const call of avnuCalls) {
+            const rawCalldata = call.calldata ?? [];
+            const calldataArray = Array.isArray(rawCalldata) ? rawCalldata : CallData.compile(rawCalldata);
+            const selector = hash.getSelectorFromName(call.entrypoint);
+            fullCalldata.push(call.contractAddress, selector, calldataArray.length.toString(), ...calldataArray.map(cd => cd.toString()));
+        }
+        // Format calldata for RPC (convert numbers to hex)
+        const formattedCalldata = fullCalldata.map(data => {
+            if (!data.startsWith('0x')) {
+                return num.toHex(data);
+            }
+            return data;
+        });
+        // Get nonce using adapter method (checks deployment status and returns appropriate nonce)
+        const chainIdHex = await adapter.getStarknetProvider().getChainId();
+        const nonce = await adapter.getNonce(from);
+        // Estimate fees for the multi-call swap transaction
+        const version = '0x3';
+        const estimateTx = {
+            type: 'INVOKE',
+            version,
+            sender_address: from,
+            calldata: formattedCalldata,
+            signature: [],
+            nonce,
+            resource_bounds: {
+                l1_gas: { max_amount: '0x186a0', max_price_per_unit: '0x5f5e100' },
+                l2_gas: { max_amount: '0x0', max_price_per_unit: '0x0' },
+                l1_data_gas: { max_amount: '0x186a0', max_price_per_unit: '0x1' },
+            },
+            tip: '0x0',
+            paymaster_data: [],
+            account_deployment_data: [],
+            nonce_data_availability_mode: 'L1',
+            fee_data_availability_mode: 'L1',
+        };
+        const estimateResponse = await adapter
+            .getStarknetProvider()
+            .fetch('starknet_estimateFee', [[estimateTx], ['SKIP_VALIDATE'], 'latest']);
+        const estimateResult = await estimateResponse.json();
+        if (estimateResult.error) {
+            throw new Error(`Fee estimation failed: ${JSON.stringify(estimateResult.error)}`);
+        }
+        const feeEstimate = estimateResult.result?.[0];
+        if (!feeEstimate) {
+            throw new Error('Fee estimation failed: no estimate returned');
+        }
+        // Calculate resource bounds with buffer (5x gas amount, 2x gas price)
+        const l1GasConsumed = feeEstimate.l1_gas_consumed
+            ? BigInt(feeEstimate.l1_gas_consumed)
+            : BigInt('0x186a0');
+        const l1GasPrice = feeEstimate.l1_gas_price
+            ? BigInt(feeEstimate.l1_gas_price)
+            : BigInt('0x5f5e100');
+        const l2GasConsumed = feeEstimate.l2_gas_consumed
+            ? BigInt(feeEstimate.l2_gas_consumed)
+            : BigInt('0x0');
+        const l2GasPrice = feeEstimate.l2_gas_price ? BigInt(feeEstimate.l2_gas_price) : BigInt('0x0');
+        const l1DataGasConsumed = feeEstimate.l1_data_gas_consumed
+            ? BigInt(feeEstimate.l1_data_gas_consumed)
+            : BigInt('0x186a0');
+        const l1DataGasPrice = feeEstimate.l1_data_gas_price
+            ? BigInt(feeEstimate.l1_data_gas_price)
+            : BigInt('0x1');
+        const resourceBounds = {
+            l1_gas: {
+                max_amount: (l1GasConsumed * BigInt(500)) / BigInt(100),
+                max_price_per_unit: (l1GasPrice * BigInt(200)) / BigInt(100),
+            },
+            l2_gas: {
+                max_amount: (l2GasConsumed * BigInt(500)) / BigInt(100),
+                max_price_per_unit: (l2GasPrice * BigInt(200)) / BigInt(100),
+            },
+            l1_data_gas: {
+                max_amount: (l1DataGasConsumed * BigInt(500)) / BigInt(100),
+                max_price_per_unit: (l1DataGasPrice * BigInt(200)) / BigInt(100),
+            },
+        };
+        // Calculate transaction hash for signing
+        const invokeHashInputs = {
+            senderAddress: from,
+            version,
+            compiledCalldata: formattedCalldata,
+            chainId: chainIdHex,
+            nonce,
+            nonceDataAvailabilityMode: 0,
+            feeDataAvailabilityMode: 0,
+            resourceBounds: {
+                l1_gas: {
+                    max_amount: resourceBounds.l1_gas.max_amount,
+                    max_price_per_unit: resourceBounds.l1_gas.max_price_per_unit,
+                },
+                l2_gas: {
+                    max_amount: resourceBounds.l2_gas.max_amount,
+                    max_price_per_unit: resourceBounds.l2_gas.max_price_per_unit,
+                },
+                l1_data_gas: {
+                    max_amount: resourceBounds.l1_data_gas.max_amount,
+                    max_price_per_unit: resourceBounds.l1_data_gas.max_price_per_unit,
+                },
+            },
+            tip: '0x0',
+            paymasterData: [],
+            accountDeploymentData: [],
+        };
+        const txHash = hash.calculateInvokeTransactionHash(invokeHashInputs);
+        // Return transaction ready for signing
+        return {
+            addressNList: toAddressNList(adapter.getBip44Params({ accountNumber })),
+            txHash,
+            _txDetails: {
+                fromAddress: from,
+                calldata: formattedCalldata,
+                nonce,
+                version,
+                resourceBounds,
+                chainId: chainIdHex,
+                nonceDataAvailabilityMode: 0,
+                feeDataAvailabilityMode: 0,
+                tip: '0x0',
+                paymasterData: [],
+                accountDeploymentData: [],
+            },
+        };
+    },
+    getStarknetTransactionFees: ({ tradeQuote, stepIndex }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        if (!step.feeData.networkFeeCryptoBaseUnit) {
+            throw new Error('Missing network fee in quote');
+        }
+        return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
+    },
+    checkTradeStatus: ({ swap, assertGetStarknetChainAdapter }) => {
+        if (!swap?.sellTxHash) {
+            return Promise.resolve(createDefaultStatusResponse());
+        }
+        return checkStarknetSwapStatus({
+            txHash: swap.sellTxHash,
+            assertGetStarknetChainAdapter,
+        });
+    },
+};

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

@@ -0,0 +1 @@
+export { AVNU_SUPPORTED_CHAIN_IDS } from './utils/constants.js';

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

@@ -0,0 +1 @@
+export { AVNU_SUPPORTED_CHAIN_IDS } from './utils/constants.js';

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

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

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

@@ -0,0 +1,138 @@
+import { getQuotes } from '@avnu/avnu-sdk';
+import { bn } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { AVNU_SUPPORTED_CHAIN_IDS } from '../utils/constants.js';
+import { getTokenAddress } from '../utils/helpers.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,
+        }));
+    }
+    try {
+        const sellTokenAddress = getTokenAddress(sellAsset);
+        const buyTokenAddress = getTokenAddress(buyAsset);
+        const quotes = await getQuotes({
+            sellTokenAddress,
+            buyTokenAddress,
+            sellAmount: BigInt(sellAmount),
+            takerAddress: sendAddress,
+            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 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({
+            to: receiveAddress,
+            value: sellAmount,
+            chainSpecific: {
+                from: sendAddress,
+                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(),
+            receiveAddress,
+            affiliateBps,
+            rate,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??
+                getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Avnu),
+            quoteOrRate: 'quote',
+            swapperName: SwapperName.Avnu,
+            steps: [
+                {
+                    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,
+                    },
+                },
+            ],
+        };
+        return Ok([tradeQuote]);
+    }
+    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/swapperApi/getTradeRate.d.ts

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

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

@@ -0,0 +1,116 @@
+import { getQuotes } from '@avnu/avnu-sdk';
+import { bn } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { AVNU_SUPPORTED_CHAIN_IDS } from '../utils/constants.js';
+import { getTokenAddress } from '../utils/helpers.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);
+        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 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);
+        // For rate quotes, use receiveAddress as a dummy from/to for fee estimation
+        const feeData = await sellAdapter.getFeeData({
+            to: receiveAddress ?? '',
+            value: sellAmount,
+            chainSpecific: {
+                from: receiveAddress ?? '',
+                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 tradeRate = {
+            id: uuid(),
+            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,
+                },
+            ],
+        };
+        return Ok([tradeRate]);
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: error instanceof Error ? error.message : 'Unknown error getting AVNU rate',
+            code: TradeQuoteError.QueryFailed,
+            cause: error,
+        }));
+    }
+};

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

@@ -0,0 +1,2 @@
+import type { KnownChainIds } from '@shapeshiftoss/types';
+export type AvnuSupportedChainId = typeof KnownChainIds.StarknetMainnet;

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

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

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

@@ -0,0 +1,5 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+export declare const AVNU_SUPPORTED_CHAIN_IDS: readonly ChainId[];
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is ChainId;
+export declare const DEFAULT_SLIPPAGE_PERCENTAGE = "0.005";
+export declare const AVNU_API_BASE_URL = "https://starknet.api.avnu.fi";

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

@@ -0,0 +1,7 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export const AVNU_SUPPORTED_CHAIN_IDS = [KnownChainIds.StarknetMainnet];
+export const isSupportedChainId = (chainId) => {
+    return AVNU_SUPPORTED_CHAIN_IDS.includes(chainId);
+};
+export const DEFAULT_SLIPPAGE_PERCENTAGE = '0.005';
+export const AVNU_API_BASE_URL = 'https://starknet.api.avnu.fi';

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

@@ -0,0 +1,7 @@
+import type { Asset } from '@shapeshiftoss/types';
+/**
+ * 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;

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

@@ -0,0 +1,17 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+// STRK native token contract address on Starknet
+const AVNU_STRK_NATIVE_ADDRESS = '0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d';
+/**
+ * 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 const getTokenAddress = (asset) => {
+    const { assetReference, assetNamespace } = fromAssetId(asset.assetId);
+    // For native STRK token, the assetReference is 'slip44:9004' but AVNU expects the STRK contract address
+    if (assetNamespace === 'slip44') {
+        return AVNU_STRK_NATIVE_ADDRESS;
+    }
+    // For other tokens, the assetReference should be the token contract address
+    return assetReference;
+};

package/dist/esm/swappers/ButterSwap/swapperApi/getTradeQuote.test.js

@@ -32,6 +32,8 @@ describe('getTradeQuote', () => {
             assertGetSolanaChainAdapter: () => vi.fn(),
             assertGetTronChainAdapter: () => vi.fn(),
             assertGetSuiChainAdapter: () => vi.fn(),
+            assertGetNearChainAdapter: () => vi.fn(),
+            assertGetStarknetChainAdapter: () => vi.fn(),
             config: {
                 VITE_BUTTERSWAP_CLIENT_ID: 'test',
             },

package/dist/esm/swappers/ButterSwap/swapperApi/getTradeRate.test.js

@@ -23,6 +23,8 @@ describe('getTradeRate', () => {
             assertGetSolanaChainAdapter: () => vi.fn(),
             assertGetTronChainAdapter: () => vi.fn(),
             assertGetSuiChainAdapter: () => vi.fn(),
+            assertGetNearChainAdapter: () => vi.fn(),
+            assertGetStarknetChainAdapter: () => vi.fn(),
             config: {
                 VITE_BUTTERSWAP_CLIENT_ID: 'test',
             },
@@ -57,6 +59,8 @@ describe('getTradeRate', () => {
             assertGetSolanaChainAdapter: () => vi.fn(),
             assertGetTronChainAdapter: () => vi.fn(),
             assertGetSuiChainAdapter: () => vi.fn(),
+            assertGetNearChainAdapter: () => vi.fn(),
+            assertGetStarknetChainAdapter: () => vi.fn(),
             config: {
                 VITE_BUTTERSWAP_CLIENT_ID: 'test',
             },

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

@@ -7,6 +7,7 @@ const BUTTERSWAP_CHAIN_ID_TO_CHAIN_ID = {
     42161: KnownChainIds.ArbitrumMainnet,
     10: KnownChainIds.OptimismMainnet,
     8453: KnownChainIds.BaseMainnet,
+    43114: KnownChainIds.AvalancheMainnet,
     1360108768460801: KnownChainIds.SolanaMainnet,
     1360095883558913: KnownChainIds.BitcoinMainnet,
 };