@imtbl/sdk 0.20.1 → 0.22.0-alpha.1

package/dist/checkout_sdk.js

@@ -16167,8 +16167,8 @@ var Fee;
 (function (Fee) {
     (function (fee_type) {
         fee_type["ROYALTY"] = "ROYALTY";
-        fee_type["MAKER_MARKETPLACE"] = "MAKER_MARKETPLACE";
-        fee_type["TAKER_MARKETPLACE"] = "TAKER_MARKETPLACE";
+        fee_type["MAKER_ECOSYSTEM"] = "MAKER_ECOSYSTEM";
+        fee_type["TAKER_ECOSYSTEM"] = "TAKER_ECOSYSTEM";
         fee_type["PROTOCOL"] = "PROTOCOL";
     })(Fee.fee_type || (Fee.fee_type = {}));
 })(Fee || (Fee = {}));
@@ -16201,8 +16201,8 @@ var ProtocolData;
 
 var FeeType;
 (function (FeeType) {
-    FeeType["MAKER_MARKETPLACE"] = "MAKER_MARKETPLACE";
-    FeeType["TAKER_MARKETPLACE"] = "TAKER_MARKETPLACE";
+    FeeType["MAKER_ECOSYSTEM"] = "MAKER_ECOSYSTEM";
+    FeeType["TAKER_ECOSYSTEM"] = "TAKER_ECOSYSTEM";
     FeeType["PROTOCOL"] = "PROTOCOL";
     FeeType["ROYALTY"] = "ROYALTY";
 })(FeeType || (FeeType = {}));
@@ -16259,8 +16259,8 @@ function mapFromOpenApiOrder(order) {
             type: fee.fee_type,
         })),
         chain: order.chain,
-        createTime: order.create_time,
-        endTime: order.end_time,
+        createdAt: order.created_at,
+        endAt: order.end_at,
         protocolData: {
             counter: order.protocol_data.counter,
             orderType: order.protocol_data.order_type,
@@ -16270,9 +16270,9 @@ function mapFromOpenApiOrder(order) {
         },
         salt: order.salt,
         signature: order.signature,
-        startTime: order.start_time,
+        startAt: order.start_at,
         status: order.status,
-        updateTime: order.update_time,
+        updatedAt: order.updated_at,
     };
 }
 function mapFromOpenApiTrade(trade) {
@@ -16475,8 +16475,8 @@ function mapImmutableOrderToSeaportOrderComponents(order, counter, zoneAddress)
                 };
             }),
             counter,
-            endTime: Math.round(new Date(order.end_time).getTime() / 1000).toString(),
-            startTime: Math.round(new Date(order.start_time).getTime() / 1000).toString(),
+            endTime: Math.round(new Date(order.end_at).getTime() / 1000).toString(),
+            startTime: Math.round(new Date(order.start_at).getTime() / 1000).toString(),
             salt: order.salt,
             offerer: order.account_address,
             zone: zoneAddress,
@@ -16704,10 +16704,10 @@ class ImmutableApiClient {
                 ],
                 fees: makerFees.map((x) => ({
                     amount: x.amount,
-                    fee_type: FeeType.MAKER_MARKETPLACE,
+                    fee_type: FeeType.MAKER_ECOSYSTEM,
                     recipient: x.recipient,
                 })),
-                end_time: new Date(parseInt(`${orderComponents.endTime.toString()}000`, 10)).toISOString(),
+                end_at: new Date(parseInt(`${orderComponents.endTime.toString()}000`, 10)).toISOString(),
                 protocol_data: {
                     order_type: ProtocolData.order_type.FULL_RESTRICTED,
                     zone_address: orderComponents.zone,
@@ -16724,7 +16724,7 @@ class ImmutableApiClient {
                     },
                 ],
                 signature: orderSignature,
-                start_time: new Date(parseInt(`${orderComponents.startTime.toString()}000`, 10)).toISOString(),
+                start_at: new Date(parseInt(`${orderComponents.startTime.toString()}000`, 10)).toISOString(),
             },
         });
     }
@@ -16917,16 +16917,19 @@ class Orderbook {
                 order_id: listingId,
                 fees: takerFees.map((fee) => ({
                     amount: fee.amount,
-                    fee_type: FeeType.TAKER_MARKETPLACE,
+                    fee_type: FeeType.TAKER_ECOSYSTEM,
                     recipient: fee.recipient,
                 })),
             },
         ]);
-        if (fulfillmentDataRes.result.length !== 1) {
-            throw new Error('unexpected fulfillment data result length');
+        if (fulfillmentDataRes.result.unfulfillable_orders?.length > 0) {
+            throw new Error(`Unable to prepare fulfillment date: ${fulfillmentDataRes.result.unfulfillable_orders[0].reason}`);
         }
-        const extraData = fulfillmentDataRes.result[0].extra_data;
-        const orderResult = fulfillmentDataRes.result[0].order;
+        else if (fulfillmentDataRes.result.fulfillable_orders?.length !== 1) {
+            throw new Error('unexpected fulfillable order result length');
+        }
+        const extraData = fulfillmentDataRes.result.fulfillable_orders[0].extra_data;
+        const orderResult = fulfillmentDataRes.result.fulfillable_orders[0].order;
         if (orderResult.status !== OrderStatus$1.ACTIVE) {
             throw new Error(`Cannot fulfil order that is not active. Current status: ${orderResult.status}`);
         }
@@ -17039,6 +17042,18 @@ const assertParamExists = function (functionName, paramName, paramValue) {
         throw new RequiredError(paramName, `Required parameter ${paramName} was null or undefined when calling ${functionName}.`);
     }
 };
+/**
+ *
+ * @export
+ */
+const setApiKeyToObject = async function (object, keyParamName, configuration) {
+    if (configuration && configuration.apiKey) {
+        const localVarApiKeyValue = typeof configuration.apiKey === 'function'
+            ? await configuration.apiKey(keyParamName)
+            : await configuration.apiKey;
+        object[keyParamName] = localVarApiKeyValue;
+    }
+};
 /**
  *
  * @export
@@ -17588,6 +17603,46 @@ const CollectionsApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Refresh collection metadata
+         * @summary Refresh collection metadata
+         * @param {string} contractAddress The address contract
+         * @param {string} chainName The name of chain
+         * @param {RefreshCollectionMetadataRequest} refreshCollectionMetadataRequest The request body
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        refreshCollectionMetadata: async (contractAddress, chainName, refreshCollectionMetadataRequest, options = {}) => {
+            // verify required parameter 'contractAddress' is not null or undefined
+            assertParamExists('refreshCollectionMetadata', 'contractAddress', contractAddress);
+            // verify required parameter 'chainName' is not null or undefined
+            assertParamExists('refreshCollectionMetadata', 'chainName', chainName);
+            // verify required parameter 'refreshCollectionMetadataRequest' is not null or undefined
+            assertParamExists('refreshCollectionMetadata', 'refreshCollectionMetadataRequest', refreshCollectionMetadataRequest);
+            const localVarPath = `/v1/chains/{chain_name}/collections/{contract_address}/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);
+            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(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(refreshCollectionMetadataRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
     };
 };
 /**
@@ -17636,6 +17691,19 @@ const CollectionsApiFp = function (configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.listCollectionsByNFTOwner(accountAddress, chainName, pageCursor, pageSize, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Refresh collection metadata
+         * @summary Refresh collection metadata
+         * @param {string} contractAddress The address contract
+         * @param {string} chainName The name of chain
+         * @param {RefreshCollectionMetadataRequest} refreshCollectionMetadataRequest The request body
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async refreshCollectionMetadata(contractAddress, chainName, refreshCollectionMetadataRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.refreshCollectionMetadata(contractAddress, chainName, refreshCollectionMetadataRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
     };
 };
 /**
@@ -17681,6 +17749,18 @@ const CollectionsApiFactory = function (configuration, basePath, axios) {
         listCollectionsByNFTOwner(accountAddress, chainName, pageCursor, pageSize, options) {
             return localVarFp.listCollectionsByNFTOwner(accountAddress, chainName, pageCursor, pageSize, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Refresh collection metadata
+         * @summary Refresh collection metadata
+         * @param {string} contractAddress The address contract
+         * @param {string} chainName The name of chain
+         * @param {RefreshCollectionMetadataRequest} refreshCollectionMetadataRequest The request body
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        refreshCollectionMetadata(contractAddress, chainName, refreshCollectionMetadataRequest, options) {
+            return localVarFp.refreshCollectionMetadata(contractAddress, chainName, refreshCollectionMetadataRequest, options).then((request) => request(axios, basePath));
+        },
     };
 };
 /**
@@ -17723,6 +17803,210 @@ class CollectionsApi extends BaseAPI {
     listCollectionsByNFTOwner(requestParameters, options) {
         return CollectionsApiFp(this.configuration).listCollectionsByNFTOwner(requestParameters.accountAddress, requestParameters.chainName, requestParameters.pageCursor, requestParameters.pageSize, options).then((request) => request(this.axios, this.basePath));
     }
+    /**
+     * Refresh collection metadata
+     * @summary Refresh collection metadata
+     * @param {CollectionsApiRefreshCollectionMetadataRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof CollectionsApi
+     */
+    refreshCollectionMetadata(requestParameters, options) {
+        return CollectionsApiFp(this.configuration).refreshCollectionMetadata(requestParameters.contractAddress, requestParameters.chainName, requestParameters.refreshCollectionMetadataRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+}
+
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Immutable zkEVM API
+ * Immutable Multi Rollup API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@immutable.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * MetadataApi - axios parameter creator
+ * @export
+ */
+const MetadataApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         * Get a single metadata by ID
+         * @summary Get a single metadata by ID
+         * @param {string} chainName The name of chain
+         * @param {string} contractAddress The address of metadata contract
+         * @param {string} metadataId The id of the metadata
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getMetadata: async (chainName, contractAddress, metadataId, options = {}) => {
+            // verify required parameter 'chainName' is not null or undefined
+            assertParamExists('getMetadata', 'chainName', chainName);
+            // verify required parameter 'contractAddress' is not null or undefined
+            assertParamExists('getMetadata', 'contractAddress', contractAddress);
+            // verify required parameter 'metadataId' is not null or undefined
+            assertParamExists('getMetadata', 'metadataId', metadataId);
+            const localVarPath = `/v1/chains/{chain_name}/collections/{contract_address}/metadata/{metadata_id}`
+                .replace(`{${"chain_name"}}`, encodeURIComponent(String(chainName)))
+                .replace(`{${"contract_address"}}`, encodeURIComponent(String(contractAddress)))
+                .replace(`{${"metadata_id"}}`, encodeURIComponent(String(metadataId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Refresh shared metadata for a collection
+         * @param {string} chainName The name of chain
+         * @param {string} contractAddress Contract address
+         * @param {RefreshMetadataByIDRequest} refreshMetadataByIDRequest NFT Metadata Refresh Request
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        refreshMetadataByID: async (chainName, contractAddress, refreshMetadataByIDRequest, options = {}) => {
+            // verify required parameter 'chainName' is not null or undefined
+            assertParamExists('refreshMetadataByID', 'chainName', chainName);
+            // verify required parameter 'contractAddress' is not null or undefined
+            assertParamExists('refreshMetadataByID', 'contractAddress', contractAddress);
+            // verify required parameter 'refreshMetadataByIDRequest' is not null or undefined
+            assertParamExists('refreshMetadataByID', 'refreshMetadataByIDRequest', refreshMetadataByIDRequest);
+            const localVarPath = `/v1/chains/{chain_name}/collections/{contract_address}/metadata/refresh-metadata`
+                .replace(`{${"chain_name"}}`, encodeURIComponent(String(chainName)))
+                .replace(`{${"contract_address"}}`, encodeURIComponent(String(contractAddress)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            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(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(refreshMetadataByIDRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    };
+};
+/**
+ * MetadataApi - functional programming interface
+ * @export
+ */
+const MetadataApiFp = function (configuration) {
+    const localVarAxiosParamCreator = MetadataApiAxiosParamCreator(configuration);
+    return {
+        /**
+         * Get a single metadata by ID
+         * @summary Get a single metadata by ID
+         * @param {string} chainName The name of chain
+         * @param {string} contractAddress The address of metadata contract
+         * @param {string} metadataId The id of the metadata
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getMetadata(chainName, contractAddress, metadataId, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getMetadata(chainName, contractAddress, metadataId, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Refresh shared metadata for a collection
+         * @param {string} chainName The name of chain
+         * @param {string} contractAddress Contract address
+         * @param {RefreshMetadataByIDRequest} refreshMetadataByIDRequest NFT Metadata Refresh Request
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async refreshMetadataByID(chainName, contractAddress, refreshMetadataByIDRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.refreshMetadataByID(chainName, contractAddress, refreshMetadataByIDRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+    };
+};
+/**
+ * MetadataApi - factory interface
+ * @export
+ */
+const MetadataApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = MetadataApiFp(configuration);
+    return {
+        /**
+         * Get a single metadata by ID
+         * @summary Get a single metadata by ID
+         * @param {string} chainName The name of chain
+         * @param {string} contractAddress The address of metadata contract
+         * @param {string} metadataId The id of the metadata
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getMetadata(chainName, contractAddress, metadataId, options) {
+            return localVarFp.getMetadata(chainName, contractAddress, metadataId, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Refresh shared metadata for a collection
+         * @param {string} chainName The name of chain
+         * @param {string} contractAddress Contract address
+         * @param {RefreshMetadataByIDRequest} refreshMetadataByIDRequest NFT Metadata Refresh Request
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        refreshMetadataByID(chainName, contractAddress, refreshMetadataByIDRequest, options) {
+            return localVarFp.refreshMetadataByID(chainName, contractAddress, refreshMetadataByIDRequest, options).then((request) => request(axios, basePath));
+        },
+    };
+};
+/**
+ * MetadataApi - object-oriented interface
+ * @export
+ * @class MetadataApi
+ * @extends {BaseAPI}
+ */
+class MetadataApi extends BaseAPI {
+    /**
+     * Get a single metadata by ID
+     * @summary Get a single metadata by ID
+     * @param {MetadataApiGetMetadataRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MetadataApi
+     */
+    getMetadata(requestParameters, options) {
+        return MetadataApiFp(this.configuration).getMetadata(requestParameters.chainName, requestParameters.contractAddress, requestParameters.metadataId, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Refresh shared metadata for a collection
+     * @param {MetadataApiRefreshMetadataByIDRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MetadataApi
+     */
+    refreshMetadataByID(requestParameters, options) {
+        return MetadataApiFp(this.configuration).refreshMetadataByID(requestParameters.chainName, requestParameters.contractAddress, requestParameters.refreshMetadataByIDRequest, options).then((request) => request(this.axios, this.basePath));
+    }
 }
 
 /* tslint:disable */
@@ -18363,7 +18647,7 @@ const OrdersApiAxiosParamCreator = function (configuration) {
          * @param {string} chainName
          * @param {string} [accountAddress]
          * @param {number} [pageSize] Maximum number of trades to return per page
-         * @param {'created_at'} [sortBy] Trade field to sort by
+         * @param {'indexed_at'} [sortBy] Trade field to sort by
          * @param {'asc' | 'desc'} [sortDirection] Ascending or descending direction for sort
          * @param {string} [pageCursor] Page cursor to retrieve previous or next page. Use the value returned in the response.
          * @param {*} [options] Override http request option.
@@ -18488,7 +18772,7 @@ const OrdersApiFp = function (configuration) {
          * @param {string} chainName
          * @param {string} [accountAddress]
          * @param {number} [pageSize] Maximum number of trades to return per page
-         * @param {'created_at'} [sortBy] Trade field to sort by
+         * @param {'indexed_at'} [sortBy] Trade field to sort by
          * @param {'asc' | 'desc'} [sortDirection] Ascending or descending direction for sort
          * @param {string} [pageCursor] Page cursor to retrieve previous or next page. Use the value returned in the response.
          * @param {*} [options] Override http request option.
@@ -18575,7 +18859,7 @@ const OrdersApiFactory = function (configuration, basePath, axios) {
          * @param {string} chainName
          * @param {string} [accountAddress]
          * @param {number} [pageSize] Maximum number of trades to return per page
-         * @param {'created_at'} [sortBy] Trade field to sort by
+         * @param {'indexed_at'} [sortBy] Trade field to sort by
          * @param {'asc' | 'desc'} [sortDirection] Ascending or descending direction for sort
          * @param {string} [pageCursor] Page cursor to retrieve previous or next page. Use the value returned in the response.
          * @param {*} [options] Override http request option.
@@ -19481,6 +19765,10 @@ var index = /*#__PURE__*/Object.freeze({
     ERC20ItemItemTypeEnum: ERC20ItemItemTypeEnum,
     ERC721ItemItemTypeEnum: ERC721ItemItemTypeEnum,
     FeeFeeTypeEnum: FeeFeeTypeEnum,
+    MetadataApi: MetadataApi,
+    MetadataApiAxiosParamCreator: MetadataApiAxiosParamCreator,
+    MetadataApiFactory: MetadataApiFactory,
+    MetadataApiFp: MetadataApiFp,
     NFTContractType: NFTContractType,
     NativeItemItemTypeEnum: NativeItemItemTypeEnum,
     NftOwnersApi: NftOwnersApi,
@@ -19528,7 +19816,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.20.1',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.22.0-alpha.1',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -20303,14 +20591,16 @@ var $e055e79256bbc1dd$export$80f4da0d409a629d;
     CheckoutErrorType["CANCEL_ORDER_LISTING_ERROR"] = "CANCEL_ORDER_LISTING_ERROR";
     CheckoutErrorType["PREPARE_ORDER_LISTING_ERROR"] = "PREPARE_ORDER_LISTING_ERROR";
     CheckoutErrorType["CREATE_ORDER_LISTING_ERROR"] = "CREATE_ORDER_LISTING_ERROR";
+    CheckoutErrorType["FULFILL_ORDER_LISTING_ERROR"] = "FULFILL_ORDER_LISTING_ERROR";
     CheckoutErrorType["SWITCH_NETWORK_UNSUPPORTED"] = "SWITCH_NETWORK_UNSUPPORTED";
     CheckoutErrorType["GET_ERC20_ALLOWANCE_ERROR"] = "GET_ERC20_ALLOWANCE_ERROR";
     CheckoutErrorType["GET_ERC721_ALLOWANCE_ERROR"] = "GET_ERC721_ALLOWANCE_ERROR";
     CheckoutErrorType["EXECUTE_APPROVAL_TRANSACTION_ERROR"] = "EXECUTE_APPROVAL_TRANSACTION_ERROR";
-    CheckoutErrorType["EXECUTE_FULFILMENT_TRANSACTION_ERROR"] = "EXECUTE_FULFILMENT_TRANSACTION_ERROR";
+    CheckoutErrorType["EXECUTE_FULFILLMENT_TRANSACTION_ERROR"] = "EXECUTE_FULFILLMENT_TRANSACTION_ERROR";
     CheckoutErrorType["SIGN_MESSAGE_ERROR"] = "SIGN_MESSAGE_ERROR";
     CheckoutErrorType["BRIDGE_GAS_ESTIMATE_ERROR"] = "BRIDGE_GAS_ESTIMATE_ERROR";
     CheckoutErrorType["ORDER_FEE_ERROR"] = "ORDER_FEE_ERROR";
+    CheckoutErrorType["ITEM_REQUIREMENTS_ERROR"] = "ITEM_REQUIREMENTS_ERROR";
 })($a8bc256d81a5e2c1$export$e3dc0620abde7f5a || ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a = {}));
 class $a8bc256d81a5e2c1$export$b722478a3cbfa3bc extends Error {
     message;
@@ -21164,6 +21454,12 @@ function $67fc622a2b913d5f$export$436dd76f23f463ff(config) {
 
 
 
+function $06a6c5c23f7f2479$export$fbbc17f6e6e58544(address, contractInterface, signerOrProvider) {
+    return new (Contract$1)(address, contractInterface, signerOrProvider);
+}
+
+
+
 
 
 const $2e7bf45a7c9a9570$var$DUMMY_WALLET_ADDRESS = "0x0000000000000000000000000000000000000001";
@@ -21891,7 +22187,7 @@ const $7d1bfafb81e64d74$export$3a4140bd9e983e4e = async (provider, insufficientI
         if (item.approvalTransaction === undefined) continue;
         estimateGasPromises.push($7d1bfafb81e64d74$export$e0580ae1f48db848(provider, item.approvalTransaction));
     }
-    // If the transaction is a fulfilment transaction get the estimate gas promise
+    // If the transaction is a fulfillment transaction get the estimate gas promise
     // Otherwise use the gas amount with the limit to estimate the gas
     if (transactionOrGas.type === ($4b58188d47aafe8d$export$65c64e46348ee3c1).TRANSACTION) estimateGasPromises.push($7d1bfafb81e64d74$export$e0580ae1f48db848(provider, transactionOrGas.transaction));
     else {
@@ -21951,6 +22247,7 @@ const $7f2e17f026d4fc8d$export$f1ca3744c025ab81 = async (config, provider)=>{
 
 
 
+
 var $b23305044c0e096a$export$3057de18ac0c076;
 (function(RouteCalculatorType) {
     RouteCalculatorType["ROUTES_FOUND"] = "ROUTES_FOUND";
@@ -22012,83 +22309,195 @@ const $33acec7b4a26c053$export$23ddeb2642d2f9d = async (config, readOnlyProvider
 };
 
 
-/* eslint-disable @typescript-eslint/no-unused-vars */ 
 
 
 
-const $f730af3b727f04ac$export$22fea095b15361de = (balances)=>{
-    for (const balance of balances.balances){
-        if (!balance.token.address || balance.token.address === "") return balance.balance;
-    }
-    return (BigNumber$1).from(0);
-};
+
+async function $0e0060cb42e136d2$export$339cb2be73677b30(config, existingReadOnlyProviders) {
+    if (config.isProduction && existingReadOnlyProviders?.has(($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM)) return existingReadOnlyProviders;
+    if (existingReadOnlyProviders?.has(($0472f23319457bfb$export$c06e1e7429de6283).SEPOLIA)) return existingReadOnlyProviders;
+    const readOnlyProviders = new Map();
+    const allowedNetworks = await $de192de6ef100f9f$export$3043f6442a9ef563(config, {
+        type: ($a47e48dd2c04791b$export$1f05a55fe0680cc7).ALL
+    });
+    allowedNetworks.networks.forEach((networkInfo)=>{
+        const rpcUrl = config.networkMap.get(networkInfo.chainId)?.rpcUrls[0];
+        const provider = new (JsonRpcProvider)(rpcUrl);
+        readOnlyProviders.set(networkInfo.chainId, provider);
+    });
+    return readOnlyProviders;
+}
 
 
 
 
 
 
-const $8a49d1a3783a2640$export$3aff971444a4f244 = async (config, readOnlyProviders)=>{
+
+
+const $049bba630af05555$export$6946a1f17c2bbf26 = async (config, chainId, walletAddress, requiredToken, swappableTokens)=>{
+    const dexQuotes = new Map();
+    // Apply a small slippage percent as a buffer to cover price fluctuations between token pairs
+    const slippagePercent = 1;
     try {
-        const estimate = await (0, $2e7bf45a7c9a9570$export$942c8de7174809fc)({
-            gasEstimateType: (0, $de275b98d2b651c3$export$788b1fd17f3dad84).BRIDGE_TO_L2,
-            isSpendingCapApprovalRequired: false
-        }, readOnlyProviders, config);
-        const gasEstimate = estimate.gasFee.estimatedAmount;
-        const bridgeFee = estimate.bridgeFee.estimatedAmount;
-        let totalFees = (0, BigNumber$1).from(0);
-        if (gasEstimate) totalFees = totalFees.add(gasEstimate);
-        if (bridgeFee) totalFees = totalFees.add(bridgeFee);
-        return totalFees;
-    } catch (err) {
-        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Error estimating gas for bridge", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).BRIDGE_GAS_ESTIMATE_ERROR, {
-            message: err.message
+        const exchange = await $67fc622a2b913d5f$export$7cf6178417769841(chainId, config);
+        const dexTransactionResponsePromises = [];
+        // Create a quote for each swappable token
+        for (const swappableToken of swappableTokens)dexTransactionResponsePromises.push(exchange.getUnsignedSwapTxFromAmountOut(walletAddress, swappableToken, requiredToken.address, requiredToken.amount, slippagePercent));
+        // Resolve all the quotes and link them back to the swappable token
+        // The swappable token array is in the same position in the array as the quote in the promise array
+        const dexTransactionResponse = await Promise.all(dexTransactionResponsePromises);
+        dexTransactionResponse.forEach((response, index)=>{
+            const swappableToken = swappableTokens[index];
+            dexQuotes.set(swappableToken, {
+                quote: response.quote,
+                approval: response.approval?.gasFeeEstimate,
+                swap: response.swap.gasFeeEstimate
+            });
         });
+        return dexQuotes;
+    } catch  {
+        return dexQuotes;
     }
 };
 
 
-
-const $823db9fb0ca4bc15$export$c37d8687c27b9660 = "0x0000000000000000000000000000000000000001";
-const $823db9fb0ca4bc15$export$1430626eec86fce9 = (chainId)=>{
-    if (chainId === ($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_TESTNET) return "imtbl-zkevm-testnet";
-    return "";
-};
-const $823db9fb0ca4bc15$export$53e663abd9b77fc1 = (chainId)=>{
-    if (chainId === ($0472f23319457bfb$export$c06e1e7429de6283).SEPOLIA) return "0x2Fa06C6672dDCc066Ab04631192738799231dE4a";
-    if (chainId === ($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM) return "0xF57e7e7C23978C3cAEC3C3548E3D615c346e79fF";
-    return "";
+const $3ee85f12225c19f3$export$fb80fe94a81a3132 = async (config, dexQuoteCache, walletAddress, requiredToken, swappableTokens)=>{
+    const dexQuotes = dexQuoteCache.get(requiredToken.address);
+    if (dexQuotes && dexQuotes.size > 0) return dexQuotes;
+    const quotes = await ($049bba630af05555$export$6946a1f17c2bbf26)(config, ($4013c5c91bb535f6$export$c9af4e4b001c6476)(config), walletAddress, requiredToken, swappableTokens);
+    dexQuoteCache.set(requiredToken.address, quotes);
+    return quotes;
 };
 
 
-
-
-
-
-
-const $07ac9c0576988336$export$7847f5f5cce25dfa = async (config, readOnlyProviders, l1provider, depositorAddress, fromChainId, toChainId, token, depositAmount)=>{
-    try {
-        const tokenBridge = await $67fc622a2b913d5f$export$989eefe1274a439c(fromChainId, toChainId, readOnlyProviders, config);
-        const { unsignedTx: unsignedTx } = await tokenBridge.getUnsignedApproveDepositBridgeTx({
-            depositorAddress: depositorAddress,
-            token: token,
-            depositAmount: depositAmount
-        });
-        if (unsignedTx === null) return (0, BigNumber$1).from(0);
-        return await l1provider.estimateGas(unsignedTx);
-    } catch (err) {
-        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Error occurred while attempting ot estimate gas for approval transaction", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).BRIDGE_GAS_ESTIMATE_ERROR, {
-            message: err.message
-        });
+const $91807edfd7057288$export$85e4d8628aabb217 = (balanceRequirement)=>{
+    let address = "";
+    let amount = (BigNumber$1).from(0);
+    switch(balanceRequirement.type){
+        case ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20:
+            address = balanceRequirement.required.token.address ?? "";
+            amount = balanceRequirement.delta.balance;
+            break;
+        case ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE:
+            address = ($d85ad1457a3f1a83$export$b80040cb173ba6e9);
+            amount = balanceRequirement.delta.balance;
+            break;
     }
+    return {
+        address: address,
+        amount: amount
+    };
 };
-const $07ac9c0576988336$export$a3dd181de896b7c7 = async (config, readOnlyProviders, l1provider, depositorAddress, l1Address, delta)=>{
-    if (l1Address === ($823db9fb0ca4bc15$export$c37d8687c27b9660)) return (BigNumber$1).from(0); // Native ETH does not require approval
-    const fromChainId = ($4013c5c91bb535f6$export$9b794d067cdd1af6)(config);
-    const toChainId = ($4013c5c91bb535f6$export$c9af4e4b001c6476)(config);
-    return await $07ac9c0576988336$export$7847f5f5cce25dfa(config, readOnlyProviders, l1provider, depositorAddress, fromChainId, toChainId, l1Address, delta);
+const $91807edfd7057288$export$7b6318fc1a8067b3 = (l2Balances, approval)=>{
+    // Check if approval required
+    if (!approval) return {
+        sufficient: true,
+        approvalGasFee: (BigNumber$1).from(0),
+        approvalGasTokenAddress: ""
+    };
+    const approvalGasFee = approval.value;
+    const approvalGasTokenAddress = approval.token.address;
+    // No balance on L2 to cover approval fees
+    if (l2Balances.length === 0) return {
+        sufficient: false,
+        approvalGasFee: approvalGasFee,
+        approvalGasTokenAddress: approvalGasTokenAddress
+    };
+    // Find the users balance of the approval token
+    const l2BalanceOfApprovalToken = l2Balances.find((balance)=>balance.token.address === approvalGasTokenAddress);
+    if (!l2BalanceOfApprovalToken) return {
+        sufficient: false,
+        approvalGasFee: approvalGasFee,
+        approvalGasTokenAddress: approvalGasTokenAddress
+    };
+    // If the user does not have enough of the token to cover approval fees then return sufficient false
+    if (l2BalanceOfApprovalToken.balance.lt(approvalGasFee)) return {
+        sufficient: false,
+        approvalGasFee: approvalGasFee,
+        approvalGasTokenAddress: approvalGasTokenAddress
+    };
+    // The user has enough to cover approval gas fees
+    return {
+        sufficient: true,
+        approvalGasFee: approvalGasFee,
+        approvalGasTokenAddress: approvalGasTokenAddress
+    };
+};
+const $91807edfd7057288$export$38077235fe748d40 = (l2Balances, swapFees, approvalFees, tokenBeingSwapped)=>{
+    // Set up a map of token addresses to amounts for each of the swap fees
+    const feeMap = new Map();
+    // Add the approval fee to list of fees
+    if (approvalFees.approvalGasTokenAddress !== "") feeMap.set(approvalFees.approvalGasTokenAddress, approvalFees.approvalGasFee);
+    // Add the token being swapped to list of fees to ensure the user can cover the fee + the token swap
+    if (tokenBeingSwapped) {
+        const fee = feeMap.get(tokenBeingSwapped.address);
+        if (fee) feeMap.set(tokenBeingSwapped.address, fee.add(tokenBeingSwapped.amount));
+        else feeMap.set(tokenBeingSwapped.address, tokenBeingSwapped.amount);
+    }
+    // Get all the fees and key them by their token id
+    for (const swapFee of swapFees){
+        const fee = feeMap.get(swapFee.amount.token.address);
+        if (fee) {
+            feeMap.set(swapFee.amount.token.address, fee.add(swapFee.amount.value));
+            continue;
+        }
+        feeMap.set(swapFee.amount.token.address, swapFee.amount.value);
+    }
+    // Go through the map and for each token address check if the user has enough balance to cover the fee
+    for (const [tokenAddress, fee] of feeMap.entries()){
+        if (fee === (BigNumber$1).from(0)) continue;
+        const l2BalanceOfFeeToken = l2Balances.find((balance)=>balance.token.address === tokenAddress);
+        if (!l2BalanceOfFeeToken) return false;
+        if (l2BalanceOfFeeToken.balance.lt(fee)) return false;
+    }
+    return true;
+};
+const $91807edfd7057288$export$8e03ea04d59f2402 = async (config, availableRoutingOptions, dexQuoteCache, walletAddress, balanceRequirement, tokenBalanceResults, swappableTokens)=>{
+    const fundingSteps = [];
+    if (!availableRoutingOptions.swap) return fundingSteps;
+    if (swappableTokens.length === 0) return fundingSteps;
+    const requiredToken = $91807edfd7057288$export$85e4d8628aabb217(balanceRequirement);
+    if (requiredToken.address === "") return fundingSteps;
+    const l2TokenBalanceResult = tokenBalanceResults.get(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
+    if (!l2TokenBalanceResult) return fundingSteps;
+    const l2Balances = l2TokenBalanceResult.balances;
+    if (l2Balances.length === 0) return fundingSteps;
+    const quotes = await ($3ee85f12225c19f3$export$fb80fe94a81a3132)(config, dexQuoteCache, walletAddress, requiredToken, swappableTokens);
+    const quoteTokenAddresses = Array.from(quotes.keys());
+    for (const quoteTokenAddress of quoteTokenAddresses){
+        const quote = quotes.get(quoteTokenAddress);
+        if (!quote) continue;
+        // Find the balance the user has for this quoted token
+        const userBalanceOfQuotedToken = l2Balances.find((balance)=>balance.token.address === quoteTokenAddress);
+        // If no balance found on L2 for this quoted token then continue
+        if (!userBalanceOfQuotedToken) continue;
+        // Check the amount of quoted token required against the user balance
+        const amountOfQuoteTokenRequired = quote.quote.amount;
+        // If user does not have enough balance to perform the swap with this token then continue
+        if (userBalanceOfQuotedToken.balance.lt(amountOfQuoteTokenRequired.value)) continue;
+        const approvalFees = $91807edfd7057288$export$7b6318fc1a8067b3(l2Balances, quote.approval);
+        // If user does not have enough to cover approval fees then continue
+        if (!approvalFees.sufficient) continue;
+        // If user does not have enough to cover swap fees then continue
+        if (!$91807edfd7057288$export$38077235fe748d40(l2Balances, quote.quote.fees, approvalFees, {
+            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({
+            type: ($4b58188d47aafe8d$export$3af78bb3e8650ee6).SWAP,
+            chainId: ($4013c5c91bb535f6$export$c9af4e4b001c6476)(config),
+            asset: {
+                balance: userBalanceOfQuotedToken.balance,
+                formattedBalance: userBalanceOfQuotedToken.formattedBalance,
+                token: userBalanceOfQuotedToken.token
+            }
+        });
+    }
+    return fundingSteps;
 };
-
 
 
 
@@ -22136,29 +22545,122 @@ const $5a5ccedc98d53d25$export$1ad29657d49c5440 = async (config, tokenBalances,
 };
 
 
-const $fa9ac5bfdbbf9dfa$export$9994ad18c2f0e665 = (balances, totalFees)=>{
-    const balance = ($f730af3b727f04ac$export$22fea095b15361de)(balances);
-    return balance.gte(totalFees);
+
+
+
+
+
+
+
+const $f730af3b727f04ac$export$22fea095b15361de = (balances)=>{
+    for (const balance of balances.balances){
+        if (!balance.token.address || balance.token.address === "") return balance.balance;
+    }
+    return (BigNumber$1).from(0);
+};
+
+
+
+
+
+
+const $8a49d1a3783a2640$export$3aff971444a4f244 = async (config, readOnlyProviders)=>{
+    try {
+        const estimate = await (0, $2e7bf45a7c9a9570$export$942c8de7174809fc)({
+            gasEstimateType: (0, $de275b98d2b651c3$export$788b1fd17f3dad84).BRIDGE_TO_L2,
+            isSpendingCapApprovalRequired: false
+        }, readOnlyProviders, config);
+        const gasEstimate = estimate.gasFee.estimatedAmount;
+        const bridgeFee = estimate.bridgeFee.estimatedAmount;
+        let totalFees = (0, BigNumber$1).from(0);
+        if (gasEstimate) totalFees = totalFees.add(gasEstimate);
+        if (bridgeFee) totalFees = totalFees.add(bridgeFee);
+        return totalFees;
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Error estimating gas for bridge", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).BRIDGE_GAS_ESTIMATE_ERROR, {
+            message: err.message
+        });
+    }
 };
-const $fa9ac5bfdbbf9dfa$export$97330fab5f794e7f = (balanceRequirement)=>{
-    if (balanceRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE) return $d85ad1457a3f1a83$export$b80040cb173ba6e9;
-    if (balanceRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) return balanceRequirement.required.token.address ?? "";
+
+
+
+
+
+
+
+
+
+const $887d24b47765b1c0$export$c37d8687c27b9660 = "0x0000000000000000000000000000000000000001";
+const $887d24b47765b1c0$export$1430626eec86fce9 = (chainId)=>{
+    if (chainId === ($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_TESTNET) return "imtbl-zkevm-testnet";
     return "";
 };
-const $fa9ac5bfdbbf9dfa$export$952cdf461a00a8c6 = async (config, balanceRequirement)=>{
-    const l2address = $fa9ac5bfdbbf9dfa$export$97330fab5f794e7f(balanceRequirement);
-    if (l2address === "") return "";
-    if (l2address === ($d85ad1457a3f1a83$export$b80040cb173ba6e9)) return ($823db9fb0ca4bc15$export$53e663abd9b77fc1)(($4013c5c91bb535f6$export$9b794d067cdd1af6)(config));
-    const chainName = ($823db9fb0ca4bc15$export$1430626eec86fce9)(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
-    if (chainName === "") return ""; // Chain name not a valid indexer chain name
+const $887d24b47765b1c0$export$53e663abd9b77fc1 = async (chainId, config)=>{
+    const imxMappingConfig = await config.remote.getConfig("imxAddressMapping");
+    return imxMappingConfig[chainId] ?? "";
+};
+const $887d24b47765b1c0$export$952cdf461a00a8c6 = async (config, l2address)=>{
+    if (l2address === "") return {
+        l1address: "",
+        l2address: l2address
+    };
+    if (l2address === ($d85ad1457a3f1a83$export$b80040cb173ba6e9)) return {
+        l1address: await $887d24b47765b1c0$export$53e663abd9b77fc1(($4013c5c91bb535f6$export$9b794d067cdd1af6)(config), config),
+        l2address: ($d85ad1457a3f1a83$export$b80040cb173ba6e9)
+    };
+    const chainName = $887d24b47765b1c0$export$1430626eec86fce9(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
+    if (chainName === "") return {
+        l1address: "",
+        l2address: l2address
+    }; // Chain name not a valid indexer chain name
     const blockchainData = ($67fc622a2b913d5f$export$436dd76f23f463ff)(config);
     const tokenData = await blockchainData.getToken({
         chainName: chainName,
         contractAddress: l2address
     });
     const l1address = tokenData.result.root_contract_address;
-    if (l1address === null) return ""; // No L1 representation of this token
-    return l1address;
+    if (l1address === null) return {
+        l1address: "",
+        l2address: l2address
+    }; // No L1 representation of this token
+    return {
+        l1address: l1address,
+        l2address: l2address
+    };
+};
+
+
+const $07ac9c0576988336$export$7847f5f5cce25dfa = async (config, readOnlyProviders, l1provider, depositorAddress, fromChainId, toChainId, token, depositAmount)=>{
+    try {
+        const tokenBridge = await $67fc622a2b913d5f$export$989eefe1274a439c(fromChainId, toChainId, readOnlyProviders, config);
+        const { unsignedTx: unsignedTx } = await tokenBridge.getUnsignedApproveDepositBridgeTx({
+            depositorAddress: depositorAddress,
+            token: token,
+            depositAmount: depositAmount
+        });
+        if (unsignedTx === null) return (0, BigNumber$1).from(0);
+        return await l1provider.estimateGas(unsignedTx);
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Error occurred while attempting ot estimate gas for approval transaction", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).BRIDGE_GAS_ESTIMATE_ERROR, {
+            message: err.message
+        });
+    }
+};
+const $07ac9c0576988336$export$a3dd181de896b7c7 = async (config, readOnlyProviders, l1provider, depositorAddress, l1Address, delta)=>{
+    if (l1Address === ($887d24b47765b1c0$export$c37d8687c27b9660)) return (BigNumber$1).from(0); // Native ETH does not require approval
+    const fromChainId = ($4013c5c91bb535f6$export$9b794d067cdd1af6)(config);
+    const toChainId = ($4013c5c91bb535f6$export$c9af4e4b001c6476)(config);
+    return await $07ac9c0576988336$export$7847f5f5cce25dfa(config, readOnlyProviders, l1provider, depositorAddress, fromChainId, toChainId, l1Address, delta);
+};
+
+
+
+
+
+const $fa9ac5bfdbbf9dfa$export$9994ad18c2f0e665 = (tokenBalanceResult, totalFees)=>{
+    const balance = ($f730af3b727f04ac$export$22fea095b15361de)(tokenBalanceResult);
+    return balance.gte(totalFees);
 };
 const $fa9ac5bfdbbf9dfa$export$da05aed50d75046 = async (config, readOnlyProviders, feeEstimates)=>{
     let bridgeFeeEstimate = feeEstimates.get(($4b58188d47aafe8d$export$3af78bb3e8650ee6).BRIDGE);
@@ -22185,230 +22687,319 @@ const $fa9ac5bfdbbf9dfa$export$3139474685e4dedd = (address)=>{
     if (!address || address === "") return true;
     return false;
 };
-const $fa9ac5bfdbbf9dfa$export$ddc7ba2b57d7c5fa = async (config, readOnlyProviders, depositorAddress, availableRoutingOptions, balanceRequirement, balances, feeEstimates)=>{
+const $fa9ac5bfdbbf9dfa$export$ddc7ba2b57d7c5fa = async (config, readOnlyProviders, depositorAddress, availableRoutingOptions, bridgeRequirement, tokenBalanceResults, feeEstimates)=>{
     if (!availableRoutingOptions.bridge) return undefined;
+    if (bridgeRequirement.l2address === undefined || bridgeRequirement.l2address === "") return undefined;
     const chainId = ($4013c5c91bb535f6$export$9b794d067cdd1af6)(config);
-    const tokenBalanceResult = balances.get(chainId);
+    const tokenBalanceResult = tokenBalanceResults.get(chainId);
     const l1provider = readOnlyProviders.get(chainId);
     if (!l1provider) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No L1 provider available", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_ERROR, {
         chainId: chainId.toString()
     });
     // If no balances on layer 1 then Bridge cannot be an option
     if (tokenBalanceResult === undefined || tokenBalanceResult.success === false) return undefined;
-    const allowedTokenList = await ($5a5ccedc98d53d25$export$d744af9f1c0712bc)(config, balances, availableRoutingOptions);
+    const allowedTokenList = await ($5a5ccedc98d53d25$export$d744af9f1c0712bc)(config, tokenBalanceResults, availableRoutingOptions);
     if (allowedTokenList.length === 0) return undefined;
     const bridgeFeeEstimate = await $fa9ac5bfdbbf9dfa$export$da05aed50d75046(config, readOnlyProviders, feeEstimates);
     // If the user has no ETH to cover the bridge fees or approval fees then bridge cannot be an option
     if (!$fa9ac5bfdbbf9dfa$export$9994ad18c2f0e665(tokenBalanceResult, bridgeFeeEstimate)) return undefined;
-    const l1address = await $fa9ac5bfdbbf9dfa$export$952cdf461a00a8c6(config, balanceRequirement);
+    const l1RepresentationResult = await ($887d24b47765b1c0$export$952cdf461a00a8c6)(config, bridgeRequirement.l2address);
+    // No mapping on L1 for this token
+    const { l1address: l1address } = l1RepresentationResult;
     if (l1address === "") return undefined;
     // Ensure l1address is in the allowed token list
-    if (l1address === ($823db9fb0ca4bc15$export$c37d8687c27b9660)) {
+    if (l1address === ($887d24b47765b1c0$export$c37d8687c27b9660)) {
         if (!allowedTokenList.find((token)=>!("address" in token))) return undefined;
     } else if (!allowedTokenList.find((token)=>token.address === l1address)) return undefined;
-    const gasForApproval = await ($07ac9c0576988336$export$a3dd181de896b7c7)(config, readOnlyProviders, l1provider, depositorAddress, l1address, balanceRequirement.delta.balance);
+    const gasForApproval = await ($07ac9c0576988336$export$a3dd181de896b7c7)(config, readOnlyProviders, l1provider, depositorAddress, l1address, bridgeRequirement.amount);
     if (!$fa9ac5bfdbbf9dfa$export$9994ad18c2f0e665(tokenBalanceResult, gasForApproval.add(bridgeFeeEstimate))) return undefined;
     // If the L1 representation of the requirement is ETH then find the ETH balance and check if the balance covers the delta
-    if (l1address === ($823db9fb0ca4bc15$export$c37d8687c27b9660)) {
+    if (l1address === ($887d24b47765b1c0$export$c37d8687c27b9660)) {
         const nativeETHBalance = tokenBalanceResult.balances.find((balance)=>$fa9ac5bfdbbf9dfa$export$3139474685e4dedd(balance.token.address));
-        if (nativeETHBalance && nativeETHBalance.balance.gte(balanceRequirement.delta.balance.add(bridgeFeeEstimate))) return $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute(chainId, nativeETHBalance);
+        if (nativeETHBalance && nativeETHBalance.balance.gte(bridgeRequirement.amount.add(bridgeFeeEstimate))) return $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute(chainId, nativeETHBalance);
         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(balanceRequirement.delta.balance)) return $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute(chainId, erc20balance);
+    if (erc20balance && erc20balance.balance.gte(bridgeRequirement.amount)) return $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute(chainId, erc20balance);
     return undefined;
 };
 
 
 
 
-
-
-async function $0e0060cb42e136d2$export$339cb2be73677b30(config, existingReadOnlyProviders) {
-    if (config.isProduction && existingReadOnlyProviders?.has(($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM)) return existingReadOnlyProviders;
-    if (existingReadOnlyProviders?.has(($0472f23319457bfb$export$c06e1e7429de6283).SEPOLIA)) return existingReadOnlyProviders;
-    const readOnlyProviders = new Map();
-    const allowedNetworks = await $de192de6ef100f9f$export$3043f6442a9ef563(config, {
-        type: ($a47e48dd2c04791b$export$1f05a55fe0680cc7).ALL
-    });
-    allowedNetworks.networks.forEach((networkInfo)=>{
-        const rpcUrl = config.networkMap.get(networkInfo.chainId)?.rpcUrls[0];
-        const provider = new (JsonRpcProvider)(rpcUrl);
-        readOnlyProviders.set(networkInfo.chainId, provider);
-    });
-    return readOnlyProviders;
-}
-
-
-
-
-
-
-
-
-const $049bba630af05555$export$6946a1f17c2bbf26 = async (config, chainId, walletAddress, requiredToken, swappableTokens)=>{
-    const dexQuotes = new Map();
-    try {
-        const exchange = await $67fc622a2b913d5f$export$7cf6178417769841(chainId, config);
-        const dexTransactionResponsePromises = [];
-        // Create a quote for each swappable token
-        for (const swappableToken of swappableTokens)dexTransactionResponsePromises.push(exchange.getUnsignedSwapTxFromAmountOut(walletAddress, swappableToken, requiredToken.address, requiredToken.amount));
-        // Resolve all the quotes and link them back to the swappable token
-        // The swappable token array is in the same position in the array as the quote in the promise array
-        const dexTransactionResponse = await Promise.all(dexTransactionResponsePromises);
-        dexTransactionResponse.forEach((response, index)=>{
-            const swappableToken = swappableTokens[index];
-            dexQuotes.set(swappableToken, {
-                quote: response.quote,
-                approval: response.approval?.gasFeeEstimate,
-                swap: response.swap.gasFeeEstimate
-            });
-        });
-        return dexQuotes;
-    } catch  {
-        return dexQuotes;
-    }
-};
-
-
-const $3ee85f12225c19f3$export$fb80fe94a81a3132 = async (config, dexQuoteCache, walletAddress, requiredToken, swappableTokens)=>{
-    const dexQuotes = dexQuoteCache.get(requiredToken.address);
-    if (dexQuotes) return dexQuotes;
-    const quotes = await ($049bba630af05555$export$6946a1f17c2bbf26)(config, ($4013c5c91bb535f6$export$c9af4e4b001c6476)(config), walletAddress, requiredToken, swappableTokens);
-    dexQuoteCache.set(requiredToken.address, quotes);
-    return quotes;
-};
-
-
-const $91807edfd7057288$export$85e4d8628aabb217 = (balanceRequirement)=>{
-    let address = "";
-    let amount = (BigNumber$1).from(0);
-    switch(balanceRequirement.type){
-        case ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20:
-            address = balanceRequirement.required.token.address ?? "";
-            amount = balanceRequirement.delta.balance;
-            break;
-        case ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE:
-            address = ($d85ad1457a3f1a83$export$b80040cb173ba6e9);
-            amount = balanceRequirement.delta.balance;
-            break;
-    }
-    return {
-        address: address,
-        amount: amount
-    };
-};
-const $91807edfd7057288$export$7b6318fc1a8067b3 = (l2Balances, approval)=>{
-    // Check if approval required
-    if (!approval) return {
-        sufficient: true,
-        approvalGasFee: (BigNumber$1).from(0),
-        approvalGasTokenAddress: ""
-    };
-    const approvalGasFee = approval.value;
-    const approvalGasTokenAddress = approval.token.address;
-    // No balance on L2 to cover approval fees
-    if (l2Balances.length === 0) return {
-        sufficient: false,
-        approvalGasFee: approvalGasFee,
-        approvalGasTokenAddress: approvalGasTokenAddress
-    };
-    // Find the users balance of the approval token
-    const l2BalanceOfApprovalToken = l2Balances.find((balance)=>balance.token.address === approvalGasTokenAddress);
-    if (!l2BalanceOfApprovalToken) return {
-        sufficient: false,
-        approvalGasFee: approvalGasFee,
-        approvalGasTokenAddress: approvalGasTokenAddress
-    };
-    // If the user does not have enough of the token to cover approval fees then return sufficient false
-    if (l2BalanceOfApprovalToken.balance.lt(approvalGasFee)) return {
-        sufficient: false,
-        approvalGasFee: approvalGasFee,
-        approvalGasTokenAddress: approvalGasTokenAddress
+const $7bb5af1d8b5d9127$export$8280985cc3da7882 = (config, tokenBalances)=>{
+    const balances = {
+        l1balances: [],
+        l2balances: []
     };
-    // The user has enough to cover approval gas fees
+    const l1balancesResult = tokenBalances.get(($4013c5c91bb535f6$export$9b794d067cdd1af6)(config));
+    const l2balancesResult = tokenBalances.get(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
+    // If there are no l1 balance then cannot bridge
+    if (!l1balancesResult) return balances;
+    if (l1balancesResult.error !== undefined) return balances;
+    if (!l1balancesResult.success) return balances;
+    // If there are no l2 balance then cannot swap
+    if (!l2balancesResult) return balances;
+    if (l2balancesResult.error !== undefined) return balances;
+    if (!l2balancesResult.success) return balances;
+    const l1balances = l1balancesResult.balances;
+    const l2balances = l2balancesResult.balances;
     return {
-        sufficient: true,
-        approvalGasFee: approvalGasFee,
-        approvalGasTokenAddress: approvalGasTokenAddress
+        l1balances: l1balances,
+        l2balances: l2balances
     };
 };
-const $91807edfd7057288$export$38077235fe748d40 = (l2Balances, swapFees, approvalFees, tokenBeingSwapped)=>{
-    // Set up a map of token addresses to amounts for each of the swap fees
-    const feeMap = new Map();
-    // Add the approval fee to list of fees
-    if (approvalFees.approvalGasTokenAddress !== "") feeMap.set(approvalFees.approvalGasTokenAddress, approvalFees.approvalGasFee);
-    // Add the token being swapped to list of fees to ensure the user can cover the fee + the token swap
-    if (tokenBeingSwapped) {
-        const fee = feeMap.get(tokenBeingSwapped.address);
-        if (fee) feeMap.set(tokenBeingSwapped.address, fee.add(tokenBeingSwapped.amount));
-        else feeMap.set(tokenBeingSwapped.address, tokenBeingSwapped.amount);
+
+
+
+
+
+const $62e968a3dd87940e$export$8059963805b7876c = (dexQuote, tokenAddress)=>{
+    let fees = (BigNumber$1).from(0);
+    dexQuote.quote.fees.forEach((fee)=>{
+        if (fee.amount.token.address === tokenAddress) fees = fees.add(fee.amount.value);
+    });
+    if (dexQuote.approval) {
+        if (dexQuote.approval.token.address === tokenAddress) fees = fees.add(dexQuote.approval.value);
     }
-    // Get all the fees and key them by their token id
-    for (const swapFee of swapFees){
-        const fee = feeMap.get(swapFee.amount.token.address);
-        if (fee) {
-            feeMap.set(swapFee.amount.token.address, fee.add(swapFee.amount.value));
-            continue;
+    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);
         }
-        feeMap.set(swapFee.amount.token.address, swapFee.amount.value);
-    }
-    // Go through the map and for each token address check if the user has enough balance to cover the fee
-    for (const [tokenAddress, fee] of feeMap.entries()){
-        if (fee === (BigNumber$1).from(0)) continue;
-        const l2BalanceOfFeeToken = l2Balances.find((balance)=>balance.token.address === tokenAddress);
-        if (!l2BalanceOfFeeToken) return false;
-        if (l2BalanceOfFeeToken.balance.lt(fee)) return false;
+    });
+    return amount;
+};
+const $62e968a3dd87940e$export$df667c749c93b110 = (dexQuotes, l1balances, l2balances, l1tol2addresses, balanceRequirements)=>{
+    const bridgeRequirements = [];
+    for (const [tokenAddress, quote] of dexQuotes){
+        // Get the L2 balance for the token address
+        const l2balance = l2balances.find((balance)=>balance.token.address === tokenAddress);
+        const l1tol2TokenMapping = l1tol2addresses.find((token)=>token.l2address === tokenAddress);
+        if (!l1tol2TokenMapping) continue;
+        const { l1address: l1address, l2address: l2address } = l1tol2TokenMapping;
+        if (!l1address) continue;
+        // If the user does not have any L1 balance for this token then cannot bridge
+        const l1balance = l1balances.find((balance)=>{
+            if (balance.token.address === undefined && l1address === ($887d24b47765b1c0$export$c37d8687c27b9660)) return true;
+            return balance.token.address === l1address;
+        });
+        if (!l1balance) continue;
+        // Get the total amount using slippage to ensure a small buffer is added to cover price fluctuations
+        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;
+        if (amountToBridge.lte(0)) continue;
+        if (amountToBridge.gt(l1balance.balance)) continue;
+        bridgeRequirements.push({
+            amount: amountToBridge,
+            formattedAmount: (utils).formatUnits(amountToBridge, l1balance.token.decimals),
+            l2address: // L2 address is used for the bridge requirement as the bridge route uses the indexer to find L1 address
+            l2address
+        });
     }
-    return true;
+    return bridgeRequirements;
 };
-const $91807edfd7057288$export$8e03ea04d59f2402 = async (config, availableRoutingOptions, dexQuoteCache, walletAddress, balanceRequirement, tokenBalanceResults, swappableTokens)=>{
-    if (!availableRoutingOptions.swap) return undefined;
-    if (swappableTokens.length === 0) return undefined;
-    const requiredToken = $91807edfd7057288$export$85e4d8628aabb217(balanceRequirement);
-    if (requiredToken.address === "") return undefined;
-    const l2TokenBalanceResult = tokenBalanceResults.get(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
-    if (!l2TokenBalanceResult) return undefined;
-    const l2Balances = l2TokenBalanceResult.balances;
-    if (l2Balances.length === 0) return undefined;
-    const quotes = await ($3ee85f12225c19f3$export$fb80fe94a81a3132)(config, dexQuoteCache, walletAddress, requiredToken, swappableTokens);
-    const quoteTokenAddresses = Array.from(quotes.keys());
-    for (const quoteTokenAddress of quoteTokenAddresses){
-        const quote = quotes.get(quoteTokenAddress);
-        if (!quote) continue;
-        // Find the balance the user has for this quoted token
-        const userBalanceOfQuotedToken = l2Balances.find((balance)=>balance.token.address === quoteTokenAddress);
-        // If no balance found on L2 for this quoted token then continue
-        if (!userBalanceOfQuotedToken) continue;
-        // Check the amount of quoted token required against the user balance
-        const amountOfQuoteTokenRequired = quote.quote.amount;
-        // If user does not have enough balance to perform the swap with this token then continue
-        if (userBalanceOfQuotedToken.balance.lt(amountOfQuoteTokenRequired.value)) continue;
-        const approvalFees = $91807edfd7057288$export$7b6318fc1a8067b3(l2Balances, quote.approval);
-        // If user does not have enough to cover approval fees then continue
-        if (!approvalFees.sufficient) continue;
-        // If user does not have enough to cover swap fees then continue
-        if (!$91807edfd7057288$export$38077235fe748d40(l2Balances, quote.quote.fees, approvalFees, {
-            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
-        return {
-            type: ($4b58188d47aafe8d$export$3af78bb3e8650ee6).SWAP,
-            chainId: ($4013c5c91bb535f6$export$c9af4e4b001c6476)(config),
-            asset: {
-                balance: userBalanceOfQuotedToken.balance,
-                formattedBalance: userBalanceOfQuotedToken.formattedBalance,
-                token: userBalanceOfQuotedToken.token
-            }
-        };
+
+
+
+const $7500587317643fc8$export$c3e193fd573f1a94 = async (config, swappableTokens)=>{
+    const l1tol2addressMappingPromises = swappableTokens.map((token)=>($887d24b47765b1c0$export$952cdf461a00a8c6)(config, token.address ?? ""));
+    return await Promise.all(l1tol2addressMappingPromises);
+};
+
+
+
+
+const $d54df4a884f14123$export$d46f2133747ffd93 = async (config, dexQuoteCache, ownerAddress, requiredTokenAddress, insufficientRequirement, filteredSwappableTokens)=>{
+    const filteredSwappableTokensAddresses = [];
+    for (const token of filteredSwappableTokens){
+        if (!token.address) continue;
+        filteredSwappableTokensAddresses.push(token.address);
     }
-    return undefined;
+    const dexQuotes = await ($3ee85f12225c19f3$export$fb80fe94a81a3132)(config, dexQuoteCache, ownerAddress, {
+        address: requiredTokenAddress,
+        amount: insufficientRequirement.delta.balance
+    }, filteredSwappableTokensAddresses);
+    return dexQuotes;
 };
 
 
+const $afd57acae9471ac5$export$b94e88f4f8805f71 = (bridgeableTokens, swappableTokens, l1balances, l2balances, availableRoutingOptions, requiredTokenAddress)=>{
+    if (bridgeableTokens.length === 0) return true;
+    if (swappableTokens.length === 0) return true;
+    if (l1balances.length === 0) return true;
+    if (l2balances.length === 0) return true;
+    if (!availableRoutingOptions.bridge) return true;
+    if (!availableRoutingOptions.swap) return true;
+    if (requiredTokenAddress === undefined) return true;
+    if (requiredTokenAddress === "") return true;
+    return false;
+};
+const $afd57acae9471ac5$export$ed7c59bd8d1bb5a7 = (requiredTokenAddress, bridgeableTokens, swappableTokens, l1tol2Addresses)=>{
+    const filteredSwappableTokens = [];
+    for (const addresses of l1tol2Addresses){
+        if (addresses.l1address === "") continue;
+        if (addresses.l2address === "") continue;
+        if (!bridgeableTokens.includes(addresses.l1address)) continue;
+        // Filter out the token that is required from the swappable tokens list
+        if (addresses.l2address === requiredTokenAddress) continue;
+        const tokenInfo = swappableTokens.find((token)=>token.address === addresses.l2address);
+        if (!tokenInfo) continue;
+        filteredSwappableTokens.push(tokenInfo);
+    }
+    return filteredSwappableTokens;
+};
+// Modifies a users balance to include the amount as if the user successfully bridged
+// This is so the swap route can check against the balance once the user has performed a bridge
+const $afd57acae9471ac5$var$modifyTokenBalancesWithBridgedAmount = (config, tokenBalances, l2balances, bridgedTokens, swappableTokens)=>{
+    const modifiedTokenBalances = new Map();
+    for (const [chainId, tokenBalance] of tokenBalances)modifiedTokenBalances.set(chainId, {
+        success: tokenBalance.success,
+        balances: tokenBalance.balances
+    });
+    // Construct a map of balances to the L2 token address to make
+    // it easier to adjust the balances for the tokens that can be bridged
+    const balanceMap = new Map();
+    for (const balance of l2balances){
+        if (!balance.token.address) continue;
+        balanceMap.set(balance.token.address, balance);
+    }
+    // Go through each of the tokens that can be bridged
+    // and adjust the balances to fake the bridge
+    for (const bridgedToken of bridgedTokens){
+        const { amount: amount, l2address: l2address } = bridgedToken;
+        if (l2address === "") continue;
+        let l2balance = (BigNumber$1).from(0);
+        // Find the current balance of this token
+        const currentBalance = balanceMap.get(l2address);
+        if (currentBalance) l2balance = currentBalance.balance;
+        const newBalance = l2balance.add(amount);
+        const tokenInfo = swappableTokens.find((token)=>token.address === l2address);
+        balanceMap.set(l2address, {
+            balance: newBalance,
+            formattedBalance: (utils).formatUnits(newBalance, tokenInfo.decimals),
+            token: tokenInfo
+        });
+    }
+    const updatedBalances = Array.from(balanceMap.values());
+    modifiedTokenBalances.set(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config), {
+        success: true,
+        balances: updatedBalances
+    });
+    return modifiedTokenBalances;
+};
+const $afd57acae9471ac5$export$1fc63300bde5e690 = (tokenBalances, swapRoutes)=>{
+    const originalSwapSteps = [];
+    for (const route of swapRoutes){
+        const { chainId: chainId, asset: asset } = route;
+        const tokenBalance = tokenBalances.get(chainId);
+        if (!tokenBalance) continue;
+        let originalBalance = (BigNumber$1).from(0);
+        let originalFormattedBalance = "0";
+        const l2balance = tokenBalance.balances.find((balance)=>balance.token.address === asset.token.address);
+        if (l2balance) {
+            originalBalance = l2balance.balance;
+            originalFormattedBalance = l2balance.formattedBalance;
+        }
+        route.asset.balance = originalBalance;
+        route.asset.formattedBalance = originalFormattedBalance;
+        originalSwapSteps.push(route);
+    }
+    return originalSwapSteps;
+};
+const $afd57acae9471ac5$export$d9b96654eebdaf2a = (bridgeFundingSteps, swapFundingSteps, l1tol2Addresses)=>{
+    const bridgeAndSwapRoutes = [];
+    for (const bridgeFundingStep of bridgeFundingSteps){
+        if (!bridgeFundingStep) continue;
+        const mapping = l1tol2Addresses.find((addresses)=>{
+            if (bridgeFundingStep.asset.token.address === undefined) return addresses.l1address === ($887d24b47765b1c0$export$c37d8687c27b9660) && addresses.l2address;
+            return addresses.l1address === bridgeFundingStep.asset.token.address && addresses.l2address;
+        });
+        if (!mapping) continue;
+        const swapFundingStep = swapFundingSteps.find((step)=>step.asset.token.address === mapping.l2address);
+        if (!swapFundingStep) continue;
+        bridgeAndSwapRoutes.push({
+            bridgeFundingStep: bridgeFundingStep,
+            swapFundingStep: swapFundingStep
+        });
+    }
+    return bridgeAndSwapRoutes;
+};
+const $afd57acae9471ac5$export$f95ed27e871fe308 = async (config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, feeEstimates, tokenBalances, bridgeableTokens, swappableTokens, balanceRequirements)=>{
+    const { l1balances: l1balances, l2balances: l2balances } = ($7bb5af1d8b5d9127$export$8280985cc3da7882)(config, tokenBalances);
+    const requiredTokenAddress = insufficientRequirement.required.token.address;
+    if ($afd57acae9471ac5$export$b94e88f4f8805f71(bridgeableTokens, swappableTokens, l1balances, l2balances, availableRoutingOptions, requiredTokenAddress)) return [];
+    // Fetch L2 to L1 address mapping and based on the L1 address existing then
+    // filter the bridgeable and swappable tokens list further to only include
+    // tokens that can be both swapped and bridged
+    const l1tol2Addresses = await ($7500587317643fc8$export$c3e193fd573f1a94)(config, swappableTokens);
+    const filteredSwappableTokens = $afd57acae9471ac5$export$ed7c59bd8d1bb5a7(requiredTokenAddress, bridgeableTokens, swappableTokens, l1tol2Addresses);
+    if (filteredSwappableTokens.length === 0) return [];
+    // Fetch all the dex quotes from the list of swappable tokens
+    const dexQuotes = await ($d54df4a884f14123$export$d46f2133747ffd93)(config, dexQuoteCache, ownerAddress, requiredTokenAddress, insufficientRequirement, filteredSwappableTokens);
+    // Construct bridge requirements based on L2 balances, slippage and swap fees
+    const bridgeRequirements = ($62e968a3dd87940e$export$df667c749c93b110)(dexQuotes, l1balances, l2balances, l1tol2Addresses, balanceRequirements);
+    if (bridgeRequirements.length === 0) return [];
+    // Create a mapping of bridge routes to L2 addresses
+    const bridgePromises = new Map();
+    // Create map of bridgeable tokens to make it easier to get the amount that was bridged when modifying the users balance later
+    const bridgeableRequirementsMap = new Map();
+    const bridgedTokens = [];
+    for (const bridgeRequirement of bridgeRequirements){
+        if (!bridgeRequirement.l2address) continue;
+        bridgePromises.set(bridgeRequirement.l2address, ($fa9ac5bfdbbf9dfa$export$ddc7ba2b57d7c5fa)(config, readOnlyProviders, ownerAddress, availableRoutingOptions, bridgeRequirement, tokenBalances, feeEstimates));
+        bridgeableRequirementsMap.set(bridgeRequirement.l2address, {
+            amount: bridgeRequirement.amount,
+            formattedAmount: bridgeRequirement.formattedAmount,
+            l2address: bridgeRequirement.l2address
+        });
+    }
+    const bridgeResults = await Promise.all(bridgePromises.values());
+    const bridgeKeys = Array.from(bridgePromises.keys());
+    // Create an array to store all the tokens that are able to be bridged
+    const swappableTokensAfterBridging = [];
+    // Iterate through all the bridge route results
+    // If a bridge route result was successful then add this token to the
+    // list of tokens that should be checked with the swap route
+    bridgeResults.forEach((result, index)=>{
+        const key = bridgeKeys[index];
+        if (result === undefined) return;
+        swappableTokensAfterBridging.push(key);
+        const bridgedToken = bridgeableRequirementsMap.get(key);
+        if (!bridgedToken) return;
+        bridgedTokens.push({
+            amount: bridgedToken.amount,
+            formattedAmount: bridgedToken.formattedAmount,
+            l2address: bridgedToken.l2address
+        });
+    });
+    // Bridge route determined that no tokens could be bridged
+    if (swappableTokensAfterBridging.length === 0) return [];
+    if (bridgedTokens.length === 0) return []; // No tokens were bridged
+    // 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);
+    if (!swapRoutes) return [];
+    const originalBalanceSwapRoutes = $afd57acae9471ac5$export$1fc63300bde5e690(tokenBalances, swapRoutes);
+    return $afd57acae9471ac5$export$d9b96654eebdaf2a(bridgeResults, originalBalanceSwapRoutes, l1tol2Addresses);
+};
 
 
 
@@ -22440,6 +23031,8 @@ const $5649bc8af91da370$export$1fb2bd867f4a9be3 = async (config, availableRoutin
 
 
 
+
+const $c16168a9c28ae4fd$var$hasAvailableRoutingOptions = (availableRoutingOptions)=>availableRoutingOptions.bridge || availableRoutingOptions.swap || availableRoutingOptions.onRamp;
 const $c16168a9c28ae4fd$export$31ce7ba1a2956195 = (balanceRequirements)=>{
     let insufficientBalanceCount = 0;
     let insufficientRequirement;
@@ -22450,18 +23043,51 @@ const $c16168a9c28ae4fd$export$31ce7ba1a2956195 = (balanceRequirements)=>{
     if (insufficientBalanceCount === 1) return insufficientRequirement;
     return undefined;
 };
-const $c16168a9c28ae4fd$export$c39a7b7dc167cdb4 = async (config, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, swapTokenAllowList)=>{
-    if (!availableRoutingOptions.swap) return undefined;
+const $c16168a9c28ae4fd$export$ab86023c267660 = async (config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, ownerAddress, tokenBalances, feeEstimates)=>{
+    let bridgeFundingStep;
     if (insufficientRequirement === undefined) return undefined;
-    if (swapTokenAllowList === undefined) return undefined;
+    if (insufficientRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE && insufficientRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) return undefined;
+    const bridgeRequirement = {
+        amount: insufficientRequirement.delta.balance,
+        formattedAmount: insufficientRequirement.delta.formattedBalance,
+        l2address: insufficientRequirement.required.token.address ?? ""
+    };
+    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 fundingSteps = [];
+    if (!availableRoutingOptions.swap) return fundingSteps;
+    if (insufficientRequirement === undefined) return fundingSteps;
+    if (swapTokenAllowList === undefined) return fundingSteps;
     const tokenBalanceResult = tokenBalances.get(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
-    if (!tokenBalanceResult) return undefined;
-    if (tokenBalanceResult.error !== undefined || !tokenBalanceResult.success) return undefined;
-    if (swapTokenAllowList.length === 0) return undefined;
+    if (!tokenBalanceResult) return fundingSteps;
+    if (tokenBalanceResult.error !== undefined || !tokenBalanceResult.success) return fundingSteps;
+    if (swapTokenAllowList.length === 0) return fundingSteps;
     const swappableTokens = swapTokenAllowList.filter((token)=>token.address).map((token)=>token.address);
-    if (swappableTokens.length === 0) return undefined;
-    const swapFundingStep = await ($91807edfd7057288$export$8e03ea04d59f2402)(config, availableRoutingOptions, dexQuoteCache, ownerAddress, insufficientRequirement, tokenBalances, swappableTokens);
-    return swapFundingStep;
+    if (swappableTokens.length === 0) return fundingSteps;
+    return await ($91807edfd7057288$export$8e03ea04d59f2402)(config, availableRoutingOptions, dexQuoteCache, ownerAddress, insufficientRequirement, tokenBalances, swappableTokens);
+};
+const $c16168a9c28ae4fd$export$2becd43da9d21f73 = async (config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, tokenAllowList, feeEstimates, balanceRequirements)=>{
+    if (!insufficientRequirement) return [];
+    const l1balancesResult = tokenBalances.get(($4013c5c91bb535f6$export$9b794d067cdd1af6)(config));
+    const l2balancesResult = tokenBalances.get(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
+    // If there are no l1 balance then cannot bridge
+    if (!l1balancesResult) return [];
+    if (l1balancesResult.error !== undefined || !l1balancesResult.success) return [];
+    // If there are no l2 balance then cannot swap
+    if (!l2balancesResult) return [];
+    if (l2balancesResult.error !== undefined || !l2balancesResult.success) return [];
+    // Get a list of all the swappable tokens
+    const bridgeTokenAllowList = tokenAllowList?.bridge ?? [];
+    const bridgeableL1Addresses = bridgeTokenAllowList.map((token)=>{
+        if (token.address === undefined) return $887d24b47765b1c0$export$c37d8687c27b9660;
+        return token.address;
+    });
+    const swapTokenAllowList = tokenAllowList?.swap ?? [];
+    if (insufficientRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE && insufficientRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) return [];
+    const routes = await ($afd57acae9471ac5$export$f95ed27e871fe308)(config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, feeEstimates, tokenBalances, bridgeableL1Addresses, swapTokenAllowList, balanceRequirements);
+    return routes;
 };
 const $c16168a9c28ae4fd$export$e1b6e4d22d0365ee = async (config, availableRoutingOptions, insufficientRequirement)=>{
     if (!availableRoutingOptions.onRamp) return undefined;
@@ -22470,6 +23096,13 @@ const $c16168a9c28ae4fd$export$e1b6e4d22d0365ee = async (config, availableRoutin
     return onRampFundingStep;
 };
 const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, balanceRequirements, availableRoutingOptions)=>{
+    if (!$c16168a9c28ae4fd$var$hasAvailableRoutingOptions(availableRoutingOptions)) return {
+        response: {
+            type: ($b23305044c0e096a$export$3057de18ac0c076).NO_OPTIONS,
+            message: "No options available"
+        },
+        fundingRoutes: []
+    };
     let readOnlyProviders;
     try {
         readOnlyProviders = await (0, $0e0060cb42e136d2$export$339cb2be73677b30)(config);
@@ -22484,16 +23117,24 @@ const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, b
     const feeEstimates = new Map();
     // Dex quotes cache
     const dexQuoteCache = new Map();
-    // Ensures only 1 balance requirement is insufficient otherwise one bridge or one swap route cannot be recommended
+    // Ensures only 1 balance requirement is insufficient
     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$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);
     let bridgeFundingStep;
-    if (availableRoutingOptions.bridge && insufficientRequirement) bridgeFundingStep = await ($fa9ac5bfdbbf9dfa$export$ddc7ba2b57d7c5fa)(config, readOnlyProviders, ownerAddress, availableRoutingOptions, insufficientRequirement, tokenBalances, feeEstimates);
-    const swapFundingStep = await $c16168a9c28ae4fd$export$c39a7b7dc167cdb4(config, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, allowList.swap);
-    const onRampFundingStep = await $c16168a9c28ae4fd$export$e1b6e4d22d0365ee(config, availableRoutingOptions, insufficientRequirement);
-    // Check swap routes
-    // > Could bridge first
-    // > Could on-ramp first
-    // > Could double swap
+    let swapFundingSteps = [];
+    let onRampFundingStep;
+    let bridgeAndSwapFundingSteps = [];
+    resolved.forEach((result, index)=>{
+        if (index === 0) bridgeFundingStep = result;
+        if (index === 1) swapFundingSteps = result;
+        if (index === 2) onRampFundingStep = result;
+        if (index === 3) bridgeAndSwapFundingSteps = result;
+    });
     const response = {
         response: {
             type: ($b23305044c0e096a$export$3057de18ac0c076).NO_ROUTES,
@@ -22502,7 +23143,7 @@ const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, b
         fundingRoutes: []
     };
     let priority = 0;
-    if (bridgeFundingStep || swapFundingStep || onRampFundingStep) {
+    if (bridgeFundingStep || swapFundingSteps.length > 0 || onRampFundingStep || bridgeAndSwapFundingSteps.length > 0) {
         response.response.type = ($b23305044c0e096a$export$3057de18ac0c076).ROUTES_FOUND;
         response.response.message = "Routes found";
     }
@@ -22515,13 +23156,15 @@ const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, b
             ]
         });
     }
-    if (swapFundingStep) {
+    if (swapFundingSteps.length > 0) {
         priority++;
-        response.fundingRoutes.push({
-            priority: priority,
-            steps: [
-                swapFundingStep
-            ]
+        swapFundingSteps.forEach((swapFundingStep)=>{
+            response.fundingRoutes.push({
+                priority: priority,
+                steps: [
+                    swapFundingStep
+                ]
+            });
         });
     }
     if (onRampFundingStep) {
@@ -22533,6 +23176,22 @@ const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, b
             ]
         });
     }
+    if (bridgeAndSwapFundingSteps) {
+        priority++;
+        bridgeAndSwapFundingSteps.forEach((bridgeAndSwapFundingStep)=>{
+            const bridgeStep = bridgeAndSwapFundingStep.bridgeFundingStep;
+            const swapStep = bridgeAndSwapFundingStep.swapFundingStep;
+            response.fundingRoutes.push({
+                priority: priority,
+                steps: [
+                    bridgeStep,
+                    swapStep
+                ]
+            });
+        });
+    }
+    // eslint-disable-next-line no-console
+    console.log("** response", response);
     return response;
 };
 
@@ -22606,13 +23265,13 @@ const $25ac589234c10b67$export$19693ca396db083e = async (provider, approvalTrans
         type: ($d855a5ba32004345$export$f51b97f3aaf2d5a8).SUCCESS
     };
 };
-const $25ac589234c10b67$export$2161274619257102 = async (provider, fulfilmentTransactions)=>{
+const $25ac589234c10b67$export$3f05b33bd1f29038 = async (provider, fulfillmentTransactions)=>{
     let receipts = [];
     try {
-        const response = await Promise.all(fulfilmentTransactions.map((transaction)=>provider.getSigner().sendTransaction(transaction)));
+        const response = await Promise.all(fulfillmentTransactions.map((transaction)=>provider.getSigner().sendTransaction(transaction)));
         receipts = await Promise.all(response.map((transaction)=>transaction.wait()));
     } catch (err) {
-        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while executing the fulfilment transaction", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).EXECUTE_FULFILMENT_TRANSACTION_ERROR, {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while executing the fulfillment transaction", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).EXECUTE_FULFILLMENT_TRANSACTION_ERROR, {
             message: err.message
         });
     }
@@ -22620,7 +23279,7 @@ const $25ac589234c10b67$export$2161274619257102 = async (provider, fulfilmentTra
         if (receipt.status === 0) return {
             type: ($d855a5ba32004345$export$f51b97f3aaf2d5a8).FAILED,
             transactionHash: receipt.transactionHash,
-            reason: "Fulfilment transaction failed and was reverted"
+            reason: "Fulfillment transaction failed and was reverted"
         };
     }
     return {
@@ -22645,23 +23304,43 @@ const $25ac589234c10b67$export$1d9a7a8a40780de = async (provider, unsignedMessag
 
 
 
-const $a7367d01c6e76b1c$export$b087719c36e0f2dc = async (actions)=>{
+const $a7367d01c6e76b1c$export$c5b3365853cb6159 = async (actions)=>{
     let approvalTransactions = [];
-    let fulfilmentTransactions = [];
+    let fulfillmentTransactions = [];
     const approvalPromises = [];
-    const fulfilmentPromises = [];
+    const fulfillmentPromises = [];
     for (const action of actions){
         if (action.type !== (ActionType).TRANSACTION) continue;
         if (action.purpose === (TransactionPurpose).APPROVAL) approvalPromises.push(action.buildTransaction());
-        if (action.purpose === (TransactionPurpose).FULFILL_ORDER) fulfilmentPromises.push(action.buildTransaction());
+        if (action.purpose === (TransactionPurpose).FULFILL_ORDER) fulfillmentPromises.push(action.buildTransaction());
     }
     approvalTransactions = await Promise.all(approvalPromises);
-    fulfilmentTransactions = await Promise.all(fulfilmentPromises);
+    fulfillmentTransactions = await Promise.all(fulfillmentPromises);
     return {
         approvalTransactions: approvalTransactions,
-        fulfilmentTransactions: fulfilmentTransactions
+        fulfillmentTransactions: fulfillmentTransactions
     };
 };
+const $a7367d01c6e76b1c$export$f64a20a30eb98855 = async (actions)=>{
+    let approvalTransactions = [];
+    const approvalPromises = [];
+    for (const action of actions){
+        if (action.type !== (ActionType).TRANSACTION) continue;
+        if (action.purpose === (TransactionPurpose).APPROVAL) approvalPromises.push(action.buildTransaction());
+    }
+    approvalTransactions = await Promise.all(approvalPromises);
+    return approvalTransactions;
+};
+const $a7367d01c6e76b1c$export$396bd6ce7d3ab533 = async (actions)=>{
+    let fulfillmentTransactions = [];
+    const fulfillmentPromises = [];
+    for (const action of actions){
+        if (action.type !== (ActionType).TRANSACTION) continue;
+        if (action.purpose === (TransactionPurpose).FULFILL_ORDER) fulfillmentPromises.push(action.buildTransaction());
+    }
+    fulfillmentTransactions = await Promise.all(fulfillmentPromises);
+    return fulfillmentTransactions;
+};
 const $a7367d01c6e76b1c$export$d62081fac18000c2 = (orderHash, orderComponents, actions)=>{
     let unsignedMessage;
     for (const action of actions){
@@ -22684,6 +23363,49 @@ const $a7367d01c6e76b1c$export$d62081fac18000c2 = (orderHash, orderComponents, a
 
 
 
+
+
+
+
+const $9051cee080948594$export$9ac1563efd38130 = 1; // 100%
+const $9051cee080948594$export$768e717351d4b176 = 6; // will allow 0.000001 (0.0001%) as the minimum value
+const $9051cee080948594$var$calculateFeesPercent = (orderFee, amountBn)=>{
+    const feePercentage = orderFee.amount;
+    // note: multiply in and out of the maximum decimal places to the power of ten to do the math in big number integers
+    const feePercentageMultiplier = Math.round(feePercentage.percentageDecimal * 10 ** $9051cee080948594$export$768e717351d4b176);
+    const bnFeeAmount = amountBn.mul((BigNumber$1).from(feePercentageMultiplier)).div(10 ** $9051cee080948594$export$768e717351d4b176);
+    return bnFeeAmount;
+};
+const $9051cee080948594$var$calculateFeesToken = (orderFee, decimals)=>{
+    const feeToken = orderFee.amount;
+    const bnFeeAmount = (parseUnits)(feeToken.token, decimals);
+    return bnFeeAmount;
+};
+const $9051cee080948594$export$1e69c9cfc42e28d8 = (orderFees, weiAmount, decimals = 18)=>{
+    let totalTokenFees = (BigNumber$1).from(0);
+    const amountBn = (BigNumber$1).from(weiAmount);
+    // note: multiply in and out of the maximum decimal places to the power of ten to do the math in big number integers
+    const totalAllowableFees = amountBn.mul($9051cee080948594$export$9ac1563efd38130 * 10 ** $9051cee080948594$export$768e717351d4b176).div(10 ** $9051cee080948594$export$768e717351d4b176);
+    const calculateFeesResult = [];
+    for (const orderFee of orderFees){
+        let currentFeeBn = (BigNumber$1).from(0);
+        if (Object.hasOwn(orderFee.amount, "percentageDecimal")) {
+            currentFeeBn = $9051cee080948594$var$calculateFeesPercent(orderFee, amountBn);
+            totalTokenFees = totalTokenFees.add(currentFeeBn);
+        } else if (Object.hasOwn(orderFee.amount, "token")) {
+            currentFeeBn = $9051cee080948594$var$calculateFeesToken(orderFee, decimals);
+            totalTokenFees = totalTokenFees.add(currentFeeBn);
+        } else throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Unknown fee type parsed, must be percentageDecimal or token", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).ORDER_FEE_ERROR);
+        if (totalTokenFees.gt(totalAllowableFees)) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`The combined fees are above the allowed maximum of ${$9051cee080948594$export$9ac1563efd38130 * 100}%`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).ORDER_FEE_ERROR);
+        if (currentFeeBn.gt(0)) calculateFeesResult.push({
+            amount: currentFeeBn.toString(),
+            recipient: orderFee.recipient
+        });
+    } // for
+    return calculateFeesResult;
+};
+
+
 const $64863c39386de592$export$4249179755829904 = (type, contractAddress, amount, spenderAddress)=>{
     switch(type){
         case ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20:
@@ -22701,10 +23423,10 @@ const $64863c39386de592$export$4249179755829904 = (type, contractAddress, amount
             };
     }
 };
-const $64863c39386de592$export$8f2ff92ab8657f0b = (gasLimit, unsignedTransactions)=>{
-    if (unsignedTransactions.fulfilmentTransactions.length > 0) return {
+const $64863c39386de592$export$8f2ff92ab8657f0b = (gasLimit, fulfillmentTransactions)=>{
+    if (fulfillmentTransactions.length > 0) return {
         type: ($4b58188d47aafe8d$export$65c64e46348ee3c1).TRANSACTION,
-        transaction: unsignedTransactions.fulfilmentTransactions[0]
+        transaction: fulfillmentTransactions[0]
     };
     return {
         type: ($4b58188d47aafe8d$export$65c64e46348ee3c1).GAS,
@@ -22714,34 +23436,54 @@ const $64863c39386de592$export$8f2ff92ab8657f0b = (gasLimit, unsignedTransaction
         }
     };
 };
-const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, orderId)=>{
+const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, orders)=>{
     let orderbook;
     let order;
     let spenderAddress = "";
     const gasLimit = (constants).estimatedFulfillmentGasGwei;
+    if (orders.length === 0) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No orders were passed in, must pass at least one order", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).FULFILL_ORDER_LISTING_ERROR);
+    const { id: id, takerFees: takerFees } = orders[0];
     try {
         orderbook = await $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
-        order = await orderbook.getListing(orderId);
+        order = await orderbook.getListing(id);
         const { seaportContractAddress: seaportContractAddress } = orderbook.config();
         spenderAddress = seaportContractAddress;
     } catch (err) {
         throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while getting the order listing", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_ORDER_LISTING_ERROR, {
-            orderId: orderId,
+            orderId: id,
             message: err.message
         });
     }
-    let unsignedTransactions = {
-        approvalTransactions: [],
-        fulfilmentTransactions: []
-    };
+    if (order.result.buy.length === 0) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred with the get order listing", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_ORDER_LISTING_ERROR, {
+        orderId: id,
+        message: "No buy side tokens found on order"
+    });
+    const buyToken = order.result.buy[0];
+    let decimals = 18;
+    if (order.result.buy[0].type === "ERC20") {
+        const tokenContract = $06a6c5c23f7f2479$export$fbbc17f6e6e58544(order.result.buy[0].contractAddress, ($d85ad1457a3f1a83$export$db5daa1b5156ccfe), provider);
+        decimals = await tokenContract.decimals();
+    }
+    let fees = [];
+    if (takerFees && takerFees.length > 0) fees = ($9051cee080948594$export$1e69c9cfc42e28d8)(takerFees, buyToken.amount, decimals);
+    let unsignedApprovalTransactions = [];
+    let unsignedFulfillmentTransactions = [];
+    let orderActions = [];
     try {
         const fulfillerAddress = await provider.getSigner().getAddress();
-        const { actions: actions } = await orderbook.fulfillOrder(orderId, fulfillerAddress, []);
-        unsignedTransactions = await (0, $a7367d01c6e76b1c$export$b087719c36e0f2dc)(actions);
+        const { actions: actions } = await orderbook.fulfillOrder(id, fulfillerAddress, fees);
+        orderActions = actions;
+        unsignedApprovalTransactions = await (0, $a7367d01c6e76b1c$export$f64a20a30eb98855)(actions);
     } catch  {
     // Silently ignore error as this is usually thrown if user does not have enough balance
     // todo: if balance error - can we determine if its the balance error otherwise throw?
     }
+    try {
+        unsignedFulfillmentTransactions = await (0, $a7367d01c6e76b1c$export$396bd6ce7d3ab533)(orderActions);
+    } catch  {
+    // if cannot estimate gas then silently continue and use gas limit in smartCheckout
+    // but get the fulfillment transactions after they have approved the spending
+    }
     let amount = (BigNumber$1).from("0");
     let type = ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE;
     let contractAddress = "";
@@ -22756,7 +23498,7 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
             break;
         default:
             throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Purchasing token type is unsupported", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).UNSUPPORTED_TOKEN_TYPE_ERROR, {
-                orderId: orderId
+                orderId: id
             });
     }
     buyArray.forEach((item)=>{
@@ -22769,31 +23511,38 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
     const itemRequirements = [
         $64863c39386de592$export$4249179755829904(type, contractAddress, amount, spenderAddress)
     ];
-    const smartCheckoutResult = await ($0e7419077c373b24$export$9e073f9ada8c81e6)(config, provider, itemRequirements, $64863c39386de592$export$8f2ff92ab8657f0b(gasLimit, unsignedTransactions));
+    const smartCheckoutResult = await ($0e7419077c373b24$export$9e073f9ada8c81e6)(config, provider, itemRequirements, $64863c39386de592$export$8f2ff92ab8657f0b(gasLimit, unsignedFulfillmentTransactions));
     if (smartCheckoutResult.sufficient) {
-        const approvalResult = await ($25ac589234c10b67$export$19693ca396db083e)(provider, unsignedTransactions.approvalTransactions);
+        const approvalResult = await ($25ac589234c10b67$export$19693ca396db083e)(provider, unsignedApprovalTransactions);
         if (approvalResult.type === ($d855a5ba32004345$export$f51b97f3aaf2d5a8).FAILED) return {
             smartCheckoutResult: smartCheckoutResult,
-            orderId: orderId,
+            orderId: id,
             status: {
                 type: ($aa144554f9ef124b$export$226b052ecb8ca80).FAILED,
                 transactionHash: approvalResult.transactionHash,
                 reason: approvalResult.reason
             }
         };
-        const fulfilmentResult = await ($25ac589234c10b67$export$2161274619257102)(provider, unsignedTransactions.fulfilmentTransactions);
-        if (fulfilmentResult.type === ($d855a5ba32004345$export$f51b97f3aaf2d5a8).FAILED) return {
+        try {
+            if (unsignedFulfillmentTransactions.length === 0) unsignedFulfillmentTransactions = await (0, $a7367d01c6e76b1c$export$396bd6ce7d3ab533)(orderActions);
+        } catch (err) {
+            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Error fetching fulfillment transaction", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).FULFILL_ORDER_LISTING_ERROR, {
+                message: err.message
+            });
+        }
+        const fulfillmentResult = await ($25ac589234c10b67$export$3f05b33bd1f29038)(provider, unsignedFulfillmentTransactions);
+        if (fulfillmentResult.type === ($d855a5ba32004345$export$f51b97f3aaf2d5a8).FAILED) return {
             smartCheckoutResult: smartCheckoutResult,
-            orderId: orderId,
+            orderId: id,
             status: {
                 type: ($aa144554f9ef124b$export$226b052ecb8ca80).FAILED,
-                transactionHash: fulfilmentResult.transactionHash,
-                reason: fulfilmentResult.reason
+                transactionHash: fulfillmentResult.transactionHash,
+                reason: fulfillmentResult.reason
             }
         };
         return {
             smartCheckoutResult: smartCheckoutResult,
-            orderId: orderId,
+            orderId: id,
             status: {
                 type: ($aa144554f9ef124b$export$226b052ecb8ca80).SUCCESS
             }
@@ -22801,7 +23550,7 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
     }
     return {
         smartCheckoutResult: smartCheckoutResult,
-        orderId: orderId
+        orderId: id
     };
 };
 
@@ -22813,8 +23562,11 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
 
 
 
-const $9c3db1bb9c8b69d3$export$70b61ad426ddbe54 = async (config, provider, orderId)=>{
+const $9c3db1bb9c8b69d3$export$70b61ad426ddbe54 = async (config, provider, orderIds)=>{
     let unsignedCancelOrderTransaction;
+    if (orderIds.length === 0) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No orderIds were passed in, must pass at least one orderId to cancel", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CANCEL_ORDER_LISTING_ERROR);
+    // Update this when bulk cancel is supproted
+    const orderId = orderIds[0];
     try {
         const offererAddress = await provider.getSigner().getAddress();
         const orderbook = await $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
@@ -22826,7 +23578,7 @@ const $9c3db1bb9c8b69d3$export$70b61ad426ddbe54 = async (config, provider, order
             message: err.message
         });
     }
-    const result = await ($25ac589234c10b67$export$2161274619257102)(provider, [
+    const result = await ($25ac589234c10b67$export$3f05b33bd1f29038)(provider, [
         unsignedCancelOrderTransaction
     ]);
     if (result.type === ($d855a5ba32004345$export$f51b97f3aaf2d5a8).FAILED) return {
@@ -22859,47 +23611,6 @@ const $9c3db1bb9c8b69d3$export$70b61ad426ddbe54 = async (config, provider, order
 
 
 
-
-
-const $9051cee080948594$export$9ac1563efd38130 = 1; // 100%
-const $9051cee080948594$export$768e717351d4b176 = 6; // will allow 0.000001 (0.0001%) as the minimum value
-const $9051cee080948594$var$calculateFeesPercent = (orderFee, amountBn)=>{
-    const feePercentage = orderFee.amount;
-    // note: multiply in and out of the maximum decimal places to the power of ten to do the math in big number integers
-    const feePercentageMultiplier = Math.round(feePercentage.percentageDecimal * 10 ** $9051cee080948594$export$768e717351d4b176);
-    const bnFeeAmount = amountBn.mul((BigNumber$1).from(feePercentageMultiplier)).div(10 ** $9051cee080948594$export$768e717351d4b176);
-    return bnFeeAmount;
-};
-const $9051cee080948594$var$calculateFeesToken = (orderFee, decimals)=>{
-    const feeToken = orderFee.amount;
-    const bnFeeAmount = (parseUnits)(feeToken.token, decimals);
-    return bnFeeAmount;
-};
-const $9051cee080948594$export$1e69c9cfc42e28d8 = (orderFees, weiAmount, decimals = 18)=>{
-    let totalTokenFees = (BigNumber$1).from(0);
-    const amountBn = (BigNumber$1).from(weiAmount);
-    // note: multiply in and out of the maximum decimal places to the power of ten to do the math in big number integers
-    const totalAllowableFees = amountBn.mul($9051cee080948594$export$9ac1563efd38130 * 10 ** $9051cee080948594$export$768e717351d4b176).div(10 ** $9051cee080948594$export$768e717351d4b176);
-    const calculateFeesResult = [];
-    for (const orderFee of orderFees){
-        let currentFeeBn = (BigNumber$1).from(0);
-        if (Object.hasOwn(orderFee.amount, "percentageDecimal")) {
-            currentFeeBn = $9051cee080948594$var$calculateFeesPercent(orderFee, amountBn);
-            totalTokenFees = totalTokenFees.add(currentFeeBn);
-        } else if (Object.hasOwn(orderFee.amount, "token")) {
-            currentFeeBn = $9051cee080948594$var$calculateFeesToken(orderFee, decimals);
-            totalTokenFees = totalTokenFees.add(currentFeeBn);
-        } else throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Unknown fee type parsed, must be percentageDecimal or token", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).ORDER_FEE_ERROR);
-        if (totalTokenFees.gt(totalAllowableFees)) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`The combined fees are above the allowed maximum of ${$9051cee080948594$export$9ac1563efd38130 * 100}%`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).ORDER_FEE_ERROR);
-        if (currentFeeBn.gt(0)) calculateFeesResult.push({
-            amount: currentFeeBn.toString(),
-            recipient: orderFee.recipient
-        });
-    } // for
-    return calculateFeesResult;
-};
-
-
 const $9085b221b72ac69e$export$af768ccdf17d5c04 = (id, contractAddress, spenderAddress)=>({
         type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721,
         id: id,
@@ -22928,7 +23639,7 @@ const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, order
     if (buyToken.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) {
         // get this from the allowed list
         const buyTokenContract = new (Contract$1)(buyToken.contractAddress, JSON.stringify(($d85ad1457a3f1a83$export$db5daa1b5156ccfe)), provider);
-        decimals = buyTokenContract.decimals();
+        decimals = await buyTokenContract.decimals();
     }
     const buyTokenOrNative = $9085b221b72ac69e$export$586d02673c66d423(buyToken, decimals);
     try {
@@ -22971,7 +23682,7 @@ const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, order
             collectionAddress: sellToken.collectionAddress
         });
         const signedMessage = await ($25ac589234c10b67$export$1d9a7a8a40780de)(provider, unsignedMessage);
-        const unsignedTransactions = await ($a7367d01c6e76b1c$export$b087719c36e0f2dc)(listing.actions);
+        const unsignedTransactions = await ($a7367d01c6e76b1c$export$c5b3365853cb6159)(listing.actions);
         const approvalResult = await ($25ac589234c10b67$export$19693ca396db083e)(provider, unsignedTransactions.approvalTransactions);
         if (approvalResult.type === ($d855a5ba32004345$export$f51b97f3aaf2d5a8).FAILED) return {
             id: sellToken.id,
@@ -23071,6 +23782,38 @@ class $a77d203f701a3b72$export$1453e9b801542ef4 {
 
 
 
+
+
+
+async function $d35036efee31c5d1$export$dc8635800ef20f4b(provider, requirements) {
+    // Get all decimal values by calling contracts for each ERC20
+    const decimalPromises = [];
+    requirements.forEach((itemRequirementParam)=>{
+        if (itemRequirementParam.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) {
+            const { contractAddress: contractAddress } = itemRequirementParam;
+            decimalPromises.push(($06a6c5c23f7f2479$export$fbbc17f6e6e58544)(contractAddress, ($d85ad1457a3f1a83$export$db5daa1b5156ccfe), provider).decimals());
+        }
+    });
+    const decimals = await Promise.all(decimalPromises);
+    // Map ItemRequirementsParam objects to ItemRequirement by parsing amounts from formatted string to BigNumebrs
+    const itemRequirements = requirements.map((itemRequirementParam, index)=>{
+        if (itemRequirementParam.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE) return {
+            ...itemRequirementParam,
+            amount: (parseUnits)(itemRequirementParam.amount, 18)
+        };
+        if (itemRequirementParam.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) return {
+            ...itemRequirementParam,
+            amount: (parseUnits)(itemRequirementParam.amount, decimals[index])
+        };
+        return itemRequirementParam;
+    });
+    return itemRequirements;
+}
+
+
+
+
+
 const $a8cb37a3fc8eb863$var$SANDBOX_CONFIGURATION = {
     baseConfig: {
         environment: (Environment$1).SANDBOX
@@ -23197,8 +23940,10 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
         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 actions the first order in the array.");
         const web3Provider = await $bb88265fe45a0393$export$9e1fd9cc88c637a0(this.config, params.provider);
-        await $64863c39386de592$export$7f8e2b98eca5a7f0(this.config, web3Provider, params.orderId);
+        await $64863c39386de592$export$7f8e2b98eca5a7f0(this.config, web3Provider, params.orders);
     }
     /**
    * Determines the requirements for performing a sell.
@@ -23221,8 +23966,10 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
         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 actions the first order in the array.");
         const web3Provider = await $bb88265fe45a0393$export$9e1fd9cc88c637a0(this.config, params.provider);
-        await $9c3db1bb9c8b69d3$export$70b61ad426ddbe54(this.config, web3Provider, params.orderId);
+        await $9c3db1bb9c8b69d3$export$70b61ad426ddbe54(this.config, web3Provider, params.orderIds);
     }
     /**
    * Determines the transaction requirements to complete a purchase.
@@ -23232,8 +23979,13 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
         // eslint-disable-next-line no-console
         console.warn("This endpoint is currently under construction.");
         const web3Provider = await $bb88265fe45a0393$export$9e1fd9cc88c637a0(this.config, params.provider);
-        // console.log('Smart Checkout Params ::', params);
-        await $0e7419077c373b24$export$9e073f9ada8c81e6(this.config, web3Provider, params.itemRequirements, params.transactionOrGasAmount);
+        let itemRequirements = [];
+        try {
+            itemRequirements = await (0, $d35036efee31c5d1$export$dc8635800ef20f4b)(web3Provider, params.itemRequirements);
+        } catch  {
+            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Failed to map item requirements", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).ITEM_REQUIREMENTS_ERROR);
+        }
+        await $0e7419077c373b24$export$9e073f9ada8c81e6(this.config, web3Provider, itemRequirements, params.transactionOrGasAmount);
     }
     /**
    * Checks if the given object is a Web3 provider.