@imtbl/sdk 0.27.6 → 0.27.8

package/dist/checkout_sdk.d.ts

@@ -566,25 +566,41 @@ interface ModuleConfiguration<T> {
 }
 
 /**
- * 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;
 }
 
 /**

package/dist/checkout_sdk.js

@@ -14715,23 +14715,36 @@ function isValidNonZeroAddress(address) {
         return false;
     }
 }
-const tokenInfoToUniswapToken = (tokenInfo) => new Token(tokenInfo.chainId, tokenInfo.address, tokenInfo.decimals, tokenInfo.symbol, tokenInfo.name);
+const erc20ToUniswapToken = (token) => 
+// eslint-disable-next-line implicit-arrow-linebreak
+new 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 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 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 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 };
 };
 
@@ -14771,10 +14784,12 @@ async function getQuotesForRoutes(multicallContract, quoterContractAddress, rout
                 const quoteAmount = decodedQuoteResult[amountIndex];
                 if (!(quoteAmount instanceof BigNumber$1))
                     throw new Error('Expected BigNumber');
+                const input = uniswapTokenToERC20(routes[i].input);
+                const output = uniswapTokenToERC20(routes[i].output);
                 decodedQuoteResults.push({
                     route: routes[i],
-                    amountIn: tradeType === TradeType.EXACT_INPUT ? amountSpecified : newAmount(quoteAmount, routes[i].input),
-                    amountOut: tradeType === TradeType.EXACT_INPUT ? newAmount(quoteAmount, routes[i].output) : amountSpecified,
+                    amountIn: tradeType === TradeType.EXACT_INPUT ? amountSpecified : newAmount(quoteAmount, input),
+                    amountOut: tradeType === TradeType.EXACT_INPUT ? newAmount(quoteAmount, output) : amountSpecified,
                     gasEstimate: ethers.BigNumber.from(decodedQuoteResult[gasEstimateIndex]),
                     tradeType,
                 });
@@ -14905,7 +14920,7 @@ const fetchValidPools = async (multicallContract, erc20Pair, commonRoutingERC20s
         if (zeroPrice || zeroLiquidity) {
             return;
         }
-        const validPool = new Pool(tokenInfoToUniswapToken(poolID.erc20Pair[0]), tokenInfoToUniswapToken(poolID.erc20Pair[1]), poolID.fee, poolSlot0.sqrtPriceX96.toString(), poolLiquidity.toString(), poolSlot0.tick);
+        const validPool = new Pool(erc20ToUniswapToken(poolID.erc20Pair[0]), erc20ToUniswapToken(poolID.erc20Pair[1]), poolID.fee, poolSlot0.sqrtPriceX96.toString(), poolLiquidity.toString(), poolSlot0.tick);
         validPools.push(validPool);
     });
     return validPools;
@@ -14991,9 +15006,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
@@ -15012,7 +15027,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;
@@ -15142,7 +15157,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;
@@ -15151,7 +15166,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,
     };
 };
 
@@ -15200,13 +15216,18 @@ function prepareUserQuote(otherToken, tradeInfo, slippage, fees) {
         fees: fees.withAmounts(),
     };
 }
-function getOurQuoteReqAmount(amount, fees, tradeType) {
+function getOurQuoteReqAmount(amountSpecified, // the amount specified by the user, either exactIn or exactOut
+fees, tradeType, nativeTokenService) {
+    // TODO: TP-1649: Remove this when we support Native
+    if (!isERC20Amount(amountSpecified)) {
+        throw new Error('Not implemented yet!');
+    }
     if (tradeType === 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
@@ -15222,7 +15243,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;
@@ -15232,13 +15253,13 @@ class Fees {
         this.amount = newAmount(BigNumber$1.from(0), token);
     }
     addAmount(amount) {
-        this.amount = addAmount(this.amount, amount);
+        this.amount = addERC20Amount(this.amount, amount);
     }
     amountWithFeesApplied() {
-        return addAmount(this.amount, this.total());
+        return addERC20Amount(this.amount, this.total());
     }
     amountLessFees() {
-        return subtractAmount(this.amount, this.total());
+        return subtractERC20Amount(this.amount, this.total());
     }
     withAmounts() {
         return this.secondaryFees.map((fee) => {
@@ -15257,24 +15278,71 @@ class Fees {
             const feeAmount = this.amount.value
                 .mul(fee.basisPoints)
                 .div(BASIS_POINT_PRECISION);
-            totalFees = addAmount(totalFees, newAmount(feeAmount, this.amount.token));
+            totalFees = addERC20Amount(totalFees, newAmount(feeAmount, this.amount.token));
         }
         return totalFees;
     }
 }
 
+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';
@@ -15371,7 +15439,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;
@@ -15382,7 +15450,8 @@ 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) {
@@ -15410,7 +15479,7 @@ const CONTRACTS_FOR_CHAIN_ID = {
         multicall: '0xD17c98b38bA28c7eA1080317EB9AB2b9663BEd92',
         coreFactory: '0x8AC26EfCbf5D700b37A27aA00E6934e6904e7B8e',
         quoterV2: '0x0Afe6F5f4DC34461A801420634239FFaD50A2e44',
-        peripheryRouter: '0x5893A5c7bc615Dfd36D7383366d00FFFca5f7178',
+        peripheryRouter: '0x57c73281f2697a632AEF1A48CD6ff600f49ee344',
         secondaryFee: '0x5893A5c7bc615Dfd36D7383366d00FFFca5f7178',
     },
 };
@@ -15420,7 +15489,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 = {};
@@ -15478,6 +15548,7 @@ class ExchangeConfiguration {
                 contracts: overrides.exchangeContracts,
                 commonRoutingTokens: overrides.commonRoutingTokens,
                 nativeToken: overrides.nativeToken,
+                wrappedNativeToken: overrides.wrappedNativeToken,
             };
             this.secondaryFees = secondaryFees || [];
             return;
@@ -15495,11 +15566,15 @@ class Exchange {
     router;
     chainId;
     nativeToken;
+    wrappedNativeToken;
     secondaryFees;
+    nativeTokenService;
     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.provider = new ethers.providers.JsonRpcProvider(config.chain.rpcUrl);
         this.router = new Router(this.provider, config.chain.commonRoutingTokens, {
@@ -15540,11 +15615,13 @@ 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,
@@ -15554,18 +15631,18 @@ class Exchange {
             ? [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 swap = getSwap(adjustedQuote, fromAddress, slippagePercent, deadline, this.router.routingContracts.peripheryRouterAddress, this.router.routingContracts.secondaryFeeAddress, gasPrice, secondaryFees, this.nativeTokenService);
         const userQuote = prepareUserQuote(otherToken, adjustedQuote, slippagePercent, fees);
         const preparedApproval = prepareApproval(tradeType, amountSpecified, userQuote.amountWithMaxSlippage, this.router.routingContracts, 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,
@@ -16604,9 +16681,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 {
@@ -17025,14 +17099,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
@@ -20409,7 +20503,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.27.6',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.27.8',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -22935,8 +23029,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).post(`${postEndpoint()}/v1/availability/checkout/swap`);
@@ -23101,7 +23193,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
             });
         });
@@ -24813,9 +24905,6 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
    * Determines the requirements for performing a buy.
    * @param {BuyParams} params - The parameters for the buy.
   */ async buy(params) {
-        if (this.config.isProduction) throw new Error("This endpoint is not currently available.");
-        // eslint-disable-next-line no-console
-        console.warn("This endpoint is currently under construction.");
         if (params.orders.length > 1) // eslint-disable-next-line no-console
         console.warn("This endpoint currently only processes the first order in the array.");
         const web3Provider = await $bb88265fe45a0393$export$9e1fd9cc88c637a0(this.config, params.provider);
@@ -24827,9 +24916,6 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
    * Only currently actions the first order in the array until we support batch processing.
    * Only currently actions the first fee in the fees array of each order until we support multiple fees.
   */ async sell(params) {
-        if (this.config.isProduction) throw new Error("This endpoint is not currently available.");
-        // eslint-disable-next-line no-console
-        console.warn("This endpoint is currently under construction.");
         if (params.orders.length > 1) // eslint-disable-next-line no-console
         console.warn("This endpoint currently only processes the first order in the array.");
         const web3Provider = await $bb88265fe45a0393$export$9e1fd9cc88c637a0(this.config, params.provider);
@@ -24839,9 +24925,6 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
    * Cancels a sell.
    * @param {CancelParams} params - The parameters for the cancel.
    */ async cancel(params) {
-        if (this.config.isProduction) throw new Error("This endpoint is not currently available.");
-        // eslint-disable-next-line no-console
-        console.warn("This endpoint is currently under construction.");
         // eslint-disable-next-line no-console
         console.warn("This endpoint currently only processes the first order in the array.");
         const web3Provider = await $bb88265fe45a0393$export$9e1fd9cc88c637a0(this.config, params.provider);
@@ -24851,9 +24934,6 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
    * Determines the transaction requirements to complete a purchase.
    * @params {SmartCheckoutParams} params - The parameters for smart checkout.
    */ async smartCheckout(params) {
-        if (this.config.isProduction) throw new Error("This endpoint is not currently available.");
-        // eslint-disable-next-line no-console
-        console.warn("This endpoint is currently under construction.");
         const web3Provider = await $bb88265fe45a0393$export$9e1fd9cc88c637a0(this.config, params.provider);
         let itemRequirements = [];
         try {

package/dist/checkout_widgets.js

@@ -25,7 +25,7 @@ var $045213b18e9f1f94$export$75be0f6af9650f2c;
 })($045213b18e9f1f94$export$75be0f6af9650f2c || ($045213b18e9f1f94$export$75be0f6af9650f2c = {}));
 
 
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.27.6";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.27.8";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 

package/dist/immutablex_client.js

@@ -16,7 +16,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.27.6',
+    sdkVersion: 'ts-immutable-sdk-0.27.8',
 });
 /**
  * Sets `sdkVersion` at the time of build