@imtbl/sdk 0.27.7 → 0.27.9

package/dist/index.cjs

@@ -3631,7 +3631,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.27.7' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.27.9' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -3691,7 +3691,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.27.7',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.27.9',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -4102,7 +4102,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.27.7',
+    sdkVersion: 'ts-immutable-sdk-0.27.9',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -11793,9 +11793,6 @@ class Seaport {
         };
     }
     async fulfillBulkOrders(fulfillingOrders, account) {
-        // TODO: this function right now does not handle errors from the seaport.js
-        // we should figure out why orders are rejected and return a submission
-        // transaction on best efforts basis
         const fulfillOrderDetails = fulfillingOrders.map((o) => {
             const { orderComponents, tips } = this.mapImmutableOrderToSeaportOrderComponents(o.order);
             return {
@@ -12214,14 +12211,34 @@ class Orderbook {
                 recipient: fee.recipient,
             })),
         })));
-        return {
-            ...(await this.seaport.fulfillBulkOrders(fulfillmentDataRes.result.fulfillable_orders, takerAddress)),
-            fulfillableOrders: fulfillmentDataRes.result.fulfillable_orders.map((o) => mapFromOpenApiOrder(o.order)),
-            unfulfillableOrders: fulfillmentDataRes.result.unfulfillable_orders.map((o) => ({
-                orderId: o.order_id,
-                reason: o.reason,
-            })),
-        };
+        try {
+            return {
+                ...(await this.seaport.fulfillBulkOrders(fulfillmentDataRes.result.fulfillable_orders, takerAddress)),
+                fulfillableOrders: fulfillmentDataRes.result.fulfillable_orders.map((o) => mapFromOpenApiOrder(o.order)),
+                unfulfillableOrders: fulfillmentDataRes.result.unfulfillable_orders.map((o) => ({
+                    orderId: o.order_id,
+                    reason: o.reason,
+                })),
+                sufficientBalance: true,
+            };
+        }
+        catch (e) {
+            // if insufficient balance error, we return FulfillBulkOrdersInsufficientBalanceResponse
+            if (String(e).includes('The fulfiller does not have the balances needed to fulfill.')) {
+                return {
+                    fulfillableOrders: fulfillmentDataRes.result.fulfillable_orders.map((o) => mapFromOpenApiOrder(o.order)),
+                    unfulfillableOrders: fulfillmentDataRes.result.unfulfillable_orders.map((o) => ({
+                        orderId: o.order_id,
+                        reason: o.reason,
+                    })),
+                    sufficientBalance: false,
+                };
+            }
+            // if some other error is thrown,
+            // there likely is a race condition of the original order validity
+            // we throw the error back out
+            throw e;
+        }
     }
     /**
      * Get an unsigned cancel order transaction. Orders can only be cancelled by
@@ -28017,25 +28034,65 @@ function isValidNonZeroAddress(address) {
         return false;
     }
 }
-const tokenInfoToUniswapToken = (tokenInfo) => new sdkCore.Token(tokenInfo.chainId, tokenInfo.address, tokenInfo.decimals, tokenInfo.symbol, tokenInfo.name);
+const erc20ToUniswapToken = (token) => 
+// eslint-disable-next-line implicit-arrow-linebreak
+new sdkCore.Token(token.chainId, token.address, token.decimals, token.symbol, token.name);
+const uniswapTokenToERC20 = (token) => ({
+    chainId: token.chainId,
+    address: token.address,
+    decimals: token.decimals,
+    symbol: token.symbol,
+    name: token.name,
+    type: 'erc20',
+});
 const toCurrencyAmount = (amount) => {
-    const token = tokenInfoToUniswapToken(amount.token);
+    const token = erc20ToUniswapToken(amount.token);
     return sdkCore.CurrencyAmount.fromRawAmount(token, amount.value.toString());
 };
 const newAmount = (amount, token) => ({
     value: amount,
     token,
 });
-const addAmount = (a, b) => {
+const isERC20Amount = (amount) => amount.token.type === 'erc20';
+const isNativeAmount = (amount) => amount.token.type === 'native';
+const addERC20Amount = (a, b) => {
+    // Make sure the ERC20s have the same address
     if (a.token.address !== b.token.address)
-        throw new Error('Token mismatch');
+        throw new Error('Token mismatch: token addresses must be the same');
     return { value: a.value.add(b.value), token: a.token };
 };
-const subtractAmount = (a, b) => {
+const addNativeAmount = (a, b) => ({
+    value: a.value.add(b.value),
+    token: a.token,
+});
+const addAmount = (a, b) => {
+    if (isERC20Amount(a) && isERC20Amount(b)) {
+        return addERC20Amount(a, b);
+    }
+    if (isNativeAmount(a) && isNativeAmount(b)) {
+        return addNativeAmount(a, b);
+    }
+    throw new Error('Token mismatch: token types must be the same');
+};
+const subtractERC20Amount = (a, b) => {
+    // Make sure the ERC20s have the same address
     if (a.token.address !== b.token.address)
-        throw new Error('Token mismatch');
+        throw new Error('Token mismatch: token addresses must be the same');
     return { value: a.value.sub(b.value), token: a.token };
 };
+const subtractNativeAmount = (a, b) => ({
+    value: a.value.sub(b.value),
+    token: a.token,
+});
+const subtractAmount = (a, b) => {
+    if (isERC20Amount(a) && isERC20Amount(b)) {
+        return subtractERC20Amount(a, b);
+    }
+    if (isNativeAmount(a) && isNativeAmount(b)) {
+        return subtractNativeAmount(a, b);
+    }
+    throw new Error('Token mismatch: token types must be the same');
+};
 
 const amountIndex = 0;
 const gasEstimateIndex = 3;
@@ -28073,10 +28130,12 @@ async function getQuotesForRoutes(multicallContract, quoterContractAddress, rout
                 const quoteAmount = decodedQuoteResult[amountIndex];
                 if (!(quoteAmount instanceof ethers.BigNumber))
                     throw new Error('Expected BigNumber');
+                const input = uniswapTokenToERC20(routes[i].input);
+                const output = uniswapTokenToERC20(routes[i].output);
                 decodedQuoteResults.push({
                     route: routes[i],
-                    amountIn: tradeType === sdkCore.TradeType.EXACT_INPUT ? amountSpecified : newAmount(quoteAmount, routes[i].input),
-                    amountOut: tradeType === sdkCore.TradeType.EXACT_INPUT ? newAmount(quoteAmount, routes[i].output) : amountSpecified,
+                    amountIn: tradeType === sdkCore.TradeType.EXACT_INPUT ? amountSpecified : newAmount(quoteAmount, input),
+                    amountOut: tradeType === sdkCore.TradeType.EXACT_INPUT ? newAmount(quoteAmount, output) : amountSpecified,
                     gasEstimate: ethers.ethers.BigNumber.from(decodedQuoteResult[gasEstimateIndex]),
                     tradeType,
                 });
@@ -28207,7 +28266,7 @@ const fetchValidPools = async (multicallContract, erc20Pair, commonRoutingERC20s
         if (zeroPrice || zeroLiquidity) {
             return;
         }
-        const validPool = new v3Sdk.Pool(tokenInfoToUniswapToken(poolID.erc20Pair[0]), tokenInfoToUniswapToken(poolID.erc20Pair[1]), poolID.fee, poolSlot0.sqrtPriceX96.toString(), poolLiquidity.toString(), poolSlot0.tick);
+        const validPool = new v3Sdk.Pool(erc20ToUniswapToken(poolID.erc20Pair[0]), erc20ToUniswapToken(poolID.erc20Pair[1]), poolID.fee, poolSlot0.sqrtPriceX96.toString(), poolLiquidity.toString(), poolSlot0.tick);
         validPools.push(validPool);
     });
     return validPools;
@@ -28293,9 +28352,9 @@ maxHops, // the maximum number of pools that can be traversed
 currentRoute = [], // list of pools already traversed
 routes = [], // list of all routes found so far
 startTokenIn = tokenIn) => {
-    const currencyIn = tokenInfoToUniswapToken(tokenIn);
-    const currencyOut = tokenInfoToUniswapToken(tokenOut);
-    const startCurrencyIn = tokenInfoToUniswapToken(startTokenIn);
+    const currencyIn = erc20ToUniswapToken(tokenIn);
+    const currencyOut = erc20ToUniswapToken(tokenOut);
+    const startCurrencyIn = erc20ToUniswapToken(startTokenIn);
     for (const pool of pools) {
         // if the pool doesn't have the tokenIn or if it has already been traversed,
         // skip to the next pool
@@ -28314,7 +28373,7 @@ startTokenIn = tokenIn) => {
         else if (maxHops > 1) {
             // otherwise, if we haven't exceeded the maximum number of pools that can be traversed,
             // recursively call this function with the output token as the new starting currency
-            generateAllAcyclicPaths(outputToken, tokenOut, pools, maxHops - 1, [...currentRoute, pool], routes, startTokenIn);
+            generateAllAcyclicPaths(uniswapTokenToERC20(outputToken), tokenOut, pools, maxHops - 1, [...currentRoute, pool], routes, startTokenIn);
         }
     }
     return routes;
@@ -28407,11 +28466,11 @@ const getUnsignedERC20ApproveTransaction = (ownerAddress, tokenAmount, spenderAd
         from: ownerAddress,
     };
 };
-const prepareApproval = (tradeType, amountSpecified, amountWithSlippage, routingContracts, secondaryFees) => {
+const prepareApproval = (tradeType, amountSpecified, amountWithSlippage, contracts, secondaryFees) => {
     const amountOfTokenIn = tradeType === sdkCore.TradeType.EXACT_INPUT ? amountSpecified : amountWithSlippage;
     const spender = secondaryFees.length === 0
-        ? routingContracts.peripheryRouterAddress
-        : routingContracts.secondaryFeeAddress;
+        ? contracts.routerAddress
+        : contracts.secondaryFeeAddress;
     return { spender, amount: amountOfTokenIn };
 };
 /**
@@ -28444,7 +28503,7 @@ async function getApproveGasEstimate(provider, ownerAddress, spenderAddress, tok
         from: ownerAddress,
     });
 }
-const getApproval = async (provider, ownerAddress, preparedApproval, gasPrice) => {
+const getApproval = async (provider, ownerAddress, preparedApproval, gasPrice, nativeTokenService) => {
     const approveTransaction = await getApproveTransaction(provider, ownerAddress, preparedApproval.amount, preparedApproval.spender);
     if (!approveTransaction) {
         return null;
@@ -28453,7 +28512,8 @@ const getApproval = async (provider, ownerAddress, preparedApproval, gasPrice) =
     const gasFeeEstimate = gasPrice ? calculateGasFee(gasPrice, gasEstimate) : null;
     return {
         transaction: approveTransaction,
-        gasFeeEstimate,
+        // TODO: TP-1649: Remove the wrapping here
+        gasFeeEstimate: gasFeeEstimate ? nativeTokenService.maybeWrapAmount(gasFeeEstimate) : null,
     };
 };
 
@@ -28489,7 +28549,7 @@ function applySlippage(tradeType, amount, slippage) {
     const amountWithSlippage = maybeInverted.multiply(amount.toString()).quotient;
     return ethers.ethers.BigNumber.from(amountWithSlippage.toString());
 }
-function prepareUserQuote(otherToken, tradeInfo, slippage, fees) {
+function prepareUserQuote(otherToken, tradeInfo, slippage, fees, nativeTokenService) {
     const quote = getQuoteAmountFromTradeType(tradeInfo);
     const amountWithSlippage = applySlippage(tradeInfo.tradeType, quote.value, slippage);
     return {
@@ -28499,16 +28559,20 @@ function prepareUserQuote(otherToken, tradeInfo, slippage, fees) {
             value: amountWithSlippage,
         },
         slippage,
-        fees: fees.withAmounts(),
+        fees: fees.withAmounts().map((fee) => ({
+            ...fee,
+            amount: nativeTokenService.maybeWrapAmount(fee.amount),
+        })),
     };
 }
-function getOurQuoteReqAmount(amount, fees, tradeType) {
+function getOurQuoteReqAmount(amountSpecified, // the amount specified by the user, either exactIn or exactOut
+fees, tradeType, nativeTokenService) {
     if (tradeType === sdkCore.TradeType.EXACT_OUTPUT) {
         // For an exact output swap, we do not need to subtract fees from the given amount
-        return amount;
+        return nativeTokenService.maybeWrapAmount(amountSpecified);
     }
-    fees.addAmount(amount);
-    return fees.amountLessFees();
+    fees.addAmount(amountSpecified);
+    return nativeTokenService.maybeWrapAmount(fees.amountLessFees());
 }
 
 // 0.1% default slippage
@@ -28524,7 +28588,7 @@ const MIN_MAX_HOPS = 1;
 // precision used to calculate percentage from basis points
 const BASIS_POINT_PRECISION = 10000;
 // 10% maximum secondary fee
-const MAX_SECONDARY_FEE_BASIS_POINTS = 10000;
+const MAX_SECONDARY_FEE_BASIS_POINTS = 1000;
 
 class Fees {
     secondaryFees;
@@ -28533,6 +28597,9 @@ class Fees {
         this.secondaryFees = secondaryFees;
         this.amount = newAmount(ethers.BigNumber.from(0), token);
     }
+    get token() {
+        return this.amount.token;
+    }
     addAmount(amount) {
         this.amount = addAmount(this.amount, amount);
     }
@@ -28565,18 +28632,65 @@ class Fees {
     }
 }
 
+class NativeTokenService {
+    nativeToken;
+    wrappedToken;
+    constructor(nativeToken, wrappedToken) {
+        this.nativeToken = nativeToken;
+        this.wrappedToken = wrappedToken;
+    }
+    wrapAmount(amount) {
+        return newAmount(amount.value, this.wrappedToken);
+    }
+    unwrapAmount(amount) {
+        if (amount.token !== this.wrappedToken) {
+            throw new Error(`token ${amount.token.address} is not wrapped`);
+        }
+        return newAmount(amount.value, this.nativeToken);
+    }
+    maybeWrapToken(token) {
+        if (this.isNativeToken(token)) {
+            return this.wrappedToken;
+        }
+        return token;
+    }
+    maybeWrapAmount(amount) {
+        return newAmount(amount.value, this.maybeWrapToken(amount.token));
+    }
+    isNativeToken(token) {
+        return token === this.nativeToken;
+    }
+}
+
 const IMMUTABLE_TESTNET_RPC_URL = 'https://rpc.testnet.immutable.com';
 const IMMUTABLE_TESTNET_CHAIN_ID = 13472;
 
+const NATIVE_IMX_IMMUTABLE_TESTNET = {
+    chainId: IMMUTABLE_TESTNET_CHAIN_ID,
+    decimals: 18,
+    symbol: 'tIMX',
+    name: 'Immutable Testnet Token',
+    type: 'native',
+};
 const TIMX_IMMUTABLE_TESTNET = {
     chainId: IMMUTABLE_TESTNET_CHAIN_ID,
     address: '0x0000000000000000000000000000000000001010',
     decimals: 18,
     symbol: 'tIMX',
     name: 'Immutable Testnet Token',
+    type: 'erc20',
+};
+const WIMX_IMMUTABLE_TESTNET = {
+    chainId: IMMUTABLE_TESTNET_CHAIN_ID,
+    address: '0xAf7cf5D4Af0BFAa85d384d42b8D410762Ccbce69',
+    decimals: 18,
+    symbol: 'WIMX',
+    name: 'Wrapped Immutable Testnet Token',
+    type: 'erc20',
 };
 const IMMUTABLE_TESTNET_COMMON_ROUTING_TOKENS = [
     TIMX_IMMUTABLE_TESTNET,
+    WIMX_IMMUTABLE_TESTNET,
 ];
 
 const zeroNativeCurrencyValue = '0x00';
@@ -28673,7 +28787,7 @@ function createSwapParameters(adjustedQuote, fromAddress, slippage, deadline, se
     }
     return createSwapCallParametersWithFees(uncheckedTrade, fromAddress, options, secondaryFees);
 }
-function getSwap(adjustedQuote, fromAddress, slippage, deadline, peripheryRouterAddress, secondaryFeesAddress, gasPrice, secondaryFees) {
+function getSwap(adjustedQuote, fromAddress, slippage, deadline, peripheryRouterAddress, secondaryFeesAddress, gasPrice, secondaryFees, nativeTokenService) {
     const calldata = createSwapParameters(adjustedQuote, fromAddress, slippage, deadline, secondaryFees);
     // TODO: Add additional gas fee estimates for secondary fees
     const gasFeeEstimate = gasPrice ? calculateGasFee(gasPrice, adjustedQuote.gasEstimate) : null;
@@ -28684,24 +28798,37 @@ function getSwap(adjustedQuote, fromAddress, slippage, deadline, peripheryRouter
             value: zeroNativeCurrencyValue,
             from: fromAddress,
         },
-        gasFeeEstimate,
+        // TODO: TP-1649: Remove the wrapping here
+        gasFeeEstimate: gasFeeEstimate ? nativeTokenService.maybeWrapAmount(gasFeeEstimate) : null,
     };
 }
-function prepareSwap(ourQuote, amountSpecified, fees) {
+const adjustAmountIn = (ourQuote, amountSpecified, fees, nativeTokenService) => {
     if (ourQuote.tradeType === sdkCore.TradeType.EXACT_OUTPUT) {
-        fees.addAmount(ourQuote.amountIn);
-        return {
-            gasEstimate: ourQuote.gasEstimate,
-            route: ourQuote.route,
-            amountIn: fees.amountWithFeesApplied(),
-            amountOut: amountSpecified,
-            tradeType: ourQuote.tradeType,
-        };
+        // when doing exact output, calculate the fees based on the amountIn
+        const amountToAdd = nativeTokenService.isNativeToken(fees.token)
+            ? nativeTokenService.unwrapAmount(ourQuote.amountIn)
+            : ourQuote.amountIn;
+        fees.addAmount(amountToAdd);
+        return nativeTokenService.maybeWrapAmount(fees.amountWithFeesApplied());
     }
+    return nativeTokenService.maybeWrapAmount(amountSpecified);
+};
+/**
+ * adjustQuoteWithFees adjusts the amountIn of the quote to account for fees
+ * EXACT_OUTPUT swaps will have the fees added to the amountIn if there are fees specified
+ * EXACT_INPUT swaps will have amountIn set to the user-specified amount
+ * @param ourQuote The quote from calling the Quoter contract
+ * @param amountSpecified The user-specified amount for the swap (EXACT...)
+ * @param fees The fees applied to the swap
+ * @param tokenWrapper Helper class for the native token and associated ERC20
+ * @returns {QuoteResult} The adjusted quote
+ */
+function adjustQuoteWithFees(ourQuote, amountSpecified, fees, nativeTokenService) {
+    const adjustedAmountIn = adjustAmountIn(ourQuote, amountSpecified, fees, nativeTokenService);
     return {
         gasEstimate: ourQuote.gasEstimate,
         route: ourQuote.route,
-        amountIn: amountSpecified,
+        amountIn: adjustedAmountIn,
         amountOut: ourQuote.amountOut,
         tradeType: ourQuote.tradeType,
     };
@@ -28722,7 +28849,8 @@ const SUPPORTED_SANDBOX_CHAINS = {
         rpcUrl: IMMUTABLE_TESTNET_RPC_URL,
         contracts: CONTRACTS_FOR_CHAIN_ID[IMMUTABLE_TESTNET_CHAIN_ID],
         commonRoutingTokens: IMMUTABLE_TESTNET_COMMON_ROUTING_TOKENS,
-        nativeToken: TIMX_IMMUTABLE_TESTNET,
+        nativeToken: NATIVE_IMX_IMMUTABLE_TESTNET,
+        wrappedNativeToken: TIMX_IMMUTABLE_TESTNET, // TODO: TP-1649: Change to WIMX when ready.
     },
 };
 const SUPPORTED_PRODUCTION_CHAINS = {};
@@ -28780,6 +28908,7 @@ class ExchangeConfiguration {
                 contracts: overrides.exchangeContracts,
                 commonRoutingTokens: overrides.commonRoutingTokens,
                 nativeToken: overrides.nativeToken,
+                wrappedNativeToken: overrides.wrappedNativeToken,
             };
             this.secondaryFees = secondaryFees || [];
             return;
@@ -28797,19 +28926,25 @@ class Exchange {
     router;
     chainId;
     nativeToken;
+    wrappedNativeToken;
     secondaryFees;
+    nativeTokenService;
+    secondaryFeeContractAddress;
+    routerContractAddress;
     constructor(configuration) {
         const config = new ExchangeConfiguration(configuration);
         this.chainId = config.chain.chainId;
         this.nativeToken = config.chain.nativeToken;
+        this.wrappedNativeToken = config.chain.wrappedNativeToken;
+        this.nativeTokenService = new NativeTokenService(this.nativeToken, this.wrappedNativeToken);
         this.secondaryFees = config.secondaryFees;
+        this.routerContractAddress = config.chain.contracts.peripheryRouter;
+        this.secondaryFeeContractAddress = config.chain.contracts.secondaryFee;
         this.provider = new ethers.ethers.providers.JsonRpcProvider(config.chain.rpcUrl);
         this.router = new Router(this.provider, config.chain.commonRoutingTokens, {
             multicallAddress: config.chain.contracts.multicall,
             factoryAddress: config.chain.contracts.coreFactory,
             quoterAddress: config.chain.contracts.quoterV2,
-            peripheryRouterAddress: config.chain.contracts.peripheryRouter,
-            secondaryFeeAddress: config.chain.contracts.secondaryFee,
         });
     }
     static validate(tokenInAddress, tokenOutAddress, maxHops, slippagePercent, fromAddress) {
@@ -28826,7 +28961,7 @@ class Exchange {
         if (this.secondaryFees.length === 0) {
             return [];
         }
-        const secondaryFeeContract = SecondaryFee__factory.connect(this.router.routingContracts.secondaryFeeAddress, this.provider);
+        const secondaryFeeContract = SecondaryFee__factory.connect(this.secondaryFeeContractAddress, this.provider);
         if (await secondaryFeeContract.paused()) {
             // Do not use secondary fees if the contract is paused
             return [];
@@ -28842,32 +28977,36 @@ class Exchange {
             this.getSecondaryFees(),
         ]);
         const tokenIn = {
+            type: 'erc20',
             address: tokenInAddress,
             chainId: this.chainId,
             decimals: tokenInDecimals,
         };
         const tokenOut = {
+            type: 'erc20',
             address: tokenOutAddress,
             chainId: this.chainId,
             decimals: tokenOutDecimals,
         };
         // determine which amount was specified for the swap from the TradeType
-        const [tokenSpecified, otherToken] = tradeType === sdkCore.TradeType.EXACT_INPUT
-            ? [tokenIn, tokenOut] : [tokenOut, tokenIn];
+        const [tokenSpecified, otherToken] = tradeType === sdkCore.TradeType.EXACT_INPUT ? [tokenIn, tokenOut] : [tokenOut, tokenIn];
         const amountSpecified = newAmount(amount, tokenSpecified);
         const fees = new Fees(secondaryFees, tokenIn);
-        const ourQuoteReqAmount = getOurQuoteReqAmount(amountSpecified, fees, tradeType);
+        const ourQuoteReqAmount = getOurQuoteReqAmount(amountSpecified, fees, tradeType, this.nativeTokenService);
         // get quote and gas details
         const [ourQuote, gasPrice] = await Promise.all([
             this.router.findOptimalRoute(ourQuoteReqAmount, otherToken, tradeType, maxHops),
             fetchGasPrice(this.provider, this.nativeToken),
         ]);
-        const adjustedQuote = prepareSwap(ourQuote, amountSpecified, fees);
-        const swap = getSwap(adjustedQuote, fromAddress, slippagePercent, deadline, this.router.routingContracts.peripheryRouterAddress, this.router.routingContracts.secondaryFeeAddress, gasPrice, secondaryFees);
-        const userQuote = prepareUserQuote(otherToken, adjustedQuote, slippagePercent, fees);
-        const preparedApproval = prepareApproval(tradeType, amountSpecified, userQuote.amountWithMaxSlippage, this.router.routingContracts, secondaryFees);
+        const adjustedQuote = adjustQuoteWithFees(ourQuote, amountSpecified, fees, this.nativeTokenService);
+        const swap = getSwap(adjustedQuote, fromAddress, slippagePercent, deadline, this.routerContractAddress, this.secondaryFeeContractAddress, gasPrice, secondaryFees, this.nativeTokenService);
+        const userQuote = prepareUserQuote(otherToken, adjustedQuote, slippagePercent, fees, this.nativeTokenService);
+        const preparedApproval = prepareApproval(tradeType, amountSpecified, userQuote.amountWithMaxSlippage, {
+            routerAddress: this.routerContractAddress,
+            secondaryFeeAddress: this.secondaryFeeContractAddress,
+        }, secondaryFees);
         // preparedApproval always uses the tokenIn address because we are always selling the tokenIn
-        const approval = await getApproval(this.provider, fromAddress, preparedApproval, gasPrice);
+        const approval = await getApproval(this.provider, fromAddress, preparedApproval, gasPrice, this.nativeTokenService);
         return {
             approval,
             swap,
@@ -31045,8 +31184,6 @@ const $5e9bcae98dc8ff19$export$1165ca270f090a66 = (isDevelopment, isProduction)=
         return ($d85ad1457a3f1a83$export$89133ca13c5ee30)[(Environment$1).SANDBOX];
     };
     const checkDexAvailability = async ()=>{
-        // TEMP FIX: Returns true for sandbox environment
-        if (!isDevelopment && !isProduction) return true;
         let response;
         try {
             response = await (0, globalAxios$1).post(`${postEndpoint()}/v1/availability/checkout/swap`);
@@ -31211,7 +31348,7 @@ const $049bba630af05555$export$6946a1f17c2bbf26 = async (config, chainId, wallet
             const swappableToken = fromToken[index];
             dexQuotes.set(swappableToken, {
                 quote: response.value.quote,
-                approval: response.value.approval?.gasFeeEstimate,
+                approval: response.value.approval?.gasFeeEstimate ?? null,
                 swap: response.value.swap.gasFeeEstimate
             });
         });
@@ -33066,7 +33203,7 @@ var $045213b18e9f1f94$export$75be0f6af9650f2c;
 })($045213b18e9f1f94$export$75be0f6af9650f2c || ($045213b18e9f1f94$export$75be0f6af9650f2c = {}));
 
 
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.27.7";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.27.9";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 

package/dist/index.d.ts

@@ -15784,12 +15784,19 @@ interface FulfillmentListing {
     listingId: string;
     takerFees: Array<FeeValue>;
 }
-interface FulfillBulkOrdersResponse {
+type FulfillBulkOrdersResponse = FulfillBulkOrdersInsufficientBalanceResponse | FulfillBulkOrdersSufficientBalanceResponse;
+interface FulfillBulkOrdersSufficientBalanceResponse {
+    sufficientBalance: true;
     actions: Action[];
     expiration: string;
     fulfillableOrders: Order[];
     unfulfillableOrders: UnfulfillableOrder[];
 }
+interface FulfillBulkOrdersInsufficientBalanceResponse {
+    sufficientBalance: false;
+    fulfillableOrders: Order[];
+    unfulfillableOrders: UnfulfillableOrder[];
+}
 interface UnfulfillableOrder {
     orderId: string;
     reason: string;
@@ -15989,7 +15996,9 @@ type orderbook_d_ERC721Item = ERC721Item;
 type orderbook_d_FeeType = FeeType;
 declare const orderbook_d_FeeType: typeof FeeType;
 type orderbook_d_FeeValue = FeeValue;
+type orderbook_d_FulfillBulkOrdersInsufficientBalanceResponse = FulfillBulkOrdersInsufficientBalanceResponse;
 type orderbook_d_FulfillBulkOrdersResponse = FulfillBulkOrdersResponse;
+type orderbook_d_FulfillBulkOrdersSufficientBalanceResponse = FulfillBulkOrdersSufficientBalanceResponse;
 type orderbook_d_FulfillOrderResponse = FulfillOrderResponse;
 type orderbook_d_FulfillmentListing = FulfillmentListing;
 type orderbook_d_ListListingsParams = ListListingsParams;
@@ -16029,7 +16038,9 @@ declare namespace orderbook_d {
     Fee$1 as Fee,
     orderbook_d_FeeType as FeeType,
     orderbook_d_FeeValue as FeeValue,
+    orderbook_d_FulfillBulkOrdersInsufficientBalanceResponse as FulfillBulkOrdersInsufficientBalanceResponse,
     orderbook_d_FulfillBulkOrdersResponse as FulfillBulkOrdersResponse,
+    orderbook_d_FulfillBulkOrdersSufficientBalanceResponse as FulfillBulkOrdersSufficientBalanceResponse,
     orderbook_d_FulfillOrderResponse as FulfillOrderResponse,
     orderbook_d_FulfillmentListing as FulfillmentListing,
     orderbook_d_ListListingsParams as ListListingsParams,
@@ -16074,25 +16085,41 @@ declare namespace provider_d {
 }
 
 /**
- * Interface representing a token
+ * Interface representing an ERC20 token
  * @property {number} chainId - The chain ID
  * @property {string} address - The token address
  * @property {number} decimals - The token decimals
  * @property {string | undefined} symbol - The token symbol or undefined if it is not available
  * @property {string | undefined} name - The token name or undefined if it is not available
  */
-type TokenInfo$1 = {
+type ERC20 = {
+    type: 'erc20';
     chainId: number;
     address: string;
     decimals: number;
     symbol?: string;
     name?: string;
 };
+/**
+ * Interface representing a native token
+ * @property {number} chainId - The chain ID
+ * @property {number} decimals - The token decimals
+ * @property {string | undefined} symbol - The token symbol or undefined if it is not available
+ * @property {string | undefined} name - The token name or undefined if it is not available
+ */
+type Native = {
+    type: 'native';
+    chainId: number;
+    decimals: number;
+    symbol?: string;
+    name?: string;
+};
 interface ExchangeOverrides {
     rpcURL: string;
     exchangeContracts: ExchangeContracts;
-    commonRoutingTokens: TokenInfo$1[];
-    nativeToken: TokenInfo$1;
+    commonRoutingTokens: ERC20[];
+    nativeToken: Native;
+    wrappedNativeToken: ERC20;
 }
 
 /**