@shapeshiftoss/swapper 17.6.8 → 17.6.10

package/dist/esm/swappers/AcrossSwapper/utils/getTrade.js

@@ -0,0 +1,328 @@
+import { fromAssetId, isAssetReference, solanaChainId, usdcOnSolanaAssetId, } from '@shapeshiftoss/caip';
+import { evm, isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { BigAmount, bnOrZero, chainIdToFeeAssetId, convertPrecision, isTreasuryChainId, } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { AddressLookupTableAccount, ComputeBudgetProgram, PublicKey, TransactionMessage, VersionedTransaction, } from '@solana/web3.js';
+import axios from 'axios';
+import { zeroAddress } from 'viem';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { getTreasuryAddressFromChainId, isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { ACROSS_SOLANA_TOKEN_ADDRESS, acrossChainIdToChainId, acrossErrorCodeToTradeQuoteError, chainIdToAcrossChainId, DEFAULT_ACROSS_EVM_TOKEN_ADDRESS, DEFAULT_ACROSS_EVM_USER_ADDRESS, DEFAULT_ACROSS_SOLANA_USER_ADDRESS, } from '../constant.js';
+import { fetchAcrossTrade } from './fetchAcrossTrade.js';
+import { isAcrossError } from './types.js';
+const getAcrossAssetAddress = (assetId) => {
+    if (isNativeEvmAsset(assetId))
+        return DEFAULT_ACROSS_EVM_TOKEN_ADDRESS;
+    const { chainId, assetReference } = fromAssetId(assetId);
+    if (chainId === solanaChainId && !isAssetReference(assetReference))
+        return assetReference;
+    if (chainId === solanaChainId)
+        return ACROSS_SOLANA_TOKEN_ADDRESS;
+    return isAssetReference(assetReference) ? zeroAddress : assetReference;
+};
+const getDefaultUserAddress = (chainId) => {
+    if (chainId === solanaChainId)
+        return DEFAULT_ACROSS_SOLANA_USER_ADDRESS;
+    return DEFAULT_ACROSS_EVM_USER_ADDRESS;
+};
+export async function getTrade({ input, deps, }) {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    if (sellAsset.chainId === buyAsset.chainId) {
+        return Err(makeSwapErrorRight({
+            message: 'Across does not support same-chain swaps',
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    const sellAcrossChainId = chainIdToAcrossChainId[sellAsset.chainId];
+    const buyAcrossChainId = chainIdToAcrossChainId[buyAsset.chainId];
+    if (sellAcrossChainId === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `Sell asset chain '${sellAsset.chainId}' not supported by Across`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (buyAcrossChainId === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `Buy asset chain '${buyAsset.chainId}' not supported by Across`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    // Across only supports USDC as the bridgeable token on Solana destinations
+    if (buyAsset.chainId === solanaChainId && buyAsset.assetId !== usdcOnSolanaAssetId) {
+        return Err(makeSwapErrorRight({
+            message: 'Across only supports USDC as destination token on Solana',
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    const depositor = (() => {
+        if (input.quoteOrRate === 'rate') {
+            if (input.sendAddress)
+                return input.sendAddress;
+            return getDefaultUserAddress(sellAsset.chainId);
+        }
+        return input.sendAddress ?? getDefaultUserAddress(sellAsset.chainId);
+    })();
+    const recipient = (() => {
+        if (input.quoteOrRate === 'rate') {
+            if (input.receiveAddress)
+                return input.receiveAddress;
+            return getDefaultUserAddress(buyAsset.chainId);
+        }
+        return input.receiveAddress;
+    })();
+    const isSolanaRoute = sellAsset.chainId === solanaChainId || buyAsset.chainId === solanaChainId;
+    const appFee = (() => {
+        if (isSolanaRoute)
+            return undefined;
+        if (!isTreasuryChainId(buyAsset.chainId))
+            return undefined;
+        const bps = bnOrZero(affiliateBps);
+        if (!bps.isFinite() || bps.lte(0))
+            return undefined;
+        return bps.div(10000).toNumber();
+    })();
+    const appFeeRecipient = (() => {
+        if (appFee === undefined)
+            return undefined;
+        try {
+            return getTreasuryAddressFromChainId(buyAsset.chainId).toLowerCase();
+        }
+        catch (e) {
+            console.error(`[getTrade] Failed to get treasury address for chainId ${buyAsset.chainId}, affiliate fee will not be applied`, e);
+            return undefined;
+        }
+    })();
+    const slippage = input.slippageTolerancePercentageDecimal ?? 'auto';
+    const integratorId = deps.config.VITE_ACROSS_INTEGRATOR_ID || undefined;
+    const maybeQuote = await fetchAcrossTrade({
+        tradeType: 'exactInput',
+        amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        inputToken: getAcrossAssetAddress(sellAsset.assetId),
+        outputToken: getAcrossAssetAddress(buyAsset.assetId),
+        originChainId: sellAcrossChainId,
+        destinationChainId: buyAcrossChainId,
+        depositor,
+        recipient,
+        appFee,
+        appFeeRecipient,
+        integratorId,
+        slippage,
+    }, deps.config);
+    if (maybeQuote.isErr()) {
+        const error = maybeQuote.unwrapErr();
+        if (!axios.isAxiosError(error.cause)) {
+            return Err(makeSwapErrorRight({
+                message: 'Unknown error',
+                code: TradeQuoteError.UnknownError,
+            }));
+        }
+        const acrossError = error.cause?.response?.data;
+        if (!isAcrossError(acrossError)) {
+            return Err(makeSwapErrorRight({
+                message: 'Unknown error',
+                code: TradeQuoteError.UnknownError,
+            }));
+        }
+        const tradeQuoteErrorCode = acrossErrorCodeToTradeQuoteError[acrossError.code];
+        return Err(makeSwapErrorRight({
+            message: acrossError.message,
+            code: tradeQuoteErrorCode ?? TradeQuoteError.UnknownError,
+        }));
+    }
+    const { data: quote } = maybeQuote.unwrap();
+    const buyAmountAfterFeesCryptoBaseUnit = quote.expectedOutputAmount;
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const bridgeFeeAmount = quote.fees.total.amount;
+    const bridgeFeeAsset = quote.fees.total.token;
+    const buyAssetAcrossAddress = getAcrossAssetAddress(buyAsset.assetId);
+    const isBridgeFeeInBuyAsset = bridgeFeeAsset.chainId === buyAcrossChainId &&
+        (bridgeFeeAsset.address === buyAssetAcrossAddress ||
+            (isEvmChainId(buyAsset.chainId) &&
+                bridgeFeeAsset.address.toLowerCase() === buyAssetAcrossAddress.toLowerCase()));
+    const buyAmountBeforeFeesCryptoBaseUnit = (() => {
+        if (!isBridgeFeeInBuyAsset)
+            return buyAmountAfterFeesCryptoBaseUnit;
+        const bridgeFeeInBuyAssetPrecision = BigAmount.fromBaseUnit({
+            value: convertPrecision({
+                value: bridgeFeeAmount,
+                inputExponent: bridgeFeeAsset.decimals,
+                outputExponent: buyAsset.precision,
+            }).toFixed(0),
+            precision: buyAsset.precision,
+        });
+        return BigAmount.fromBaseUnit({
+            value: buyAmountAfterFeesCryptoBaseUnit,
+            precision: buyAsset.precision,
+        })
+            .plus(bridgeFeeInBuyAssetPrecision)
+            .toBaseUnit();
+    })();
+    const allowanceContract = isEvmChainId(sellAsset.chainId) ? quote.checks.allowance.spender : '';
+    const acrossTransactionMetadata = {
+        to: quote.swapTx.to,
+        data: quote.swapTx.data,
+        value: quote.swapTx.value ?? '0',
+        gasLimit: quote.swapTx.gas,
+        ecosystem: quote.swapTx.ecosystem,
+        quoteId: quote.id,
+    };
+    // For SVM transactions, decompile the pre-built base64 blob into instructions
+    // so getUnsignedSolanaTransaction can rebuild it at execution time
+    const maybeSolanaTransactionMetadata = await (async () => {
+        if (quote.swapTx.ecosystem !== 'svm')
+            return Ok(undefined);
+        try {
+            const versionedTransaction = VersionedTransaction.deserialize(new Uint8Array(Buffer.from(quote.swapTx.data, 'base64')));
+            const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+            const addressLookupTableAccountKeys = versionedTransaction.message.addressTableLookups.map(lookup => lookup.accountKey.toString());
+            const addressLookupTableAccountsInfos = await adapter.getAddressLookupTableAccounts(addressLookupTableAccountKeys);
+            const addressLookupTableAccounts = addressLookupTableAccountsInfos.map(info => new AddressLookupTableAccount({
+                key: new PublicKey(info.key),
+                state: AddressLookupTableAccount.deserialize(new Uint8Array(info.data)),
+            }));
+            const instructions = TransactionMessage.decompile(versionedTransaction.message, {
+                addressLookupTableAccounts,
+            }).instructions;
+            const computeBudgetProgramId = ComputeBudgetProgram.programId.toString();
+            const instructionsWithoutComputeBudget = instructions.filter(instruction => instruction.programId.toString() !== computeBudgetProgramId);
+            return Ok({
+                instructions: instructionsWithoutComputeBudget,
+                addressLookupTableAddresses: addressLookupTableAccountKeys,
+            });
+        }
+        catch (e) {
+            return Err(makeSwapErrorRight({
+                message: `[getTrade] Failed to decompile Solana transaction: ${e}`,
+                code: TradeQuoteError.UnknownError,
+            }));
+        }
+    })();
+    if (maybeSolanaTransactionMetadata.isErr())
+        return Err(maybeSolanaTransactionMetadata.unwrapErr());
+    const solanaTransactionMetadata = maybeSolanaTransactionMetadata.unwrap();
+    const networkFeeCryptoBaseUnit = await (async () => {
+        if (solanaTransactionMetadata) {
+            const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+            const { fast } = await adapter.getFeeData({
+                to: '',
+                value: '0',
+                chainSpecific: {
+                    from: depositor,
+                    addressLookupTableAccounts: solanaTransactionMetadata.addressLookupTableAddresses,
+                    instructions: solanaTransactionMetadata.instructions,
+                },
+            });
+            return fast.txFee;
+        }
+        if (isEvmChainId(sellAsset.chainId)) {
+            const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+            const { average } = await adapter.getGasFeeData();
+            const supportsEIP1559 = 'maxFeePerGas' in average;
+            if (bnOrZero(acrossTransactionMetadata.gasLimit).gt(0)) {
+                return evm.calcNetworkFeeCryptoBaseUnit({
+                    ...average,
+                    supportsEIP1559,
+                    gasLimit: acrossTransactionMetadata.gasLimit ?? '0',
+                });
+            }
+            try {
+                const feeData = await evm.getFees({
+                    adapter,
+                    data: acrossTransactionMetadata.data,
+                    to: acrossTransactionMetadata.to,
+                    value: acrossTransactionMetadata.value,
+                    from: depositor,
+                    supportsEIP1559,
+                });
+                return feeData.networkFeeCryptoBaseUnit;
+            }
+            catch {
+                return quote.fees.originGas.amount;
+            }
+        }
+        return quote.fees.originGas.amount;
+    })();
+    // Build protocol fee asset ID — Across returns its own numeric chain IDs, convert to CAIP
+    const bridgeFeeAssetCaipChainId = acrossChainIdToChainId[bridgeFeeAsset.chainId.toString()];
+    const bridgeFeeAssetId = (() => {
+        if (!bridgeFeeAssetCaipChainId)
+            return undefined;
+        const isNativeFeeAsset = (() => {
+            if (bridgeFeeAssetCaipChainId === solanaChainId) {
+                return (bridgeFeeAsset.address === 'So11111111111111111111111111111111111111112' ||
+                    bridgeFeeAsset.address === zeroAddress);
+            }
+            return bridgeFeeAsset.address === zeroAddress;
+        })();
+        if (isNativeFeeAsset)
+            return chainIdToFeeAssetId(bridgeFeeAssetCaipChainId);
+        const tokenStandard = bridgeFeeAssetCaipChainId.startsWith('solana') ? 'token' : 'erc20';
+        return `${bridgeFeeAssetCaipChainId}/${tokenStandard}:${bridgeFeeAsset.address}`;
+    })();
+    const accountNumber = input.accountNumber;
+    const step = {
+        allowanceContract,
+        rate,
+        buyAmountBeforeFeesCryptoBaseUnit,
+        buyAmountAfterFeesCryptoBaseUnit,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAsset,
+        sellAsset,
+        accountNumber,
+        feeData: {
+            networkFeeCryptoBaseUnit,
+            protocolFees: bridgeFeeAssetId
+                ? {
+                    [bridgeFeeAssetId]: {
+                        amountCryptoBaseUnit: bridgeFeeAmount,
+                        asset: {
+                            symbol: bridgeFeeAsset.symbol,
+                            chainId: bridgeFeeAssetCaipChainId,
+                            precision: bridgeFeeAsset.decimals,
+                        },
+                        requiresBalance: false,
+                    },
+                }
+                : {},
+        },
+        source: SwapperName.Across,
+        estimatedExecutionTimeMs: quote.expectedFillTime * 1000,
+        acrossTransactionMetadata,
+        solanaTransactionMetadata,
+    };
+    const baseQuoteOrRate = {
+        id: quote.id,
+        rate,
+        swapperName: SwapperName.Across,
+        affiliateBps,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+    };
+    if (input.quoteOrRate === 'quote') {
+        if (!input.receiveAddress) {
+            return Err(makeSwapErrorRight({
+                message: 'Receive address is required for quote',
+                code: TradeQuoteError.InternalError,
+            }));
+        }
+        const tradeQuote = {
+            ...baseQuoteOrRate,
+            steps: [step],
+            receiveAddress: input.receiveAddress,
+            quoteOrRate: 'quote',
+        };
+        return Ok([tradeQuote]);
+    }
+    const tradeRate = {
+        ...baseQuoteOrRate,
+        steps: [step],
+        receiveAddress: recipient,
+        quoteOrRate: 'rate',
+    };
+    return Ok([tradeRate]);
+}

package/dist/esm/swappers/AcrossSwapper/utils/types.d.ts

@@ -0,0 +1,177 @@
+import type { Asset } from '@shapeshiftoss/types';
+export type AcrossTradeBaseParams = {
+    buyAsset: Asset;
+    sellAsset: Asset;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    affiliateBps: string;
+};
+export type AcrossTradeInputParams<T extends 'rate' | 'quote'> = AcrossTradeBaseParams & {
+    quoteOrRate: T;
+    receiveAddress: T extends 'rate' ? string | undefined : string;
+    sendAddress: T extends 'rate' ? undefined : string;
+    accountNumber: T extends 'rate' ? undefined : number;
+    slippageTolerancePercentageDecimal?: string;
+};
+export type AcrossTransactionMetadata = {
+    to: string;
+    data: string;
+    value: string;
+    gasLimit?: string;
+    ecosystem: 'evm' | 'svm';
+    quoteId: string;
+};
+export type AcrossTokenInfo = {
+    address: string;
+    decimals: number;
+    symbol: string;
+    name: string;
+    chainId: number;
+};
+export type AcrossSwapStep = {
+    tokenIn: AcrossTokenInfo;
+    tokenOut: AcrossTokenInfo;
+    inputAmount: string;
+    outputAmount: string;
+    minOutputAmount: string;
+    maxInputAmount: string;
+    swapProvider: {
+        name: string;
+        sources: string[];
+    };
+    slippage: number;
+};
+export type AcrossFeePart = {
+    amount: string;
+    pct: string;
+    token: AcrossTokenInfo;
+};
+export type AcrossBridgeFeeDetails = {
+    type: 'across';
+    relayerCapital: AcrossFeePart;
+    destinationGas: AcrossFeePart;
+    lp: AcrossFeePart;
+};
+export type AcrossBridgeStep = {
+    inputAmount: string;
+    outputAmount: string;
+    tokenIn: AcrossTokenInfo;
+    tokenOut: AcrossTokenInfo;
+    fees: {
+        amount: string;
+        pct: string;
+        token: AcrossTokenInfo;
+        details: AcrossBridgeFeeDetails;
+    };
+    provider: string;
+};
+export type AcrossFeeBreakdown = {
+    amount: string;
+    amountUsd: string;
+    token: AcrossTokenInfo;
+    pct: string;
+    details: {
+        type: string;
+        swapImpact: {
+            amount: string;
+            amountUsd: string;
+            token: AcrossTokenInfo;
+            pct: string;
+        };
+        app: {
+            amount: string;
+            amountUsd: string;
+            pct: string;
+            token: AcrossTokenInfo;
+        };
+        bridge: AcrossBridgeStep['fees'];
+    };
+};
+export type AcrossSwapTx = {
+    simulationSuccess: boolean;
+    chainId: number;
+    to: string;
+    data: string;
+    value?: string;
+    gas?: string;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+    ecosystem: 'evm' | 'svm';
+};
+export type AcrossSwapApprovalResponse = {
+    crossSwapType: 'bridgeableToBridgeable' | 'bridgeableToBridgeableIndirect' | 'bridgeableToAny' | 'anyToBridgeable' | 'anyToAny';
+    amountType: string;
+    approvalTxns: {
+        chainId: number;
+        to: string;
+        data: string;
+    }[];
+    swapTx: AcrossSwapTx;
+    checks: {
+        allowance: {
+            token: string;
+            spender: string;
+            actual: string;
+            expected: string;
+        };
+        balance: {
+            token: string;
+            actual: string;
+            expected: string;
+        };
+    };
+    steps: {
+        originSwap?: AcrossSwapStep;
+        bridge: AcrossBridgeStep;
+        destinationSwap?: AcrossSwapStep;
+    };
+    inputToken: AcrossTokenInfo;
+    outputToken: AcrossTokenInfo;
+    refundToken: AcrossTokenInfo;
+    inputAmount: string;
+    maxInputAmount: string;
+    expectedOutputAmount: string;
+    minOutputAmount: string;
+    fees: {
+        total: AcrossFeeBreakdown;
+        totalMax: AcrossFeeBreakdown;
+        originGas: {
+            amount: string;
+            amountUsd: string;
+            token: AcrossTokenInfo;
+        };
+    };
+    expectedFillTime: number;
+    quoteExpiryTimestamp: number;
+    id: string;
+};
+export type AcrossDepositStatus = {
+    status: 'filled' | 'pending' | 'expired' | 'refunded' | 'slowFillRequested';
+    fillTxnRef?: string;
+    destinationChainId: number;
+    originChainId: number;
+    depositId: number;
+    depositTxnRef: string;
+    depositRefundTxnRef?: string;
+    actionsSucceeded?: boolean;
+    pagination: {
+        currentIndex: number;
+        maxIndex: number;
+    };
+};
+export type AcrossError = {
+    type: string;
+    code: string;
+    status: number;
+    message: string;
+    id: string;
+};
+export declare const isAcrossError: (error: unknown) => error is AcrossError;
+export declare enum AcrossErrorCode {
+    InvalidParam = "INVALID_PARAM",
+    AmountTooLow = "AMOUNT_TOO_LOW",
+    RouteNotFound = "ROUTE_NOT_FOUND",
+    NoBridgeRoutes = "NO_BRIDGE_ROUTES",
+    UnsupportedToken = "UNSUPPORTED_TOKEN",
+    InsufficientLiquidity = "INSUFFICIENT_LIQUIDITY",
+    InternalError = "INTERNAL_ERROR"
+}

package/dist/esm/swappers/AcrossSwapper/utils/types.js

@@ -0,0 +1,13 @@
+export const isAcrossError = (error) => {
+    return typeof error === 'object' && error !== null && 'code' in error && 'status' in error;
+};
+export var AcrossErrorCode;
+(function (AcrossErrorCode) {
+    AcrossErrorCode["InvalidParam"] = "INVALID_PARAM";
+    AcrossErrorCode["AmountTooLow"] = "AMOUNT_TOO_LOW";
+    AcrossErrorCode["RouteNotFound"] = "ROUTE_NOT_FOUND";
+    AcrossErrorCode["NoBridgeRoutes"] = "NO_BRIDGE_ROUTES";
+    AcrossErrorCode["UnsupportedToken"] = "UNSUPPORTED_TOKEN";
+    AcrossErrorCode["InsufficientLiquidity"] = "INSUFFICIENT_LIQUIDITY";
+    AcrossErrorCode["InternalError"] = "INTERNAL_ERROR";
+})(AcrossErrorCode || (AcrossErrorCode = {}));

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

@@ -1,9 +1,33 @@
 import { quoteToCalls } from '@avnu/avnu-sdk';
 import { toAddressNList } from '@shapeshiftoss/chain-adapters';
-import { CallData, hash, num } from 'starknet';
+import { CallData, hash, num, validateAndParseAddress } from 'starknet';
 import { checkStarknetSwapStatus, createDefaultStatusResponse, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
 import { getTradeQuote } from './swapperApi/getTradeQuote.js';
 import { getTradeRate } from './swapperApi/getTradeRate.js';
+/**
+ * Normalize a value to hex format for Starknet RPC
+ * Handles various input types: decimal strings, hex strings (with/without 0x), numbers, BigInts
+ */
+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}`;
+    }
+};
 export const avnuApi = {
     getTradeQuote,
     getTradeRate: (input, deps) => {
@@ -19,16 +43,23 @@ export const avnuApi = {
         if (!avnuSpecific.quoteId)
             throw new Error('quoteId is required in avnuSpecific');
         const adapter = assertGetStarknetChainAdapter(sellAsset.chainId);
+        // Normalize the from address to ensure consistent format
+        // Starknet addresses can have different representations (with/without leading zeros)
+        const normalizedFrom = validateAndParseAddress(from);
         // Convert slippage from decimal percentage string to number for AVNU format (e.g., "0.01" = 1%)
+        // Use a slightly higher default slippage (2%) to account for quote staleness
         const slippage = slippageTolerancePercentageDecimal
             ? parseFloat(slippageTolerancePercentageDecimal)
-            : 0.01;
+            : 0.02;
         // Get the swap calls from AVNU SDK
         const { calls: avnuCalls } = await quoteToCalls({
             quoteId: avnuSpecific.quoteId,
             slippage,
-            takerAddress: from,
+            takerAddress: normalizedFrom,
         });
+        if (!avnuCalls || avnuCalls.length === 0) {
+            throw new Error('No swap calls returned from AVNU - quote may have expired');
+        }
         // Build the full invoke transaction calldata from AVNU calls
         // Format: [call_array_length, contract1, selector1, calldata_len1, ...calldata1, ...]
         const fullCalldata = [avnuCalls.length.toString()];
@@ -36,24 +67,21 @@ export const avnuApi = {
             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()));
+            // Normalize contract address from AVNU to ensure consistent format
+            const normalizedContractAddress = validateAndParseAddress(call.contractAddress);
+            fullCalldata.push(normalizedContractAddress, selector, calldataArray.length.toString(), ...calldataArray.map(cd => String(cd)));
         }
-        // Format calldata for RPC (convert numbers to hex)
-        const formattedCalldata = fullCalldata.map(data => {
-            if (!data.startsWith('0x')) {
-                return num.toHex(data);
-            }
-            return data;
-        });
+        // Format calldata for RPC (convert all values to proper hex format)
+        const formattedCalldata = fullCalldata.map(toHexString);
         // Get nonce using adapter method (checks deployment status and returns appropriate nonce)
         const chainIdHex = await adapter.getStarknetProvider().getChainId();
-        const nonce = await adapter.getNonce(from);
+        const nonce = await adapter.getNonce(normalizedFrom);
         // Estimate fees for the multi-call swap transaction
         const version = '0x3';
         const estimateTx = {
             type: 'INVOKE',
             version,
-            sender_address: from,
+            sender_address: normalizedFrom,
             calldata: formattedCalldata,
             signature: [],
             nonce,
@@ -112,7 +140,7 @@ export const avnuApi = {
         };
         // Calculate transaction hash for signing
         const invokeHashInputs = {
-            senderAddress: from,
+            senderAddress: normalizedFrom,
             version,
             compiledCalldata: formattedCalldata,
             chainId: chainIdHex,
@@ -143,7 +171,7 @@ export const avnuApi = {
             addressNList: toAddressNList(adapter.getBip44Params({ accountNumber })),
             txHash,
             _txDetails: {
-                fromAddress: from,
+                fromAddress: normalizedFrom,
                 calldata: formattedCalldata,
                 nonce,
                 version,

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

@@ -1,11 +1,12 @@
 import { getQuotes } from '@avnu/avnu-sdk';
 import { bn } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { getTreasuryAddressFromChainId } from 'packages/swapper/src/swappers/utils/helpers/helpers';
+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 { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
 import { AVNU_SUPPORTED_CHAIN_IDS } from '../utils/constants.js';
 import { getTokenAddress } from '../utils/helpers.js';
 export const getTradeQuote = async (input, deps) => {
@@ -43,11 +44,15 @@ export const getTradeQuote = async (input, deps) => {
     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)
+        const normalizedSendAddress = validateAndParseAddress(sendAddress);
+        const normalizedReceiveAddress = validateAndParseAddress(receiveAddress);
         const quotes = await getQuotes({
             sellTokenAddress,
             buyTokenAddress,
             sellAmount: BigInt(sellAmount),
-            takerAddress: sendAddress,
+            takerAddress: normalizedSendAddress,
             size: 1,
             integratorFees: affiliateBps ? BigInt(affiliateBps) : undefined,
             integratorFeeRecipient: getTreasuryAddressFromChainId(sellAsset.chainId),
@@ -68,10 +73,10 @@ export const getTradeQuote = async (input, deps) => {
         const buyAmountAfterFeesCryptoBaseUnit = bestQuote.buyAmount.toString();
         const sellAdapter = deps.assertGetStarknetChainAdapter(sellAsset.chainId);
         const feeData = await sellAdapter.getFeeData({
-            to: receiveAddress,
+            to: normalizedReceiveAddress,
             value: sellAmount,
             chainSpecific: {
-                from: sendAddress,
+                from: normalizedSendAddress,
                 tokenContractAddress: sellTokenAddress,
             },
             sendMax: false,
@@ -96,7 +101,7 @@ export const getTradeQuote = async (input, deps) => {
             : {};
         const tradeQuote = {
             id: uuid(),
-            receiveAddress,
+            receiveAddress: normalizedReceiveAddress,
             affiliateBps,
             rate,
             slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??