@mocanetwork/airkit-connector 1.3.0 → 1.4.0-beta.1

package/dist/airkitConnector.umd.js

@@ -98,13 +98,19 @@
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
   };
+  var version$2 = "1.4.0-beta.1";
+  var airkitPackage = {
+    version: version$2
+  };
   const AirAuthMessageTypes = {
     AUTH_SETUP_COMPLETED: "air_auth_setup_completed",
     INITIALIZATION_REQUEST: "air_auth_initialization_request",
     INITIALIZATION_RESPONSE: "air_auth_initialization_response",
     LOGIN_REQUEST: "air_auth_login_request",
     LOGIN_RESPONSE: "air_auth_login_response",
-    LOGIN_WALLET_RESPONSE: "air_auth_login_wallet_response",
+    LOGIN_SERVICE_RESPONSE: "air_auth_login_service_response",
+    PASSKEY_LOGIN_REQUEST: "air_auth_passkey_login_request",
+    PASSKEY_LOGIN_RESPONSE: "air_auth_passkey_login_response",
     USER_INFO_REQUEST: "air_auth_user_info_request",
     USER_INFO_RESPONSE: "air_auth_user_info_response",
     PARTNER_USER_INFO_REQUEST: "air_auth_partner_user_info_request",
@@ -117,17 +123,37 @@
     IFRAME_VISIBILITY_REQUEST: "air_auth_iframe_visibility_request",
     SETUP_WALLET_REQUEST: "air_auth_setup_wallet_request",
     SETUP_WALLET_RESPONSE: "air_auth_setup_wallet_response",
+    SETUP_RECOVERY_REQUEST: "air_auth_setup_recovery_request",
+    SETUP_RECOVERY_RESPONSE: "air_auth_setup_recovery_response",
     SIGN_SIWE_MESSAGE_REQUEST: "air_auth_sign_siwe_message_request",
     SIGN_SIWE_MESSAGE_RESPONSE: "air_auth_sign_siwe_message_response",
     CROSS_PARTNER_TOKEN_REQUEST: "air_auth_cross_partner_token_request",
     CROSS_PARTNER_TOKEN_RESPONSE: "air_auth_cross_partner_token_response",
     PARTNER_ACCESS_TOKEN_REQUEST: "air_auth_partner_access_token_request",
     PARTNER_ACCESS_TOKEN_RESPONSE: "air_auth_partner_access_token_response",
+    PRIVY_LOGIN_REQUEST: "air_auth_privy_login_request",
+    PRIVY_LOGIN_RESPONSE: "air_auth_privy_login_response",
     CREDENTIAL_SALT_REQUEST: "air_auth_credential_salt_request",
     CREDENTIAL_SALT_RESPONSE: "air_auth_credential_salt_response",
     LOGOUT_REQUEST: "air_auth_logout_request",
     LOGOUT_RESPONSE: "air_auth_logout_response",
-    RESET_WALLET_COMMUNICATION: "air_auth_reset_wallet_communication"
+    RESET_WALLET_COMMUNICATION: "air_auth_reset_wallet_communication",
+    INIT_RECOVERY_COMMUNICATION: "air_auth_init_recovery_communication",
+    RESET_RECOVERY_COMMUNICATION: "air_auth_reset_recovery_communication",
+    START_RECOVERY_REQUEST: "air_start_recovery_request",
+    START_RECOVERY_RESPONSE: "air_start_recovery_response",
+    OTP_REQUEST: "air_auth_otp_request",
+    OTP_RESPONSE: "air_auth_otp_response"
+  };
+  const AirRecoveryMessageTypes = {
+    SERVICE_STARTED: "air_recovery_service_started",
+    INITIALIZATION_REQUEST: "air_recovery_initialization_request",
+    INITIALIZATION_RESPONSE: "air_recovery_initialization_response",
+    INIT_AUTH_COMMUNICATION: "air_recovery_init_auth_communication",
+    RECOVERY_INITIALIZED: "air_recovery_initialized",
+    RECOVERY_IFRAME_VISIBILITY_REQUEST: "air_recovery_iframe_visibility_request",
+    LOGOUT_REQUEST: "air_recovery_logout_request",
+    LOGOUT_RESPONSE: "air_recovery_logout_response"
   };
   const AirWalletMessageTypes = {
     SERVICE_STARTED: "air_service_started",
@@ -141,223 +167,23 @@
     SETUP_OR_UPDATE_MFA_RESPONSE: "air_setup_mfa_response",
     CLAIM_ID_REQUEST: "air_claim_id_request",
     CLAIM_ID_RESPONSE: "air_claim_id_response",
+    SHOW_SWAP_UI_REQUEST: "air_show_swap_ui_request",
+    SHOW_SWAP_UI_RESPONSE: "air_show_swap_ui_response",
     DEPLOY_SMART_ACCOUNT_REQUEST: "air_deploy_smart_account_request",
     DEPLOY_SMART_ACCOUNT_RESPONSE: "air_deploy_smart_account_response",
     WALLET_IFRAME_VISIBILITY_REQUEST: "air_wallet_iframe_visibility_request",
-    OPEN_WINDOW_REQUEST: "air_open_window_request",
-    OPEN_WINDOW_RESPONSE: "air_open_window_response",
-    OPEN_WINDOW_RETRY_REQUEST: "air_open_window_retry_request",
-    OPEN_WINDOW_RETRY_RESPONSE: "air_open_window_retry_response",
-    WINDOW_CLOSED: "air_window_closed",
     IS_SMART_ACCOUNT_DEPLOYED_REQUEST: "air_is_smart_account_deployed_request",
     IS_SMART_ACCOUNT_DEPLOYED_RESPONSE: "air_is_smart_account_deployed_response",
     LOGOUT_REQUEST: "air_logout_request",
     LOGOUT_RESPONSE: "air_logout_response"
   };
-  let BaseError$2 = class BaseError extends Error {
-    constructor(name, message, options = {}) {
-      const {
-        cause,
-        context
-      } = options;
-      super(message || name);
-      this.name = name;
-      this.stack = cause?.stack;
-      this.cause = cause;
-      this.context = context;
-    }
-    toJSON() {
-      return {
-        name: this.name,
-        message: this.message,
-        context: this.context,
-        cause: this.cause
-      };
-    }
-  };
-  function ensureError(value) {
-    if (value instanceof Error) return value;
-    let stringified = "[Unable to stringify the thrown value]";
-    try {
-      stringified = JSON.stringify(value);
-    } catch {
-      // ignoring failed stringify
-    }
-    return new Error(`This value was not thrown as type Error: ${stringified}`);
-  }
-  const BUILD_ENV = {
-    PRODUCTION: "production",
-    UAT: "uat",
-    STAGING: "staging",
-    DEVELOPMENT: "development"
-  };
-  const AIR_URLS = {
-    [BUILD_ENV.DEVELOPMENT]: {
-      authUrl: "http://localhost:8200/auth/",
-      walletUrl: "http://localhost:8200/wallet/"
-    },
-    [BUILD_ENV.UAT]: {
-      authUrl: "https://account.uat.air3.com/auth/",
-      walletUrl: "https://account.uat.air3.com/wallet/"
-    },
-    [BUILD_ENV.STAGING]: {
-      authUrl: "https://account.staging.air3.com/auth/",
-      walletUrl: "https://account.staging.air3.com/wallet/"
-    },
-    [BUILD_ENV.PRODUCTION]: {
-      authUrl: "https://account.air3.com/auth/",
-      walletUrl: "https://account.air3.com/wallet/"
-    }
-  };
-  const isElement = element => element instanceof Element || element instanceof Document;
-  const randomId = () => Math.random().toString(36).slice(2);
-  const extractErrorHash = message => {
-    if (!message) return "";
-    // Format: "reason: 0x..."
-    if (message.includes("reason:")) {
-      return message.split("reason:")[1].trim();
-    }
-    // Format: "UserOperation reverted during simulation with reason: 0x..."
-    if (message.includes("with reason:")) {
-      const match = message.match(/with reason: (0x[a-fA-F0-9]+)/);
-      return match ? match[1].trim() : "";
-    }
-    // Look for any 0x pattern that could be a hash
-    const hexMatch = message.match(/(0x[a-fA-F0-9]{8,})/);
-    return hexMatch ? hexMatch[1].trim() : "";
-  };
-  class AirServiceError extends BaseError$2 {
-    static from(error) {
-      if (error instanceof AirServiceError) {
-        return error;
-      } else if (error instanceof Object && "message" in error) {
-        if (error.message === "User cancelled login") {
-          return new AirServiceError("USER_CANCELLED", error.message);
-        }
-        return new AirServiceError("UNKNOWN_ERROR", error.message.toString());
-      }
-      return new AirServiceError("UNKNOWN_ERROR");
-    }
-  }
-  let ProviderRpcError$1 = class ProviderRpcError extends Error {
-    constructor(message) {
-      super(message);
-      this.metaMessages = [];
-    }
-  };
-  let UserRejectedRequestError$1 = class UserRejectedRequestError extends ProviderRpcError$1 {
-    constructor() {
-      super(...arguments);
-      this.code = 4001;
-      this.name = "UserRejectedRequestError";
-    }
-  };
-  class UnauthorizedProviderError extends ProviderRpcError$1 {
-    constructor() {
-      super(...arguments);
-      this.code = 4100;
-      this.name = "UnauthorizedProviderError";
-    }
-  }
-  class UnsupportedProviderMethodError extends ProviderRpcError$1 {
-    constructor() {
-      super(...arguments);
-      this.code = 4200;
-      this.name = "UnsupportedProviderMethodError";
-    }
-  }
-  class ProviderDisconnectedError extends ProviderRpcError$1 {
-    constructor() {
-      super(...arguments);
-      this.code = 4900;
-      this.name = "ProviderDisconnectedError";
-    }
-  }
-  class ChainDisconnectedError extends ProviderRpcError$1 {
-    constructor() {
-      super(...arguments);
-      this.code = 4901;
-      this.name = "ChainDisconnectedError";
-    }
-  }
-  let SwitchChainError$1 = class SwitchChainError extends ProviderRpcError$1 {
-    constructor() {
-      super(...arguments);
-      this.code = 4902;
-      this.name = "SwitchChainError";
-    }
+  const AirWindowMessageTypes = {
+    OPEN_WINDOW_REQUEST: "air_open_window_request",
+    OPEN_WINDOW_RESPONSE: "air_open_window_response",
+    OPEN_WINDOW_RETRY_REQUEST: "air_open_window_retry_request",
+    OPEN_WINDOW_RETRY_RESPONSE: "air_open_window_retry_response",
+    WINDOW_CLOSED: "air_window_closed"
   };
-  class TransactionRejectedRpcError extends ProviderRpcError$1 {
-    constructor(message) {
-      // Remove the "Version: viem@x.x.x" suffix if present
-      const cleanMessage = message.replace(/\nVersion:.*$/, '');
-      super(cleanMessage);
-      this.code = -32003;
-      this.name = "TransactionRejectedRpcError";
-      // Parse the error hash from the message
-      this.metaMessages.push(extractErrorHash(cleanMessage));
-    }
-  }
-  class InvalidRequestRpcError extends ProviderRpcError$1 {
-    constructor() {
-      super(...arguments);
-      this.code = -32600;
-      this.name = "InvalidRequestRpcError";
-    }
-  }
-  class MethodNotFoundRpcError extends ProviderRpcError$1 {
-    constructor() {
-      super(...arguments);
-      this.code = -32601;
-      this.name = "MethodNotFoundRpcError";
-    }
-  }
-  class InvalidParamsRpcError extends ProviderRpcError$1 {
-    constructor() {
-      super(...arguments);
-      this.code = -32602;
-      this.name = "InvalidParamsRpcError";
-    }
-  }
-  class InternalRpcError extends ProviderRpcError$1 {
-    constructor() {
-      super(...arguments);
-      this.code = -32603;
-      this.name = "InternalRpcError";
-    }
-  }
-  function ensureProviderRpcError(value) {
-    if (value instanceof ProviderRpcError$1) {
-      return value;
-    }
-    if (typeof value === "object" && value !== null && "errorCode" in value && "errorMessage" in value) {
-      if (typeof value.errorCode === "number" && typeof value.errorMessage === "string") {
-        switch (value.errorCode) {
-          case 4001:
-            return new UserRejectedRequestError$1(value.errorMessage);
-          case 4100:
-            return new UnauthorizedProviderError(value.errorMessage);
-          case 4200:
-            return new UnsupportedProviderMethodError(value.errorMessage);
-          case 4900:
-            return new ProviderDisconnectedError(value.errorMessage);
-          case 4901:
-            return new ChainDisconnectedError(value.errorMessage);
-          case 4902:
-            return new SwitchChainError$1(value.errorMessage);
-          case -32003:
-            return new TransactionRejectedRpcError(value.errorMessage);
-        }
-      }
-    }
-    let stringified = "[Unable to stringify the thrown value]";
-    try {
-      stringified = JSON.stringify(value);
-    } catch {
-      // ignoring failed stringify
-    }
-    return new InternalRpcError(`Invalid value for ProviderRpcError: ${stringified}`);
-  }
   function getDefaultExportFromCjs$1(x) {
     return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
   }
@@ -686,44 +512,281 @@
   }
   var loglevelExports$1 = requireLoglevel$1();
   var log$1 = /*@__PURE__*/getDefaultExportFromCjs$1(loglevelExports$1);
-  function isFunction(value) {
-    return typeof value === 'function';
-  }
-  function createErrorClass(createImpl) {
-    var _super = function (instance) {
-      Error.call(instance);
-      instance.stack = new Error().stack;
-    };
-    var ctorFunc = createImpl(_super);
-    ctorFunc.prototype = Object.create(Error.prototype);
-    ctorFunc.prototype.constructor = ctorFunc;
-    return ctorFunc;
-  }
-  var UnsubscriptionError = createErrorClass(function (_super) {
-    return function UnsubscriptionErrorImpl(errors) {
-      _super(this);
-      this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) {
-        return i + 1 + ") " + err.toString();
-      }).join('\n  ') : '';
-      this.name = 'UnsubscriptionError';
-      this.errors = errors;
-    };
-  });
-  function arrRemove(arr, item) {
-    if (arr) {
-      var index = arr.indexOf(item);
-      0 <= index && arr.splice(index, 1);
-    }
-  }
-  var Subscription = function () {
-    function Subscription(initialTeardown) {
-      this.initialTeardown = initialTeardown;
-      this.closed = false;
-      this._parentage = null;
-      this._finalizers = null;
+  let BaseError$2 = class BaseError extends Error {
+    constructor(name, message, options = {}) {
+      const {
+        cause,
+        context
+      } = options;
+      super(message || name);
+      this.name = name;
+      this.stack = cause?.stack;
+      this.cause = cause;
+      this.context = context;
     }
-    Subscription.prototype.unsubscribe = function () {
-      var e_1, _a, e_2, _b;
+    toJSON() {
+      return {
+        name: this.name,
+        message: this.message,
+        context: this.context,
+        cause: this.cause
+      };
+    }
+  };
+  function ensureError(value) {
+    if (value instanceof Error) return value;
+    let stringified = "[Unable to stringify the thrown value]";
+    try {
+      stringified = JSON.stringify(value);
+    } catch {
+      // ignoring failed stringify
+    }
+    return new Error(`This value was not thrown as type Error: ${stringified}`);
+  }
+  const getLevelName = levelNum => {
+    const levelNames = Object.keys(log$1.levels);
+    if (levelNum >= 0 && levelNum < levelNames.length) {
+      return levelNames[levelNum];
+    }
+    return "UNKNOWN";
+  };
+  const configureLogLevel = (environment, enableLogging) => {
+    let level = log$1.levels.ERROR;
+    if (environment === "development") {
+      level = enableLogging ? log$1.levels.TRACE : log$1.levels.INFO;
+    } else if (environment === "staging") {
+      level = enableLogging ? log$1.levels.DEBUG : log$1.levels.INFO;
+    } else if (environment === "uat") {
+      level = enableLogging ? log$1.levels.INFO : log$1.levels.WARN;
+    } else if (environment === "production") {
+      // Be cautious with enabling more than WARN in prod
+      level = enableLogging ? log$1.levels.WARN : log$1.levels.ERROR;
+    }
+    log$1.setLevel(level);
+    log$1.info(`[${window?.location?.href}] LogLevel: ${getLevelName(log$1.getLevel())}`);
+  };
+  const BUILD_ENV = {
+    PRODUCTION: "production",
+    UAT: "uat",
+    STAGING: "staging",
+    DEVELOPMENT: "development",
+    SANDBOX: "sandbox"
+  };
+  const AIR_URLS = {
+    [BUILD_ENV.DEVELOPMENT]: {
+      authUrl: "http://localhost:8200/auth/",
+      walletUrl: "http://localhost:8200/wallet/",
+      recoveryUrl: "http://localhost:8200/recovery/"
+    },
+    [BUILD_ENV.STAGING]: {
+      authUrl: "https://account.staging.air3.com/auth/",
+      walletUrl: "https://account.staging.air3.com/wallet/",
+      recoveryUrl: "https://account.staging.air3.com/recovery/"
+    },
+    [BUILD_ENV.UAT]: {
+      authUrl: "https://account.uat.air3.com/auth/",
+      walletUrl: "https://account.uat.air3.com/wallet/",
+      recoveryUrl: "https://account.uat.air3.com/recovery/"
+    },
+    [BUILD_ENV.SANDBOX]: {
+      authUrl: "https://account.sandbox.air3.com/auth/",
+      walletUrl: "https://account.sandbox.air3.com/wallet/",
+      recoveryUrl: "https://account.sandbox.air3.com/recovery/"
+    },
+    [BUILD_ENV.PRODUCTION]: {
+      authUrl: "https://account.air3.com/auth/",
+      walletUrl: "https://account.air3.com/wallet/",
+      recoveryUrl: "https://account.air3.com/recovery/"
+    }
+  };
+  const isElement = element => element instanceof Element || element instanceof Document;
+  const randomId = () => Math.random().toString(36).slice(2);
+  const extractErrorHash = message => {
+    if (!message) return "";
+    // Format: "reason: 0x..."
+    if (message.includes("reason:")) {
+      const match = message.match(/reason:\s*(0x[a-fA-F0-9]+)/);
+      return match ? match[1].trim() : "";
+    }
+    // Format: "UserOperation reverted during simulation with reason: 0x..."
+    if (message.includes("with reason:")) {
+      const match = message.match(/with reason:\s*(0x[a-fA-F0-9]+)/);
+      return match ? match[1].trim() : "";
+    }
+    // Look for any 0x pattern that could be a hash
+    const hexMatch = message.match(/(0x[a-fA-F0-9]{8,})/);
+    return hexMatch ? hexMatch[1].trim() : "";
+  };
+  class AirServiceError extends BaseError$2 {
+    static from(error) {
+      if (error instanceof AirServiceError) {
+        return error;
+      } else if (error instanceof Object && "message" in error) {
+        if (error.message === "User cancelled login") {
+          return new AirServiceError("USER_CANCELLED", error.message);
+        }
+        return new AirServiceError("UNKNOWN_ERROR", error.message.toString());
+      }
+      return new AirServiceError("UNKNOWN_ERROR");
+    }
+  }
+  let ProviderRpcError$1 = class ProviderRpcError extends Error {
+    constructor(message) {
+      super(message);
+      this.metaMessages = [];
+    }
+  };
+  let UserRejectedRequestError$1 = class UserRejectedRequestError extends ProviderRpcError$1 {
+    constructor() {
+      super(...arguments);
+      this.code = 4001;
+      this.name = "UserRejectedRequestError";
+    }
+  };
+  class UnauthorizedProviderError extends ProviderRpcError$1 {
+    constructor() {
+      super(...arguments);
+      this.code = 4100;
+      this.name = "UnauthorizedProviderError";
+    }
+  }
+  class UnsupportedProviderMethodError extends ProviderRpcError$1 {
+    constructor() {
+      super(...arguments);
+      this.code = 4200;
+      this.name = "UnsupportedProviderMethodError";
+    }
+  }
+  class ProviderDisconnectedError extends ProviderRpcError$1 {
+    constructor() {
+      super(...arguments);
+      this.code = 4900;
+      this.name = "ProviderDisconnectedError";
+    }
+  }
+  class ChainDisconnectedError extends ProviderRpcError$1 {
+    constructor() {
+      super(...arguments);
+      this.code = 4901;
+      this.name = "ChainDisconnectedError";
+    }
+  }
+  let SwitchChainError$1 = class SwitchChainError extends ProviderRpcError$1 {
+    constructor() {
+      super(...arguments);
+      this.code = 4902;
+      this.name = "SwitchChainError";
+    }
+  };
+  class TransactionRejectedRpcError extends ProviderRpcError$1 {
+    constructor(message) {
+      // Remove the "Version: viem@x.x.x" suffix if present
+      const cleanMessage = message.replace(/\nVersion:.*$/, '');
+      super(cleanMessage);
+      this.code = -32003;
+      this.name = "TransactionRejectedRpcError";
+      // Parse the error hash from the message
+      this.metaMessages.push(extractErrorHash(cleanMessage));
+    }
+  }
+  class InvalidRequestRpcError extends ProviderRpcError$1 {
+    constructor() {
+      super(...arguments);
+      this.code = -32600;
+      this.name = "InvalidRequestRpcError";
+    }
+  }
+  class MethodNotFoundRpcError extends ProviderRpcError$1 {
+    constructor() {
+      super(...arguments);
+      this.code = -32601;
+      this.name = "MethodNotFoundRpcError";
+    }
+  }
+  class InvalidParamsRpcError extends ProviderRpcError$1 {
+    constructor() {
+      super(...arguments);
+      this.code = -32602;
+      this.name = "InvalidParamsRpcError";
+    }
+  }
+  class InternalRpcError extends ProviderRpcError$1 {
+    constructor() {
+      super(...arguments);
+      this.code = -32603;
+      this.name = "InternalRpcError";
+    }
+  }
+  function ensureProviderRpcError(value) {
+    if (value instanceof ProviderRpcError$1) {
+      return value;
+    }
+    if (typeof value === "object" && value !== null && "errorCode" in value && "errorMessage" in value) {
+      if (typeof value.errorCode === "number" && typeof value.errorMessage === "string") {
+        switch (value.errorCode) {
+          case 4001:
+            return new UserRejectedRequestError$1(value.errorMessage);
+          case 4100:
+            return new UnauthorizedProviderError(value.errorMessage);
+          case 4200:
+            return new UnsupportedProviderMethodError(value.errorMessage);
+          case 4900:
+            return new ProviderDisconnectedError(value.errorMessage);
+          case 4901:
+            return new ChainDisconnectedError(value.errorMessage);
+          case 4902:
+            return new SwitchChainError$1(value.errorMessage);
+          case -32003:
+            return new TransactionRejectedRpcError(value.errorMessage);
+        }
+      }
+    }
+    let stringified = "[Unable to stringify the thrown value]";
+    try {
+      stringified = JSON.stringify(value);
+    } catch {
+      // ignoring failed stringify
+    }
+    return new InternalRpcError(`Invalid value for ProviderRpcError: ${stringified}`);
+  }
+  function isFunction(value) {
+    return typeof value === 'function';
+  }
+  function createErrorClass(createImpl) {
+    var _super = function (instance) {
+      Error.call(instance);
+      instance.stack = new Error().stack;
+    };
+    var ctorFunc = createImpl(_super);
+    ctorFunc.prototype = Object.create(Error.prototype);
+    ctorFunc.prototype.constructor = ctorFunc;
+    return ctorFunc;
+  }
+  var UnsubscriptionError = createErrorClass(function (_super) {
+    return function UnsubscriptionErrorImpl(errors) {
+      _super(this);
+      this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) {
+        return i + 1 + ") " + err.toString();
+      }).join('\n  ') : '';
+      this.name = 'UnsubscriptionError';
+      this.errors = errors;
+    };
+  });
+  function arrRemove(arr, item) {
+    if (arr) {
+      var index = arr.indexOf(item);
+      0 <= index && arr.splice(index, 1);
+    }
+  }
+  var Subscription = function () {
+    function Subscription(initialTeardown) {
+      this.initialTeardown = initialTeardown;
+      this.closed = false;
+      this._parentage = null;
+      this._finalizers = null;
+    }
+    Subscription.prototype.unsubscribe = function () {
+      var e_1, _a, e_2, _b;
       var errors;
       if (!this.closed) {
         this.closed = true;
@@ -1687,15 +1750,17 @@
   _ProviderMessageService_instance = {
     value: void 0
   };
-  var _AirWalletProvider_instances, _AirWalletProvider_providerMessageService, _AirWalletProvider_isLoggedIn, _AirWalletProvider_ensureWallet, _AirWalletProvider_eventListeners, _AirWalletProvider_emit;
+  var _AirWalletProvider_instances, _AirWalletProvider_providerMessageService, _AirWalletProvider_isWalletInitialized, _AirWalletProvider_getLoginResult, _AirWalletProvider_ensureWallet, _AirWalletProvider_eventListeners, _AirWalletProvider_emit;
   class AirWalletProvider {
     constructor({
-      isLoggedIn,
-      ensureWallet
+      ensureWallet,
+      isWalletInitialized,
+      getLoginResult
     }) {
       _AirWalletProvider_instances.add(this);
       _AirWalletProvider_providerMessageService.set(this, void 0);
-      _AirWalletProvider_isLoggedIn.set(this, void 0);
+      _AirWalletProvider_isWalletInitialized.set(this, void 0);
+      _AirWalletProvider_getLoginResult.set(this, void 0);
       _AirWalletProvider_ensureWallet.set(this, void 0);
       _AirWalletProvider_eventListeners.set(this, void 0);
       this.startEventMessageListening = async walletIframe => {
@@ -1705,7 +1770,6 @@
         });
       };
       __classPrivateFieldSet(this, _AirWalletProvider_providerMessageService, ProviderMessageService.create());
-      __classPrivateFieldSet(this, _AirWalletProvider_isLoggedIn, isLoggedIn);
       __classPrivateFieldSet(this, _AirWalletProvider_ensureWallet, ensureWallet);
       __classPrivateFieldSet(this, _AirWalletProvider_eventListeners, {
         connect: [],
@@ -1714,6 +1778,8 @@
         chainChanged: [],
         message: []
       });
+      __classPrivateFieldSet(this, _AirWalletProvider_isWalletInitialized, isWalletInitialized);
+      __classPrivateFieldSet(this, _AirWalletProvider_getLoginResult, getLoginResult);
     }
     async request(request) {
       // Check if the request is valid
@@ -1732,11 +1798,14 @@
       if (params !== undefined && !Array.isArray(params) && (typeof params !== "object" || params === null)) {
         throw new InvalidParamsRpcError("Invalid params");
       }
-      // Check if the user is logged in
-      if (!__classPrivateFieldGet$1(this, _AirWalletProvider_isLoggedIn, "f").call(this)) {
+      const loginResult = __classPrivateFieldGet$1(this, _AirWalletProvider_getLoginResult, "f").call(this);
+      if (!loginResult) {
         throw new UnauthorizedProviderError("User is not logged in");
       }
-      const skipWalletLoginMethods = ['eth_chainId'];
+      if (method === "eth_accounts" && !__classPrivateFieldGet$1(this, _AirWalletProvider_isWalletInitialized, "f").call(this) && loginResult?.abstractAccountAddress) {
+        return [loginResult.abstractAccountAddress];
+      }
+      const skipWalletLoginMethods = ["eth_chainId"];
       try {
         if (skipWalletLoginMethods.includes(method)) {
           await __classPrivateFieldGet$1(this, _AirWalletProvider_ensureWallet, "f").call(this, {
@@ -1779,7 +1848,7 @@
       });
     }
   }
-  _AirWalletProvider_providerMessageService = new WeakMap(), _AirWalletProvider_isLoggedIn = new WeakMap(), _AirWalletProvider_ensureWallet = new WeakMap(), _AirWalletProvider_eventListeners = new WeakMap(), _AirWalletProvider_instances = new WeakSet(), _AirWalletProvider_emit = function _AirWalletProvider_emit(eventName, ...args) {
+  _AirWalletProvider_providerMessageService = new WeakMap(), _AirWalletProvider_isWalletInitialized = new WeakMap(), _AirWalletProvider_getLoginResult = new WeakMap(), _AirWalletProvider_ensureWallet = new WeakMap(), _AirWalletProvider_eventListeners = new WeakMap(), _AirWalletProvider_instances = new WeakSet(), _AirWalletProvider_emit = function _AirWalletProvider_emit(eventName, ...args) {
     (__classPrivateFieldGet$1(this, _AirWalletProvider_eventListeners, "f")[eventName] || []).forEach(listener => {
       try {
         return listener(...args);
@@ -1788,274 +1857,8 @@
       }
     });
   };
-  class IframeController {
-    constructor(iframeUrl, iframeId, state) {
-      this._iframeElement = null;
-      this.state = {
-        ...IframeController.defaultState,
-        ...state
-      };
-      this.iframeUrl = iframeUrl;
-      this.iframeId = iframeId;
-    }
-    get iframeElement() {
-      return this._iframeElement;
-    }
-    createIframe() {
-      if (this._iframeElement) return this._iframeElement;
-      const iframe = document.createElement("iframe");
-      iframe.id = this.iframeId;
-      iframe.allow = "publickey-credentials-get *; publickey-credentials-create *";
-      iframe.src = this.iframeUrl;
-      iframe.style.position = "fixed";
-      iframe.style.zIndex = "999999";
-      iframe.style.border = "none";
-      iframe.style.margin = "0";
-      iframe.style.padding = "0";
-      iframe.style.display = "none";
-      iframe.style.colorScheme = "auto";
-      document.body.appendChild(iframe);
-      this._iframeElement = iframe;
-      return iframe;
-    }
-    setIframeVisibility(isVisible) {
-      this.state.isVisible = isVisible;
-    }
-    updateIframeState() {
-      if (!this.iframeElement) return;
-      const style = {};
-      style.display = this.state.isVisible ? "block" : "none";
-      style.width = "100%";
-      style.height = "100%";
-      style.top = "0px";
-      style.right = "0px";
-      style.left = "0px";
-      style.bottom = "0px";
-      Object.assign(this.iframeElement.style, style);
-    }
-    destroy() {
-      if (this.iframeElement) {
-        this.iframeElement.remove();
-        this._iframeElement = null;
-      }
-    }
-    postMessage(message) {
-      if (!this.iframeElement) return;
-      const {
-        origin
-      } = new URL(this.iframeElement.src);
-      this.iframeElement.contentWindow.postMessage(message, origin);
-    }
-  }
-  IframeController.defaultState = {
-    isVisible: false
-  };
-  class WindowController {
-    get messages$() {
-      return this._messages$.asObservable();
-    }
-    constructor(windowId, windowUrl) {
-      this._windowInstance = null;
-      this._messageHandler = null;
-      this._messages$ = new Subject();
-      this.windowId = windowId;
-      this.windowUrl = windowUrl;
-      this.windowOrigin = new URL(windowUrl).origin;
-      this._messageHandler = ev => {
-        if (ev.source !== this._windowInstance || ev.origin !== this.windowOrigin || !ev.data || !(ev.data instanceof Object)) {
-          return;
-        }
-        this._messages$.next(ev);
-      };
-      window.addEventListener("message", this._messageHandler);
-    }
-    get windowInstance() {
-      return this._windowInstance;
-    }
-    async openWindow(onRetry) {
-      let windowInstance = this.tryOpenWindow();
-      if (!windowInstance) {
-        await onRetry();
-        windowInstance = this.tryOpenWindow();
-        if (!windowInstance) {
-          throw new AirError(WindowErrorName.WINDOW_BLOCKED);
-        }
-      }
-      const pendingWindowOpenCheck = new Promise((resolve, reject) => {
-        setTimeout(() => {
-          if (this.isWindowOpen(windowInstance)) {
-            // only now are we scheduling the close event check since we're sure the window is open
-            this.scheduleWindowClosedChecks(windowInstance);
-            resolve("opened");
-          } else {
-            onRetry().then(() => {
-              windowInstance = this.tryOpenWindow();
-              if (windowInstance) {
-                this._windowInstance = windowInstance;
-                windowInstance.focus();
-                this.scheduleWindowClosedChecks(windowInstance);
-                resolve("retry");
-              } else {
-                reject(new AirError(WindowErrorName.WINDOW_BLOCKED));
-              }
-            }).catch(reject);
-          }
-        }, 1000);
-      });
-      this._windowInstance = windowInstance;
-      windowInstance.focus();
-      return {
-        pendingWindowOpenCheck
-      };
-    }
-    postMessage(message, transfer) {
-      if (!this._windowInstance) return;
-      this._windowInstance.postMessage(message, this.windowOrigin, transfer);
-    }
-    onMessage(callback) {
-      const listener = ev => {
-        if (ev.source !== this._windowInstance || ev.origin !== this.windowOrigin) return;
-        callback(ev);
-      };
-      window.addEventListener("message", listener);
-      const close = () => window.removeEventListener("message", listener);
-      this.onClose(close);
-      return {
-        close
-      };
-    }
-    cleanup() {
-      if (this._windowInstance && !this._windowInstance.closed) {
-        this._windowInstance.close();
-      }
-      this._windowInstance = null;
-      if (this._messageHandler) {
-        window.removeEventListener("message", this._messageHandler);
-        this._messageHandler = null;
-      }
-      if (this._messages$ && !this._messages$.closed) {
-        this._messages$.complete();
-      }
-    }
-    onClose(callback) {
-      return this._messages$.subscribe({
-        complete: callback
-      });
-    }
-    isWindowOpen(windowInstance) {
-      return !(!windowInstance || windowInstance.closed || typeof windowInstance.closed == "undefined");
-    }
-    tryOpenWindow() {
-      const windowInstance = window.open(this.windowUrl, this.windowId, getWindowFeatures(425, 680));
-      if (this.isWindowOpen(windowInstance)) {
-        return windowInstance;
-      }
-      return null;
-    }
-    scheduleWindowClosedChecks(windowInstance) {
-      const checkWindow = setInterval(() => {
-        if (!windowInstance || windowInstance.closed) {
-          clearInterval(checkWindow);
-          if (windowInstance === this._windowInstance) {
-            this.cleanup();
-          }
-        }
-      }, 500);
-    }
-  }
-  class WindowService {
-    constructor() {
-      this.windowControllers = new Map();
-    }
-    static get instance() {
-      return this._instance || (this._instance = new this());
-    }
-    async sendWindowInitializationRequest(windowId, payload, port) {
-      const windowController = this.windowControllers.get(windowId);
-      if (!windowController) {
-        throw new Error("Window controller not found");
-      }
-      const windowInstance = windowController.windowInstance;
-      if (!windowInstance) {
-        throw new Error("Window instance not found");
-      }
-      const response = firstValueFrom(windowController.messages$.pipe(filter(event => event.data.type === AirWalletMessageTypes.INITIALIZATION_RESPONSE)));
-      windowController.postMessage({
-        type: AirWalletMessageTypes.INITIALIZATION_REQUEST,
-        payload
-      }, [port]);
-      return (await response).data;
-    }
-    async openAndInitializeWalletServiceWindow({
-      url,
-      windowId,
-      partnerId,
-      enableLogging,
-      onRetry,
-      sdkVersion,
-      enableAutomation
-    }) {
-      if (this.windowControllers.has(windowId)) {
-        throw new Error("Window controller already exists");
-      }
-      const windowController = new WindowController(windowId, url);
-      const {
-        pendingWindowOpenCheck
-      } = await windowController.openWindow(onRetry);
-      windowController.onClose(() => {
-        this.removeWindowController(windowId);
-      });
-      this.windowControllers.set(windowId, windowController);
-      let channel = null;
-      const initializeWindow = () => {
-        return new Promise((resolve, reject) => {
-          windowController.onMessage(async ev => {
-            if (ev.data === AirWalletMessageTypes.SERVICE_STARTED) {
-              try {
-                channel = new MessageChannel();
-                const {
-                  payload
-                } = await this.sendWindowInitializationRequest(windowId, {
-                  partnerId,
-                  enableLogging,
-                  sdkVersion,
-                  enableAutomation
-                }, channel.port1);
-                if (payload.success === false) {
-                  reject(new AirServiceError(payload.errorName, payload.errorMessage));
-                } else {
-                  resolve();
-                }
-              } catch (e) {
-                reject(e);
-              }
-            }
-          });
-        });
-      };
-      const initializeWindowPromise = initializeWindow();
-      const result = await pendingWindowOpenCheck;
-      if (result === "retry") {
-        // we can ignore previous initialization attempt since a new window was opened
-        await initializeWindow();
-      } else {
-        await initializeWindowPromise;
-      }
-      return {
-        windowController,
-        port: channel.port2
-      };
-    }
-    getWindowController(windowId) {
-      return this.windowControllers.get(windowId);
-    }
-    removeWindowController(windowId) {
-      this.windowControllers.delete(windowId);
-    }
-  }
-  var WindowService$1 = WindowService.instance;
   var _a$1, _AuthMessageService_instance;
-  const ALLOWED_AUTH_MESSAGES = [AirAuthMessageTypes.INITIALIZATION_RESPONSE, AirAuthMessageTypes.LOGIN_RESPONSE, AirAuthMessageTypes.SETUP_WALLET_REQUEST, AirAuthMessageTypes.LOGOUT_RESPONSE, AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE, AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE, AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_RESPONSE, AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST, AirAuthMessageTypes.CREDENTIAL_SALT_RESPONSE];
+  const ALLOWED_AUTH_MESSAGES = [AirAuthMessageTypes.INITIALIZATION_RESPONSE, AirAuthMessageTypes.LOGIN_RESPONSE, AirAuthMessageTypes.SETUP_WALLET_REQUEST, AirAuthMessageTypes.SETUP_RECOVERY_REQUEST, AirAuthMessageTypes.INIT_RECOVERY_COMMUNICATION, AirAuthMessageTypes.RESET_RECOVERY_COMMUNICATION, AirAuthMessageTypes.LOGOUT_RESPONSE, AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE, AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE, AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_RESPONSE, AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST, AirAuthMessageTypes.CREDENTIAL_SALT_RESPONSE, AirAuthMessageTypes.START_RECOVERY_RESPONSE];
   class AuthMessageService extends MessageServiceBase {
     static create() {
       if (__classPrivateFieldGet$1(this, _a$1, "f", _AuthMessageService_instance)) throw new Error("AuthMessageService already created");
@@ -2124,6 +1927,34 @@
     async sendSetupWalletErrorResponse(error) {
       await this.sendMessage(this.createErrorResponseMessage(AirAuthMessageTypes.SETUP_WALLET_RESPONSE, error));
     }
+    async initRecoveryCommunication() {
+      await this.sendMessage({
+        type: AirAuthMessageTypes.INIT_RECOVERY_COMMUNICATION
+      });
+    }
+    async resetRecoveryCommunication() {
+      await this.sendMessage({
+        type: AirAuthMessageTypes.RESET_RECOVERY_COMMUNICATION
+      });
+    }
+    async sendSetupRecoverySuccessResponse() {
+      await this.sendMessage({
+        type: AirAuthMessageTypes.SETUP_RECOVERY_RESPONSE,
+        payload: {
+          success: true
+        }
+      });
+    }
+    async sendSetupRecoveryErrorResponse(error) {
+      await this.sendMessage({
+        type: AirAuthMessageTypes.SETUP_RECOVERY_RESPONSE,
+        payload: {
+          success: false,
+          errorName: error instanceof AirError ? error.name : "UNKNOWN_ERROR",
+          errorMessage: error.message
+        }
+      });
+    }
     async sendCrossPartnerTokenRequest(targetPartnerUrl) {
       const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE)));
       await this.sendMessage({
@@ -2141,6 +1972,14 @@
       });
       return response;
     }
+    async sendAccountRecoveryRequest(payload) {
+      const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirAuthMessageTypes.START_RECOVERY_RESPONSE)));
+      await this.sendMessage({
+        type: AirAuthMessageTypes.START_RECOVERY_REQUEST,
+        payload
+      });
+      return response;
+    }
     async sendCredentialSaltRequest() {
       const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirAuthMessageTypes.CREDENTIAL_SALT_RESPONSE)));
       await this.sendMessage({
@@ -2153,8 +1992,113 @@
   _AuthMessageService_instance = {
     value: void 0
   };
+  class IframeController {
+    constructor(iframeUrl, iframeId, state) {
+      this._iframeElement = null;
+      this.AUTH_IFRAME_Z_INDEX = "9999999";
+      this.DEFAULT_IFRAME_Z_INDEX = "999999";
+      this.state = {
+        ...IframeController.defaultState,
+        ...state
+      };
+      this.iframeUrl = iframeUrl;
+      this.iframeId = iframeId;
+    }
+    get iframeElement() {
+      return this._iframeElement;
+    }
+    createIframe() {
+      if (this._iframeElement) return this._iframeElement;
+      const iframe = document.createElement("iframe");
+      iframe.id = this.iframeId;
+      iframe.allow = "publickey-credentials-get *; publickey-credentials-create *";
+      iframe.src = this.iframeUrl;
+      iframe.style.position = "fixed";
+      iframe.style.zIndex = this.iframeUrl.includes("auth") ? this.AUTH_IFRAME_Z_INDEX : this.DEFAULT_IFRAME_Z_INDEX;
+      iframe.style.border = "none";
+      iframe.style.margin = "0";
+      iframe.style.padding = "0";
+      iframe.style.display = "none";
+      iframe.style.colorScheme = "auto";
+      document.body.appendChild(iframe);
+      this._iframeElement = iframe;
+      return iframe;
+    }
+    setIframeVisibility(isVisible) {
+      this.state.isVisible = isVisible;
+    }
+    updateIframeState() {
+      if (!this.iframeElement) return;
+      const style = {};
+      style.display = this.state.isVisible ? "block" : "none";
+      style.width = "100%";
+      style.height = "100%";
+      style.top = "0px";
+      style.right = "0px";
+      style.left = "0px";
+      style.bottom = "0px";
+      Object.assign(this.iframeElement.style, style);
+    }
+    destroy() {
+      if (this.iframeElement) {
+        this.iframeElement.remove();
+        this._iframeElement = null;
+      }
+    }
+    postMessage(message) {
+      if (!this.iframeElement) return;
+      const {
+        origin
+      } = new URL(this.iframeElement.src);
+      this.iframeElement.contentWindow.postMessage(message, origin);
+    }
+  }
+  IframeController.defaultState = {
+    isVisible: false
+  };
+  const ALLOWED_RECOVERY_MESSAGES = Object.values(AirRecoveryMessageTypes);
+  class RecoveryMessageService extends MessageServiceBase {
+    static create() {
+      if (!RecoveryMessageService._instance) {
+        RecoveryMessageService._instance = new RecoveryMessageService("Recovery Service", ALLOWED_RECOVERY_MESSAGES);
+      }
+      return RecoveryMessageService._instance;
+    }
+    async sendInitializationRequest(payload) {
+      const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirRecoveryMessageTypes.INITIALIZATION_RESPONSE)));
+      await this.sendMessage({
+        type: AirRecoveryMessageTypes.INITIALIZATION_REQUEST,
+        payload
+      });
+      return response;
+    }
+    async initAuthCommunication() {
+      await this.sendMessage({
+        type: AirRecoveryMessageTypes.INIT_AUTH_COMMUNICATION
+      });
+    }
+    async onInitialized() {
+      return firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirRecoveryMessageTypes.RECOVERY_INITIALIZED)));
+    }
+    async logout() {
+      const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirRecoveryMessageTypes.LOGOUT_RESPONSE)));
+      await this.sendMessage({
+        type: AirRecoveryMessageTypes.LOGOUT_REQUEST
+      });
+      return response;
+    }
+    async open(element) {
+      await this._open({
+        window: element.contentWindow,
+        origin: new URL(element.src).origin
+      });
+    }
+    async close() {
+      await super.close();
+    }
+  }
   var _a, _WalletMessageService_instance;
-  const ALLOWED_WALLET_MESSAGES = [AirWalletMessageTypes.INITIALIZATION_RESPONSE, AirWalletMessageTypes.WALLET_INITIALIZED, AirWalletMessageTypes.WALLET_LOGIN_RESPONSE, AirWalletMessageTypes.SETUP_OR_UPDATE_MFA_RESPONSE, AirWalletMessageTypes.CLAIM_ID_RESPONSE, AirWalletMessageTypes.IS_SMART_ACCOUNT_DEPLOYED_RESPONSE, AirWalletMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE, AirWalletMessageTypes.WALLET_INITIALIZED, AirWalletMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST, AirWalletMessageTypes.LOGOUT_RESPONSE, AirWalletMessageTypes.OPEN_WINDOW_REQUEST, AirWalletMessageTypes.OPEN_WINDOW_RETRY_RESPONSE];
+  const ALLOWED_WALLET_MESSAGES = [AirWalletMessageTypes.INITIALIZATION_RESPONSE, AirWalletMessageTypes.WALLET_INITIALIZED, AirWalletMessageTypes.WALLET_LOGIN_RESPONSE, AirWalletMessageTypes.SETUP_OR_UPDATE_MFA_RESPONSE, AirWalletMessageTypes.SHOW_SWAP_UI_RESPONSE, AirWalletMessageTypes.CLAIM_ID_RESPONSE, AirWalletMessageTypes.IS_SMART_ACCOUNT_DEPLOYED_RESPONSE, AirWalletMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE, AirWalletMessageTypes.WALLET_INITIALIZED, AirWalletMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST, AirWalletMessageTypes.LOGOUT_RESPONSE, AirWindowMessageTypes.OPEN_WINDOW_REQUEST, AirWindowMessageTypes.OPEN_WINDOW_RETRY_RESPONSE];
   class WalletMessageService extends MessageServiceBase {
     static create() {
       if (__classPrivateFieldGet$1(this, _a, "f", _WalletMessageService_instance)) throw new Error("WalletMessageService already created");
@@ -2225,7 +2169,7 @@
     }
     async sendOpenWindowSuccessResponse(windowId, port) {
       await this.sendMessage({
-        type: AirWalletMessageTypes.OPEN_WINDOW_RESPONSE,
+        type: AirWindowMessageTypes.OPEN_WINDOW_RESPONSE,
         payload: {
           success: true,
           windowId
@@ -2233,7 +2177,7 @@
       }, [port]);
     }
     async sendOpenWindowErrorResponse(windowId, error) {
-      const errorResponse = this.createErrorResponseMessage(AirWalletMessageTypes.OPEN_WINDOW_RESPONSE, error);
+      const errorResponse = this.createErrorResponseMessage(AirWindowMessageTypes.OPEN_WINDOW_RESPONSE, error);
       await this.sendMessage({
         ...errorResponse,
         payload: {
@@ -2243,9 +2187,9 @@
       });
     }
     async sendOpenWindowRetryRequest(windowId) {
-      const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.OPEN_WINDOW_RETRY_RESPONSE), filter(msg => msg.payload.windowId === windowId)));
+      const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWindowMessageTypes.OPEN_WINDOW_RETRY_RESPONSE), filter(msg => msg.payload.windowId === windowId)));
       await this.sendMessage({
-        type: AirWalletMessageTypes.OPEN_WINDOW_RETRY_REQUEST,
+        type: AirWindowMessageTypes.OPEN_WINDOW_RETRY_REQUEST,
         payload: {
           windowId
         }
@@ -2254,52 +2198,237 @@
     }
     async sendWindowClosed(windowId) {
       await this.sendMessage({
-        type: AirWalletMessageTypes.WINDOW_CLOSED,
+        type: AirWindowMessageTypes.WINDOW_CLOSED,
         payload: {
           windowId
         }
-      });
+      });
+    }
+    async sendClaimIdRequest(payload) {
+      const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.CLAIM_ID_RESPONSE)));
+      await this.sendMessage({
+        type: AirWalletMessageTypes.CLAIM_ID_REQUEST,
+        payload
+      });
+      return response;
+    }
+    async sendShowSwapUIRequest() {
+      const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.SHOW_SWAP_UI_RESPONSE)));
+      await this.sendMessage({
+        type: AirWalletMessageTypes.SHOW_SWAP_UI_REQUEST
+      });
+      return response;
+    }
+  }
+  _a = WalletMessageService;
+  _WalletMessageService_instance = {
+    value: void 0
+  };
+  class WindowController {
+    get messages$() {
+      return this._messages$.asObservable();
+    }
+    constructor(windowId, windowUrl) {
+      this._windowInstance = null;
+      this._messageHandler = null;
+      this._messages$ = new Subject();
+      this.windowId = windowId;
+      this.windowUrl = windowUrl;
+      this.windowOrigin = new URL(windowUrl).origin;
+      this._messageHandler = ev => {
+        if (ev.source !== this._windowInstance || ev.origin !== this.windowOrigin || !ev.data || !(ev.data instanceof Object)) {
+          return;
+        }
+        this._messages$.next(ev);
+      };
+      window.addEventListener("message", this._messageHandler);
+    }
+    get windowInstance() {
+      return this._windowInstance;
+    }
+    async openWindow(onRetry) {
+      let windowInstance = this.tryOpenWindow();
+      if (!windowInstance) {
+        await onRetry();
+        windowInstance = this.tryOpenWindow();
+        if (!windowInstance) {
+          throw new AirError(WindowErrorName.WINDOW_BLOCKED);
+        }
+      }
+      const pendingWindowOpenCheck = new Promise((resolve, reject) => {
+        setTimeout(() => {
+          if (this.isWindowOpen(windowInstance)) {
+            // only now are we scheduling the close event check since we're sure the window is open
+            this.scheduleWindowClosedChecks(windowInstance);
+            resolve("opened");
+          } else {
+            onRetry().then(() => {
+              windowInstance = this.tryOpenWindow();
+              if (windowInstance) {
+                this._windowInstance = windowInstance;
+                windowInstance.focus();
+                this.scheduleWindowClosedChecks(windowInstance);
+                resolve("retry");
+              } else {
+                reject(new AirError(WindowErrorName.WINDOW_BLOCKED));
+              }
+            }).catch(reject);
+          }
+        }, 1000);
+      });
+      this._windowInstance = windowInstance;
+      windowInstance.focus();
+      return {
+        pendingWindowOpenCheck
+      };
+    }
+    postMessage(message, transfer) {
+      if (!this._windowInstance) return;
+      this._windowInstance.postMessage(message, this.windowOrigin, transfer);
+    }
+    onMessage(callback) {
+      const listener = ev => {
+        if (ev.source !== this._windowInstance || ev.origin !== this.windowOrigin) return;
+        callback(ev);
+      };
+      window.addEventListener("message", listener);
+      const close = () => window.removeEventListener("message", listener);
+      this.onClose(close);
+      return {
+        close
+      };
+    }
+    cleanup() {
+      if (this._windowInstance && !this._windowInstance.closed) {
+        this._windowInstance.close();
+      }
+      this._windowInstance = null;
+      if (this._messageHandler) {
+        window.removeEventListener("message", this._messageHandler);
+        this._messageHandler = null;
+      }
+      if (this._messages$ && !this._messages$.closed) {
+        this._messages$.complete();
+      }
+    }
+    onClose(callback) {
+      return this._messages$.subscribe({
+        complete: callback
+      });
+    }
+    isWindowOpen(windowInstance) {
+      return !(!windowInstance || windowInstance.closed || typeof windowInstance.closed == "undefined");
+    }
+    tryOpenWindow() {
+      const windowInstance = window.open(this.windowUrl, this.windowId, getWindowFeatures(425, 680));
+      if (this.isWindowOpen(windowInstance)) {
+        return windowInstance;
+      }
+      return null;
+    }
+    scheduleWindowClosedChecks(windowInstance) {
+      const checkWindow = setInterval(() => {
+        if (!windowInstance || windowInstance.closed) {
+          clearInterval(checkWindow);
+          if (windowInstance === this._windowInstance) {
+            this.cleanup();
+          }
+        }
+      }, 500);
     }
-    async sendClaimIdRequest(payload) {
-      const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.CLAIM_ID_RESPONSE)));
-      await this.sendMessage({
-        type: AirWalletMessageTypes.CLAIM_ID_REQUEST,
+  }
+  class WindowService {
+    constructor() {
+      this.windowControllers = new Map();
+    }
+    static get instance() {
+      return this._instance || (this._instance = new this());
+    }
+    async sendWindowInitializationRequest(windowId, payload, port) {
+      const windowController = this.windowControllers.get(windowId);
+      if (!windowController) {
+        throw new Error("Window controller not found");
+      }
+      const windowInstance = windowController.windowInstance;
+      if (!windowInstance) {
+        throw new Error("Window instance not found");
+      }
+      const response = firstValueFrom(windowController.messages$.pipe(filter(event => event.data.type === AirWalletMessageTypes.INITIALIZATION_RESPONSE)));
+      windowController.postMessage({
+        type: AirWalletMessageTypes.INITIALIZATION_REQUEST,
         payload
+      }, [port]);
+      return (await response).data;
+    }
+    async openAndInitializeWalletServiceWindow({
+      url,
+      windowId,
+      partnerId,
+      enableLogging,
+      onRetry,
+      sdkVersion,
+      enableAutomation
+    }) {
+      if (this.windowControllers.has(windowId)) {
+        throw new Error("Window controller already exists");
+      }
+      const windowController = new WindowController(windowId, url);
+      const {
+        pendingWindowOpenCheck
+      } = await windowController.openWindow(onRetry);
+      windowController.onClose(() => {
+        this.removeWindowController(windowId);
       });
-      return response;
+      this.windowControllers.set(windowId, windowController);
+      let channel = null;
+      const initializeWindow = () => {
+        return new Promise((resolve, reject) => {
+          windowController.onMessage(async ev => {
+            if (ev.data === AirWalletMessageTypes.SERVICE_STARTED) {
+              try {
+                channel = new MessageChannel();
+                const {
+                  payload
+                } = await this.sendWindowInitializationRequest(windowId, {
+                  partnerId,
+                  enableLogging,
+                  sdkVersion,
+                  enableAutomation
+                }, channel.port1);
+                if (payload.success === false) {
+                  reject(new AirServiceError(payload.errorName, payload.errorMessage));
+                } else {
+                  resolve();
+                }
+              } catch (e) {
+                reject(e);
+              }
+            }
+          });
+        });
+      };
+      const initializeWindowPromise = initializeWindow();
+      const result = await pendingWindowOpenCheck;
+      if (result === "retry") {
+        // we can ignore previous initialization attempt since a new window was opened
+        await initializeWindow();
+      } else {
+        await initializeWindowPromise;
+      }
+      return {
+        windowController,
+        port: channel.port2
+      };
     }
-  }
-  _a = WalletMessageService;
-  _WalletMessageService_instance = {
-    value: void 0
-  };
-  const getLevelName = levelNum => {
-    const levelNames = Object.keys(log$1.levels);
-    if (levelNum >= 0 && levelNum < levelNames.length) {
-      return levelNames[levelNum];
+    getWindowController(windowId) {
+      return this.windowControllers.get(windowId);
     }
-    return "UNKNOWN";
-  };
-  const configureLogLevel = (environment, enableLogging) => {
-    let level = log$1.levels.ERROR;
-    if (environment === "development") {
-      level = enableLogging ? log$1.levels.TRACE : log$1.levels.INFO;
-    } else if (environment === "staging") {
-      level = enableLogging ? log$1.levels.DEBUG : log$1.levels.INFO;
-    } else if (environment === "uat") {
-      level = enableLogging ? log$1.levels.INFO : log$1.levels.WARN;
-    } else if (environment === "production") {
-      // Be cautious with enabling more than WARN in prod
-      level = enableLogging ? log$1.levels.WARN : log$1.levels.ERROR;
+    removeWindowController(windowId) {
+      this.windowControllers.delete(windowId);
     }
-    log$1.setLevel(level);
-    log$1.info(`[${window?.location?.href}] LogLevel: ${getLevelName(log$1.getLevel())}`);
-  };
-  var version$2 = "1.3.0";
-  var airkitPackage = {
-    version: version$2
-  };
-  var _AirService_instances, _AirService_loginResult, _AirService_buildEnv, _AirService_enableLogging, _AirService_partnerId, _AirService_authMessagingService, _AirService_authIframeController, _AirService_isAuthInitialized, _AirService_airAuthListener, _AirService_walletMessagingService, _AirService_walletIframeController, _AirService_walletInitialization, _AirService_walletLoggedInResult, _AirService_airWalletProvider, _AirService_ensureWallet, _AirService_initializeWallet, _AirService_subscribeToWalletEvents, _AirService_triggerEventListeners, _AirService_triggerAirAuthInitialized, _AirService_triggerAirAuthLoggedIn, _AirService_triggerAirAuthLoggedOut, _AirService_triggerWalletInitialized, _AirService_createLoginResult, _AirService_createWalletInitializedResult, _AirService_cleanUpAuth, _AirService_cleanUpWallet;
+  }
+  var WindowService$1 = WindowService.instance;
+  var _AirService_instances, _AirService_loginResult, _AirService_buildEnv, _AirService_enableLogging, _AirService_partnerId, _AirService_authMessagingService, _AirService_authIframeController, _AirService_isAuthInitialized, _AirService_airAuthListener, _AirService_walletMessagingService, _AirService_walletIframeController, _AirService_walletInitialization, _AirService_walletLoggedInResult, _AirService_airWalletProvider, _AirService_recoveryInitialization, _AirService_recoveryMessagingService, _AirService_recoveryIframeController, _AirService_ensureWallet, _AirService_initializeWallet, _AirService_subscribeToWalletEvents, _AirService_triggerEventListeners, _AirService_triggerAirAuthInitialized, _AirService_triggerAirAuthLoggedIn, _AirService_triggerAirAuthLoggedOut, _AirService_triggerWalletInitialized, _AirService_createLoginResult, _AirService_createWalletInitializedResult, _AirService_cleanUpAuth, _AirService_cleanUpWallet, _AirService_ensureRecovery, _AirService_initializeRecovery, _AirService_subscribeToRecoveryEvents, _AirService_cleanUpRecovery;
   const airKitVersion = airkitPackage.version;
   class AirService {
     constructor({
@@ -2320,12 +2449,17 @@
       _AirService_walletInitialization.set(this, void 0);
       _AirService_walletLoggedInResult.set(this, void 0);
       _AirService_airWalletProvider.set(this, void 0);
+      _AirService_recoveryInitialization.set(this, void 0);
+      _AirService_recoveryMessagingService.set(this, void 0);
+      _AirService_recoveryIframeController.set(this, void 0);
       __classPrivateFieldSet(this, _AirService_partnerId, partnerId);
       __classPrivateFieldSet(this, _AirService_authMessagingService, AuthMessageService.create());
       __classPrivateFieldSet(this, _AirService_walletMessagingService, WalletMessageService.create());
+      __classPrivateFieldSet(this, _AirService_recoveryMessagingService, RecoveryMessageService.create());
       __classPrivateFieldSet(this, _AirService_airWalletProvider, new AirWalletProvider({
-        isLoggedIn: () => this.isLoggedIn,
-        ensureWallet: __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureWallet).bind(this)
+        isWalletInitialized: () => this.isWalletInitialized,
+        ensureWallet: __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureWallet).bind(this),
+        getLoginResult: () => __classPrivateFieldGet$1(this, _AirService_loginResult, "f")
       }));
       // this.#modalZIndex = modalZIndex ?? 99999;
     }
@@ -2338,6 +2472,9 @@
     get isLoggedIn() {
       return !!__classPrivateFieldGet$1(this, _AirService_loginResult, "f");
     }
+    get loginResult() {
+      return __classPrivateFieldGet$1(this, _AirService_loginResult, "f");
+    }
     get isWalletInitialized() {
       return !!__classPrivateFieldGet$1(this, _AirService_walletLoggedInResult, "f");
     }
@@ -2393,6 +2530,17 @@
                 }
                 break;
               }
+            case AirAuthMessageTypes.SETUP_RECOVERY_REQUEST:
+              {
+                try {
+                  await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureRecovery).call(this);
+                  await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").sendSetupRecoverySuccessResponse();
+                } catch (err) {
+                  const error = ensureError(err);
+                  await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").sendSetupRecoveryErrorResponse(error);
+                }
+                break;
+              }
           }
         });
         const result = await new Promise((resolve, reject) => {
@@ -2535,6 +2683,16 @@
       }
       throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
     }
+    async showSwapUI() {
+      await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+      const result = await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").sendShowSwapUIRequest();
+      if (result.payload.success === false) {
+        throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+      }
+      return {
+        txHash: result.payload.txHash
+      };
+    }
     async getUserInfo() {
       if (!this.isLoggedIn) throw new Error("User not logged in");
       const info = await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").sendPartnerUserInfoRequest();
@@ -2564,6 +2722,16 @@
         urlWithToken: result.payload.urlWithToken
       };
     }
+    async startRecovery(payload) {
+      try {
+        const result = await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").sendAccountRecoveryRequest(payload);
+        if (result.payload.success === false) {
+          throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+        }
+      } catch (error) {
+        throw AirServiceError.from(error);
+      }
+    }
     async getAccessToken() {
       if (!__classPrivateFieldGet$1(this, _AirService_isAuthInitialized, "f")) throw new Error("Service is not initialized");
       if (!this.isLoggedIn) throw new Error("No active session to get partner access token");
@@ -2590,6 +2758,7 @@
     async cleanUp() {
       await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
       await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_cleanUpAuth).call(this);
+      await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_cleanUpRecovery).call(this);
       this.clearEventListeners();
     }
     on(listener) {
@@ -2602,7 +2771,7 @@
       __classPrivateFieldSet(this, _AirService_airAuthListener, []);
     }
   }
-  _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _AirService_enableLogging = new WeakMap(), _AirService_partnerId = new WeakMap(), _AirService_authMessagingService = new WeakMap(), _AirService_authIframeController = new WeakMap(), _AirService_isAuthInitialized = new WeakMap(), _AirService_airAuthListener = new WeakMap(), _AirService_walletMessagingService = new WeakMap(), _AirService_walletIframeController = new WeakMap(), _AirService_walletInitialization = new WeakMap(), _AirService_walletLoggedInResult = new WeakMap(), _AirService_airWalletProvider = new WeakMap(), _AirService_instances = new WeakSet(), _AirService_ensureWallet = async function _AirService_ensureWallet(option) {
+  _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _AirService_enableLogging = new WeakMap(), _AirService_partnerId = new WeakMap(), _AirService_authMessagingService = new WeakMap(), _AirService_authIframeController = new WeakMap(), _AirService_isAuthInitialized = new WeakMap(), _AirService_airAuthListener = new WeakMap(), _AirService_walletMessagingService = new WeakMap(), _AirService_walletIframeController = new WeakMap(), _AirService_walletInitialization = new WeakMap(), _AirService_walletLoggedInResult = new WeakMap(), _AirService_airWalletProvider = new WeakMap(), _AirService_recoveryInitialization = new WeakMap(), _AirService_recoveryMessagingService = new WeakMap(), _AirService_recoveryIframeController = new WeakMap(), _AirService_instances = new WeakSet(), _AirService_ensureWallet = async function _AirService_ensureWallet(option) {
     if (!this.isInitialized) throw new Error("Service not initialized");
     if (!this.isLoggedIn && !option?.skipWalletLogin) throw new Error("User not logged in");
     if (!__classPrivateFieldGet$1(this, _AirService_walletInitialization, "f")) __classPrivateFieldSet(this, _AirService_walletInitialization, __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_initializeWallet).call(this, option));
@@ -2694,7 +2863,7 @@
             }
             break;
           }
-        case AirWalletMessageTypes.OPEN_WINDOW_REQUEST:
+        case AirWindowMessageTypes.OPEN_WINDOW_REQUEST:
           {
             try {
               const onRetry = async () => {
@@ -2798,9 +2967,96 @@
     await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").close();
     __classPrivateFieldSet(this, _AirService_walletLoggedInResult, undefined);
     __classPrivateFieldSet(this, _AirService_walletInitialization, undefined);
+  }, _AirService_ensureRecovery = async function _AirService_ensureRecovery() {
+    if (!this.isInitialized) throw new Error("Service not initialized");
+    if (!__classPrivateFieldGet$1(this, _AirService_recoveryInitialization, "f")) {
+      __classPrivateFieldSet(this, _AirService_recoveryInitialization, __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_initializeRecovery).call(this));
+    }
+    try {
+      await __classPrivateFieldGet$1(this, _AirService_recoveryInitialization, "f");
+    } catch (error) {
+      __classPrivateFieldSet(this, _AirService_recoveryInitialization, null);
+      log$1.error("Error initializing recovery", error);
+      throw error;
+    }
+  }, _AirService_initializeRecovery = async function _AirService_initializeRecovery() {
+    if (__classPrivateFieldGet$1(this, _AirService_recoveryInitialization, "f")) throw new Error("Already initializing");
+    const {
+      recoveryUrl
+    } = AIR_URLS[__classPrivateFieldGet$1(this, _AirService_buildEnv, "f")];
+    const recoveryIframeOrigin = new URL(recoveryUrl).origin;
+    try {
+      const recoveryInitRequestPromise = new Promise((resolve, reject) => {
+        const handleRecoveryMessage = async ev => {
+          if (ev.origin !== recoveryIframeOrigin) return;
+          if (ev.data === AirRecoveryMessageTypes.SERVICE_STARTED) {
+            window.removeEventListener("message", handleRecoveryMessage);
+            const {
+              payload
+            } = await __classPrivateFieldGet$1(this, _AirService_recoveryMessagingService, "f").sendInitializationRequest({
+              partnerId: __classPrivateFieldGet$1(this, _AirService_partnerId, "f"),
+              enableLogging: __classPrivateFieldGet$1(this, _AirService_enableLogging, "f"),
+              sdkVersion: airKitVersion,
+              enableAutomation: this.shouldEnableAutomation()
+            });
+            if (payload.success === true) {
+              resolve();
+            } else {
+              reject(new AirServiceError(payload.errorName, payload.errorMessage));
+            }
+          }
+        };
+        window.addEventListener("message", handleRecoveryMessage);
+      });
+      __classPrivateFieldSet(this, _AirService_recoveryIframeController, new IframeController(recoveryUrl, `air-recovery-${randomId()}`), "f");
+      __classPrivateFieldGet$1(this, _AirService_recoveryIframeController, "f").createIframe();
+      log$1.info(recoveryUrl, "url loaded");
+      await __classPrivateFieldGet$1(this, _AirService_recoveryMessagingService, "f").open(__classPrivateFieldGet$1(this, _AirService_recoveryIframeController, "f").iframeElement);
+      __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_subscribeToRecoveryEvents).call(this);
+      const recoveryInitPromise = __classPrivateFieldGet$1(this, _AirService_recoveryMessagingService, "f").onInitialized();
+      await recoveryInitRequestPromise;
+      await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").initRecoveryCommunication();
+      await __classPrivateFieldGet$1(this, _AirService_recoveryMessagingService, "f").initAuthCommunication();
+      const recoveryInitResult = await recoveryInitPromise;
+      if (recoveryInitResult.payload.success !== true) {
+        throw new AirServiceError(recoveryInitResult.payload.errorName, recoveryInitResult.payload.errorMessage);
+      }
+    } catch (error) {
+      log$1.error("Error initializing recovery", error);
+      await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_cleanUpRecovery).call(this);
+      throw error;
+    }
+  }, _AirService_subscribeToRecoveryEvents = function _AirService_subscribeToRecoveryEvents() {
+    __classPrivateFieldGet$1(this, _AirService_recoveryMessagingService, "f").messages$.subscribe(async message => {
+      switch (message.type) {
+        case AirRecoveryMessageTypes.RECOVERY_IFRAME_VISIBILITY_REQUEST:
+          {
+            const recoveryIframeController = __classPrivateFieldGet$1(this, _AirService_recoveryIframeController, "f");
+            recoveryIframeController.setIframeVisibility(message.payload.visible);
+            recoveryIframeController.updateIframeState();
+            break;
+          }
+      }
+    });
+  }, _AirService_cleanUpRecovery = async function _AirService_cleanUpRecovery() {
+    if (!__classPrivateFieldGet$1(this, _AirService_isAuthInitialized, "f")) return;
+    // Logout recovery and destroy the recovery iframe
+    const recoveryIframeElement = __classPrivateFieldGet$1(this, _AirService_recoveryIframeController, "f")?.iframeElement;
+    if (isElement(recoveryIframeElement) && window.document.body.contains(recoveryIframeElement)) {
+      await __classPrivateFieldGet$1(this, _AirService_recoveryMessagingService, "f").logout();
+      __classPrivateFieldGet$1(this, _AirService_recoveryIframeController, "f").destroy();
+      __classPrivateFieldSet(this, _AirService_recoveryIframeController, undefined);
+    }
+    const authIframeElement = __classPrivateFieldGet$1(this, _AirService_authIframeController, "f")?.iframeElement;
+    if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
+      await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").resetRecoveryCommunication();
+    }
+    // Close the message service
+    await __classPrivateFieldGet$1(this, _AirService_recoveryMessagingService, "f").close();
+    __classPrivateFieldSet(this, _AirService_recoveryInitialization, undefined);
   };
 
-  const version$1 = '2.26.5';
+  const version$1 = '2.31.0';
 
   let errorConfig = {
     getDocsUrl: ({
@@ -3265,37 +3521,6 @@
     }
   }
 
-  /**
-   * Internal assertion helpers.
-   * @module
-   */
-  /** Asserts something is positive integer. */
-  function anumber(n) {
-    if (!Number.isSafeInteger(n) || n < 0) throw new Error('positive integer expected, got ' + n);
-  }
-  /** Is number an Uint8Array? Copied from utils for perf. */
-  function isBytes(a) {
-    return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array';
-  }
-  /** Asserts something is Uint8Array. */
-  function abytes(b, ...lengths) {
-    if (!isBytes(b)) throw new Error('Uint8Array expected');
-    if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
-  }
-  /** Asserts a hash instance has not been destroyed / finished */
-  function aexists(instance, checkFinished = true) {
-    if (instance.destroyed) throw new Error('Hash instance has been destroyed');
-    if (checkFinished && instance.finished) throw new Error('Hash#digest() has already been called');
-  }
-  /** Asserts output is properly-sized byte array */
-  function aoutput(out, instance) {
-    abytes(out);
-    const min = instance.outputLen;
-    if (out.length < min) {
-      throw new Error('digestInto() expects output buffer of length at least ' + min);
-    }
-  }
-
   /**
    * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
    * @todo re-check https://issues.chromium.org/issues/42212588
@@ -3314,9 +3539,10 @@
     };
   }
   function split(lst, le = false) {
-    let Ah = new Uint32Array(lst.length);
-    let Al = new Uint32Array(lst.length);
-    for (let i = 0; i < lst.length; i++) {
+    const len = lst.length;
+    let Ah = new Uint32Array(len);
+    let Al = new Uint32Array(len);
+    for (let i = 0; i < len; i++) {
       const {
         h,
         l
@@ -3343,12 +3569,45 @@
   // from `crypto` to `cryptoNode`, which imports native module.
   // Makes the utils un-importable in browsers without a bundler.
   // Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
+  /** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+  function isBytes(a) {
+    return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array';
+  }
+  /** Asserts something is positive integer. */
+  function anumber(n) {
+    if (!Number.isSafeInteger(n) || n < 0) throw new Error('positive integer expected, got ' + n);
+  }
+  /** Asserts something is Uint8Array. */
+  function abytes(b, ...lengths) {
+    if (!isBytes(b)) throw new Error('Uint8Array expected');
+    if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+  }
+  /** Asserts a hash instance has not been destroyed / finished */
+  function aexists(instance, checkFinished = true) {
+    if (instance.destroyed) throw new Error('Hash instance has been destroyed');
+    if (checkFinished && instance.finished) throw new Error('Hash#digest() has already been called');
+  }
+  /** Asserts output is properly-sized byte array */
+  function aoutput(out, instance) {
+    abytes(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+      throw new Error('digestInto() expects output buffer of length at least ' + min);
+    }
+  }
+  /** Cast u8 / u16 / u32 to u32. */
   function u32(arr) {
     return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
   }
+  /** Zeroize a byte array. Warning: JS provides no guarantees. */
+  function clean(...arrays) {
+    for (let i = 0; i < arrays.length; i++) {
+      arrays[i].fill(0);
+    }
+  }
   /** Is current platform little-endian? Most are. Big-Endian platform: IBM */
   const isLE = /* @__PURE__ */(() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
-  // The byte swap operation for uint32
+  /** The byte swap operation for uint32 */
   function byteSwap(word) {
     return word << 24 & 0xff000000 | word << 8 & 0xff0000 | word >>> 8 & 0xff00 | word >>> 24 & 0xff;
   }
@@ -3357,13 +3616,15 @@
     for (let i = 0; i < arr.length; i++) {
       arr[i] = byteSwap(arr[i]);
     }
+    return arr;
   }
+  const swap32IfBE = isLE ? u => u : byteSwap32;
   /**
-   * Convert JS string to byte array.
-   * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+   * Converts string to bytes using UTF8 encoding.
+   * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
    */
   function utf8ToBytes(str) {
-    if (typeof str !== 'string') throw new Error('utf8ToBytes expected string, got ' + typeof str);
+    if (typeof str !== 'string') throw new Error('string expected');
     return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
   }
   /**
@@ -3377,14 +3638,9 @@
     return data;
   }
   /** For runtime check if class implements interface */
-  class Hash {
-    // Safe version that clones internal state
-    clone() {
-      return this._cloneInto();
-    }
-  }
+  class Hash {}
   /** Wraps hash function, creating an interface on top of it */
-  function wrapConstructor(hashCons) {
+  function createHasher(hashCons) {
     const hashC = msg => hashCons().update(toBytes(msg)).digest();
     const tmp = hashCons();
     hashC.outputLen = tmp.outputLen;
@@ -3404,16 +3660,18 @@
    * Check out `sha3-addons` module for cSHAKE, k12, and others.
    * @module
    */
+  // No __PURE__ annotations in sha3 header:
+  // EVERYTHING is in fact used on every export.
   // Various per round constants calculations
+  const _0n = BigInt(0);
+  const _1n = BigInt(1);
+  const _2n = BigInt(2);
+  const _7n = BigInt(7);
+  const _256n = BigInt(256);
+  const _0x71n = BigInt(0x71);
   const SHA3_PI = [];
   const SHA3_ROTL = [];
   const _SHA3_IOTA = [];
-  const _0n = /* @__PURE__ */BigInt(0);
-  const _1n = /* @__PURE__ */BigInt(1);
-  const _2n = /* @__PURE__ */BigInt(2);
-  const _7n = /* @__PURE__ */BigInt(7);
-  const _256n = /* @__PURE__ */BigInt(256);
-  const _0x71n = /* @__PURE__ */BigInt(0x71);
   for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
     // Pi
     [x, y] = [y, (2 * x + 3 * y) % 5];
@@ -3428,7 +3686,9 @@
     }
     _SHA3_IOTA.push(t);
   }
-  const [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */split(_SHA3_IOTA, true);
+  const IOTAS = split(_SHA3_IOTA, true);
+  const SHA3_IOTA_H = IOTAS[0];
+  const SHA3_IOTA_L = IOTAS[1];
   // Left rotation (without 0, 32, 64)
   const rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
   const rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
@@ -3473,44 +3733,49 @@
       s[0] ^= SHA3_IOTA_H[round];
       s[1] ^= SHA3_IOTA_L[round];
     }
-    B.fill(0);
+    clean(B);
   }
   /** Keccak sponge function. */
   class Keccak extends Hash {
     // NOTE: we accept arguments in bytes instead of bits here.
     constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
       super();
+      this.pos = 0;
+      this.posOut = 0;
+      this.finished = false;
+      this.destroyed = false;
+      this.enableXOF = false;
       this.blockLen = blockLen;
       this.suffix = suffix;
       this.outputLen = outputLen;
       this.enableXOF = enableXOF;
       this.rounds = rounds;
-      this.pos = 0;
-      this.posOut = 0;
-      this.finished = false;
-      this.destroyed = false;
       // Can be passed from user as dkLen
       anumber(outputLen);
       // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes
       // 0 < blockLen < 200
-      if (0 >= this.blockLen || this.blockLen >= 200) throw new Error('Sha3 supports only keccak-f1600 function');
+      if (!(0 < blockLen && blockLen < 200)) throw new Error('only keccak-f1600 function is supported');
       this.state = new Uint8Array(200);
       this.state32 = u32(this.state);
     }
+    clone() {
+      return this._cloneInto();
+    }
     keccak() {
-      if (!isLE) byteSwap32(this.state32);
+      swap32IfBE(this.state32);
       keccakP(this.state32, this.rounds);
-      if (!isLE) byteSwap32(this.state32);
+      swap32IfBE(this.state32);
       this.posOut = 0;
       this.pos = 0;
     }
     update(data) {
       aexists(this);
+      data = toBytes(data);
+      abytes(data);
       const {
         blockLen,
         state
       } = this;
-      data = toBytes(data);
       const len = data.length;
       for (let pos = 0; pos < len;) {
         const take = Math.min(blockLen - this.pos, len - pos);
@@ -3572,7 +3837,7 @@
     }
     destroy() {
       this.destroyed = true;
-      this.state.fill(0);
+      clean(this.state);
     }
     _cloneInto(to) {
       const {
@@ -3596,9 +3861,9 @@
       return to;
     }
   }
-  const gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
+  const gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));
   /** keccak-256 hash function. Different from SHA3-256. */
-  const keccak_256 = /* @__PURE__ */gen(0x01, 136, 256 / 8);
+  const keccak_256 = /* @__PURE__ */(() => gen(0x01, 136, 256 / 8))();
 
   function keccak256(value, to_) {
     const bytes = keccak_256(isHex(value, {