@imtbl/sdk 0.35.0 → 0.35.2

package/dist/checkout.js

@@ -14673,7 +14673,6 @@ class UniswapV3Pool__factory extends ContractFactory {
     }
 }
 
-const DEFAULT_GAS_QUOTE = 2000000;
 // TODO: Better description of function and args
 async function multicallSingleCallDataMultipleContracts(multicallContract, functionName, addresses) {
     // Encode args - generate calldata for contract
@@ -14695,22 +14694,6 @@ async function multicallSingleCallDataMultipleContracts(multicallContract, funct
     }
     return multicallContract.callStatic.multicall(calls);
 }
-// TODO: Better description of function and args
-async function multicallMultipleCallDataSingContract(multicallContract, calldata, address, options) {
-    // Create call objects
-    const calls = new Array(calldata.length);
-    // TODO: use object.keys of something similar to avoid iterating over
-    // entire object prototype
-    // eslint-disable-next-line no-restricted-syntax, guard-for-in
-    for (const i in calldata) {
-        calls[i] = {
-            target: address,
-            callData: calldata[i],
-            gasLimit: options?.gasRequired ?? DEFAULT_GAS_QUOTE,
-        };
-    }
-    return multicallContract.callStatic.multicall(calls);
-}
 const getCallData = (methodName, contractInterface) => {
     // Create ethers function fragment
     const fragment = contractInterface?.getFunction(methodName);
@@ -14870,35 +14853,27 @@ const getDefaultDeadlineSeconds = () => Math.floor(Date.now() / 1000) + DEFAULT_
 
 const amountIndex = 0;
 const gasEstimateIndex = 3;
-async function getQuotesForRoutes(multicallContract, quoterContractAddress, routes, amountSpecified, tradeType) {
-    const callData = routes.map((route) => SwapQuoter.quoteCallParameters(route, toCurrencyAmount(amountSpecified), tradeType, {
+async function getQuotesForRoutes(provider, quoterContractAddress, routes, amountSpecified, tradeType) {
+    const callDatas = routes.map((route) => SwapQuoter.quoteCallParameters(route, toCurrencyAmount(amountSpecified), tradeType, {
         useQuoterV2: true,
     }).calldata);
-    let quoteResults;
-    try {
-        quoteResults = await multicallMultipleCallDataSingContract(multicallContract, callData, quoterContractAddress);
-    }
-    catch (e) {
-        const message = e instanceof Error ? e.message : 'Unknown Error';
-        throw new ProviderCallError(`failed multicall: ${message}`);
-    }
-    const decodedQuoteResults = [];
-    // TODO: for..in loops iterate over the entire prototype chain,
-    // Use Object.{keys,values,entries}, and iterate over the resulting array.
-    // eslint-disable-next-line no-restricted-syntax, guard-for-in
-    for (const i in quoteResults.returnData) {
-        const functionSig = callData[i].substring(0, 10);
+    const promises = await Promise.allSettled(callDatas.map((data) => provider.send('eth_call', [
+        { to: quoterContractAddress, data }, 'latest',
+    ])));
+    const decodedQuoteResults = promises.reduce((quoteResults, promiseResult, i) => {
+        if (promiseResult.status === 'rejected')
+            return quoteResults;
+        const functionSig = callDatas[i].substring(0, 10);
         const returnTypes = quoteReturnMapping[functionSig];
         if (!returnTypes) {
             throw new Error('No quoting function signature found');
         }
-        if (quoteResults.returnData[i].returnData === '0x') {
+        if (promiseResult.value === '0x') {
             // There is no quote result for the swap using this route, so don't include it in results
-            // eslint-disable-next-line no-continue
-            continue;
+            return quoteResults;
         }
         try {
-            const decodedQuoteResult = ethers.utils.defaultAbiCoder.decode(returnTypes, quoteResults.returnData[i].returnData);
+            const decodedQuoteResult = utils.defaultAbiCoder.decode(returnTypes, promiseResult.value);
             if (decodedQuoteResult) {
                 // The 0th element in each decoded data is going to be the amountOut or amountIn.
                 const quoteAmount = decodedQuoteResult[amountIndex];
@@ -14906,11 +14881,11 @@ async function getQuotesForRoutes(multicallContract, quoterContractAddress, rout
                     throw new Error('Expected BigNumber');
                 const input = uniswapTokenToERC20(routes[i].input);
                 const output = uniswapTokenToERC20(routes[i].output);
-                decodedQuoteResults.push({
+                quoteResults.push({
                     route: routes[i],
                     amountIn: tradeType === TradeType.EXACT_INPUT ? amountSpecified : newAmount(quoteAmount, input),
                     amountOut: tradeType === TradeType.EXACT_INPUT ? newAmount(quoteAmount, output) : amountSpecified,
-                    gasEstimate: ethers.BigNumber.from(decodedQuoteResult[gasEstimateIndex]),
+                    gasEstimate: BigNumber$1.from(decodedQuoteResult[gasEstimateIndex]),
                     tradeType,
                 });
             }
@@ -14920,7 +14895,8 @@ async function getQuotesForRoutes(multicallContract, quoterContractAddress, rout
             // Other quotes for routes may still succeed, so do nothing
             // and continue processing
         }
-    }
+        return quoteResults;
+    }, new Array());
     return decodedQuoteResults;
 }
 
@@ -15048,19 +15024,24 @@ const fetchValidPools = async (multicallContract, erc20Pair, commonRoutingERC20s
 
 class Router {
     provider;
+    multicallContract;
     routingTokens;
     routingContracts;
-    constructor(provider, routingTokens, routingContracts) {
+    constructor(provider, multicallContract, routingTokens, routingContracts) {
         this.provider = provider;
+        this.multicallContract = multicallContract;
+        this.routingTokens = routingTokens;
+        this.routingContracts = routingContracts;
+        this.provider = provider;
+        this.multicallContract = multicallContract;
         this.routingTokens = routingTokens;
         this.routingContracts = routingContracts;
     }
     async findOptimalRoute(amountSpecified, otherToken, tradeType, maxHops = 2) {
         const [tokenIn, tokenOut] = this.determineERC20InAndERC20Out(tradeType, amountSpecified, otherToken);
-        const multicallContract = Multicall__factory.connect(this.routingContracts.multicallAddress, this.provider);
         const erc20Pair = [tokenIn, tokenOut];
         // Get all pools and use these to get all possible routes.
-        const pools = await fetchValidPools(multicallContract, erc20Pair, this.routingTokens, this.routingContracts.factoryAddress);
+        const pools = await fetchValidPools(this.multicallContract, erc20Pair, this.routingTokens, this.routingContracts.coreFactory);
         const noValidPools = pools.length === 0;
         if (noValidPools) {
             throw new NoRoutesAvailableError();
@@ -15074,10 +15055,10 @@ class Router {
             throw new NoRoutesAvailableError();
         }
         // Get the best quote from all of the given routes
-        return await this.getBestQuoteFromRoutes(multicallContract, routes, amountSpecified, tradeType);
+        return await this.getBestQuoteFromRoutes(routes, amountSpecified, tradeType);
     }
-    async getBestQuoteFromRoutes(multicallContract, routes, amountSpecified, tradeType) {
-        const quotes = await getQuotesForRoutes(multicallContract, this.routingContracts.quoterAddress, routes, amountSpecified, tradeType);
+    async getBestQuoteFromRoutes(routes, amountSpecified, tradeType) {
+        const quotes = await getQuotesForRoutes(this.provider, this.routingContracts.quoterV2, routes, amountSpecified, tradeType);
         if (quotes.length === 0) {
             throw new NoRoutesAvailableError();
         }
@@ -15153,36 +15134,38 @@ startTokenIn = tokenIn) => {
     return routes;
 };
 
-/**
- * Determines whether or not the chain supports EIP-1559 by checking for the existence
- * of {@link FeeData.maxFeePerGas} and {@link FeeData.maxPriorityFeePerGas}
- *
- * @param {FeeData} fee - The fee data for the chain
- */
-const doesChainSupportEIP1559$1 = (fee) => {
-    const supportsEIP1559 = !!fee.maxFeePerGas && !!fee.maxPriorityFeePerGas;
-    return supportsEIP1559;
+const getFeeData = async (provider) => {
+    const [block, maxPriorityFeePerGas] = await Promise.all([
+        provider.getBlock('latest'),
+        provider.send('eth_maxPriorityFeePerGas', []),
+    ]);
+    if (!block.baseFeePerGas)
+        throw new Error('Base fee per gas not found in block');
+    return {
+        // https://www.blocknative.com/blog/eip-1559-fees
+        maxFeePerGas: block.baseFeePerGas.mul(2).add(maxPriorityFeePerGas),
+        maxPriorityFeePerGas,
+        lastBaseFeePerGas: block.baseFeePerGas,
+    };
 };
 /**
  * Fetch the current gas price estimate. Supports both EIP-1559 and non-EIP1559 chains
- * @param {JsonRpcProvider} provider - The JSON RPC provider used to fetch fee data
+ * @param {Provider} provider - The JSON RPC provider used to fetch fee data
  * @param {Native} nativeToken - The native token of the chain. Gas prices will be denominated in this token
- * @returns {Amount | null} - The gas price in the smallest denomination of the chain's currency,
+ * @returns {CoinAmount<Native> | null} - The gas price in the smallest denomination of the chain's currency,
  *  or null if no gas price is available
  */
+// eslint-disable-next-line max-len
 const fetchGasPrice = async (provider, nativeToken) => {
-    const feeData = await provider.getFeeData().catch(() => null);
+    const feeData = await getFeeData(provider).catch(() => null);
     if (!feeData)
         return null;
-    if (doesChainSupportEIP1559$1(feeData)) {
-        return newAmount(feeData.maxFeePerGas.add(feeData.maxPriorityFeePerGas), nativeToken);
-    }
-    return feeData.gasPrice ? newAmount(feeData.gasPrice, nativeToken) : null;
+    return newAmount(feeData.maxFeePerGas, nativeToken);
 };
 /**
  * Calculate the gas fee from the gas price and gas units used for the transaction
  *
- * @param {Amount} gasPrice - The price of gas
+ * @param {CoinAmount<Native>} gasPrice - The price of gas
  * @param {BigNumber} gasEstimate - The total gas units that will be used for the transaction
  * @returns - The cost of the transaction in the gas token's smallest denomination (e.g. WEI)
  */
@@ -15806,6 +15789,7 @@ const toPublicQuote = (amount, amountWithMaxSlippage, slippage, fees) => ({
 });
 class Exchange {
     provider;
+    batchProvider;
     router;
     chainId;
     nativeToken;
@@ -15823,12 +15807,16 @@ class Exchange {
         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,
-        });
+        this.provider = new ethers.providers.StaticJsonRpcProvider({
+            url: config.chain.rpcUrl,
+            skipFetchSetup: true,
+        }, config.chain.chainId);
+        this.batchProvider = new ethers.providers.JsonRpcBatchProvider({
+            url: config.chain.rpcUrl,
+            skipFetchSetup: true,
+        }, config.chain.chainId);
+        const multicallContract = Multicall__factory.connect(config.chain.contracts.multicall, this.provider);
+        this.router = new Router(this.batchProvider, multicallContract, config.chain.commonRoutingTokens, config.chain.contracts);
     }
     static validate(tokenInAddress, tokenOutAddress, maxHops, slippagePercent, fromAddress) {
         assert(isValidNonZeroAddress(fromAddress), new InvalidAddressError('invalid from address'));
@@ -15840,11 +15828,11 @@ class Exchange {
         assert(slippagePercent <= 50, new InvalidSlippageError('slippage percent must be less than or equal to 50'));
         assert(slippagePercent >= 0, new InvalidSlippageError('slippage percent must be greater than or equal to 0'));
     }
-    async getSecondaryFees() {
+    async getSecondaryFees(provider) {
         if (this.secondaryFees.length === 0) {
             return [];
         }
-        const secondaryFeeContract = SecondaryFee__factory.connect(this.secondaryFeeContractAddress, this.provider);
+        const secondaryFeeContract = SecondaryFee__factory.connect(this.secondaryFeeContractAddress, provider);
         if (await secondaryFeeContract.paused()) {
             // Do not use secondary fees if the contract is paused
             return [];
@@ -15865,11 +15853,13 @@ class Exchange {
     async getUnsignedSwapTx(fromAddress, tokenInLiteral, tokenOutLiteral, amount, slippagePercent, maxHops, deadline, tradeType) {
         Exchange.validate(tokenInLiteral, tokenOutLiteral, maxHops, slippagePercent, fromAddress);
         // get the decimals of the tokens that will be swapped
-        const [tokenInDecimals, tokenOutDecimals, secondaryFees] = await Promise.all([
-            getTokenDecimals(tokenInLiteral, this.provider, this.nativeToken),
-            getTokenDecimals(tokenOutLiteral, this.provider, this.nativeToken),
-            this.getSecondaryFees(),
-        ]);
+        const promises = [
+            getTokenDecimals(tokenInLiteral, this.batchProvider, this.nativeToken),
+            getTokenDecimals(tokenOutLiteral, this.batchProvider, this.nativeToken),
+            this.getSecondaryFees(this.batchProvider),
+            fetchGasPrice(this.batchProvider, this.nativeToken),
+        ];
+        const [tokenInDecimals, tokenOutDecimals, secondaryFees, gasPrice] = await Promise.all(promises);
         const tokenIn = this.parseTokenLiteral(tokenInLiteral, tokenInDecimals);
         const tokenOut = this.parseTokenLiteral(tokenOutLiteral, tokenOutDecimals);
         // determine which amount was specified for the swap from the TradeType
@@ -15878,10 +15868,7 @@ class Exchange {
         const fees = new Fees(secondaryFees, tokenIn);
         const ourQuoteReqAmount = getOurQuoteReqAmount(amountSpecified, fees, tradeType, this.nativeTokenService);
         // Quotes will always use ERC20s. If the user-specified token is Native, we use the Wrapped Native Token pool
-        const [ourQuote, gasPrice] = await Promise.all([
-            this.router.findOptimalRoute(ourQuoteReqAmount, this.nativeTokenService.maybeWrapToken(otherToken), tradeType, maxHops),
-            fetchGasPrice(this.provider, this.nativeToken),
-        ]);
+        const ourQuote = await this.router.findOptimalRoute(ourQuoteReqAmount, this.nativeTokenService.maybeWrapToken(otherToken), tradeType, maxHops);
         const adjustedQuote = adjustQuoteWithFees(ourQuote, amountSpecified, fees, this.nativeTokenService);
         const swap = getSwap(tokenIn, tokenOut, adjustedQuote, fromAddress, slippagePercent, deadline, this.routerContractAddress, this.secondaryFeeContractAddress, gasPrice, secondaryFees);
         const { quotedAmount, quotedAmountWithMaxSlippage } = prepareUserQuote(this.nativeTokenService, adjustedQuote, slippagePercent, otherToken);
@@ -20999,7 +20986,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.35.0',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.35.2',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -22276,7 +22263,7 @@ const GAS_OVERRIDES = {
     maxPriorityFeePerGas: BigNumber$1.from(101e9),
 };
 
-const SDK_VERSION_MARKER = '0.35.0';
+const SDK_VERSION_MARKER = '0.35.2';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 

package/dist/immutablex_client.js

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