@imtbl/sdk 0.17.6 → 0.18.1

package/dist/index.cjs

@@ -24,6 +24,7 @@ var assert = require('assert');
 var v3Sdk = require('@uniswap/v3-sdk');
 var solidity = require('@ethersproject/solidity');
 var routerSdk = require('@uniswap/router-sdk');
+var utils$1 = require('ethers/lib/utils');
 var jsxRuntime = require('react/jsx-runtime');
 var react = require('react');
 
@@ -2724,7 +2725,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.17.6' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.18.1' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -2784,7 +2785,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.17.6',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.18.1',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -3070,7 +3071,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.17.6',
+    sdkVersion: 'ts-immutable-sdk-0.18.1',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -6802,6 +6803,8 @@ var globalAxios = axios;
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
+// Some imports not used depending on template conditions
+// @ts-ignore
 const BASE_PATH = "https://guardian.sandbox.imtbl.com".replace(/\/+$/, "");
 /**
  *
@@ -6829,10 +6832,10 @@ class BaseAPI {
  */
 class RequiredError extends Error {
     field;
+    name = "RequiredError";
     constructor(field, msg) {
         super(msg);
         this.field = field;
-        this.name = "RequiredError";
     }
 }
 
@@ -6877,8 +6880,6 @@ const setBearerAuthToObject = async function (object, configuration) {
     }
 };
 function setFlattenedQueryParams(urlSearchParams, parameter, key = "") {
-    if (parameter == null)
-        return;
     if (typeof parameter === "object") {
         if (Array.isArray(parameter)) {
             parameter.forEach(item => setFlattenedQueryParams(urlSearchParams, item, key));
@@ -6936,6 +6937,208 @@ const createRequestFunction = function (axiosArgs, globalAxios, BASE_PATH, confi
     };
 };
 
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Guardian
+ * Guardian 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.
+ */
+/**
+ * MessagesApi - axios parameter creator
+ * @export
+ */
+const MessagesApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         * Approve a pending evm message
+         * @summary Approve a pending evm message
+         * @param {string} messageID id for the message
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        approvePendingMessage: async (messageID, options = {}) => {
+            // verify required parameter 'messageID' is not null or undefined
+            assertParamExists('approvePendingMessage', 'messageID', messageID);
+            const localVarPath = `/guardian/v1/messages/{messageID}/approve`
+                .replace(`{${"messageID"}}`, encodeURIComponent(String(messageID)));
+            // 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 BearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Check if a given message is valid  for EVM
+         * @summary Evaluate an evm message to sign
+         * @param {MessageEvaluationRequest} messageEvaluationRequest Specifies the kind of transaction
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        evaluateMessage: async (messageEvaluationRequest, options = {}) => {
+            // verify required parameter 'messageEvaluationRequest' is not null or undefined
+            assertParamExists('evaluateMessage', 'messageEvaluationRequest', messageEvaluationRequest);
+            const localVarPath = `/guardian/v1/messages/evaluate`;
+            // 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 BearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, 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(messageEvaluationRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Get an evm message by id
+         * @summary Info for a specific evm message
+         * @param {string} messageID The id of the evm message
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getMessageByID: async (messageID, options = {}) => {
+            // verify required parameter 'messageID' is not null or undefined
+            assertParamExists('getMessageByID', 'messageID', messageID);
+            const localVarPath = `/guardian/v1/messages/{messageID}`
+                .replace(`{${"messageID"}}`, encodeURIComponent(String(messageID)));
+            // 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 = {};
+            // authentication BearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    };
+};
+/**
+ * MessagesApi - functional programming interface
+ * @export
+ */
+const MessagesApiFp = function (configuration) {
+    const localVarAxiosParamCreator = MessagesApiAxiosParamCreator(configuration);
+    return {
+        /**
+         * Approve a pending evm message
+         * @summary Approve a pending evm message
+         * @param {string} messageID id for the message
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async approvePendingMessage(messageID, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.approvePendingMessage(messageID, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Check if a given message is valid  for EVM
+         * @summary Evaluate an evm message to sign
+         * @param {MessageEvaluationRequest} messageEvaluationRequest Specifies the kind of transaction
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async evaluateMessage(messageEvaluationRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.evaluateMessage(messageEvaluationRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Get an evm message by id
+         * @summary Info for a specific evm message
+         * @param {string} messageID The id of the evm message
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getMessageByID(messageID, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getMessageByID(messageID, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+    };
+};
+/**
+ * MessagesApi - object-oriented interface
+ * @export
+ * @class MessagesApi
+ * @extends {BaseAPI}
+ */
+class MessagesApi extends BaseAPI {
+    /**
+     * Approve a pending evm message
+     * @summary Approve a pending evm message
+     * @param {MessagesApiApprovePendingMessageRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MessagesApi
+     */
+    approvePendingMessage(requestParameters, options) {
+        return MessagesApiFp(this.configuration).approvePendingMessage(requestParameters.messageID, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Check if a given message is valid  for EVM
+     * @summary Evaluate an evm message to sign
+     * @param {MessagesApiEvaluateMessageRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MessagesApi
+     */
+    evaluateMessage(requestParameters, options) {
+        return MessagesApiFp(this.configuration).evaluateMessage(requestParameters.messageEvaluationRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Get an evm message by id
+     * @summary Info for a specific evm message
+     * @param {MessagesApiGetMessageByIDRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MessagesApi
+     */
+    getMessageByID(requestParameters, options) {
+        return MessagesApiFp(this.configuration).getMessageByID(requestParameters.messageID, options).then((request) => request(this.axios, this.basePath));
+    }
+}
+
 /* tslint:disable */
 /* eslint-disable */
 /**
@@ -6959,7 +7162,7 @@ const TransactionsApiAxiosParamCreator = function (configuration) {
          * Approve a pending transaction
          * @summary Approve a pending transaction given chain
          * @param {string} payloadHash Hash for the payload
-         * @param {TransactionApprovalRequest} transactionApprovalRequest request body for approving a pending transactio
+         * @param {TransactionApprovalRequest} transactionApprovalRequest request body for approving a pending transaction
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
@@ -7084,7 +7287,7 @@ const TransactionsApiFp = function (configuration) {
          * Approve a pending transaction
          * @summary Approve a pending transaction given chain
          * @param {string} payloadHash Hash for the payload
-         * @param {TransactionApprovalRequest} transactionApprovalRequest request body for approving a pending transactio
+         * @param {TransactionApprovalRequest} transactionApprovalRequest request body for approving a pending transaction
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
@@ -7451,6 +7654,7 @@ const getAuthConfiguration = ({ oidcConfiguration, authenticationDomain, }) => {
         mergeClaims: true,
         loadUserInfo: true,
         scope: oidcConfiguration.scope,
+        userStore: new oidcClientTs.WebStorageStateStore({ store: window.localStorage }),
     };
     if (oidcConfiguration.audience) {
         baseConfiguration.extraQueryParams = {
@@ -7850,18 +8054,18 @@ const transformGuardianTransactions = (txs) => {
 };
 class GuardianClient {
     transactionAPI;
+    messageAPI;
     confirmationScreen;
     // TODO: ID-977, make this rollup agnostic
     imxEtherAddress;
     crossSdkBridgeEnabled;
     constructor({ accessToken, confirmationScreen, imxEtherAddress, config, }) {
+        const guardianConfiguration = new Configuration({ accessToken, basePath: config.imxPublicApiDomain });
         this.confirmationScreen = confirmationScreen;
-        this.transactionAPI = new TransactionsApi(new Configuration({
-            accessToken,
-            basePath: config.imxPublicApiDomain,
-        }));
+        this.transactionAPI = new TransactionsApi(new Configuration(guardianConfiguration));
         this.imxEtherAddress = imxEtherAddress;
         this.crossSdkBridgeEnabled = config.crossSdkBridgeEnabled;
+        this.messageAPI = new MessagesApi(guardianConfiguration);
     }
     /**
      * Open confirmation screen and close it automatically if the
@@ -7960,6 +8164,31 @@ class GuardianClient {
             this.confirmationScreen.closeWindow();
         }
     }
+    async evaluateMessage({ chainID, payload, user }) {
+        try {
+            const messageEvalResponse = await this.messageAPI.evaluateMessage({ messageEvaluationRequest: { chainID, payload } }, { headers: { Authorization: `Bearer ${user.accessToken}` } });
+            return messageEvalResponse.data;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Message failed to validate with error: ${errorMessage}`);
+        }
+    }
+    async validateMessage({ chainID, payload, user }) {
+        const { messageId, confirmationRequired } = await this.evaluateMessage({ chainID, payload, user });
+        if (confirmationRequired && this.crossSdkBridgeEnabled) {
+            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
+        }
+        if (confirmationRequired && !!messageId) {
+            const confirmationResult = await this.confirmationScreen.requestMessageConfirmation(messageId);
+            if (!confirmationResult.confirmed) {
+                throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Signature rejected by user');
+            }
+        }
+        else {
+            this.confirmationScreen.closeWindow();
+        }
+    }
 }
 
 var PassportEvents;
@@ -8587,6 +8816,8 @@ var ReceiveMessage;
     ReceiveMessage["CONFIRMATION_WINDOW_READY"] = "confirmation_window_ready";
     ReceiveMessage["TRANSACTION_CONFIRMED"] = "transaction_confirmed";
     ReceiveMessage["TRANSACTION_ERROR"] = "transaction_error";
+    ReceiveMessage["MESSAGE_CONFIRMED"] = "message_confirmed";
+    ReceiveMessage["MESSAGE_REJECTED"] = "message_rejected";
 })(ReceiveMessage || (ReceiveMessage = {}));
 const PASSPORT_EVENT_TYPE = 'imx_passport_confirmation';
 
@@ -8640,11 +8871,11 @@ class ConfirmationScreen {
                         reject(new Error('Unsupported message type'));
                 }
             };
-            window.addEventListener('message', messageHandler);
             if (!this.confirmationWindow) {
                 resolve({ confirmed: false });
                 return;
             }
+            window.addEventListener('message', messageHandler);
             let href = '';
             if (chainType === TransactionApprovalRequestChainTypeEnum.Starkex) {
                 // eslint-disable-next-line max-len
@@ -8654,15 +8885,39 @@ class ConfirmationScreen {
                 // eslint-disable-next-line max-len
                 href = `${this.config.passportDomain}/transaction-confirmation/zkevm?transactionId=${transactionId}&imxEtherAddress=${imxEtherAddress}&chainType=evm&chainId=${chainId}`;
             }
-            this.confirmationWindow.location.href = href;
-            // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
-            const timer = setInterval(() => {
-                if (this.confirmationWindow?.closed) {
-                    clearInterval(timer);
-                    window.removeEventListener('message', messageHandler);
-                    resolve({ confirmed: false });
+            this.showConfirmationScreen(href, messageHandler, resolve);
+        });
+    }
+    requestMessageConfirmation(messageId) {
+        return new Promise((resolve, reject) => {
+            const messageHandler = ({ data, origin }) => {
+                if (origin !== this.config.passportDomain
+                    || data.eventType !== PASSPORT_EVENT_TYPE) {
+                    return;
+                }
+                switch (data.messageType) {
+                    case ReceiveMessage.CONFIRMATION_WINDOW_READY: {
+                        break;
+                    }
+                    case ReceiveMessage.MESSAGE_CONFIRMED: {
+                        resolve({ confirmed: true });
+                        break;
+                    }
+                    case ReceiveMessage.MESSAGE_REJECTED: {
+                        reject(new Error('Message rejected'));
+                        break;
+                    }
+                    default:
+                        reject(new Error('Unsupported message type'));
                 }
-            }, CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION);
+            };
+            if (!this.confirmationWindow) {
+                resolve({ confirmed: false });
+                return;
+            }
+            window.addEventListener('message', messageHandler);
+            const href = `${this.config.passportDomain}/transaction-confirmation/zkevm/message?messageID=${messageId}`;
+            this.showConfirmationScreen(href, messageHandler, resolve);
         });
     }
     loading(popupOptions) {
@@ -8680,6 +8935,17 @@ class ConfirmationScreen {
     closeWindow() {
         this.confirmationWindow?.close();
     }
+    showConfirmationScreen(href, messageHandler, resolve) {
+        this.confirmationWindow.location.href = href;
+        // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
+        const timer = setInterval(() => {
+            if (this.confirmationWindow?.closed) {
+                clearInterval(timer);
+                window.removeEventListener('message', messageHandler);
+                resolve({ confirmed: false });
+            }
+        }, CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION);
+    }
 }
 
 var RelayerTransactionStatus;
@@ -8708,13 +8974,9 @@ class TypedEventEmitter {
     }
 }
 
-// These are ignored by the Relayer but for consistency we set them to the
-// appropriate values for a 1/1 wallet.
-//
-// Weight of a single signature in the multisig
-const SIGNATURE_WEIGHT = 1;
-// Total required weight in the multisig
-const SIGNATURE_THRESHOLD = 1;
+const SIGNATURE_WEIGHT = 1; // Weight of a single signature in the multi-sig
+const TRANSACTION_SIGNATURE_THRESHOLD = 1; // Total required weight in the multi-sig for a transaction
+const EIP712_SIGNATURE_THRESHOLD = 2; // Total required weight in the multi-sig for data signing
 const ETH_SIGN_FLAG = '02';
 const ETH_SIGN_PREFIX = '\x19\x01';
 const META_TRANSACTIONS_TYPE = `tuple(
@@ -8747,11 +9009,12 @@ const getNonce = async (jsonRpcProvider, smartContractWalletAddress) => {
     }
     return 0;
 };
+const encodeMessageSubDigest = (chainId, walletAddress, digest) => (ethers.ethers.utils.solidityPack(['string', 'uint256', 'address', 'bytes32'], [ETH_SIGN_PREFIX, chainId, walletAddress, digest]));
 const getSignedMetaTransactions = async (metaTransactions, nonce, chainId, walletAddress, signer) => {
     const normalisedMetaTransactions = getNormalisedTransactions(metaTransactions);
     // Get the hash
     const digest = digestOfTransactionsAndNonce(nonce, normalisedMetaTransactions);
-    const completePayload = ethers.ethers.utils.solidityPack(['string', 'uint256', 'address', 'bytes32'], [ETH_SIGN_PREFIX, chainId, walletAddress, digest]);
+    const completePayload = encodeMessageSubDigest(chainId, walletAddress, digest);
     const hash = ethers.ethers.utils.keccak256(completePayload);
     // Sign the digest
     const hashArray = ethers.ethers.utils.arrayify(hash);
@@ -8759,7 +9022,7 @@ const getSignedMetaTransactions = async (metaTransactions, nonce, chainId, walle
     const signedDigest = `${ethsigNoType}${ETH_SIGN_FLAG}`;
     // Add metadata
     const encodedSignature = config$1.encodeSignature({
-        threshold: SIGNATURE_THRESHOLD,
+        threshold: TRANSACTION_SIGNATURE_THRESHOLD,
         signers: [
             {
                 weight: SIGNATURE_WEIGHT,
@@ -8775,6 +9038,35 @@ const getSignedMetaTransactions = async (metaTransactions, nonce, chainId, walle
         encodedSignature,
     ]);
 };
+const decodeRelayerTypedDataSignature = (relayerSignature) => {
+    const signatureWithThreshold = `0000${relayerSignature}`;
+    return config$1.decodeSignature(signatureWithThreshold);
+};
+const getSignedTypedData = async (typedData, relayerSignature, chainId, walletAddress, signer) => {
+    // Ethers auto-generates the EIP712Domain type in the TypedDataEncoder, and so it needs to be removed
+    const types = { ...typedData.types };
+    // @ts-ignore
+    delete types.EIP712Domain;
+    // eslint-disable-next-line no-underscore-dangle
+    const digest = ethers.ethers.utils._TypedDataEncoder.hash(typedData.domain, types, typedData.message);
+    const completePayload = encodeMessageSubDigest(chainId, walletAddress, digest);
+    const hash = ethers.ethers.utils.keccak256(completePayload);
+    // Sign the digest
+    const hashArray = ethers.ethers.utils.arrayify(hash);
+    const ethsigNoType = await signer.signMessage(hashArray);
+    const signedDigest = `${ethsigNoType}${ETH_SIGN_FLAG}`;
+    const { signers } = decodeRelayerTypedDataSignature(relayerSignature);
+    return config$1.encodeSignature({
+        threshold: EIP712_SIGNATURE_THRESHOLD,
+        signers: [
+            ...signers,
+            {
+                weight: SIGNATURE_WEIGHT,
+                signature: signedDigest,
+            },
+        ],
+    });
+};
 const getEip155ChainId = (chainId) => `eip155:${chainId}`;
 
 class RelayerClient {
@@ -8840,6 +9132,19 @@ class RelayerClient {
         const { result } = await this.postToRelayer(payload);
         return result;
     }
+    async imSignTypedData(address, eip712Payload) {
+        const { chainId } = await this.jsonRpcProvider.ready;
+        const payload = {
+            method: 'im_signTypedData',
+            params: [{
+                    address,
+                    eip712Payload,
+                    chainId: getEip155ChainId(chainId),
+                }],
+        };
+        const { result } = await this.postToRelayer(payload);
+        return result;
+    }
 }
 
 const MESSAGE_TO_SIGN = 'Only sign this message from Immutable Passport';
@@ -8980,6 +9285,60 @@ const sendTransaction = ({ params, magicProvider, jsonRpcProvider, relayerClient
     return relayerTransaction.hash;
 });
 
+const REQUIRED_TYPED_DATA_PROPERTIES = ['types', 'domain', 'primaryType', 'message'];
+const isValidTypedDataPayload = (typedData) => (REQUIRED_TYPED_DATA_PROPERTIES.every((key) => key in typedData));
+const transformTypedData = (typedData, chainId) => {
+    let transformedTypedData;
+    if (typeof typedData === 'string') {
+        try {
+            transformedTypedData = JSON.parse(typedData);
+        }
+        catch (err) {
+            throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `Failed to parse typed data JSON: ${err}`);
+        }
+    }
+    else if (typeof typedData === 'object') {
+        transformedTypedData = typedData;
+    }
+    else {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `Invalid typed data argument: ${typedData}`);
+    }
+    if (!isValidTypedDataPayload(transformedTypedData)) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `Invalid typed data argument. The following properties are required: ${REQUIRED_TYPED_DATA_PROPERTIES.join(', ')}`);
+    }
+    const providedChainId = transformedTypedData.domain?.chainId;
+    if (providedChainId) {
+        // domain.chainId (if defined) can be a number, string, or hex value, but the relayer & guardian only accept a number.
+        if (typeof providedChainId === 'string') {
+            if (providedChainId.startsWith('0x')) {
+                transformedTypedData.domain.chainId = parseInt(providedChainId, 16);
+            }
+            else {
+                transformedTypedData.domain.chainId = parseInt(providedChainId, 10);
+            }
+        }
+        if (transformedTypedData.domain.chainId !== chainId) {
+            throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `Invalid chainId, expected ${chainId}`);
+        }
+    }
+    return transformedTypedData;
+};
+const signTypedDataV4 = async ({ params, method, magicProvider, jsonRpcProvider, relayerClient, guardianClient, user, }) => guardianClient
+    .withConfirmationScreen({ width: 480, height: 730 })(async () => {
+    const fromAddress = params[0];
+    const typedDataParam = params[1];
+    if (!fromAddress || !typedDataParam) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `${method} requires an address and a typed data JSON`);
+    }
+    const { chainId } = await jsonRpcProvider.ready;
+    const typedData = transformTypedData(typedDataParam, chainId);
+    await guardianClient.validateMessage({ chainID: String(chainId), payload: typedData, user });
+    const relayerSignature = await relayerClient.imSignTypedData(fromAddress, typedData);
+    const magicWeb3Provider = new providers.Web3Provider(magicProvider);
+    const signer = magicWeb3Provider.getSigner();
+    return getSignedTypedData(typedData, relayerSignature, ethers.BigNumber.from(chainId), fromAddress, signer);
+});
+
 class ZkEvmProvider {
     authManager;
     config;
@@ -9063,6 +9422,21 @@ class ZkEvmProvider {
             case 'eth_accounts': {
                 return this.isLoggedIn() ? [this.user.zkEvm.ethAddress] : [];
             }
+            case 'eth_signTypedData':
+            case 'eth_signTypedData_v4': {
+                if (!this.isLoggedIn()) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorised - call eth_requestAccounts first');
+                }
+                return signTypedDataV4({
+                    method: request.method,
+                    params: request.params || [],
+                    magicProvider: this.magicProvider,
+                    jsonRpcProvider: this.jsonRpcProvider,
+                    relayerClient: this.relayerClient,
+                    user: this.user,
+                    guardianClient: this.guardianClient,
+                });
+            }
             // Pass through methods
             case 'eth_gasPrice':
             case 'eth_getBalance':
@@ -27383,6 +27757,8 @@ var $bc2bfebf768286d3$export$8cb0af6b2bed4b64;
 
 
 
+
+
 var $de275b98d2b651c3$export$788b1fd17f3dad84;
 (function(GasEstimateType) {
     GasEstimateType["BRIDGE_TO_L2"] = "BRIDGE_TO_L2";
@@ -27788,6 +28164,12 @@ var $4b58188d47aafe8d$export$537fa3efd10ed435;
     GasTokenType["NATIVE"] = "NATIVE";
     GasTokenType["ERC20"] = "ERC20";
 })($4b58188d47aafe8d$export$537fa3efd10ed435 || ($4b58188d47aafe8d$export$537fa3efd10ed435 = {}));
+var $4b58188d47aafe8d$export$3af78bb3e8650ee6;
+(function(FundingRouteType) {
+    FundingRouteType["BRIDGE"] = "BRIDGE";
+    FundingRouteType["ONRAMP"] = "ONRAMP";
+    FundingRouteType["SWAP"] = "SWAP";
+})($4b58188d47aafe8d$export$3af78bb3e8650ee6 || ($4b58188d47aafe8d$export$3af78bb3e8650ee6 = {}));
 
 
 var $e055e79256bbc1dd$export$80f4da0d409a629d;
@@ -27833,6 +28215,7 @@ var $e055e79256bbc1dd$export$80f4da0d409a629d;
     CheckoutErrorType["EXECUTE_FULFILMENT_TRANSACTION_ERROR"] = "EXECUTE_FULFILMENT_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";
 })($a8bc256d81a5e2c1$export$e3dc0620abde7f5a || ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a = {}));
 class $a8bc256d81a5e2c1$export$b722478a3cbfa3bc extends Error {
     message;
@@ -29479,12 +29862,6 @@ var $b23305044c0e096a$export$3057de18ac0c076;
     RouteCalculatorType["NO_ROUTES"] = "NO_ROUTES";
     RouteCalculatorType["NO_OPTIONS"] = "NO_OPTIONS";
 })($b23305044c0e096a$export$3057de18ac0c076 || ($b23305044c0e096a$export$3057de18ac0c076 = {}));
-var $b23305044c0e096a$export$3af78bb3e8650ee6;
-(function(FundingRouteType) {
-    FundingRouteType["BRIDGE"] = "BRIDGE";
-    FundingRouteType["ON_RAMP"] = "ONRAMP";
-    FundingRouteType["SWAP"] = "SWAP";
-})($b23305044c0e096a$export$3af78bb3e8650ee6 || ($b23305044c0e096a$export$3af78bb3e8650ee6 = {}));
 
 
 
@@ -29544,7 +29921,6 @@ const $33acec7b4a26c053$export$23ddeb2642d2f9d = async (config, readOnlyProvider
 
 
 
-
 const $f730af3b727f04ac$export$22fea095b15361de = (balances)=>{
     for (const balance of balances.balances){
         if (!balance.token.address || balance.token.address === "") return balance.balance;
@@ -29628,6 +30004,18 @@ const $5a5ccedc98d53d25$var$filterTokens = (allowedTokens, balances)=>{
     });
     return [];
 };
+const $5a5ccedc98d53d25$export$9ec9fc71f3ce62c4 = async (config, availableRoutingOptions)=>{
+    if (availableRoutingOptions.onRamp) {
+        const onRampOptions = await config.remote.getConfig("onramp");
+        const onRampAllowList = {};
+        Object.entries(onRampOptions).forEach(([onRampProvider, onRampProviderConfig])=>{
+            // Allowed list per onRamp provider
+            onRampAllowList[onRampProvider] = onRampProviderConfig.tokens ?? [];
+        });
+        return onRampAllowList;
+    }
+    return {};
+};
 const $5a5ccedc98d53d25$export$d744af9f1c0712bc = async (config, tokenBalances, availableRoutingOptions)=>{
     if (availableRoutingOptions.bridge) {
         const allowedTokens = (await config.remote.getConfig("bridge"))?.tokens ?? [];
@@ -29636,6 +30024,21 @@ const $5a5ccedc98d53d25$export$d744af9f1c0712bc = async (config, tokenBalances,
     }
     return [];
 };
+const $5a5ccedc98d53d25$export$87ed7f956d73690 = async (config, tokenBalances, availableRoutingOptions)=>{
+    if (availableRoutingOptions.swap) {
+        const allowedTokens = (await config.remote.getConfig("dex"))?.tokens ?? [];
+        const balances = tokenBalances.get(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
+        return $5a5ccedc98d53d25$var$filterTokens(allowedTokens, balances);
+    }
+    return [];
+};
+const $5a5ccedc98d53d25$export$1ad29657d49c5440 = async (config, tokenBalances, availableRoutingOptions)=>{
+    const tokenAllowList = {};
+    tokenAllowList.swap = await $5a5ccedc98d53d25$export$87ed7f956d73690(config, tokenBalances, availableRoutingOptions);
+    tokenAllowList.bridge = await $5a5ccedc98d53d25$export$d744af9f1c0712bc(config, tokenBalances, availableRoutingOptions);
+    tokenAllowList.onRamp = await $5a5ccedc98d53d25$export$9ec9fc71f3ce62c4(config, availableRoutingOptions);
+    return tokenAllowList;
+};
 
 
 const $fa9ac5bfdbbf9dfa$export$9994ad18c2f0e665 = (balances, totalFees)=>{
@@ -29663,14 +30066,14 @@ const $fa9ac5bfdbbf9dfa$export$952cdf461a00a8c6 = async (config, balanceRequirem
     return l1address;
 };
 const $fa9ac5bfdbbf9dfa$export$da05aed50d75046 = async (config, readOnlyProviders, feeEstimates)=>{
-    let bridgeFeeEstimate = feeEstimates.get(($b23305044c0e096a$export$3af78bb3e8650ee6).BRIDGE);
+    let bridgeFeeEstimate = feeEstimates.get(($4b58188d47aafe8d$export$3af78bb3e8650ee6).BRIDGE);
     if (bridgeFeeEstimate) return bridgeFeeEstimate;
     bridgeFeeEstimate = await ($8a49d1a3783a2640$export$3aff971444a4f244)(config, readOnlyProviders);
-    feeEstimates.set(($b23305044c0e096a$export$3af78bb3e8650ee6).BRIDGE, bridgeFeeEstimate);
+    feeEstimates.set(($4b58188d47aafe8d$export$3af78bb3e8650ee6).BRIDGE, bridgeFeeEstimate);
     return bridgeFeeEstimate;
 };
 const $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute = (chainId, balance)=>({
-        type: ($b23305044c0e096a$export$3af78bb3e8650ee6).BRIDGE,
+        type: ($4b58188d47aafe8d$export$3af78bb3e8650ee6).BRIDGE,
         chainId: chainId,
         asset: {
             balance: balance.balance,
@@ -29726,6 +30129,7 @@ const $fa9ac5bfdbbf9dfa$export$ddc7ba2b57d7c5fa = async (config, readOnlyProvide
 
 
 
+
 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;
@@ -29743,16 +30147,199 @@ async function $0e0060cb42e136d2$export$339cb2be73677b30(config, existingReadOnl
 
 
 
+
+
+
+
+
+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 = (ethers.BigNumber).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: (ethers.BigNumber).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 === (ethers.BigNumber).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)=>{
+    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
+            }
+        };
+    }
+    return undefined;
+};
+
+
+
+
+
 const $c16168a9c28ae4fd$export$31ce7ba1a2956195 = (balanceRequirements)=>{
     let insufficientBalanceCount = 0;
-    let insufficientBridgeRequirement;
+    let insufficientRequirement;
     for (const balanceRequirement of balanceRequirements.balanceRequirements)if (!balanceRequirement.sufficient) {
         insufficientBalanceCount++;
-        insufficientBridgeRequirement = balanceRequirement;
+        insufficientRequirement = balanceRequirement;
     }
-    if (insufficientBalanceCount === 1) return insufficientBridgeRequirement;
+    if (insufficientBalanceCount === 1) return insufficientRequirement;
     return undefined;
 };
+const $c16168a9c28ae4fd$export$c39a7b7dc167cdb4 = async (config, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, swapTokenAllowList)=>{
+    if (!availableRoutingOptions.swap) return undefined;
+    if (insufficientRequirement === undefined) return undefined;
+    if (swapTokenAllowList === undefined) return undefined;
+    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;
+    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;
+};
 const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, balanceRequirements, availableRoutingOptions)=>{
     let readOnlyProviders;
     try {
@@ -29763,40 +30350,52 @@ const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, b
         });
     }
     const tokenBalances = await ($33acec7b4a26c053$export$23ddeb2642d2f9d)(config, readOnlyProviders, ownerAddress, availableRoutingOptions);
+    const allowList = await ($5a5ccedc98d53d25$export$1ad29657d49c5440)(config, tokenBalances, availableRoutingOptions);
     // Bridge and swap fee cache
     const feeEstimates = new Map();
-    // Ensures only 1 balance requirement is insufficient otherwise one bridge route cannot be recommended
-    let bridgeFundingStep;
+    // Dex quotes cache
+    const dexQuoteCache = new Map();
+    // Ensures only 1 balance requirement is insufficient otherwise one bridge or one swap route cannot be recommended
     const insufficientRequirement = $c16168a9c28ae4fd$export$31ce7ba1a2956195(balanceRequirements);
+    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);
     // Check on-ramp routes
     // Check swap routes
     // > Could bridge first
     // > Could on-ramp first
     // > Could double swap
-    if (bridgeFundingStep) return {
-        availableOptions: [],
-        response: {
-            type: ($b23305044c0e096a$export$3057de18ac0c076).ROUTES_FOUND,
-            message: "Routes found"
-        },
-        fundingRoutes: [
-            {
-                priority: 1,
-                steps: [
-                    bridgeFundingStep
-                ]
-            }
-        ]
-    };
-    return {
-        availableOptions: [],
+    const response = {
         response: {
             type: ($b23305044c0e096a$export$3057de18ac0c076).NO_ROUTES,
             message: "Routes not found"
         },
         fundingRoutes: []
     };
+    let priority = 0;
+    if (bridgeFundingStep || swapFundingStep) {
+        response.response.type = ($b23305044c0e096a$export$3057de18ac0c076).ROUTES_FOUND;
+        response.response.message = "Routes found";
+    }
+    if (bridgeFundingStep) {
+        priority++;
+        response.fundingRoutes.push({
+            priority: priority,
+            steps: [
+                bridgeFundingStep
+            ]
+        });
+    }
+    if (swapFundingStep) {
+        priority++;
+        response.fundingRoutes.push({
+            priority: priority,
+            steps: [
+                swapFundingStep
+            ]
+        });
+    }
+    return response;
 };
 
 
@@ -30120,27 +30719,80 @@ 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((ethers.BigNumber).from(feePercentageMultiplier)).div(10 ** $9051cee080948594$export$768e717351d4b176);
+    return bnFeeAmount;
+};
+const $9051cee080948594$var$calculateFeesToken = (orderFee, decimals)=>{
+    const feeToken = orderFee.amount;
+    const bnFeeAmount = (utils$1.parseUnits)(feeToken.token, decimals);
+    return bnFeeAmount;
+};
+const $9051cee080948594$export$1e69c9cfc42e28d8 = (orderFees, weiAmount, decimals = 18)=>{
+    let totalTokenFees = (ethers.BigNumber).from(0);
+    const amountBn = (ethers.BigNumber).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 = (ethers.BigNumber).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,
         contractAddress: contractAddress,
         spenderAddress: spenderAddress
     });
-const $9085b221b72ac69e$export$586d02673c66d423 = (buyToken)=>{
+const $9085b221b72ac69e$export$586d02673c66d423 = (buyToken, decimals = 18)=>{
+    const bnAmount = (utils$1.parseUnits)(buyToken.amount, decimals);
     if (buyToken.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE) return {
         type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE,
-        amount: buyToken.amount.toString()
+        amount: bnAmount.toString()
     };
     return {
         type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20,
-        amount: buyToken.amount.toString(),
+        amount: bnAmount.toString(),
         contractAddress: buyToken.contractAddress
     };
 };
-const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, id, contractAddress, buyToken)=>{
+const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, orders)=>{
     let orderbook;
     let listing;
     let spenderAddress = "";
+    if (orders.length === 0) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No orders were parsed, must parse at least one order", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PREPARE_ORDER_LISTING_ERROR);
+    const { buyToken: buyToken, sellToken: sellToken, makerFees: makerFees } = orders[0];
+    let decimals = 18;
+    if (buyToken.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) {
+        // get this from the allowed list
+        const buyTokenContract = new (ethers.Contract)(buyToken.contractAddress, JSON.stringify(($d85ad1457a3f1a83$export$db5daa1b5156ccfe)), provider);
+        decimals = buyTokenContract.decimals();
+    }
+    const buyTokenOrNative = $9085b221b72ac69e$export$586d02673c66d423(buyToken, decimals);
     try {
         const walletAddress = await provider.getSigner().getAddress();
         orderbook = await $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
@@ -30148,22 +30800,22 @@ const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, id, c
         spenderAddress = seaportContractAddress;
         listing = await orderbook.prepareListing({
             makerAddress: walletAddress,
-            buy: $9085b221b72ac69e$export$586d02673c66d423(buyToken),
+            buy: buyTokenOrNative,
             sell: {
                 type: (0, $4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721,
-                contractAddress: contractAddress,
-                tokenId: id
+                contractAddress: sellToken.collectionAddress,
+                tokenId: sellToken.id
             }
         });
     } catch (err) {
         throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while preparing the listing", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PREPARE_ORDER_LISTING_ERROR, {
             message: err.message,
-            id: id,
-            collectionAddress: contractAddress
+            id: sellToken.id,
+            collectionAddress: sellToken.collectionAddress
         });
     }
     const itemRequirements = [
-        $9085b221b72ac69e$export$af768ccdf17d5c04(id, contractAddress, spenderAddress)
+        $9085b221b72ac69e$export$af768ccdf17d5c04(sellToken.id, sellToken.collectionAddress, spenderAddress)
     ];
     const smartCheckoutResult = await ($0e7419077c373b24$export$9e073f9ada8c81e6)(config, provider, itemRequirements, {
         type: ($4b58188d47aafe8d$export$65c64e46348ee3c1).GAS,
@@ -30177,15 +30829,15 @@ const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, id, c
         if (!unsignedMessage) // For sell it is expected the orderbook will always return an unsigned message
         // If for some reason it is missing then we cannot proceed with the create listing
         throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("The unsigned message is missing after preparing the listing", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).SIGN_MESSAGE_ERROR, {
-            id: id,
-            collectionAddress: contractAddress
+            id: sellToken.id,
+            collectionAddress: sellToken.collectionAddress
         });
         const signedMessage = await ($25ac589234c10b67$export$1d9a7a8a40780de)(provider, unsignedMessage);
         const unsignedTransactions = await ($a7367d01c6e76b1c$export$b087719c36e0f2dc)(listing.actions);
         const approvalResult = await ($25ac589234c10b67$export$19693ca396db083e)(provider, unsignedTransactions.approvalTransactions);
         if (approvalResult.type === ($d855a5ba32004345$export$f51b97f3aaf2d5a8).FAILED) return {
-            id: id,
-            collectionAddress: contractAddress,
+            id: sellToken.id,
+            collectionAddress: sellToken.collectionAddress,
             smartCheckoutResult: smartCheckoutResult,
             status: {
                 type: ($c2874b006e92b115$export$a9780122aaa0801a).FAILED,
@@ -30194,23 +30846,31 @@ const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, id, c
             }
         };
         let orderId = "";
+        const createListingParams = {
+            orderComponents: signedMessage.orderComponents,
+            orderHash: signedMessage.orderHash,
+            orderSignature: signedMessage.signedMessage
+        };
+        if (makerFees !== undefined) {
+            const orderBookFees = ($9051cee080948594$export$1e69c9cfc42e28d8)(makerFees, buyTokenOrNative.amount, decimals);
+            // @TODO add support for an array of fees when the orderbook enables it
+            if (orderBookFees.length !== makerFees.length) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("One of the fees is too small, must be greater than 0.000001", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CREATE_ORDER_LISTING_ERROR);
+            const [makerFee] = orderBookFees;
+            createListingParams.makerFee = makerFee;
+        }
         try {
-            const order = await orderbook.createListing({
-                orderComponents: signedMessage.orderComponents,
-                orderHash: signedMessage.orderHash,
-                orderSignature: signedMessage.signedMessage
-            });
+            const order = await orderbook.createListing(createListingParams);
             orderId = order.result.id;
         } catch (err) {
             throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while creating the listing", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CREATE_ORDER_LISTING_ERROR, {
                 message: err.message,
-                id: id,
-                collectionAddress: contractAddress
+                collectionId: sellToken.id,
+                collectionAddress: sellToken.collectionAddress
             });
         }
         return {
-            id: id,
-            collectionAddress: contractAddress,
+            id: sellToken.id,
+            collectionAddress: sellToken.collectionAddress,
             smartCheckoutResult: smartCheckoutResult,
             status: {
                 type: ($c2874b006e92b115$export$a9780122aaa0801a).SUCCESS,
@@ -30219,8 +30879,8 @@ const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, id, c
         };
     }
     return {
-        id: id,
-        collectionAddress: contractAddress,
+        id: sellToken.id,
+        collectionAddress: sellToken.collectionAddress,
         smartCheckoutResult: smartCheckoutResult
     };
 };
@@ -30406,12 +31066,16 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
     /**
    * Determines the requirements for performing a sell.
    * @param {SellParams} params - The parameters for the sell.
+   * Only currently actions the first order in the array until we support batch processing.
+   * Only currently actions the first fee in the fees array of each order until we support multiple fees.
   */ async sell(params) {
         if (this.config.isProduction) throw new Error("This endpoint is not currently available.");
         // eslint-disable-next-line no-console
         console.warn("This endpoint is currently under construction.");
+        if (params.orders.length > 1) // eslint-disable-next-line no-console
+        console.warn("This endpoint currently only actions the first order in the array.");
         const web3Provider = await $bb88265fe45a0393$export$9e1fd9cc88c637a0(this.config, params.provider);
-        await $9085b221b72ac69e$export$e761f9e0703de895(this.config, web3Provider, params.id, params.collectionAddress, params.buyToken);
+        await $9085b221b72ac69e$export$e761f9e0703de895(this.config, web3Provider, params.orders);
     }
     /**
    * Cancels a sell.
@@ -30509,31 +31173,30 @@ var checkout_sdk = /*#__PURE__*/Object.freeze({
 function $parcel$export(e, n, v, s) {
   Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
 }
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.17.6";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.18.1";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 
 
 function $430e3eda76fa4d5f$export$46b1ae20f762ad4c(version) {
     const defaultPackageVersion = ($d663162fd5a0853f$export$1169f5475725171b)();
-    if (version === undefined) return defaultPackageVersion;
-    // Pre-production release
-    // TODO: https://immutable.atlassian.net/browse/WT-1501
-    if (version.major === undefined || version.minor === undefined || version.patch === undefined || version.prerelease === undefined) return defaultPackageVersion;
-    if (version.major < 0) return defaultPackageVersion;
-    if (version.minor < 0) return defaultPackageVersion;
-    if (version.patch < 0) return defaultPackageVersion;
-    if (version.prerelease !== "alpha") return defaultPackageVersion;
+    if (version === undefined || version.major === undefined) return defaultPackageVersion;
+    if (!Number.isInteger(version.major) || version.major < 0) return defaultPackageVersion;
+    if (version.minor !== undefined && version.minor < 0) return defaultPackageVersion;
+    if (version.patch !== undefined && version.patch < 0) return defaultPackageVersion;
+    if (version.major === 0 && version.minor === undefined) return defaultPackageVersion;
+    if (version.major === 0 && version.minor === 0 && version.patch === undefined) return defaultPackageVersion;
+    if (version.major === 0 && version.minor === undefined && version.patch === undefined) return defaultPackageVersion;
     if (version.major === 0 && version.minor === 0 && version.patch === 0) return defaultPackageVersion;
-    let validatedVersion = defaultPackageVersion;
-    if (!Number.isNaN(version.major) && version.major >= 0) validatedVersion = version.major.toString();
-    if (!Number.isNaN(version.minor)) validatedVersion += `.${version.minor.toString()}`;
-    if (!Number.isNaN(version.patch)) validatedVersion += `.${version.patch.toString()}`;
-    // TODO: https://immutable.atlassian.net/browse/WT-1501
-    // Ensure this is gated by `version.prerelease !== undefined`
-    // once we go to prod with checkout.
-    validatedVersion += `-${version.prerelease}`;
-    if (version.build !== undefined && version.build > 0) validatedVersion += `.${version.build}`;
+    let validatedVersion = version.major.toString();
+    if (version.minor === undefined) return validatedVersion;
+    if (Number.isInteger(version.minor)) validatedVersion += `.${version.minor.toString()}`;
+    if (version.patch === undefined) return validatedVersion;
+    if (Number.isInteger(version.patch)) validatedVersion += `.${version.patch.toString()}`;
+    if (version.prerelease === undefined || version.prerelease !== "alpha") return validatedVersion;
+    if (version.prerelease === "alpha") validatedVersion += `-${version.prerelease}`;
+    if (version.build === undefined) return validatedVersion;
+    if (Number.isInteger(version.build) && version.build >= 0) validatedVersion += `.${version.build.toString()}`;
     return validatedVersion;
 }
 function $430e3eda76fa4d5f$export$af210a0808087845(config) {
@@ -30665,7 +31328,6 @@ $parcel$export($045213b18e9f1f94$exports, "CheckoutWidgetTagNames", () => $04521
 (function(WidgetTheme) {
     WidgetTheme["LIGHT"] = "light";
     WidgetTheme["DARK"] = "dark";
-    WidgetTheme["CUSTOM"] = "custom";
 })($045213b18e9f1f94$export$c88931fdc51854eb || ($045213b18e9f1f94$export$c88931fdc51854eb = {}));
 var $045213b18e9f1f94$export$75be0f6af9650f2c;
 (function(CheckoutWidgetTagNames) {