@imtbl/sdk 0.23.0-alpha → 0.23.2-alpha.1

package/dist/index.js

@@ -1079,6 +1079,46 @@ const MetadataApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * refresh metadata of a list of nfts
+         * @summary refresh the metedata data of a list of nfts by token id
+         * @param {string} contractAddress The address of contract
+         * @param {string} chainName The name of chain
+         * @param {RefreshNFTMetadataByTokenIDRequest} refreshNFTMetadataByTokenIDRequest the request body
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        refreshNFTMetadataByTokenID: async (contractAddress, chainName, refreshNFTMetadataByTokenIDRequest, options = {}) => {
+            // verify required parameter 'contractAddress' is not null or undefined
+            assertParamExists$1('refreshNFTMetadataByTokenID', 'contractAddress', contractAddress);
+            // verify required parameter 'chainName' is not null or undefined
+            assertParamExists$1('refreshNFTMetadataByTokenID', 'chainName', chainName);
+            // verify required parameter 'refreshNFTMetadataByTokenIDRequest' is not null or undefined
+            assertParamExists$1('refreshNFTMetadataByTokenID', 'refreshNFTMetadataByTokenIDRequest', refreshNFTMetadataByTokenIDRequest);
+            const localVarPath = `/v1/chains/{chain_name}/collections/{contract_address}/nfts/refresh-metadata`
+                .replace(`{${"contract_address"}}`, encodeURIComponent(String(contractAddress)))
+                .replace(`{${"chain_name"}}`, encodeURIComponent(String(chainName)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL$1);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication ImmutableApiKey required
+            await setApiKeyToObject(localVarHeaderParameter, "X-Immutable-API-Key", configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams$1(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded$1(refreshNFTMetadataByTokenIDRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString$1(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
     };
 };
 /**
@@ -1113,6 +1153,19 @@ const MetadataApiFp = function (configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.refreshMetadataByID(chainName, contractAddress, refreshMetadataByIDRequest, options);
             return createRequestFunction$1(localVarAxiosArgs, globalAxios$1, BASE_PATH$1, configuration);
         },
+        /**
+         * refresh metadata of a list of nfts
+         * @summary refresh the metedata data of a list of nfts by token id
+         * @param {string} contractAddress The address of contract
+         * @param {string} chainName The name of chain
+         * @param {RefreshNFTMetadataByTokenIDRequest} refreshNFTMetadataByTokenIDRequest the request body
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async refreshNFTMetadataByTokenID(contractAddress, chainName, refreshNFTMetadataByTokenIDRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.refreshNFTMetadataByTokenID(contractAddress, chainName, refreshNFTMetadataByTokenIDRequest, options);
+            return createRequestFunction$1(localVarAxiosArgs, globalAxios$1, BASE_PATH$1, configuration);
+        },
     };
 };
 /**
@@ -1145,6 +1198,18 @@ const MetadataApiFactory = function (configuration, basePath, axios) {
         refreshMetadataByID(chainName, contractAddress, refreshMetadataByIDRequest, options) {
             return localVarFp.refreshMetadataByID(chainName, contractAddress, refreshMetadataByIDRequest, options).then((request) => request(axios, basePath));
         },
+        /**
+         * refresh metadata of a list of nfts
+         * @summary refresh the metedata data of a list of nfts by token id
+         * @param {string} contractAddress The address of contract
+         * @param {string} chainName The name of chain
+         * @param {RefreshNFTMetadataByTokenIDRequest} refreshNFTMetadataByTokenIDRequest the request body
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        refreshNFTMetadataByTokenID(contractAddress, chainName, refreshNFTMetadataByTokenIDRequest, options) {
+            return localVarFp.refreshNFTMetadataByTokenID(contractAddress, chainName, refreshNFTMetadataByTokenIDRequest, options).then((request) => request(axios, basePath));
+        },
     };
 };
 /**
@@ -1175,6 +1240,17 @@ class MetadataApi extends BaseAPI$1 {
     refreshMetadataByID(requestParameters, options) {
         return MetadataApiFp(this.configuration).refreshMetadataByID(requestParameters.chainName, requestParameters.contractAddress, requestParameters.refreshMetadataByIDRequest, options).then((request) => request(this.axios, this.basePath));
     }
+    /**
+     * refresh metadata of a list of nfts
+     * @summary refresh the metedata data of a list of nfts by token id
+     * @param {MetadataApiRefreshNFTMetadataByTokenIDRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MetadataApi
+     */
+    refreshNFTMetadataByTokenID(requestParameters, options) {
+        return MetadataApiFp(this.configuration).refreshNFTMetadataByTokenID(requestParameters.contractAddress, requestParameters.chainName, requestParameters.refreshNFTMetadataByTokenIDRequest, options).then((request) => request(this.axios, this.basePath));
+    }
 }
 
 /* tslint:disable */
@@ -2987,7 +3063,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.23.0-alpha' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.23.2-alpha.1' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -3047,29 +3123,24 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.23.0-alpha',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.23.2-alpha.1',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
  * other than the production and sandbox defined below.
  */
-const createAPIConfiguration = ({ basePath, headers: baseHeaders, }) => {
+const createAPIConfiguration = ({ baseConfig, basePath, headers: baseHeaders, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
     }
     const headers = { ...(baseHeaders || {}), ...defaultHeaders };
     const configParams = {
+        ...baseConfig,
         basePath,
         baseOptions: { headers },
     };
     return new index.Configuration(configParams);
 };
-const production$1 = () => createAPIConfiguration({
-    basePath: 'https://indexer-mr.imtbl.com',
-});
-const sandbox$1 = () => createAPIConfiguration({
-    basePath: 'https://api.sandbox.immutable.com',
-});
 class BlockchainDataConfiguration {
     apiConfig;
     baseConfig;
@@ -3081,15 +3152,24 @@ class BlockchainDataConfiguration {
         else {
             switch (baseConfig.environment) {
                 case Environment$1.SANDBOX: {
-                    this.apiConfig = sandbox$1();
+                    this.apiConfig = createAPIConfiguration({
+                        basePath: 'https://api.sandbox.immutable.com',
+                        baseConfig,
+                    });
                     break;
                 }
                 case Environment$1.PRODUCTION: {
-                    this.apiConfig = production$1();
+                    this.apiConfig = createAPIConfiguration({
+                        basePath: 'https://indexer-mr.imtbl.com',
+                        baseConfig,
+                    });
                     break;
                 }
                 default: {
-                    this.apiConfig = sandbox$1();
+                    this.apiConfig = createAPIConfiguration({
+                        basePath: 'https://api.sandbox.immutable.com',
+                        baseConfig,
+                    });
                 }
             }
         }
@@ -3139,6 +3219,7 @@ class BlockchainData {
     nfts;
     nftOwners;
     tokens;
+    metadata;
     constructor(moduleConfig) {
         this.config = new BlockchainDataConfiguration(moduleConfig);
         this.activities = new index.ActivitiesApi(this.config.apiConfig);
@@ -3147,6 +3228,7 @@ class BlockchainData {
         this.nfts = new index.NftsApi(this.config.apiConfig);
         this.nftOwners = new index.NftOwnersApi(this.config.apiConfig);
         this.tokens = new index.TokensApi(this.config.apiConfig);
+        this.metadata = new index.MetadataApi(this.config.apiConfig);
     }
     /**
      * List all activities
@@ -3316,6 +3398,48 @@ class BlockchainData {
             throw formatError(err);
         });
     }
+    /**
+     * Refresh collection metadata
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the updated collection
+     * @throws {@link index.APIError}
+     */
+    async refreshCollectionMetadata(request) {
+        return await this.collections
+            .refreshCollectionMetadata(request)
+            .then((res) => res.data)
+            .catch((err) => {
+            throw formatError(err);
+        });
+    }
+    /**
+     * Refresh metadata for specific NFTs
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the remaining rate limits
+     * @throws {@link index.APIError}
+     */
+    async refreshNFTMetadata(request) {
+        return await this.metadata
+            .refreshNFTMetadataByTokenID(request)
+            .then((res) => res.data)
+            .catch((err) => {
+            throw formatError(err);
+        });
+    }
+    /**
+     * Refresh metadata by ID. This will refresh metadata for all NFTs that reference the given metadata ID.
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the remaining rate limits
+     * @throws {@link index.APIError}
+     */
+    async refreshStackedMetadata(request) {
+        return await this.metadata
+            .refreshMetadataByID(request)
+            .then((res) => res.data)
+            .catch((err) => {
+            throw formatError(err);
+        });
+    }
 }
 
 var blockchain_data = /*#__PURE__*/Object.freeze({
@@ -3333,7 +3457,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.23.0-alpha',
+    sdkVersion: 'ts-immutable-sdk-0.23.2-alpha.1',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -8195,14 +8319,25 @@ class AuthManager {
             this.deviceCredentialsManager.clearCredentials();
         }, PassportErrorType.LOGOUT_ERROR);
     }
-    async loginSilent() {
-        return withPassportError(async () => this.getUser(), PassportErrorType.SILENT_LOGIN_ERROR);
+    async loginSilent({ forceRefresh } = { forceRefresh: false }) {
+        // eslint-disable-next-line arrow-body-style
+        return withPassportError(async () => {
+            return this.getUser({ forceRefresh });
+        }, PassportErrorType.SILENT_LOGIN_ERROR);
     }
-    async getWebUser() {
+    /**
+     * Get the user from the cache or refresh the token if it's expired.
+     * @param forceRefresh If set to true, force an HTTP call to the OIDC server's authorization endpoint. This call will
+     * throw an error if there's no refresh token.
+     */
+    async getWebUser({ forceRefresh = false }) {
+        if (forceRefresh) {
+            const newOidcUser = await this.userManager.signinSilent();
+            return newOidcUser ? AuthManager.mapOidcUserToDomainModel(newOidcUser) : null;
+        }
         const oidcUser = await this.userManager.getUser();
-        if (!oidcUser) {
+        if (!oidcUser)
             return null;
-        }
         const tokenExpired = isTokenExpired(oidcUser);
         if (!tokenExpired) {
             return AuthManager.mapOidcUserToDomainModel(oidcUser);
@@ -8215,9 +8350,9 @@ class AuthManager {
         }
         return null;
     }
-    async getUser() {
+    async getUser({ forceRefresh } = { forceRefresh: false }) {
         return withPassportError(async () => {
-            const user = await this.getWebUser();
+            const user = await this.getWebUser({ forceRefresh });
             if (user) {
                 return user;
             }
@@ -8995,7 +9130,7 @@ class PassportImxProviderFactory {
             }, jwt);
             // User metadata is updated asynchronously. Poll userinfo endpoint until it is updated.
             const updatedUser = await retryWithDelay(async () => {
-                const user = await this.authManager.loginSilent();
+                const user = await this.authManager.loginSilent({ forceRefresh: true }); // force refresh to get updated user info
                 const metadataExists = !!user?.imx;
                 if (metadataExists) {
                     return user;
@@ -9495,7 +9630,7 @@ async function registerZkEvmUser({ authManager, config, magicProvider, multiRoll
         user = await authManager.refreshToken(credentials.refresh_token);
     }
     else {
-        user = await authManager.loginSilent();
+        user = await authManager.loginSilent({ forceRefresh: true });
     }
     if (!user?.zkEvm) {
         throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Failed to refresh user details');
@@ -30184,7 +30319,6 @@ const $7f2e17f026d4fc8d$export$86d9f998ddda013e = async (config, provider)=>{
 
 
 
-
 const $33acec7b4a26c053$export$23ddeb2642d2f9d = async (config, readOnlyProviders, ownerAddress, availableRoutingOptions)=>{
     const chainBalances = new Map();
     const chainBalancePromises = new Map();
@@ -30297,7 +30431,59 @@ const $3ee85f12225c19f3$export$fb80fe94a81a3132 = async (config, dexQuoteCache,
 };
 
 
-const $91807edfd7057288$export$db6bd467891859dc = (chainId, fundsRequired, userBalance)=>{
+const $91807edfd7057288$var$constructFees = (approvalGasFees, swapGasFees, swapFees)=>{
+    let approvalGasFeeAmount = (BigNumber$1).from(0);
+    let approvalGasFeeFormatted = "0";
+    let approvalToken;
+    if (approvalGasFees) {
+        approvalGasFeeAmount = approvalGasFees.value;
+        approvalGasFeeFormatted = (utils$1).formatUnits(approvalGasFees.value, approvalGasFees.token.decimals);
+        approvalToken = {
+            name: approvalGasFees.token.name ?? "",
+            symbol: approvalGasFees.token.symbol ?? "",
+            address: approvalGasFees.token.address,
+            decimals: approvalGasFees.token.decimals
+        };
+    }
+    let swapGasFeeAmount = (BigNumber$1).from(0);
+    let swapGasFeeFormatted = "0";
+    let swapGasToken;
+    if (swapGasFees) {
+        swapGasFeeAmount = swapGasFees.value;
+        swapGasFeeFormatted = (utils$1).formatUnits(swapGasFees.value, swapGasFees.token.decimals);
+        swapGasToken = {
+            name: swapGasFees.token.name ?? "",
+            symbol: swapGasFees.token.symbol ?? "",
+            address: swapGasFees.token.address,
+            decimals: swapGasFees.token.decimals
+        };
+    }
+    const fees = [];
+    for (const swapFee of swapFees)fees.push({
+        amount: swapFee.amount.value,
+        formattedAmount: (utils$1).formatUnits(swapFee.amount.value, swapFee.amount.token.decimals),
+        token: {
+            name: swapFee.amount.token.name ?? "",
+            symbol: swapFee.amount.token.symbol ?? "",
+            address: swapFee.amount.token.address,
+            decimals: swapFee.amount.token.decimals
+        }
+    });
+    return {
+        approvalGasFees: {
+            amount: approvalGasFeeAmount,
+            formattedAmount: approvalGasFeeFormatted,
+            token: approvalToken
+        },
+        swapGasFees: {
+            amount: swapGasFeeAmount,
+            formattedAmount: swapGasFeeFormatted,
+            token: swapGasToken
+        },
+        swapFees: fees
+    };
+};
+const $91807edfd7057288$export$db6bd467891859dc = (chainId, fundsRequired, userBalance, fees)=>{
     const tokenAddress = userBalance.token.address;
     let type = ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20;
     if (tokenAddress === ($d85ad1457a3f1a83$export$b80040cb173ba6e9)) type = ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE;
@@ -30316,23 +30502,7 @@ const $91807edfd7057288$export$db6bd467891859dc = (chainId, fundsRequired, userB
             },
             token: userBalance.token
         },
-        // WT-1734 - Add fees
-        fees: {
-            approvalGasFees: {
-                amount: (BigNumber$1).from(0),
-                formattedAmount: "0"
-            },
-            swapGasFees: {
-                amount: (BigNumber$1).from(0),
-                formattedAmount: "0"
-            },
-            swapFees: [
-                {
-                    amount: (BigNumber$1).from(0),
-                    formattedAmount: "0"
-                }
-            ]
-        }
+        fees: fees
     };
 };
 const $91807edfd7057288$export$85e4d8628aabb217 = (balanceRequirement)=>{
@@ -30417,7 +30587,31 @@ const $91807edfd7057288$export$38077235fe748d40 = (l2Balances, swapFees, approva
     }
     return true;
 };
-const $91807edfd7057288$export$8e03ea04d59f2402 = async (config, availableRoutingOptions, dexQuoteCache, walletAddress, balanceRequirement, tokenBalanceResults, swappableTokens)=>{
+const $91807edfd7057288$export$567a0c83c08c514b = (l2balance, balanceRequirements, quoteTokenAddress, amountBeingSwapped, approvalFees, swapFees)=>{
+    let remainingBalance = (BigNumber$1).from(0);
+    let balanceRequirementToken = "";
+    let requirementExists = false;
+    balanceRequirements.balanceRequirements.forEach((requirement)=>{
+        if (requirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE || requirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) {
+            if (requirement.required.token.address === quoteTokenAddress) {
+                balanceRequirementToken = requirement.required.token.address;
+                requirementExists = true;
+                // Get the balance that would remain if the requirement was removed from the users balance
+                remainingBalance = l2balance.sub(requirement.required.balance);
+            }
+        }
+    });
+    // No requirement exists matching this token so no need to check if user can cover requirement
+    if (!requirementExists) return true;
+    // Remove approval fees from the remainder if token matches as these need to be taken out to cover the swap
+    if (approvalFees.approvalGasTokenAddress === balanceRequirementToken) remainingBalance = remainingBalance.sub(approvalFees.approvalGasFee);
+    // Remove swap fees from the remainder if token matches as these need to be taken out to cover the swap
+    for (const swapFee of swapFees)if (swapFee.amount.token.address === balanceRequirementToken) remainingBalance = remainingBalance.sub(swapFee.amount.value);
+    // If the users current balance can cover the balance after fees + the amount
+    // that is going to be swapped from another item requirement then return true
+    return remainingBalance.gte(amountBeingSwapped);
+};
+const $91807edfd7057288$export$8e03ea04d59f2402 = async (config, availableRoutingOptions, dexQuoteCache, walletAddress, balanceRequirement, tokenBalanceResults, swappableTokens, balanceRequirements)=>{
     const fundingSteps = [];
     if (!availableRoutingOptions.swap) return fundingSteps;
     if (swappableTokens.length === 0) return fundingSteps;
@@ -30449,9 +30643,11 @@ const $91807edfd7057288$export$8e03ea04d59f2402 = async (config, availableRoutin
             amount: amountOfQuoteTokenRequired.value,
             address: quoteTokenAddress
         })) continue;
-        // User has sufficient funds to cover any approval and swap fees so use this token for the funding route
-        // Currently we are not prioritising any particular token so just taking the first sufficient token
-        fundingSteps.push($91807edfd7057288$export$db6bd467891859dc(chainId, amountOfQuoteTokenRequired.value, userBalanceOfQuotedToken));
+        if (!$91807edfd7057288$export$567a0c83c08c514b(userBalanceOfQuotedToken.balance, balanceRequirements, quoteTokenAddress, amountOfQuoteTokenRequired.value, approvalFees, quote.quote.fees)) continue;
+        const fees = $91807edfd7057288$var$constructFees(quote.approval, quote.swap, quote.quote.fees);
+        // User has sufficient funds of this token to cover any gas fees, swap fees and balance requirements
+        // so add this token to the possible swap options
+        fundingSteps.push($91807edfd7057288$export$db6bd467891859dc(chainId, amountOfQuoteTokenRequired.value, userBalanceOfQuotedToken, fees));
     }
     return fundingSteps;
 };
@@ -30638,7 +30834,29 @@ const $fa9ac5bfdbbf9dfa$export$da05aed50d75046 = async (config, readOnlyProvider
     feeEstimates.set(($4b58188d47aafe8d$export$6fbaa98ee06d03e8).BRIDGE, bridgeFeeEstimate);
     return bridgeFeeEstimate;
 };
-const $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute = (chainId, balance, bridgeRequirement, itemType)=>({
+const $fa9ac5bfdbbf9dfa$var$constructFees = (approvalGasFees, bridgeGasFees, bridgeFee)=>{
+    const bridgeFeeDecimals = bridgeFee.token?.decimals ?? ($d85ad1457a3f1a83$export$903389470ba9433c);
+    return {
+        approvalGasFees: {
+            amount: approvalGasFees,
+            formattedAmount: (utils$1).formatUnits(approvalGasFees, ($d85ad1457a3f1a83$export$903389470ba9433c)),
+            token: bridgeGasFees.token
+        },
+        bridgeGasFees: {
+            amount: bridgeGasFees.estimatedAmount,
+            formattedAmount: (utils$1).formatUnits(bridgeGasFees.estimatedAmount, ($d85ad1457a3f1a83$export$903389470ba9433c)),
+            token: bridgeGasFees.token
+        },
+        bridgeFees: [
+            {
+                amount: bridgeFee.estimatedAmount,
+                formattedAmount: (utils$1).formatUnits(bridgeFee.estimatedAmount, bridgeFeeDecimals),
+                token: bridgeFee.token
+            }
+        ]
+    };
+};
+const $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute = (chainId, balance, bridgeRequirement, itemType, fees)=>({
         type: ($4b58188d47aafe8d$export$6fbaa98ee06d03e8).BRIDGE,
         chainId: chainId,
         fundingItem: {
@@ -30658,23 +30876,7 @@ const $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute = (chainId, balance, bri
                 decimals: balance.token.decimals
             }
         },
-        // WT-1734 - Add fees
-        fees: {
-            approvalGasFees: {
-                amount: (BigNumber$1).from(0),
-                formattedAmount: "0"
-            },
-            bridgeGasFees: {
-                amount: (BigNumber$1).from(0),
-                formattedAmount: "0"
-            },
-            bridgeFees: [
-                {
-                    amount: (BigNumber$1).from(0),
-                    formattedAmount: "0"
-                }
-            ]
-        }
+        fees: fees
     });
 const $fa9ac5bfdbbf9dfa$export$3139474685e4dedd = (address)=>{
     if (!address || address === "") return true;
@@ -30711,14 +30913,20 @@ const $fa9ac5bfdbbf9dfa$export$ddc7ba2b57d7c5fa = async (config, readOnlyProvide
         const nativeETHBalance = tokenBalanceResult.balances.find((balance)=>$fa9ac5bfdbbf9dfa$export$3139474685e4dedd(balance.token.address));
         if (bridgeFeeEstimate.gasFee.estimatedAmount) totalFees = totalFees.add(bridgeFeeEstimate.gasFee.estimatedAmount);
         if (!$fa9ac5bfdbbf9dfa$export$9994ad18c2f0e665(tokenBalanceResult, totalFees)) return undefined;
-        if (nativeETHBalance && nativeETHBalance.balance.gte(bridgeRequirement.amount.add(totalFees))) return $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute(chainId, nativeETHBalance, bridgeRequirement, ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE);
+        if (nativeETHBalance && nativeETHBalance.balance.gte(bridgeRequirement.amount.add(totalFees))) {
+            const bridgeFees = $fa9ac5bfdbbf9dfa$var$constructFees(gasForApproval, bridgeFeeEstimate.gasFee, bridgeFeeEstimate.bridgeFee);
+            return $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute(chainId, nativeETHBalance, bridgeRequirement, ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE, bridgeFees);
+        }
         return undefined;
     }
     totalFees.add(gasForApproval).add(bridgeFeeEstimate.gasFee.estimatedAmount);
     if (!$fa9ac5bfdbbf9dfa$export$9994ad18c2f0e665(tokenBalanceResult, totalFees)) return undefined;
     // Find the balance of the L1 representation of the token and check if the balance covers the delta
     const erc20balance = tokenBalanceResult.balances.find((balance)=>balance.token.address === l1address);
-    if (erc20balance && erc20balance.balance.gte(bridgeRequirement.amount)) return $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute(chainId, erc20balance, bridgeRequirement, ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20);
+    if (erc20balance && erc20balance.balance.gte(bridgeRequirement.amount)) {
+        const bridgeFees = $fa9ac5bfdbbf9dfa$var$constructFees(gasForApproval, bridgeFeeEstimate.gasFee, bridgeFeeEstimate.bridgeFee);
+        return $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute(chainId, erc20balance, bridgeRequirement, ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20, bridgeFees);
+    }
     return undefined;
 };
 
@@ -30762,18 +30970,30 @@ const $62e968a3dd87940e$export$8059963805b7876c = (dexQuote, tokenAddress)=>{
     }
     return fees;
 };
-// The token that is being bridged may also be a balance requirement
-// Since this token is going to be swapped after bridging then get the
-// balance requirement amount so this can be considered when bridging
-// enough of the token across
-const $62e968a3dd87940e$var$getAmountFromBalanceRequirement = (balanceRequirements, tokenAddress)=>{
-    let amount = (BigNumber$1).from(0);
-    balanceRequirements.balanceRequirements.forEach((requirement)=>{
-        if (requirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE || requirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) {
-            if (requirement.required.token.address === tokenAddress) amount = amount.add(requirement.required.balance);
-        }
-    });
-    return amount;
+const $62e968a3dd87940e$export$fffeb24f5d2b8b2e = (balanceRequirements, quotedTokenAddress)=>{
+    // Find if there is an existing balance requirement of the token attempting to be bridged->swapped
+    for (const requirement of balanceRequirements.balanceRequirements)if (requirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE || requirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) {
+        if (requirement.required.token.address === quotedTokenAddress) return requirement.required.balance;
+    }
+    return (BigNumber$1).from(0);
+};
+const $62e968a3dd87940e$export$f3586982c925f01 = (quotedAmountWithFees, amountFromBalanceRequirement, l2balance)=>{
+    const balance = l2balance?.balance ?? (BigNumber$1).from(0);
+    // Balance is fully covered and does not require bridging
+    // then the one swap route will be suggested
+    if (balance.gte(quotedAmountWithFees.add(amountFromBalanceRequirement))) return (BigNumber$1).from(0);
+    // If no balance on L2 then bridge full amount and balance requirement amount if any
+    if (balance.lte(0)) return quotedAmountWithFees.add(amountFromBalanceRequirement);
+    // Get the remainder from the balance after subtracting the balance requirement amount
+    const remainder = balance.sub(amountFromBalanceRequirement);
+    // Remove the remainder from the amount needed as the user has some balance left over
+    // after covering the balance requirement or the remainder is 0 indicating they have
+    // just enough to cover the balance requirement
+    if (remainder.gte(0)) return quotedAmountWithFees.sub(remainder);
+    // If the remainder is less than 0 then add the quoted amount with the balance requirement
+    // and sub the users current balance to get the total amount needed to be bridged to cover
+    // the quoted amount + balance requirement
+    return quotedAmountWithFees.add(amountFromBalanceRequirement).sub(balance);
 };
 const $62e968a3dd87940e$export$df667c749c93b110 = (dexQuotes, l1balances, l2balances, l1tol2addresses, balanceRequirements)=>{
     const bridgeRequirements = [];
@@ -30794,15 +31014,16 @@ const $62e968a3dd87940e$export$df667c749c93b110 = (dexQuotes, l1balances, l2bala
         const quotedAmount = quote.quote.amountWithMaxSlippage.value;
         // Add fees to the quoted amount if the fees are in the same token as the token being swapped
         const fees = $62e968a3dd87940e$export$8059963805b7876c(quote, tokenAddress);
-        // If the token being bridged is a balance requirement then add this to the total
-        // to ensure when its swapped the balance requirement can still be fulfilled
-        const balanceRequirementAmount = $62e968a3dd87940e$var$getAmountFromBalanceRequirement(balanceRequirements, tokenAddress);
-        // Add all the amounts together
-        const totalAmount = quotedAmount.add(fees).add(balanceRequirementAmount);
-        // Subtract any L2 balance from the total amount to only bridge the necessary amount
-        const amountToBridge = l2balance ? totalAmount.sub(l2balance.balance) : totalAmount;
+        const quotedAmountWithFees = quotedAmount.add(fees);
+        // Get the amount from the balance requirement if the token is also a balance requirement
+        const amountFromBalanceRequirement = $62e968a3dd87940e$export$fffeb24f5d2b8b2e(balanceRequirements, tokenAddress);
+        // Get the amount to bridge factoring in any balance requirements for this swappable token
+        // and the current balance on L2
+        const amountToBridge = $62e968a3dd87940e$export$f3586982c925f01(quotedAmountWithFees, amountFromBalanceRequirement, l2balance);
+        // No amount to bridge as user has sufficient balance for one swap
         if (amountToBridge.lte(0)) continue;
-        if (amountToBridge.gt(l1balance.balance)) continue;
+        // If the amount to bridge is greater than the L1 balance then cannot bridge
+        if (amountToBridge.gte(l1balance.balance)) continue;
         bridgeRequirements.push({
             amount: amountToBridge,
             formattedAmount: (utils$1).formatUnits(amountToBridge, l1balance.token.decimals),
@@ -30993,7 +31214,7 @@ const $afd57acae9471ac5$export$f95ed27e871fe308 = async (config, readOnlyProvide
     // Modify the users L2 balance to include the amount as if the user successfully bridged
     const modifiedTokenBalances = $afd57acae9471ac5$var$modifyTokenBalancesWithBridgedAmount(config, tokenBalances, l2balances, bridgedTokens, swappableTokens);
     // Call the swap route with the faked bridged balances
-    const swapRoutes = await ($91807edfd7057288$export$8e03ea04d59f2402)(config, availableRoutingOptions, dexQuoteCache, ownerAddress, insufficientRequirement, modifiedTokenBalances, swappableTokensAfterBridging);
+    const swapRoutes = await ($91807edfd7057288$export$8e03ea04d59f2402)(config, availableRoutingOptions, dexQuoteCache, ownerAddress, insufficientRequirement, modifiedTokenBalances, swappableTokensAfterBridging, balanceRequirements);
     if (!swapRoutes) return [];
     const originalBalanceSwapRoutes = $afd57acae9471ac5$export$1fc63300bde5e690(tokenBalances, swapRoutes);
     return $afd57acae9471ac5$export$d9b96654eebdaf2a(bridgeResults, originalBalanceSwapRoutes, l1tol2Addresses);
@@ -31058,7 +31279,7 @@ const $c16168a9c28ae4fd$export$ab86023c267660 = async (config, readOnlyProviders
     if (availableRoutingOptions.bridge && insufficientRequirement) bridgeFundingStep = await ($fa9ac5bfdbbf9dfa$export$ddc7ba2b57d7c5fa)(config, readOnlyProviders, ownerAddress, availableRoutingOptions, bridgeRequirement, tokenBalances, feeEstimates);
     return bridgeFundingStep;
 };
-const $c16168a9c28ae4fd$export$814624e957fa0f11 = async (config, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, swapTokenAllowList)=>{
+const $c16168a9c28ae4fd$export$814624e957fa0f11 = async (config, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, swapTokenAllowList, balanceRequirements)=>{
     const fundingSteps = [];
     if (!availableRoutingOptions.swap) return fundingSteps;
     if (insufficientRequirement === undefined) return fundingSteps;
@@ -31069,7 +31290,7 @@ const $c16168a9c28ae4fd$export$814624e957fa0f11 = async (config, availableRoutin
     if (swapTokenAllowList.length === 0) return fundingSteps;
     const swappableTokens = swapTokenAllowList.filter((token)=>token.address).map((token)=>token.address);
     if (swappableTokens.length === 0) return fundingSteps;
-    return await ($91807edfd7057288$export$8e03ea04d59f2402)(config, availableRoutingOptions, dexQuoteCache, ownerAddress, insufficientRequirement, tokenBalances, swappableTokens);
+    return await ($91807edfd7057288$export$8e03ea04d59f2402)(config, availableRoutingOptions, dexQuoteCache, ownerAddress, insufficientRequirement, tokenBalances, swappableTokens, balanceRequirements);
 };
 const $c16168a9c28ae4fd$export$2becd43da9d21f73 = async (config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, tokenAllowList, feeEstimates, balanceRequirements)=>{
     if (!insufficientRequirement) return [];
@@ -31121,7 +31342,7 @@ const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, b
     const insufficientRequirement = $c16168a9c28ae4fd$export$31ce7ba1a2956195(balanceRequirements);
     const routePromises = [];
     routePromises.push($c16168a9c28ae4fd$export$ab86023c267660(config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, ownerAddress, tokenBalances, feeEstimates));
-    routePromises.push($c16168a9c28ae4fd$export$814624e957fa0f11(config, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, allowList.swap));
+    routePromises.push($c16168a9c28ae4fd$export$814624e957fa0f11(config, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, allowList.swap, balanceRequirements));
     routePromises.push($c16168a9c28ae4fd$export$e1b6e4d22d0365ee(config, availableRoutingOptions, insufficientRequirement));
     routePromises.push($c16168a9c28ae4fd$export$2becd43da9d21f73(config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, allowList, feeEstimates, balanceRequirements));
     const resolved = await Promise.all(routePromises);
@@ -31150,22 +31371,7 @@ const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, b
             priority: priority,
             steps: [
                 bridgeFundingStep
-            ],
-            // WT-1734 - Add fees
-            totalFees: {
-                gas: {
-                    amount: (BigNumber$1).from(0),
-                    formattedAmount: "0"
-                },
-                other: {
-                    amount: (BigNumber$1).from(0),
-                    formattedAmount: "0"
-                },
-                total: {
-                    amount: (BigNumber$1).from(0),
-                    formattedAmount: "0"
-                }
-            }
+            ]
         });
     }
     if (swapFundingSteps.length > 0) {
@@ -31175,22 +31381,7 @@ const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, b
                 priority: priority,
                 steps: [
                     swapFundingStep
-                ],
-                // WT-1734 - Add fees
-                totalFees: {
-                    gas: {
-                        amount: (BigNumber$1).from(0),
-                        formattedAmount: "0"
-                    },
-                    other: {
-                        amount: (BigNumber$1).from(0),
-                        formattedAmount: "0"
-                    },
-                    total: {
-                        amount: (BigNumber$1).from(0),
-                        formattedAmount: "0"
-                    }
-                }
+                ]
             });
         });
     }
@@ -31213,22 +31404,7 @@ const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, b
                 steps: [
                     bridgeStep,
                     swapStep
-                ],
-                // WT-1734 - Add fees
-                totalFees: {
-                    gas: {
-                        amount: (BigNumber$1).from(0),
-                        formattedAmount: "0"
-                    },
-                    other: {
-                        amount: (BigNumber$1).from(0),
-                        formattedAmount: "0"
-                    },
-                    total: {
-                        amount: (BigNumber$1).from(0),
-                        formattedAmount: "0"
-                    }
-                }
+                ]
             });
         });
     }
@@ -32073,10 +32249,12 @@ var checkout_sdk = /*#__PURE__*/Object.freeze({
     get CheckoutErrorType () { return $a8bc256d81a5e2c1$export$e3dc0620abde7f5a; },
     get CheckoutStatus () { return $4b58188d47aafe8d$export$de7bcda3c490bf18; },
     get ExchangeType () { return $e055e79256bbc1dd$export$80f4da0d409a629d; },
+    get FundingStepType () { return $4b58188d47aafe8d$export$6fbaa98ee06d03e8; },
     get GasEstimateType () { return $de275b98d2b651c3$export$788b1fd17f3dad84; },
     get GasTokenType () { return $4b58188d47aafe8d$export$537fa3efd10ed435; },
     get ItemType () { return $4b58188d47aafe8d$export$1fc8f52ad1810e52; },
     get NetworkFilterTypes () { return $a47e48dd2c04791b$export$1f05a55fe0680cc7; },
+    get RoutingOutcomeType () { return $4b58188d47aafe8d$export$d0616bd3e995b8be; },
     get TokenFilterTypes () { return $08d5ddc39acd6833$export$fd9b17d87f4121d2; },
     get TransactionOrGasType () { return $4b58188d47aafe8d$export$65c64e46348ee3c1; },
     get WalletFilterTypes () { return $4f91c5f280efe242$export$a75605c67ea83a5a; },
@@ -32107,7 +32285,7 @@ var $045213b18e9f1f94$export$75be0f6af9650f2c;
 })($045213b18e9f1f94$export$75be0f6af9650f2c || ($045213b18e9f1f94$export$75be0f6af9650f2c = {}));
 
 
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.23.0-alpha";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.23.2-alpha.1";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;