@shapeshiftoss/swapper 17.6.8 → 17.6.10

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

@@ -0,0 +1,335 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrade = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const web3_js_1 = require("@solana/web3.js");
+const axios_1 = __importDefault(require("axios"));
+const viem_1 = require("viem");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const helpers_1 = require("../../utils/helpers/helpers");
+const constant_1 = require("../constant");
+const fetchAcrossTrade_1 = require("./fetchAcrossTrade");
+const types_2 = require("./types");
+const getAcrossAssetAddress = (assetId) => {
+    if ((0, helpers_1.isNativeEvmAsset)(assetId))
+        return constant_1.DEFAULT_ACROSS_EVM_TOKEN_ADDRESS;
+    const { chainId, assetReference } = (0, caip_1.fromAssetId)(assetId);
+    if (chainId === caip_1.solanaChainId && !(0, caip_1.isAssetReference)(assetReference))
+        return assetReference;
+    if (chainId === caip_1.solanaChainId)
+        return constant_1.ACROSS_SOLANA_TOKEN_ADDRESS;
+    return (0, caip_1.isAssetReference)(assetReference) ? viem_1.zeroAddress : assetReference;
+};
+const getDefaultUserAddress = (chainId) => {
+    if (chainId === caip_1.solanaChainId)
+        return constant_1.DEFAULT_ACROSS_SOLANA_USER_ADDRESS;
+    return constant_1.DEFAULT_ACROSS_EVM_USER_ADDRESS;
+};
+async function getTrade({ input, deps, }) {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    if (sellAsset.chainId === buyAsset.chainId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Across does not support same-chain swaps',
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    const sellAcrossChainId = constant_1.chainIdToAcrossChainId[sellAsset.chainId];
+    const buyAcrossChainId = constant_1.chainIdToAcrossChainId[buyAsset.chainId];
+    if (sellAcrossChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Sell asset chain '${sellAsset.chainId}' not supported by Across`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (buyAcrossChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Buy asset chain '${buyAsset.chainId}' not supported by Across`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    // Across only supports USDC as the bridgeable token on Solana destinations
+    if (buyAsset.chainId === caip_1.solanaChainId && buyAsset.assetId !== caip_1.usdcOnSolanaAssetId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Across only supports USDC as destination token on Solana',
+            code: types_1.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 === caip_1.solanaChainId || buyAsset.chainId === caip_1.solanaChainId;
+    const appFee = (() => {
+        if (isSolanaRoute)
+            return undefined;
+        if (!(0, utils_1.isTreasuryChainId)(buyAsset.chainId))
+            return undefined;
+        const bps = (0, utils_1.bnOrZero)(affiliateBps);
+        if (!bps.isFinite() || bps.lte(0))
+            return undefined;
+        return bps.div(10000).toNumber();
+    })();
+    const appFeeRecipient = (() => {
+        if (appFee === undefined)
+            return undefined;
+        try {
+            return (0, helpers_1.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 (0, fetchAcrossTrade_1.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_1.default.isAxiosError(error.cause)) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'Unknown error',
+                code: types_1.TradeQuoteError.UnknownError,
+            }));
+        }
+        const acrossError = error.cause?.response?.data;
+        if (!(0, types_2.isAcrossError)(acrossError)) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'Unknown error',
+                code: types_1.TradeQuoteError.UnknownError,
+            }));
+        }
+        const tradeQuoteErrorCode = constant_1.acrossErrorCodeToTradeQuoteError[acrossError.code];
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: acrossError.message,
+            code: tradeQuoteErrorCode ?? types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    const { data: quote } = maybeQuote.unwrap();
+    const buyAmountAfterFeesCryptoBaseUnit = quote.expectedOutputAmount;
+    const rate = (0, utils_2.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 ||
+            ((0, chain_adapters_1.isEvmChainId)(buyAsset.chainId) &&
+                bridgeFeeAsset.address.toLowerCase() === buyAssetAcrossAddress.toLowerCase()));
+    const buyAmountBeforeFeesCryptoBaseUnit = (() => {
+        if (!isBridgeFeeInBuyAsset)
+            return buyAmountAfterFeesCryptoBaseUnit;
+        const bridgeFeeInBuyAssetPrecision = utils_1.BigAmount.fromBaseUnit({
+            value: (0, utils_1.convertPrecision)({
+                value: bridgeFeeAmount,
+                inputExponent: bridgeFeeAsset.decimals,
+                outputExponent: buyAsset.precision,
+            }).toFixed(0),
+            precision: buyAsset.precision,
+        });
+        return utils_1.BigAmount.fromBaseUnit({
+            value: buyAmountAfterFeesCryptoBaseUnit,
+            precision: buyAsset.precision,
+        })
+            .plus(bridgeFeeInBuyAssetPrecision)
+            .toBaseUnit();
+    })();
+    const allowanceContract = (0, chain_adapters_1.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 (0, monads_1.Ok)(undefined);
+        try {
+            const versionedTransaction = web3_js_1.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 web3_js_1.AddressLookupTableAccount({
+                key: new web3_js_1.PublicKey(info.key),
+                state: web3_js_1.AddressLookupTableAccount.deserialize(new Uint8Array(info.data)),
+            }));
+            const instructions = web3_js_1.TransactionMessage.decompile(versionedTransaction.message, {
+                addressLookupTableAccounts,
+            }).instructions;
+            const computeBudgetProgramId = web3_js_1.ComputeBudgetProgram.programId.toString();
+            const instructionsWithoutComputeBudget = instructions.filter(instruction => instruction.programId.toString() !== computeBudgetProgramId);
+            return (0, monads_1.Ok)({
+                instructions: instructionsWithoutComputeBudget,
+                addressLookupTableAddresses: addressLookupTableAccountKeys,
+            });
+        }
+        catch (e) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `[getTrade] Failed to decompile Solana transaction: ${e}`,
+                code: types_1.TradeQuoteError.UnknownError,
+            }));
+        }
+    })();
+    if (maybeSolanaTransactionMetadata.isErr())
+        return (0, monads_1.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 ((0, chain_adapters_1.isEvmChainId)(sellAsset.chainId)) {
+            const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+            const { average } = await adapter.getGasFeeData();
+            const supportsEIP1559 = 'maxFeePerGas' in average;
+            if ((0, utils_1.bnOrZero)(acrossTransactionMetadata.gasLimit).gt(0)) {
+                return chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({
+                    ...average,
+                    supportsEIP1559,
+                    gasLimit: acrossTransactionMetadata.gasLimit ?? '0',
+                });
+            }
+            try {
+                const feeData = await chain_adapters_1.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 = constant_1.acrossChainIdToChainId[bridgeFeeAsset.chainId.toString()];
+    const bridgeFeeAssetId = (() => {
+        if (!bridgeFeeAssetCaipChainId)
+            return undefined;
+        const isNativeFeeAsset = (() => {
+            if (bridgeFeeAssetCaipChainId === caip_1.solanaChainId) {
+                return (bridgeFeeAsset.address === 'So11111111111111111111111111111111111111112' ||
+                    bridgeFeeAsset.address === viem_1.zeroAddress);
+            }
+            return bridgeFeeAsset.address === viem_1.zeroAddress;
+        })();
+        if (isNativeFeeAsset)
+            return (0, utils_1.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: types_1.SwapperName.Across,
+        estimatedExecutionTimeMs: quote.expectedFillTime * 1000,
+        acrossTransactionMetadata,
+        solanaTransactionMetadata,
+    };
+    const baseQuoteOrRate = {
+        id: quote.id,
+        rate,
+        swapperName: types_1.SwapperName.Across,
+        affiliateBps,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+    };
+    if (input.quoteOrRate === 'quote') {
+        if (!input.receiveAddress) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'Receive address is required for quote',
+                code: types_1.TradeQuoteError.InternalError,
+            }));
+        }
+        const tradeQuote = {
+            ...baseQuoteOrRate,
+            steps: [step],
+            receiveAddress: input.receiveAddress,
+            quoteOrRate: 'quote',
+        };
+        return (0, monads_1.Ok)([tradeQuote]);
+    }
+    const tradeRate = {
+        ...baseQuoteOrRate,
+        steps: [step],
+        receiveAddress: recipient,
+        quoteOrRate: 'rate',
+    };
+    return (0, monads_1.Ok)([tradeRate]);
+}
+exports.getTrade = getTrade;

package/dist/cjs/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/cjs/swappers/AcrossSwapper/utils/types.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcrossErrorCode = exports.isAcrossError = void 0;
+const isAcrossError = (error) => {
+    return typeof error === 'object' && error !== null && 'code' in error && 'status' in error;
+};
+exports.isAcrossError = isAcrossError;
+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 || (exports.AcrossErrorCode = AcrossErrorCode = {}));

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

@@ -7,6 +7,30 @@ const starknet_1 = require("starknet");
 const utils_1 = require("../../utils");
 const getTradeQuote_1 = require("./swapperApi/getTradeQuote");
 const getTradeRate_1 = require("./swapperApi/getTradeRate");
+/**
+ * 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 starknet_1.num.toHex(strValue);
+    }
+    catch {
+        // If conversion fails, assume it's already hex and add prefix
+        return `0x${strValue}`;
+    }
+};
 exports.avnuApi = {
     getTradeQuote: getTradeQuote_1.getTradeQuote,
     getTradeRate: (input, deps) => {
@@ -22,16 +46,23 @@ exports.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 = (0, starknet_1.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 (0, avnu_sdk_1.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()];
@@ -39,24 +70,21 @@ exports.avnuApi = {
             const rawCalldata = call.calldata ?? [];
             const calldataArray = Array.isArray(rawCalldata) ? rawCalldata : starknet_1.CallData.compile(rawCalldata);
             const selector = starknet_1.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 = (0, starknet_1.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 starknet_1.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,
@@ -115,7 +143,7 @@ exports.avnuApi = {
         };
         // Calculate transaction hash for signing
         const invokeHashInputs = {
-            senderAddress: from,
+            senderAddress: normalizedFrom,
             version,
             compiledCalldata: formattedCalldata,
             chainId: chainIdHex,
@@ -146,7 +174,7 @@ exports.avnuApi = {
             addressNList: (0, chain_adapters_1.toAddressNList)(adapter.getBip44Params({ accountNumber })),
             txHash,
             _txDetails: {
-                fromAddress: from,
+                fromAddress: normalizedFrom,
                 calldata: formattedCalldata,
                 nonce,
                 version,

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

@@ -4,11 +4,12 @@ exports.getTradeQuote = void 0;
 const avnu_sdk_1 = require("@avnu/avnu-sdk");
 const utils_1 = require("@shapeshiftoss/utils");
 const monads_1 = require("@sniptt/monads");
-const helpers_1 = require("packages/swapper/src/swappers/utils/helpers/helpers");
+const starknet_1 = require("starknet");
 const uuid_1 = require("uuid");
 const constants_1 = require("../../../constants");
 const types_1 = require("../../../types");
 const utils_2 = require("../../../utils");
+const helpers_1 = require("../../utils/helpers/helpers");
 const constants_2 = require("../utils/constants");
 const helpers_2 = require("../utils/helpers");
 const getTradeQuote = async (input, deps) => {
@@ -46,11 +47,15 @@ const getTradeQuote = async (input, deps) => {
     try {
         const sellTokenAddress = (0, helpers_2.getTokenAddress)(sellAsset);
         const buyTokenAddress = (0, helpers_2.getTokenAddress)(buyAsset);
+        // Normalize addresses to ensure consistent format across quote and execution
+        // Starknet addresses can have different representations (with/without leading zeros)
+        const normalizedSendAddress = (0, starknet_1.validateAndParseAddress)(sendAddress);
+        const normalizedReceiveAddress = (0, starknet_1.validateAndParseAddress)(receiveAddress);
         const quotes = await (0, avnu_sdk_1.getQuotes)({
             sellTokenAddress,
             buyTokenAddress,
             sellAmount: BigInt(sellAmount),
-            takerAddress: sendAddress,
+            takerAddress: normalizedSendAddress,
             size: 1,
             integratorFees: affiliateBps ? BigInt(affiliateBps) : undefined,
             integratorFeeRecipient: (0, helpers_1.getTreasuryAddressFromChainId)(sellAsset.chainId),
@@ -71,10 +76,10 @@ 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,
@@ -99,7 +104,7 @@ const getTradeQuote = async (input, deps) => {
             : {};
         const tradeQuote = {
             id: (0, uuid_1.v4)(),
-            receiveAddress,
+            receiveAddress: normalizedReceiveAddress,
             affiliateBps,
             rate,
             slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??