@imtbl/sdk 0.45.2 → 0.45.3-alpha

package/dist/checkout.js

@@ -11,6 +11,264 @@ import { SwapRouter, PaymentsExtended } from '@uniswap/router-sdk';
 import FormData$2 from 'form-data';
 import { Seaport as Seaport$1 } from '@opensea/seaport-js';
 
+const isNode$1 = () => typeof window === 'undefined';
+const isBrowser$1 = () => !isNode$1();
+
+var Detail$1;
+(function (Detail) {
+    Detail["RUNTIME_ID"] = "rid";
+    Detail["PASSPORT_CLIENT_ID"] = "passportClientId";
+    Detail["ENVIRONMENT"] = "env";
+    Detail["PUBLISHABLE_API_KEY"] = "pak";
+    Detail["IDENTITY"] = "uid";
+    Detail["DOMAIN"] = "domain";
+})(Detail$1 || (Detail$1 = {}));
+var Store$1;
+(function (Store) {
+    Store["EVENTS"] = "events";
+    Store["RUNTIME"] = "runtime";
+})(Store$1 || (Store$1 = {}));
+const POLLING_FREQUENCY$1 = 5000;
+
+const IMTBL_API$1 = 'https://api.x.immutable.com';
+async function post$1(path, data) {
+    const client = globalAxios.create({
+        baseURL: IMTBL_API$1,
+    });
+    const payload = JSON.stringify(data);
+    const body = {
+        payload: btoa(payload),
+    };
+    const response = await client.post(path, body);
+    return response.data;
+}
+
+/**
+ * Abstraction on localstorage
+ */
+const localStoragePrefix$1 = '__IMX-';
+const hasLocalstorage$1 = () => isBrowser$1() && window.localStorage;
+const parseItem$1 = (payload) => {
+    // Try to parse, if can't be parsed assume string
+    // and return string
+    if (payload === null)
+        return undefined;
+    try {
+        return JSON.parse(payload);
+    }
+    catch (error) {
+        // Assumes it's a string.
+        return payload;
+    }
+};
+const serialiseItem$1 = (payload) => {
+    if (typeof payload === 'string') {
+        return payload;
+    }
+    return JSON.stringify(payload);
+};
+/**
+ * GenKey will take into account the namespace
+ * as well as if being run in the Link, it will tap into the link
+ * @param {string} key
+ * @returns key
+ */
+const genKey$1 = (key) => `${localStoragePrefix$1}${key}`;
+function getItem$1(key) {
+    if (hasLocalstorage$1()) {
+        return parseItem$1(window.localStorage.getItem(genKey$1(key)));
+    }
+    return undefined;
+}
+const setItem$1 = (key, payload) => {
+    if (hasLocalstorage$1()) {
+        window.localStorage.setItem(genKey$1(key), serialiseItem$1(payload));
+        return true;
+    }
+    return false;
+};
+
+// In memory storage for events and other data
+let EVENT_STORE$1;
+let RUNTIME_DETAILS$1;
+// Initialise store and runtime
+const initialise$1$1 = () => {
+    EVENT_STORE$1 = getItem$1(Store$1.EVENTS) || [];
+    RUNTIME_DETAILS$1 = getItem$1(Store$1.RUNTIME) || {};
+};
+initialise$1$1();
+// Runtime Details
+const storeDetail$1 = (key, value) => {
+    RUNTIME_DETAILS$1 = {
+        ...RUNTIME_DETAILS$1,
+        [key]: value,
+    };
+    setItem$1(Store$1.RUNTIME, RUNTIME_DETAILS$1);
+};
+const getDetail$1 = (key) => {
+    // Handle the scenario where detail is a falsy value
+    if (RUNTIME_DETAILS$1[key] === undefined) {
+        return undefined;
+    }
+    return RUNTIME_DETAILS$1[key];
+};
+const getAllDetails$1 = () => RUNTIME_DETAILS$1;
+// Events
+const getEvents$1 = () => EVENT_STORE$1;
+const addEvent = (event) => {
+    EVENT_STORE$1.push(event);
+    setItem$1(Store$1.EVENTS, EVENT_STORE$1);
+};
+const removeSentEvents$1 = (numberOfEvents) => {
+    EVENT_STORE$1 = EVENT_STORE$1.slice(numberOfEvents);
+    setItem$1(Store$1.EVENTS, EVENT_STORE$1);
+};
+const flattenProperties$1 = (properties) => {
+    const propertyMap = [];
+    Object.entries(properties).forEach(([key, value]) => {
+        if (typeof value === 'string' || typeof value === 'number') {
+            propertyMap.push([key, value.toString()]);
+        }
+    });
+    return propertyMap;
+};
+
+let initialised$1 = false;
+const isInitialised$1 = () => initialised$1;
+const getReferrer$1 = () => {
+    if (isNode$1()) {
+        return '';
+    }
+    if (window.location.ancestorOrigins
+        && window.location.ancestorOrigins.length > 0) {
+        return new URL(window.location.ancestorOrigins[0]).hostname;
+    }
+    return document.referrer ? new URL(window.document.referrer).hostname : '';
+};
+const runtimeHost$1 = () => {
+    if (isNode$1()) {
+        return '';
+    }
+    if (window.opener || window.parent !== window) {
+        return getReferrer$1();
+    }
+    return new URL(window.location.href).hostname;
+};
+const getRuntimeDetails$1 = () => {
+    if (isNode$1()) {
+        return { browser: 'nodejs' };
+    }
+    const domain = runtimeHost$1();
+    if (domain) {
+        storeDetail$1(Detail$1.DOMAIN, domain);
+    }
+    return {
+        browser: window.navigator.userAgent,
+        domain,
+        tz: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        screen: `${window.screen.width}x${window.screen.height}`,
+    };
+};
+const initialise$2 = async () => {
+    const runtimeDetails = flattenProperties$1(getRuntimeDetails$1());
+    // Get any existing runtimeId and send it along with the initialise
+    const existingRuntimeId = getDetail$1(Detail$1.RUNTIME_ID);
+    const body = {
+        version: 1,
+        data: {
+            runtimeDetails,
+            runtimeId: existingRuntimeId,
+        },
+    };
+    const response = await post$1('/v1/sdk/initialise', body);
+    // Get runtimeId and store it
+    const { runtimeId } = response;
+    storeDetail$1(Detail$1.RUNTIME_ID, runtimeId);
+    initialised$1 = true;
+};
+
+function errorBoundary$1(fn) {
+    const wrappedFunction = ((...args) => {
+        try {
+            // Execute the original function
+            const result = fn(...args);
+            if (result instanceof Promise) {
+                // Silent fail for now, in future
+                // we can send errors to a logging service
+                return result.catch(() => undefined);
+            }
+            return result;
+        }
+        catch (error) {
+            // As above, fail silently for now
+            return undefined;
+        }
+    });
+    return wrappedFunction;
+}
+
+function isTestEnvironment$1() {
+    if (typeof process === 'undefined') {
+        return false;
+    }
+    return process.env.JEST_WORKER_ID !== undefined;
+}
+
+// Store the event in the event store
+const trackFn = (moduleName, eventName, properties) => {
+    const event = {
+        event: `${moduleName}.${eventName}`,
+        time: new Date().toISOString(),
+        ...(properties && { properties: flattenProperties$1(properties) }),
+    };
+    addEvent(event);
+};
+const track = errorBoundary$1(trackFn);
+// Sending events to the server
+const flushFn$1 = async () => {
+    // Don't flush if not initialised
+    if (isInitialised$1() === false) {
+        await initialise$2();
+        return;
+    }
+    const events = getEvents$1();
+    if (events.length === 0) {
+        return;
+    }
+    // Track events length here, incase
+    const numEvents = events.length;
+    // Get details and send it with the track request
+    const details = getAllDetails$1();
+    const metricsPayload = {
+        version: 1,
+        data: {
+            events,
+            details,
+        },
+    };
+    const response = await post$1('/v1/sdk/metrics', metricsPayload);
+    if (response instanceof Error) {
+        return;
+    }
+    // Clear events if successfully posted
+    removeSentEvents$1(numEvents);
+};
+const flush$1 = errorBoundary$1(flushFn$1);
+// Flush events every 5 seconds
+const flushPoll$1 = async () => {
+    await flush$1();
+    setTimeout(flushPoll$1, POLLING_FREQUENCY$1);
+};
+// This will get initialised when module is imported.
+if (!isTestEnvironment$1()) {
+    errorBoundary$1(flushPoll$1)();
+}
+
+const setEnvironmentFn = (env) => {
+    storeDetail$1(Detail$1.ENVIRONMENT, env);
+};
+const setEnvironment = errorBoundary$1(setEnvironmentFn);
+
 var Environment$1;
 (function (Environment) {
     Environment["PRODUCTION"] = "production";
@@ -23,6 +281,8 @@ class ImmutableConfiguration {
     publishableKey;
     constructor(options) {
         this.environment = options.environment;
+        setEnvironment(options.environment);
+        track('config', 'load_imtbl_config');
     }
 }
 
@@ -16695,6 +16955,244 @@ class TokenBridge {
     }
 }
 
+const isNode = () => typeof window === 'undefined';
+const isBrowser = () => !isNode();
+
+var Detail;
+(function (Detail) {
+    Detail["RUNTIME_ID"] = "rid";
+    Detail["PASSPORT_CLIENT_ID"] = "passportClientId";
+    Detail["ENVIRONMENT"] = "env";
+    Detail["PUBLISHABLE_API_KEY"] = "pak";
+    Detail["IDENTITY"] = "uid";
+    Detail["DOMAIN"] = "domain";
+})(Detail || (Detail = {}));
+var Store;
+(function (Store) {
+    Store["EVENTS"] = "events";
+    Store["RUNTIME"] = "runtime";
+})(Store || (Store = {}));
+const POLLING_FREQUENCY = 5000;
+
+const IMTBL_API = 'https://api.x.immutable.com';
+async function post(path, data) {
+    const client = axios$1.create({
+        baseURL: IMTBL_API,
+    });
+    const payload = JSON.stringify(data);
+    const body = {
+        payload: btoa(payload),
+    };
+    const response = await client.post(path, body);
+    return response.data;
+}
+
+/**
+ * Abstraction on localstorage
+ */
+const localStoragePrefix = '__IMX-';
+const hasLocalstorage = () => isBrowser() && window.localStorage;
+const parseItem = (payload) => {
+    // Try to parse, if can't be parsed assume string
+    // and return string
+    if (payload === null)
+        return undefined;
+    try {
+        return JSON.parse(payload);
+    }
+    catch (error) {
+        // Assumes it's a string.
+        return payload;
+    }
+};
+const serialiseItem = (payload) => {
+    if (typeof payload === 'string') {
+        return payload;
+    }
+    return JSON.stringify(payload);
+};
+/**
+ * GenKey will take into account the namespace
+ * as well as if being run in the Link, it will tap into the link
+ * @param {string} key
+ * @returns key
+ */
+const genKey = (key) => `${localStoragePrefix}${key}`;
+function getItem(key) {
+    if (hasLocalstorage()) {
+        return parseItem(window.localStorage.getItem(genKey(key)));
+    }
+    return undefined;
+}
+const setItem = (key, payload) => {
+    if (hasLocalstorage()) {
+        window.localStorage.setItem(genKey(key), serialiseItem(payload));
+        return true;
+    }
+    return false;
+};
+
+// In memory storage for events and other data
+let EVENT_STORE;
+let RUNTIME_DETAILS;
+// Initialise store and runtime
+const initialise$1 = () => {
+    EVENT_STORE = getItem(Store.EVENTS) || [];
+    RUNTIME_DETAILS = getItem(Store.RUNTIME) || {};
+};
+initialise$1();
+// Runtime Details
+const storeDetail = (key, value) => {
+    RUNTIME_DETAILS = {
+        ...RUNTIME_DETAILS,
+        [key]: value,
+    };
+    setItem(Store.RUNTIME, RUNTIME_DETAILS);
+};
+const getDetail = (key) => {
+    // Handle the scenario where detail is a falsy value
+    if (RUNTIME_DETAILS[key] === undefined) {
+        return undefined;
+    }
+    return RUNTIME_DETAILS[key];
+};
+const getAllDetails = () => RUNTIME_DETAILS;
+// Events
+const getEvents = () => EVENT_STORE;
+const removeSentEvents = (numberOfEvents) => {
+    EVENT_STORE = EVENT_STORE.slice(numberOfEvents);
+    setItem(Store.EVENTS, EVENT_STORE);
+};
+const flattenProperties = (properties) => {
+    const propertyMap = [];
+    Object.entries(properties).forEach(([key, value]) => {
+        if (typeof value === 'string' || typeof value === 'number') {
+            propertyMap.push([key, value.toString()]);
+        }
+    });
+    return propertyMap;
+};
+
+let initialised = false;
+const isInitialised = () => initialised;
+const getReferrer = () => {
+    if (isNode()) {
+        return '';
+    }
+    if (window.location.ancestorOrigins
+        && window.location.ancestorOrigins.length > 0) {
+        return new URL(window.location.ancestorOrigins[0]).hostname;
+    }
+    return document.referrer ? new URL(window.document.referrer).hostname : '';
+};
+const runtimeHost = () => {
+    if (isNode()) {
+        return '';
+    }
+    if (window.opener || window.parent !== window) {
+        return getReferrer();
+    }
+    return new URL(window.location.href).hostname;
+};
+const getRuntimeDetails = () => {
+    if (isNode()) {
+        return { browser: 'nodejs' };
+    }
+    const domain = runtimeHost();
+    if (domain) {
+        storeDetail(Detail.DOMAIN, domain);
+    }
+    return {
+        browser: window.navigator.userAgent,
+        domain,
+        tz: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        screen: `${window.screen.width}x${window.screen.height}`,
+    };
+};
+const initialise = async () => {
+    const runtimeDetails = flattenProperties(getRuntimeDetails());
+    // Get any existing runtimeId and send it along with the initialise
+    const existingRuntimeId = getDetail(Detail.RUNTIME_ID);
+    const body = {
+        version: 1,
+        data: {
+            runtimeDetails,
+            runtimeId: existingRuntimeId,
+        },
+    };
+    const response = await post('/v1/sdk/initialise', body);
+    // Get runtimeId and store it
+    const { runtimeId } = response;
+    storeDetail(Detail.RUNTIME_ID, runtimeId);
+    initialised = true;
+};
+
+function errorBoundary(fn) {
+    const wrappedFunction = ((...args) => {
+        try {
+            // Execute the original function
+            const result = fn(...args);
+            if (result instanceof Promise) {
+                // Silent fail for now, in future
+                // we can send errors to a logging service
+                return result.catch(() => undefined);
+            }
+            return result;
+        }
+        catch (error) {
+            // As above, fail silently for now
+            return undefined;
+        }
+    });
+    return wrappedFunction;
+}
+
+function isTestEnvironment() {
+    if (typeof process === 'undefined') {
+        return false;
+    }
+    return process.env.JEST_WORKER_ID !== undefined;
+}
+// Sending events to the server
+const flushFn = async () => {
+    // Don't flush if not initialised
+    if (isInitialised() === false) {
+        await initialise();
+        return;
+    }
+    const events = getEvents();
+    if (events.length === 0) {
+        return;
+    }
+    // Track events length here, incase
+    const numEvents = events.length;
+    // Get details and send it with the track request
+    const details = getAllDetails();
+    const metricsPayload = {
+        version: 1,
+        data: {
+            events,
+            details,
+        },
+    };
+    const response = await post('/v1/sdk/metrics', metricsPayload);
+    if (response instanceof Error) {
+        return;
+    }
+    // Clear events if successfully posted
+    removeSentEvents(numEvents);
+};
+const flush = errorBoundary(flushFn);
+// Flush events every 5 seconds
+const flushPoll = async () => {
+    await flush();
+    setTimeout(flushPoll, POLLING_FREQUENCY);
+};
+// This will get initialised when module is imported.
+if (!isTestEnvironment()) {
+    errorBoundary(flushPoll)();
+}
+
 var Environment;
 (function (Environment) {
     Environment["PRODUCTION"] = "production";
@@ -16871,7 +17369,7 @@ class ApproveError extends ExchangeError {
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-const _abi$3 = [
+const _abi$4 = [
     {
         constant: true,
         inputs: [],
@@ -17094,19 +17592,19 @@ const _abi$3 = [
     },
 ];
 class ERC20__factory {
-    static abi = _abi$3;
+    static abi = _abi$4;
     static createInterface() {
-        return new utils$2.Interface(_abi$3);
+        return new utils$2.Interface(_abi$4);
     }
     static connect(address, signerOrProvider) {
-        return new Contract$1(address, _abi$3, signerOrProvider);
+        return new Contract$1(address, _abi$4, signerOrProvider);
     }
 }
 
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-const _abi$2 = [
+const _abi$3 = [
     {
         inputs: [
             {
@@ -17880,7 +18378,7 @@ class ImmutableSwapProxy__factory extends ContractFactory {
             super(...args);
         }
         else {
-            super(_abi$2, _bytecode$2, args[0]);
+            super(_abi$3, _bytecode$2, args[0]);
         }
     }
     deploy(_admin, _uniRouter, _wimx, overrides) {
@@ -17896,19 +18394,19 @@ class ImmutableSwapProxy__factory extends ContractFactory {
         return super.connect(signer);
     }
     static bytecode = _bytecode$2;
-    static abi = _abi$2;
+    static abi = _abi$3;
     static createInterface() {
-        return new utils$2.Interface(_abi$2);
+        return new utils$2.Interface(_abi$3);
     }
     static connect(address, signerOrProvider) {
-        return new Contract$1(address, _abi$2, signerOrProvider);
+        return new Contract$1(address, _abi$3, signerOrProvider);
     }
 }
 
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-const _abi$1 = [
+const _abi$2 = [
     {
         inputs: [],
         name: "getCurrentBlockTimestamp",
@@ -18008,7 +18506,7 @@ class Multicall__factory extends ContractFactory {
             super(...args);
         }
         else {
-            super(_abi$1, _bytecode$1, args[0]);
+            super(_abi$2, _bytecode$1, args[0]);
         }
     }
     deploy(overrides) {
@@ -18024,19 +18522,19 @@ class Multicall__factory extends ContractFactory {
         return super.connect(signer);
     }
     static bytecode = _bytecode$1;
-    static abi = _abi$1;
+    static abi = _abi$2;
     static createInterface() {
-        return new utils$2.Interface(_abi$1);
+        return new utils$2.Interface(_abi$2);
     }
     static connect(address, signerOrProvider) {
-        return new Contract$1(address, _abi$1, signerOrProvider);
+        return new Contract$1(address, _abi$2, signerOrProvider);
     }
 }
 
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-const _abi = [
+const _abi$1 = [
     {
         inputs: [],
         stateMutability: "nonpayable",
@@ -19032,7 +19530,7 @@ class UniswapV3Pool__factory extends ContractFactory {
             super(...args);
         }
         else {
-            super(_abi, _bytecode, args[0]);
+            super(_abi$1, _bytecode, args[0]);
         }
     }
     deploy(overrides) {
@@ -19048,6 +19546,298 @@ class UniswapV3Pool__factory extends ContractFactory {
         return super.connect(signer);
     }
     static bytecode = _bytecode;
+    static abi = _abi$1;
+    static createInterface() {
+        return new utils$2.Interface(_abi$1);
+    }
+    static connect(address, signerOrProvider) {
+        return new Contract$1(address, _abi$1, signerOrProvider);
+    }
+}
+
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+const _abi = [
+    {
+        constant: true,
+        inputs: [],
+        name: "name",
+        outputs: [
+            {
+                name: "",
+                type: "string",
+            },
+        ],
+        payable: false,
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        constant: false,
+        inputs: [
+            {
+                name: "guy",
+                type: "address",
+            },
+            {
+                name: "wad",
+                type: "uint256",
+            },
+        ],
+        name: "approve",
+        outputs: [
+            {
+                name: "",
+                type: "bool",
+            },
+        ],
+        payable: false,
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        constant: true,
+        inputs: [],
+        name: "totalSupply",
+        outputs: [
+            {
+                name: "",
+                type: "uint256",
+            },
+        ],
+        payable: false,
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        constant: false,
+        inputs: [
+            {
+                name: "src",
+                type: "address",
+            },
+            {
+                name: "dst",
+                type: "address",
+            },
+            {
+                name: "wad",
+                type: "uint256",
+            },
+        ],
+        name: "transferFrom",
+        outputs: [
+            {
+                name: "",
+                type: "bool",
+            },
+        ],
+        payable: false,
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        constant: false,
+        inputs: [
+            {
+                name: "wad",
+                type: "uint256",
+            },
+        ],
+        name: "withdraw",
+        outputs: [],
+        payable: false,
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        constant: true,
+        inputs: [],
+        name: "decimals",
+        outputs: [
+            {
+                name: "",
+                type: "uint8",
+            },
+        ],
+        payable: false,
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        constant: true,
+        inputs: [
+            {
+                name: "",
+                type: "address",
+            },
+        ],
+        name: "balanceOf",
+        outputs: [
+            {
+                name: "",
+                type: "uint256",
+            },
+        ],
+        payable: false,
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        constant: true,
+        inputs: [],
+        name: "symbol",
+        outputs: [
+            {
+                name: "",
+                type: "string",
+            },
+        ],
+        payable: false,
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        constant: false,
+        inputs: [
+            {
+                name: "dst",
+                type: "address",
+            },
+            {
+                name: "wad",
+                type: "uint256",
+            },
+        ],
+        name: "transfer",
+        outputs: [
+            {
+                name: "",
+                type: "bool",
+            },
+        ],
+        payable: false,
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        constant: false,
+        inputs: [],
+        name: "deposit",
+        outputs: [],
+        payable: true,
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        constant: true,
+        inputs: [
+            {
+                name: "",
+                type: "address",
+            },
+            {
+                name: "",
+                type: "address",
+            },
+        ],
+        name: "allowance",
+        outputs: [
+            {
+                name: "",
+                type: "uint256",
+            },
+        ],
+        payable: false,
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        payable: true,
+        stateMutability: "payable",
+        type: "fallback",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                name: "src",
+                type: "address",
+            },
+            {
+                indexed: true,
+                name: "guy",
+                type: "address",
+            },
+            {
+                indexed: false,
+                name: "wad",
+                type: "uint256",
+            },
+        ],
+        name: "Approval",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                name: "src",
+                type: "address",
+            },
+            {
+                indexed: true,
+                name: "dst",
+                type: "address",
+            },
+            {
+                indexed: false,
+                name: "wad",
+                type: "uint256",
+            },
+        ],
+        name: "Transfer",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                name: "dst",
+                type: "address",
+            },
+            {
+                indexed: false,
+                name: "wad",
+                type: "uint256",
+            },
+        ],
+        name: "Deposit",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                name: "src",
+                type: "address",
+            },
+            {
+                indexed: false,
+                name: "wad",
+                type: "uint256",
+            },
+        ],
+        name: "Withdrawal",
+        type: "event",
+    },
+];
+class WIMX__factory {
     static abi = _abi;
     static createInterface() {
         return new utils$2.Interface(_abi);
@@ -19676,6 +20466,13 @@ class NativeTokenService {
     maybeWrapAmount(amount) {
         return newAmount(amount.value, this.maybeWrapToken(amount.token));
     }
+    isWrappedNative(token) {
+        return token.type === 'erc20' && token.address.toLowerCase() === this.wrappedToken.address.toLowerCase();
+    }
+    isWrapOrUnwrap(tokenIn, tokenOut) {
+        return ((tokenIn === this.nativeToken && (this.isWrappedNative(tokenOut))) ||
+            ((this.isWrappedNative(tokenIn)) && tokenOut === this.nativeToken));
+    }
 }
 
 // slippageToPercent takes the slippage as a percentage (e.g. 0.1) and
@@ -19774,6 +20571,16 @@ class Fees {
     }
 }
 
+// 45038 is the upper bound of the gas estimate for the deposit function.
+// This upper bound is reached when a user is wrapping for the first time (cold + unused storage slot)
+// The lower bound is 27,938, so the difference is 17,100 gas. If transactions are 10 gwei IMX,
+// this is about 0.000171 IMX difference. In order to avoid an extra remote call, we just use the upper bound instead.
+const IMX_WRAP_GAS_COST = 45038;
+// 35216 is the upper bound of the gas estimate for the withdraw function.
+// The differenfce between upper and normal is less than 0.0001 IMX, so we just use the upper bound
+// to avoid an extra remote call.
+const IMX_UNWRAP_GAS_COST = 35216;
+
 const IMMUTABLE_TESTNET_RPC_URL = 'https://rpc.testnet.immutable.com';
 const IMMUTABLE_TESTNET_CHAIN_ID = 13473;
 
@@ -20287,6 +21094,67 @@ class Exchange {
             decimals,
         };
     }
+    async getUnwrapTransaction(fromAddress, tokenAmount, wimxInterface, gasPrice) {
+        const calldata = wimxInterface.encodeFunctionData('withdraw', [tokenAmount]);
+        const gasEstimate = ethers.BigNumber.from(IMX_UNWRAP_GAS_COST);
+        const gasFeeEstimate = gasPrice ? toPublicAmount(calculateGasFee(gasPrice, gasEstimate)) : null;
+        // This transaction is for calling calling `withdraw` on the WETH/WIMX contract.
+        const transactionDetails = {
+            transaction: {
+                data: calldata,
+                to: this.wrappedNativeToken.address,
+                from: fromAddress,
+            },
+            gasFeeEstimate,
+        };
+        return {
+            transaction: transactionDetails,
+            approval: null,
+        };
+    }
+    getWrapTransaction(fromAddress, tokenAmount, wimxInterface, gasPrice) {
+        const calldata = wimxInterface.encodeFunctionData('deposit');
+        const gasEstimate = ethers.BigNumber.from(IMX_WRAP_GAS_COST);
+        const gasFeeEstimate = gasPrice ? toPublicAmount(calculateGasFee(gasPrice, gasEstimate)) : null;
+        // This transaction is for calling calling `deposit` on the WETH/WIMX contract.
+        const transactionDetails = {
+            transaction: {
+                data: calldata,
+                to: this.wrappedNativeToken.address,
+                value: tokenAmount,
+                from: fromAddress,
+            },
+            gasFeeEstimate,
+        };
+        return {
+            transaction: transactionDetails,
+            approval: null,
+        };
+    }
+    async getUnsignedWrapUnwrapTx(tokenSpecified, amountIn, fromAddress, gasPrice) {
+        const isWrap = amountIn.token.type === 'native';
+        const quoteToken = tokenSpecified.type === 'native' ? this.wrappedNativeToken : this.nativeToken;
+        const otherTokenCoinAmount = {
+            token: quoteToken,
+            value: amountIn.value,
+        };
+        // The quote is always 1:1 (0 {price impact, slippage}) when wrapping/unwrapping.
+        const quote = {
+            amount: toPublicAmount(otherTokenCoinAmount),
+            amountWithMaxSlippage: toPublicAmount(otherTokenCoinAmount),
+            slippage: 0,
+            fees: [],
+        };
+        const wimxInterface = WIMX__factory.createInterface();
+        let transactionDetails;
+        if (isWrap) {
+            transactionDetails = this.getWrapTransaction(fromAddress, otherTokenCoinAmount.value, wimxInterface, gasPrice);
+        }
+        else {
+            transactionDetails = await this.getUnwrapTransaction(fromAddress, otherTokenCoinAmount.value, wimxInterface, gasPrice);
+        }
+        return { quote, approval: transactionDetails.approval, swap: transactionDetails.transaction };
+    }
     async getUnsignedSwapTx(fromAddress, tokenInLiteral, tokenOutLiteral, amount, slippagePercent, maxHops, deadline, tradeType) {
         Exchange.validate(tokenInLiteral, tokenOutLiteral, maxHops, slippagePercent, fromAddress);
         // get the decimals of the tokens that will be swapped
@@ -20302,6 +21170,11 @@ class Exchange {
         // determine which amount was specified for the swap from the TradeType
         const [tokenSpecified, otherToken] = tradeType === TradeType.EXACT_INPUT ? [tokenIn, tokenOut] : [tokenOut, tokenIn];
         const amountSpecified = newAmount(amount, tokenSpecified);
+        if (this.nativeTokenService.isWrapOrUnwrap(tokenIn, tokenOut)) {
+            // If the user is swapping between the native token and the wrapped native token,
+            // we want to just wrap/unwrap the native token instead of swapping
+            return this.getUnsignedWrapUnwrapTx(tokenSpecified, newAmount(amount, tokenIn), fromAddress, gasPrice);
+        }
         const fees = new Fees(secondaryFees, tokenIn);
         const ourQuoteReqAmount = getOurQuoteReqAmount(amountSpecified, fees, tradeType, this.nativeTokenService);
         // Quotes will always use ERC20s. If the user-specified token is Native, we use the Wrapped Native Token pool
@@ -25961,7 +26834,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.45.2',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.45.3-alpha',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -26612,6 +27485,7 @@ var WalletAction;
     WalletAction["ADD_NETWORK"] = "wallet_addEthereumChain";
     WalletAction["SWITCH_NETWORK"] = "wallet_switchEthereumChain";
     WalletAction["GET_CHAINID"] = "eth_chainId";
+    WalletAction["REQUEST_PERMISSIONS"] = "wallet_requestPermissions";
 })(WalletAction || (WalletAction = {}));
 /**
  * Enum representing the platform filters used in {@link GetWalletAllowListParams}.
@@ -27322,7 +28196,7 @@ const IMMUTABLE_ZKVEM_GAS_OVERRIDES = {
     maxPriorityFeePerGas: BigNumber$1.from(10e9),
 };
 
-const SDK_VERSION_MARKER = '0.45.2';
+const SDK_VERSION_MARKER = '0.45.3-alpha';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -27906,6 +28780,21 @@ async function connectSite(web3Provider) {
     }, { type: CheckoutErrorType.USER_REJECTED_REQUEST_ERROR });
     return web3Provider;
 }
+async function requestPermissions(web3Provider) {
+    if (!web3Provider || !web3Provider.provider?.request) {
+        throw new CheckoutError('Incompatible provider', CheckoutErrorType.PROVIDER_REQUEST_MISSING_ERROR, { details: 'Attempting to connect with an incompatible provider' });
+    }
+    await withCheckoutError(async () => {
+        if (!web3Provider.provider.request)
+            return;
+        await web3Provider.provider.request({
+            method: WalletAction.REQUEST_PERMISSIONS,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            params: [{ eth_accounts: {} }],
+        });
+    }, { type: CheckoutErrorType.USER_REJECTED_REQUEST_ERROR });
+    return web3Provider;
+}
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 async function getMetaMaskProvider() {
@@ -31054,7 +31943,12 @@ class Checkout {
      */
     async connect(params) {
         const web3Provider = await validateProvider(this.config, params.provider, { allowUnsupportedProvider: true });
-        await connectSite(web3Provider);
+        if (params.requestWalletPermissions && !web3Provider.provider?.isPassport) {
+            await requestPermissions(web3Provider);
+        }
+        else {
+            await connectSite(web3Provider);
+        }
         return { provider: web3Provider };
     }
     /**