@imtbl/sdk 0.27.8 → 0.27.10

package/dist/checkout_sdk.d.ts

@@ -566,7 +566,8 @@ interface ModuleConfiguration<T> {
 }
 
 /**
- * Interface representing an ERC20 token
+ * Type representing an ERC20 token
+ * @property {string} type - The token type, used to discriminate between {@link ERC20} and {@link Native}
  * @property {number} chainId - The chain ID
  * @property {string} address - The token address
  * @property {number} decimals - The token decimals
@@ -582,7 +583,8 @@ type ERC20 = {
     name?: string;
 };
 /**
- * Interface representing a native token
+ * Type representing a native token
+ * @property {string} type - The token type, used to discriminate between {@link ERC20} and {@link Native}
  * @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
@@ -595,13 +597,25 @@ type Native = {
     symbol?: string;
     name?: string;
 };
-interface ExchangeOverrides {
+/**
+ * Type representing a token, either an {@link ERC20} or {@link Native}
+ */
+type Coin = ERC20 | Native;
+/**
+ * Type representing the overrides for the {@link Exchange} module
+ * @property {string} rpcURL - The RPC URL for the chain
+ * @property {ExchangeContracts} exchangeContracts - The DEX contract addresses
+ * @property {ERC20[]} commonRoutingTokens - The tokens used to find available pools for a swap
+ * @property {Coin} nativeToken - The native token of the chain
+ * @property {ERC20} wrappedNativeToken - The wrapped native token of the chain
+ */
+type ExchangeOverrides = {
     rpcURL: string;
     exchangeContracts: ExchangeContracts;
     commonRoutingTokens: ERC20[];
-    nativeToken: Native;
+    nativeToken: Coin;
     wrappedNativeToken: ERC20;
-}
+};
 
 /**
  * @typedef {string} Address - Represents an Ethereum address.

package/dist/checkout_sdk.js

@@ -2,7 +2,8 @@ import { ethers, ContractFactory, utils, Contract as Contract$1, BigNumber as Bi
 import globalAxios, { HttpStatusCode } from 'axios';
 import { Web3Provider, JsonRpcProvider } from '@ethersproject/providers';
 import $7v2Z6$metamaskdetectprovider from '@metamask/detect-provider';
-import { TradeType, Token, CurrencyAmount, Percent } from '@uniswap/sdk-core';
+import * as Uniswap from '@uniswap/sdk-core';
+import { TradeType, Percent } from '@uniswap/sdk-core';
 import assert from 'assert';
 import { FeeAmount, Route, SwapQuoter, Pool, Trade, toHex as toHex$1, encodeRouteToPath } from '@uniswap/v3-sdk';
 import { keccak256 as keccak256$1 } from '@ethersproject/solidity';
@@ -14681,10 +14682,8 @@ const quoteReturnMapping = {
  * @param poolB the other pool
  */
 function poolEquals(poolA, poolB) {
-    return (poolA === poolB
-        || (poolA.token0.equals(poolB.token0)
-            && poolA.token1.equals(poolB.token1)
-            && poolA.fee === poolB.fee));
+    return (poolA === poolB ||
+        (poolA.token0.equals(poolB.token0) && poolA.token1.equals(poolB.token1) && poolA.fee === poolB.fee));
 }
 async function getERC20Decimals(tokenAddress, provider) {
     const decimalsFunctionSig = ethers.utils.id('decimals()').substring(0, 10);
@@ -14717,7 +14716,7 @@ function isValidNonZeroAddress(address) {
 }
 const erc20ToUniswapToken = (token) => 
 // eslint-disable-next-line implicit-arrow-linebreak
-new Token(token.chainId, token.address, token.decimals, token.symbol, token.name);
+new Uniswap.Token(token.chainId, token.address, token.decimals, token.symbol, token.name);
 const uniswapTokenToERC20 = (token) => ({
     chainId: token.chainId,
     address: token.address,
@@ -14728,25 +14727,74 @@ const uniswapTokenToERC20 = (token) => ({
 });
 const toCurrencyAmount = (amount) => {
     const token = erc20ToUniswapToken(amount.token);
-    return CurrencyAmount.fromRawAmount(token, amount.value.toString());
+    return Uniswap.CurrencyAmount.fromRawAmount(token, amount.value.toString());
 };
 const newAmount = (amount, token) => ({
     value: amount,
     token,
 });
 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: token addresses must be the same');
     return { value: a.value.add(b.value), token: a.token };
 };
+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: 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');
+};
+/**
+ * Converts our internal token type which could be ERC20 or Native
+ * into a format consumable by Checkout. They require an address to be
+ * present. We populate the address with empty string if it's Native.
+ * If it's ERC20, we don't need to change it.
+ */
+const toPublicTokenType = (token) => {
+    if (token.type === 'native') {
+        return {
+            address: '',
+            chainId: token.chainId,
+            decimals: token.decimals,
+            symbol: token.symbol,
+            name: token.name,
+        };
+    }
+    return token;
+};
+const toPublicAmount = (amount) => ({
+    token: toPublicTokenType(amount.token),
+    value: amount.value,
+});
 
 const amountIndex = 0;
 const gasEstimateIndex = 3;
@@ -15120,11 +15168,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 === TradeType.EXACT_INPUT ? amountSpecified : amountWithSlippage;
     const spender = secondaryFees.length === 0
-        ? routingContracts.peripheryRouterAddress
-        : routingContracts.secondaryFeeAddress;
+        ? contracts.routerAddress
+        : contracts.secondaryFeeAddress;
     return { spender, amount: amountOfTokenIn };
 };
 /**
@@ -15157,7 +15205,7 @@ async function getApproveGasEstimate(provider, ownerAddress, spenderAddress, tok
         from: ownerAddress,
     });
 }
-const getApproval = async (provider, ownerAddress, preparedApproval, gasPrice, nativeTokenService) => {
+const getApproval = async (provider, ownerAddress, preparedApproval, gasPrice) => {
     const approveTransaction = await getApproveTransaction(provider, ownerAddress, preparedApproval.amount, preparedApproval.spender);
     if (!approveTransaction) {
         return null;
@@ -15166,8 +15214,7 @@ const getApproval = async (provider, ownerAddress, preparedApproval, gasPrice, n
     const gasFeeEstimate = gasPrice ? calculateGasFee(gasPrice, gasEstimate) : null;
     return {
         transaction: approveTransaction,
-        // TODO: TP-1649: Remove the wrapping here
-        gasFeeEstimate: gasFeeEstimate ? nativeTokenService.maybeWrapAmount(gasFeeEstimate) : null,
+        gasFeeEstimate: gasFeeEstimate ? toPublicAmount(gasFeeEstimate) : null,
     };
 };
 
@@ -15203,25 +15250,8 @@ function applySlippage(tradeType, amount, slippage) {
     const amountWithSlippage = maybeInverted.multiply(amount.toString()).quotient;
     return ethers.BigNumber.from(amountWithSlippage.toString());
 }
-function prepareUserQuote(otherToken, tradeInfo, slippage, fees) {
-    const quote = getQuoteAmountFromTradeType(tradeInfo);
-    const amountWithSlippage = applySlippage(tradeInfo.tradeType, quote.value, slippage);
-    return {
-        amount: quote,
-        amountWithMaxSlippage: {
-            token: otherToken,
-            value: amountWithSlippage,
-        },
-        slippage,
-        fees: fees.withAmounts(),
-    };
-}
 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 nativeTokenService.maybeWrapAmount(amountSpecified);
@@ -15252,14 +15282,17 @@ class Fees {
         this.secondaryFees = secondaryFees;
         this.amount = newAmount(BigNumber$1.from(0), token);
     }
+    get token() {
+        return this.amount.token;
+    }
     addAmount(amount) {
-        this.amount = addERC20Amount(this.amount, amount);
+        this.amount = addAmount(this.amount, amount);
     }
     amountWithFeesApplied() {
-        return addERC20Amount(this.amount, this.total());
+        return addAmount(this.amount, this.total());
     }
     amountLessFees() {
-        return subtractERC20Amount(this.amount, this.total());
+        return subtractAmount(this.amount, this.total());
     }
     withAmounts() {
         return this.secondaryFees.map((fee) => {
@@ -15278,7 +15311,7 @@ class Fees {
             const feeAmount = this.amount.value
                 .mul(fee.basisPoints)
                 .div(BASIS_POINT_PRECISION);
-            totalFees = addERC20Amount(totalFees, newAmount(feeAmount, this.amount.token));
+            totalFees = addAmount(totalFees, newAmount(feeAmount, this.amount.token));
         }
         return totalFees;
     }
@@ -15292,11 +15325,14 @@ class NativeTokenService {
         this.wrappedToken = wrappedToken;
     }
     wrapAmount(amount) {
+        if (!this.isNativeToken(amount.token)) {
+            throw new Error(`cannot wrap non-native token: ${amount.token.address}`);
+        }
         return newAmount(amount.value, this.wrappedToken);
     }
     unwrapAmount(amount) {
         if (amount.token !== this.wrappedToken) {
-            throw new Error(`token ${amount.token.address} is not wrapped`);
+            throw new Error(`cannot unwrap non-wrapped token ${amount.token.address}`);
         }
         return newAmount(amount.value, this.nativeToken);
     }
@@ -15316,14 +15352,6 @@ class NativeTokenService {
 
 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',
@@ -15454,21 +15482,33 @@ function getSwap(adjustedQuote, fromAddress, slippage, deadline, peripheryRouter
         gasFeeEstimate: gasFeeEstimate ? nativeTokenService.maybeWrapAmount(gasFeeEstimate) : null,
     };
 }
-function prepareSwap(ourQuote, amountSpecified, fees) {
+const adjustAmountIn = (ourQuote, amountSpecified, fees, nativeTokenService) => {
     if (ourQuote.tradeType === 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,
     };
@@ -15489,7 +15529,7 @@ 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: NATIVE_IMX_IMMUTABLE_TESTNET,
+        nativeToken: TIMX_IMMUTABLE_TESTNET,
         wrappedNativeToken: TIMX_IMMUTABLE_TESTNET, // TODO: TP-1649: Change to WIMX when ready.
     },
 };
@@ -15561,6 +15601,15 @@ class ExchangeConfiguration {
     }
 }
 
+const toPublicQuote = (amount, amountWithMaxSlippage, slippage, fees) => ({
+    amount,
+    amountWithMaxSlippage,
+    slippage,
+    fees: fees.withAmounts().map((fee) => ({
+        ...fee,
+        amount: toPublicAmount(fee.amount),
+    })),
+});
 class Exchange {
     provider;
     router;
@@ -15569,6 +15618,8 @@ class Exchange {
     wrappedNativeToken;
     secondaryFees;
     nativeTokenService;
+    secondaryFeeContractAddress;
+    routerContractAddress;
     constructor(configuration) {
         const config = new ExchangeConfiguration(configuration);
         this.chainId = config.chain.chainId;
@@ -15576,13 +15627,13 @@ class Exchange {
         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.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) {
@@ -15599,7 +15650,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 [];
@@ -15627,8 +15678,7 @@ class Exchange {
             decimals: tokenOutDecimals,
         };
         // determine which amount was specified for the swap from the TradeType
-        const [tokenSpecified, otherToken] = tradeType === TradeType.EXACT_INPUT
-            ? [tokenIn, tokenOut] : [tokenOut, tokenIn];
+        const [tokenSpecified, otherToken] = tradeType === TradeType.EXACT_INPUT ? [tokenIn, tokenOut] : [tokenOut, tokenIn];
         const amountSpecified = newAmount(amount, tokenSpecified);
         const fees = new Fees(secondaryFees, tokenIn);
         const ourQuoteReqAmount = getOurQuoteReqAmount(amountSpecified, fees, tradeType, this.nativeTokenService);
@@ -15637,17 +15687,18 @@ class Exchange {
             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, this.nativeTokenService);
-        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 quotedAmount = getQuoteAmountFromTradeType(adjustedQuote);
+        const amountWithMaxSlippage = newAmount(applySlippage(adjustedQuote.tradeType, quotedAmount.value, slippagePercent), otherToken);
+        const preparedApproval = prepareApproval(tradeType, amountSpecified, 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, this.nativeTokenService);
-        return {
-            approval,
-            swap,
-            quote: userQuote,
-        };
+        const approval = await getApproval(this.provider, fromAddress, preparedApproval, gasPrice);
+        const quote = toPublicQuote(quotedAmount, amountWithMaxSlippage, slippagePercent, fees);
+        return { quote, approval, swap };
     }
     /**
      * Get the unsigned swap transaction given the amount to sell.
@@ -20503,7 +20554,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.27.8',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.27.10',
 };
 /**
  * createAPIConfiguration to create a custom Configuration

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.8";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.27.10";
 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.8',
+    sdkVersion: 'ts-immutable-sdk-0.27.10',
 });
 /**
  * Sets `sdkVersion` at the time of build