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

package/dist/airkitConnector.cjs.js

@@ -94,13 +94,19 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
   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",
@@ -113,17 +119,37 @@ const AirAuthMessageTypes = {
   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",
@@ -137,223 +163,23 @@ const AirWalletMessageTypes = {
   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;
 }
@@ -682,44 +508,281 @@ function requireLoglevel$1() {
 }
 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;
@@ -1683,15 +1746,17 @@ _a$2 = ProviderMessageService;
 _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 => {
@@ -1701,7 +1766,6 @@ class AirWalletProvider {
       });
     };
     __classPrivateFieldSet(this, _AirWalletProvider_providerMessageService, ProviderMessageService.create());
-    __classPrivateFieldSet(this, _AirWalletProvider_isLoggedIn, isLoggedIn);
     __classPrivateFieldSet(this, _AirWalletProvider_ensureWallet, ensureWallet);
     __classPrivateFieldSet(this, _AirWalletProvider_eventListeners, {
       connect: [],
@@ -1710,6 +1774,8 @@ class AirWalletProvider {
       chainChanged: [],
       message: []
     });
+    __classPrivateFieldSet(this, _AirWalletProvider_isWalletInitialized, isWalletInitialized);
+    __classPrivateFieldSet(this, _AirWalletProvider_getLoginResult, getLoginResult);
   }
   async request(request) {
     // Check if the request is valid
@@ -1728,11 +1794,14 @@ class AirWalletProvider {
     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, {
@@ -1775,7 +1844,7 @@ class AirWalletProvider {
     });
   }
 }
-_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);
@@ -1784,274 +1853,8 @@ _AirWalletProvider_providerMessageService = new WeakMap(), _AirWalletProvider_is
     }
   });
 };
-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");
@@ -2120,6 +1923,34 @@ class AuthMessageService extends MessageServiceBase {
   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({
@@ -2137,6 +1968,14 @@ class AuthMessageService extends MessageServiceBase {
     });
     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({
@@ -2149,8 +1988,113 @@ _a$1 = AuthMessageService;
 _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");
@@ -2221,7 +2165,7 @@ class WalletMessageService extends MessageServiceBase {
   }
   async sendOpenWindowSuccessResponse(windowId, port) {
     await this.sendMessage({
-      type: AirWalletMessageTypes.OPEN_WINDOW_RESPONSE,
+      type: AirWindowMessageTypes.OPEN_WINDOW_RESPONSE,
       payload: {
         success: true,
         windowId
@@ -2229,7 +2173,7 @@ class WalletMessageService extends MessageServiceBase {
     }, [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: {
@@ -2239,9 +2183,9 @@ class WalletMessageService extends MessageServiceBase {
     });
   }
   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
       }
@@ -2250,52 +2194,237 @@ class WalletMessageService extends MessageServiceBase {
   }
   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({
@@ -2316,12 +2445,17 @@ class AirService {
     _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;
   }
@@ -2334,6 +2468,9 @@ class AirService {
   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");
   }
@@ -2389,6 +2526,17 @@ class AirService {
               }
               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) => {
@@ -2531,6 +2679,16 @@ class AirService {
     }
     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();
@@ -2560,6 +2718,16 @@ class AirService {
       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");
@@ -2586,6 +2754,7 @@ class AirService {
   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) {
@@ -2598,7 +2767,7 @@ class AirService {
     __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));
@@ -2690,7 +2859,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
           }
           break;
         }
-      case AirWalletMessageTypes.OPEN_WINDOW_REQUEST:
+      case AirWindowMessageTypes.OPEN_WINDOW_REQUEST:
         {
           try {
             const onRetry = async () => {
@@ -2794,9 +2963,96 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
   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: ({
@@ -3261,37 +3517,6 @@ class LruMap extends Map {
   }
 }
 
-/**
- * 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
@@ -3310,9 +3535,10 @@ function fromBig(n, le = false) {
   };
 }
 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
@@ -3339,12 +3565,45 @@ const rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
 // 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;
 }
@@ -3353,13 +3612,15 @@ function byteSwap32(arr) {
   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
 }
 /**
@@ -3373,14 +3634,9 @@ function toBytes(data) {
   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;
@@ -3400,16 +3656,18 @@ function wrapConstructor(hashCons) {
  * 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];
@@ -3424,7 +3682,9 @@ for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
   }
   _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);
@@ -3469,44 +3729,49 @@ function keccakP(s, rounds = 24) {
     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);
@@ -3568,7 +3833,7 @@ class Keccak extends Hash {
   }
   destroy() {
     this.destroyed = true;
-    this.state.fill(0);
+    clean(this.state);
   }
   _cloneInto(to) {
     const {
@@ -3592,9 +3857,9 @@ class Keccak extends Hash {
     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, {