@human.tech/waap-sdk 1.3.0 → 2.0.0

package/dist/index.mjs

@@ -0,0 +1,2162 @@
+// src/ui/index.ts
+import {
+  silkWalletAppOrigin2 as silkWalletAppOrigin22,
+  silkWalletAppOrigin2Staging as silkWalletAppOrigin2Staging2
+} from "@human.tech/waap-constants";
+
+// src/lib/provider/EthereumProvider.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import {
+  SILK_METHOD as SILK_METHOD2,
+  JSON_RPC_METHOD
+} from "@human.tech/waap-interface-core";
+
+// src/lib/UIMessageManager.ts
+import { EventEmitter } from "events";
+var UI_EVENT_NAMES = /* @__PURE__ */ ((UI_EVENT_NAMES2) => {
+  UI_EVENT_NAMES2["show_modal"] = "show_modal";
+  UI_EVENT_NAMES2["hide_modal"] = "hide_modal";
+  return UI_EVENT_NAMES2;
+})(UI_EVENT_NAMES || {});
+var UIMessageManager = class extends EventEmitter {
+  constructor() {
+    super();
+  }
+};
+
+// src/lib/provider/requests.ts
+import { rpcMethodRequiresUI } from "@human.tech/waap-constants";
+async function handleWalletRequestAndResponse(args, interactionRequired, walletMessageManager, internalProviderEventEmitter, silkOptions) {
+  const method = args.method;
+  const params = args.params;
+  const id = await walletMessageManager.postSilkRequest({
+    method,
+    params,
+    interactionRequired,
+    silkOptions
+  });
+  return new Promise((resolve, reject) => {
+    internalProviderEventEmitter.once(id, (response) => {
+      if (response.error) reject(response.error);
+      else resolve(response.data);
+    });
+  });
+}
+
+// src/lib/provider/utils.ts
+function isMetaMask(provider) {
+  if (!(provider == null ? void 0 : provider.isMetaMask)) return false;
+  if (provider.isApexWallet) return false;
+  if (provider.isAvalanche) return false;
+  if (provider.isBitKeep) return false;
+  if (provider.isBlockWallet) return false;
+  if (provider.isMathWallet) return false;
+  if (provider.isOkxWallet || provider.isOKExWallet) return false;
+  if (provider.isOneInchIOSWallet || provider.isOneInchAndroidWallet) {
+    return false;
+  }
+  if (provider.isOpera) return false;
+  if (provider.isPortal) return false;
+  if (provider.isRabby) return false;
+  if (provider.isDefiant) return false;
+  if (provider.isTokenPocket) return false;
+  if (provider.isTokenary) return false;
+  if (provider.isZerion) return false;
+  return true;
+}
+function isSafeTransaction(params) {
+  var _a;
+  try {
+    if (!params || !Array.isArray(params)) return false;
+    const typedData = JSON.parse(
+      typeof params[1] === "string" ? params[1] : JSON.stringify(params[1])
+    );
+    return typedData.primaryType === "SafeTx" && ((_a = typedData.domain) == null ? void 0 : _a.verifyingContract) !== void 0 && typedData.message && "to" in typedData.message && "value" in typedData.message && "safeTxGas" in typedData.message && "baseGas" in typedData.message && "gasPrice" in typedData.message && "nonce" in typedData.message;
+  } catch {
+    return false;
+  }
+}
+var defaultConfig = {
+  styles: {
+    darkMode: false
+  }
+};
+
+// src/lib/WalletConnect.ts
+import { EthersAdapter } from "@reown/appkit-adapter-ethers";
+var SilkWalletConnect = class {
+  static instance = null;
+  static projectId = void 0;
+  // Ethereum, Optimism, Gnosis, Polygon, Base, Avalanche, Arbitrum, Celo, Base Sepolia, Sepolia
+  static chains = [
+    1,
+    10,
+    100,
+    137,
+    8453,
+    43114,
+    42161,
+    42220,
+    84532,
+    11155111
+  ];
+  // private static optionalChains: AppKitNetwork[]
+  /**
+   * Set the WalletConnect project ID programmatically
+   * Use this if environment variables aren't working in your setup
+   *
+   * @param id - The WalletConnect project ID to use
+   */
+  static setProjectId(id) {
+    this.projectId = id;
+  }
+  // /**
+  //  * Set the optional chains to use for WalletConnect
+  //  *
+  //  * @param chains - The optional chains to use (number[])
+  //  */
+  // static setOptionalChains(chains: AppKitNetwork[]) {
+  //   SilkWalletConnect.optionalChains = chains
+  // }
+  static getProjectIdFromEnv() {
+    try {
+      if (typeof process !== "undefined" && process.env) {
+        return process.env.NEXT_PUBLIC_WALLET_CONNECT_PROJECT_ID || process.env.VITE_WALLET_CONNECT_PROJECT_ID || process.env.REACT_APP_WALLET_CONNECT_PROJECT_ID || process.env.WALLET_CONNECT_PROJECT_ID;
+      }
+    } catch (error) {
+      return void 0;
+    }
+    return void 0;
+  }
+  static async getInstance() {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return null;
+    }
+    const { createAppKit } = await import("@reown/appkit");
+    const {
+      mainnet,
+      sepolia,
+      optimism,
+      arbitrum,
+      optimismGoerli,
+      polygon,
+      gnosis,
+      avalanche,
+      aurora,
+      fantom,
+      base,
+      celo
+    } = await import("@reown/appkit/networks");
+    try {
+      const metadata = {
+        name: "Human Wallet",
+        description: "Silk lets you create human keys for web3 wallets that are recoverable with private identity proofs and secured by zero trust protocols.",
+        url: window.location.origin,
+        // origin must match your domain & subdomain
+        icons: [
+          "https://imagedelivery.net/_aTEfDRm7z3tKgu9JhfeKA/f11f5753-616a-4aa0-2aee-9b75befea700/sm"
+        ]
+      };
+      const projectId = this.projectId || this.getProjectIdFromEnv();
+      if (!projectId) {
+        console.error(
+          'WalletConnect project ID not found. Please set it using one of these methods:\n1. Pass walletConnectProjectId when calling initSilk\n2. Call SilkWalletConnect.setProjectId("your-project-id")\n3. Set WALLET_CONNECT_PROJECT_ID (NEXT_PUBLIC_WALLET_CONNECT_PROJECT_ID for Next projects) environment variable'
+        );
+        return null;
+      }
+      this.projectId = projectId;
+      if (!this.instance) {
+        this.instance = createAppKit({
+          adapters: [new EthersAdapter()],
+          projectId,
+          metadata,
+          networks: [
+            // @ts-ignore
+            mainnet,
+            sepolia,
+            arbitrum,
+            optimism,
+            polygon,
+            gnosis,
+            avalanche,
+            aurora,
+            fantom,
+            base,
+            celo
+          ],
+          features: {
+            socials: false,
+            email: false
+          }
+        });
+      }
+      return this.instance;
+    } catch (error) {
+      console.error("Error importing or initializing WalletConnect:", error);
+      return null;
+    }
+  }
+  static async listenToAccountChangeEvent() {
+    await new Promise((resolve) => {
+      const unsubscribe = this.instance.subscribeAccount(
+        (accountState) => {
+          if (accountState == null ? void 0 : accountState.isConnected) {
+            resolve();
+          }
+        }
+      );
+    });
+  }
+  /**
+   * Wait for WalletConnect to be properly initialized and connected
+   * @returns Promise<boolean> - true if connected, false if timeout reached
+   */
+  static async waitForReadyAndCheckConnection() {
+    if (!this.instance) {
+      return false;
+    }
+    let isConnected = false;
+    let attempts = 0;
+    const maxAttempts = 15;
+    while (!isConnected && attempts < maxAttempts) {
+      const delay = attempts < 5 ? 500 : 1e3;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      isConnected = this.instance.getIsConnectedState();
+      attempts++;
+      console.log(
+        `WalletConnect connection check attempt ${attempts}: ${isConnected}`
+      );
+    }
+    return isConnected;
+  }
+  /**
+   * Check if WalletConnect is currently connected (immediate check, no waiting)
+   * @returns boolean - true if connected, false otherwise
+   */
+  static isConnected() {
+    var _a;
+    return ((_a = this.instance) == null ? void 0 : _a.getIsConnectedState()) ?? false;
+  }
+  /**
+   * Get the wallet provider from the WalletConnect instance
+   * @returns The wallet provider or null if not available
+   */
+  static getWalletProvider() {
+    var _a;
+    return ((_a = this.instance) == null ? void 0 : _a.getWalletProvider()) ?? null;
+  }
+};
+
+// src/lib/WalletMessageManager.ts
+import {
+  SILK_MESSAGE_TYPE,
+  SILK_NOTIFICATION,
+  generateMessageId
+} from "@human.tech/waap-interface-core";
+import {
+  silkWalletAppOrigin2,
+  silkWalletAppOrigin2Staging
+} from "@human.tech/waap-constants";
+var WalletMessageManager = class {
+  iframeWindow = null;
+  walletOrigin;
+  constructor(iframeWindow, useStaging) {
+    this.iframeWindow = iframeWindow;
+    this.walletOrigin = useStaging ? silkWalletAppOrigin2Staging : silkWalletAppOrigin2;
+  }
+  /**
+   * Post a Silk notification to the given iframeWindow
+   */
+  postSilkNotification(data) {
+    this.iframeWindow.postMessage(
+      {
+        target: "silk",
+        messageType: SILK_MESSAGE_TYPE.notification,
+        data
+      },
+      this.walletOrigin
+    );
+  }
+  postReadyNotification() {
+    this.postSilkNotification(SILK_NOTIFICATION.ready);
+  }
+  postConnectNotification() {
+    this.postSilkNotification(SILK_NOTIFICATION.connect);
+  }
+  /**
+   * Post a 'ready' notification to the iframe, and wait
+   * for the iframe to respond with a 'ready' notification.
+   */
+  pingIframe() {
+    return new Promise((resolve, reject) => {
+      setTimeout(() => reject("Wallet ping timed out."), 1e4);
+      const eventHandler = (event) => {
+        if (event.data.target === "silk" && event.data.messageType === SILK_MESSAGE_TYPE.notification && event.data.data === SILK_NOTIFICATION.ready) {
+          window.removeEventListener("message", eventHandler);
+          resolve();
+        }
+      };
+      window.addEventListener("message", eventHandler);
+      this.postReadyNotification();
+    });
+  }
+  /**
+   * Post a SilkRequest to the iframeWindow. Don't wait for a response.
+   */
+  async postSilkRequest(req) {
+    const { silkOptions, ...restReq } = req;
+    const baseRequest = {
+      ...restReq,
+      target: "silk",
+      messageType: SILK_MESSAGE_TYPE.request,
+      // Include silkOptions for transaction methods
+      ...silkOptions && { silkOptions }
+    };
+    const id = await generateMessageId(baseRequest);
+    this.iframeWindow.postMessage({ ...baseRequest, id }, this.walletOrigin);
+    return id;
+  }
+  /**
+   * Add a message listener to the window in which this is called (which should be the top frame).
+   * It handles all messages from the Silk iframe posted to the top frame.
+   * @param config - Configuration that includes callbacks for handling specific messages.
+   */
+  addListener(config) {
+    const {
+      handleResponse,
+      handleRequest,
+      onReceiveConnectNotif,
+      onAccountChanged,
+      onAsyncTxNotification
+    } = config;
+    window.addEventListener("message", (event) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+      try {
+        const origin = typeof process !== "undefined" && process.env && process.env.NODE_ENV === "test" ? "http://127.0.0.1:3000" : event.origin;
+        if (origin !== this.walletOrigin) {
+          return;
+        }
+      } catch (error) {
+        if (event.origin !== this.walletOrigin) {
+          return;
+        }
+      }
+      if (((_a = event.data) == null ? void 0 : _a.messageType) === SILK_MESSAGE_TYPE.request) {
+        handleRequest(event.data);
+      } else if (((_b = event.data) == null ? void 0 : _b.messageType) === SILK_MESSAGE_TYPE.response) {
+        handleResponse(event.data);
+      } else if (((_c = event.data) == null ? void 0 : _c.messageType) === SILK_MESSAGE_TYPE.notification) {
+        if (((_d = event.data) == null ? void 0 : _d.data) === SILK_NOTIFICATION.connect) {
+          onReceiveConnectNotif == null ? void 0 : onReceiveConnectNotif();
+        } else if (((_f = (_e = event.data) == null ? void 0 : _e.data) == null ? void 0 : _f.type) === SILK_NOTIFICATION.account_changed && onAccountChanged) {
+          onAccountChanged(event.data.data.account);
+        } else if ((((_i = (_h = (_g = event.data) == null ? void 0 : _g.data) == null ? void 0 : _h.type) == null ? void 0 : _i.startsWith("waap_sign_")) || ((_l = (_k = (_j = event.data) == null ? void 0 : _j.data) == null ? void 0 : _k.type) == null ? void 0 : _l.startsWith("waap_tx_"))) && onAsyncTxNotification) {
+          onAsyncTxNotification({
+            type: event.data.data.type,
+            payload: event.data.data.payload
+          });
+        }
+      }
+    });
+  }
+};
+var WalletMessageManager_default = WalletMessageManager;
+
+// src/lib/provider/EthereumProvider.ts
+var VALID_LOGIN_METHODS = [
+  "waap",
+  "human",
+  "injected",
+  "walletconnect"
+];
+function normalizeLoginResponse(response) {
+  if (response === null || response === void 0) {
+    return null;
+  }
+  if (typeof response === "string") {
+    if (VALID_LOGIN_METHODS.includes(response)) {
+      return response;
+    }
+    throw new Error(
+      `[EthereumProvider] Unexpected login method: "${response}". Expected one of: ${VALID_LOGIN_METHODS.join(", ")}`
+    );
+  }
+  if (typeof response === "object" && "loginMethod" in response && typeof response.loginMethod === "string") {
+    const method = response.loginMethod;
+    console.warn(
+      `[EthereumProvider] Received object login response. Normalizing "${method}" to string. This is unexpected for the web SDK.`
+    );
+    if (VALID_LOGIN_METHODS.includes(method)) {
+      return method;
+    }
+    throw new Error(
+      `[EthereumProvider] Unknown loginMethod in object: "${method}". Expected one of: ${VALID_LOGIN_METHODS.join(", ")}`
+    );
+  }
+  throw new Error(
+    `[EthereumProvider] Unexpected login response: ${JSON.stringify(
+      response
+    )} (type: ${typeof response})`
+  );
+}
+var EthereumProvider = class extends EventEmitter2 {
+  isSilk = true;
+  isWaaP = true;
+  connected = false;
+  walletMessageManager;
+  uiMessageManager;
+  config;
+  currentAccount = null;
+  walletConnectProvider = null;
+  /**
+   * When true, eth_sendTransaction resolves with the pre-calculated tx hash
+   * after signing. Broadcasting continues in the background with events.
+   */
+  asyncTxs = false;
+  /**
+   * When true, sends `asyncSigning: true` in silkOptions instead of `async: true`.
+   * This mimics the v1 SDK protocol for backward compatibility testing.
+   * @internal
+   */
+  legacyAsyncSigning = false;
+  persistedMethods;
+  /**
+   * We use the internalEventEmitter to emit as events
+   * Silk messages posted to the window.
+   */
+  internalEventEmitter = new EventEmitter2();
+  /**
+   * @param iframeWindow - The contentWindow of the iframe of the Silk website.
+   * @param referralCode - Silk points referral code
+   * @param customConfig - Silk custom UI configuration
+   * @param project - Silk project configuration
+   * @param useStaging - Whether to use the staging environment
+   * @param asyncTxs - When true, eth_sendTransaction resolves with tx hash after signing
+   * @param legacyAsyncSigning - When true, sends asyncSigning in silkOptions (v1 compat)
+   */
+  constructor(iframeWindow, referralCode, customConfig, project, useStaging, asyncTxs = false, legacyAsyncSigning = false) {
+    super();
+    this.asyncTxs = asyncTxs;
+    this.legacyAsyncSigning = legacyAsyncSigning;
+    this.uiMessageManager = new UIMessageManager();
+    this.walletMessageManager = new WalletMessageManager_default(
+      iframeWindow,
+      !!useStaging
+    );
+    this.config = {
+      ...defaultConfig,
+      ...customConfig || {}
+      // Override with customConfig if provided
+    };
+    this.persistedMethods = {
+      login: this.login.bind(this),
+      logout: this.logout.bind(this),
+      getLoginMethod: this.getLoginMethod.bind(this),
+      walletMessageManager: this.walletMessageManager,
+      internalEventEmitter: this.internalEventEmitter,
+      uiMessageManager: this.uiMessageManager,
+      portal: this.portal.bind(this),
+      requestEmail: this.requestEmail.bind(this),
+      requestSBT: this.requestSBT.bind(this),
+      requestPermissionToken: this.requestPermissionToken.bind(this),
+      orcid: this.orcid.bind(this),
+      enable: this.enable.bind(this),
+      isConnected: this.isConnected.bind(this),
+      toggleDarkMode: this.toggleDarkMode.bind(this),
+      // We leave this silkRequest separate and never changing so that
+      // we can still call the original request method if needed no matter
+      // the current provider
+      silkRequest: this.request.bind(this),
+      waaPRequest: this.request.bind(this)
+    };
+    this.walletMessageManager.addListener({
+      onReceiveConnectNotif: () => {
+        console.log("onReceiveConnectNotif");
+        this.connected = true;
+        this.emit("connect");
+      },
+      handleResponse: (response) => this.internalEventEmitter.emit(response.id, response),
+      handleRequest: (request) => {
+        if (request.method === SILK_METHOD2.show_modal) {
+          this.uiMessageManager.emit("show_modal" /* show_modal */);
+        } else if (request.method === SILK_METHOD2.hide_modal) {
+          this.uiMessageManager.emit("hide_modal" /* hide_modal */);
+        }
+      },
+      onAccountChanged: (newAccount) => {
+        if (this.currentAccount !== newAccount) {
+          this.currentAccount = newAccount;
+          this.emit("accountsChanged", newAccount ? [newAccount] : []);
+        }
+      },
+      onAsyncTxNotification: (notification) => {
+        this.emit(notification.type, notification.payload);
+      }
+    });
+    if (referralCode) {
+      this.walletMessageManager.pingIframe().then(() => {
+        return handleWalletRequestAndResponse(
+          {
+            method: SILK_METHOD2.set_points_referral_code,
+            params: [referralCode]
+          },
+          false,
+          this.walletMessageManager,
+          this.internalEventEmitter
+        );
+      }).catch((error) => {
+        console.error("Error setting referral code in Silk iframe:", error);
+      });
+    }
+    if (project) {
+      console.log(" =========== project =========== ", project);
+      this.walletMessageManager.pingIframe().then(() => {
+        return handleWalletRequestAndResponse(
+          {
+            method: SILK_METHOD2.set_project,
+            params: [project, window.location.origin]
+          },
+          false,
+          this.walletMessageManager,
+          this.internalEventEmitter
+        );
+      });
+    }
+    if (customConfig) {
+      this.walletMessageManager.pingIframe().then(() => {
+        return handleWalletRequestAndResponse(
+          {
+            method: SILK_METHOD2.set_custom_config,
+            params: [customConfig]
+          },
+          false,
+          this.walletMessageManager,
+          this.internalEventEmitter
+        );
+      }).catch((error) => {
+        console.error("Error setting custom config in Silk iframe:", error);
+      });
+    }
+  }
+  async initializeWalletConnect() {
+    try {
+      this.walletConnectProvider = await SilkWalletConnect.getInstance();
+      console.log("WalletConnect provider initialized");
+    } catch (error) {
+      console.error("Failed to initialize WalletConnect provider:", error);
+      this.walletConnectProvider = null;
+    }
+  }
+  async enable() {
+    return this.request({ method: "eth_requestAccounts" });
+  }
+  isConnected() {
+    return this.connected;
+  }
+  async request(args) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (!Object.keys(JSON_RPC_METHOD).includes(
+      args.method
+    )) {
+      return Promise.reject({ error: `Not implemented (${args.method})` });
+    }
+    const autoConnectResult = await this.attemptAutoConnect(args.method);
+    if (autoConnectResult !== null) {
+      return autoConnectResult;
+    }
+    const isSafeTx = isSafeTransaction(args.params);
+    if (isSafeTx) {
+      if (args.method !== JSON_RPC_METHOD.eth_signTypedData_v4) {
+        return Promise.reject({
+          error: "Safe transactions must be signed using eth_signTypedData_v4"
+        });
+      }
+    }
+    await this.walletMessageManager.pingIframe();
+    const isTxMethod = args.method === JSON_RPC_METHOD.eth_sendTransaction || args.method === JSON_RPC_METHOD.eth_signTransaction || args.method === JSON_RPC_METHOD.eth_signTypedData_v4 || args.method === JSON_RPC_METHOD.personal_sign;
+    const isAsync = isTxMethod && this.asyncTxs || args.async;
+    const silkOptions = isAsync || args.withPT ? this.legacyAsyncSigning ? {
+      // v1 SDK protocol: send asyncSigning instead of async
+      asyncSigning: isAsync || void 0,
+      withPT: args.withPT
+    } : {
+      async: isAsync,
+      withPT: args.withPT
+    } : void 0;
+    const response = await handleWalletRequestAndResponse(
+      args,
+      rpcMethodRequiresUI(args.method),
+      this.walletMessageManager,
+      this.internalEventEmitter,
+      silkOptions
+    );
+    if ((args.method === JSON_RPC_METHOD.wallet_switchEthereumChain || args.method === JSON_RPC_METHOD.wallet_addEthereumChain) && response === null) {
+      this.emit(
+        "chainChanged",
+        (_b = (_a = args.params) == null ? void 0 : _a[0]) == null ? void 0 : _b.chainId
+      );
+      try {
+        const accounts = await this.request({
+          method: "eth_accounts"
+        });
+        if (accounts && accounts.length > 0) {
+          this.currentAccount = accounts[0];
+          this.emit("accountsChanged", accounts);
+          this.emit("connect", {
+            chainId: (_d = (_c = args.params) == null ? void 0 : _c[0]) == null ? void 0 : _d.chainId
+          });
+          console.log(
+            "[EthereumProvider] Re-emitted accounts and connect after chain switch:",
+            {
+              accounts,
+              chainId: (_f = (_e = args.params) == null ? void 0 : _e[0]) == null ? void 0 : _f.chainId
+            }
+          );
+        }
+      } catch (error) {
+        console.warn(
+          "[EthereumProvider] Failed to get accounts after chain switch:",
+          error
+        );
+        if (this.currentAccount) {
+          this.emit("accountsChanged", [this.currentAccount]);
+          this.emit("connect", {
+            chainId: (_h = (_g = args.params) == null ? void 0 : _g[0]) == null ? void 0 : _h.chainId
+          });
+        }
+      }
+    }
+    return response;
+  }
+  async login(customProvider) {
+    var _a;
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return null;
+    }
+    if (((_a = this.config.authenticationMethods) == null ? void 0 : _a.includes("wallet")) && !this.walletConnectProvider) {
+      await this.initializeWalletConnect();
+    }
+    const provider = customProvider || window.ethereum;
+    const providerWalletName = provider && isMetaMask(provider) ? "MetaMask" : "Browser Wallet";
+    await this.walletMessageManager.pingIframe();
+    const rawResponse = await handleWalletRequestAndResponse(
+      { method: SILK_METHOD2.login, params: [providerWalletName] },
+      true,
+      this.walletMessageManager,
+      this.internalEventEmitter
+    );
+    const loginMethod = normalizeLoginResponse(rawResponse);
+    if (loginMethod === null) {
+      return null;
+    }
+    switch (loginMethod) {
+      case "waap":
+      case "human":
+        localStorage.setItem(`${window.location.origin}-connected`, "waap");
+        this.setupWaaP();
+        break;
+      case "injected":
+        if (provider) {
+          localStorage.setItem(
+            `${window.location.origin}-connected`,
+            "injected"
+          );
+          this.setupInjectedWallet(provider);
+        }
+        break;
+      case "walletconnect": {
+        localStorage.setItem(
+          `${window.location.origin}-connected`,
+          "walletconnect"
+        );
+        if (!SilkWalletConnect.isConnected()) {
+          await this.walletConnectProvider.open({ view: "Connect" });
+          await SilkWalletConnect.listenToAccountChangeEvent();
+        }
+        const wcProvider = SilkWalletConnect.getWalletProvider();
+        this.setupWalletConnect(wcProvider);
+        break;
+      }
+    }
+    return loginMethod;
+  }
+  async logout() {
+    await this.walletMessageManager.pingIframe();
+    this.cleanupInvalidLoginState();
+    try {
+      if (this.walletConnectProvider) {
+        await this.walletConnectProvider.disconnect();
+      }
+    } catch (error) {
+      console.error("Error disconnecting from WalletConnect:", error);
+    }
+    return handleWalletRequestAndResponse(
+      { method: SILK_METHOD2.logout },
+      false,
+      this.walletMessageManager,
+      this.internalEventEmitter
+    );
+  }
+  cleanupInvalidLoginState() {
+    try {
+      localStorage.removeItem(`${window.location.origin}-connected`);
+    } catch (error) {
+      console.warn("Could not clean up login state:", error);
+    }
+  }
+  /**
+   * Helper method to set up window.waap for WaaP
+   */
+  setupWaaP() {
+    const provider = {
+      ...this.persistedMethods,
+      isWaaP: true,
+      on: this.on.bind(this),
+      removeListener: this.removeListener.bind(this),
+      request: this.request.bind(this)
+    };
+    window.silk = provider;
+    window.waap = provider;
+  }
+  /**
+   * Helper method to set up window.silk for injected wallets (e.g., MetaMask)
+   */
+  setupInjectedWallet(provider) {
+    var _a, _b;
+    const injectedProvider = {
+      ...this.persistedMethods,
+      ...provider,
+      isSilk: true,
+      connected: provider.connected ?? false,
+      on: ((_a = provider.on) == null ? void 0 : _a.bind(provider)) ?? (() => {
+      }),
+      removeListener: ((_b = provider.removeListener) == null ? void 0 : _b.bind(provider)) ?? (() => {
+      }),
+      request: provider.request.bind(provider)
+    };
+    window.silk = injectedProvider;
+    window.waap = injectedProvider;
+  }
+  /**
+   * Helper method to set up window.silk for WalletConnect
+   */
+  setupWalletConnect(provider) {
+    var _a, _b;
+    const walletConnectProvider = {
+      ...this.persistedMethods,
+      ...provider,
+      isSilk: true,
+      connected: true,
+      on: ((_a = provider.on) == null ? void 0 : _a.bind(provider)) ?? (() => {
+      }),
+      removeListener: ((_b = provider.removeListener) == null ? void 0 : _b.bind(provider)) ?? (() => {
+      }),
+      request: provider.request.bind(provider)
+    };
+    window.silk = walletConnectProvider;
+    window.waap = walletConnectProvider;
+  }
+  /**
+   * Helper method to set up window.silk for auto-connect with injected wallets
+   */
+  setupAutoConnectInjected(provider) {
+    var _a, _b, _c;
+    const injectedProvider = {
+      ...this.persistedMethods,
+      ...provider,
+      isSilk: false,
+      // @ts-ignore
+      connected: ((_a = provider.isConnected) == null ? void 0 : _a.call(provider)) ?? false,
+      // @ts-ignore
+      on: ((_b = provider.on) == null ? void 0 : _b.bind(provider)) ?? (() => {
+      }),
+      removeListener: (
+        // @ts-ignore
+        ((_c = provider.removeListener) == null ? void 0 : _c.bind(provider)) ?? (() => {
+        })
+      ),
+      // @ts-ignore
+      request: provider.request.bind(provider)
+    };
+    window.silk = injectedProvider;
+    window.waap = injectedProvider;
+  }
+  /**
+   * Helper method to set up window.silk for auto-connect with WalletConnect
+   */
+  setupAutoConnectWalletConnect(provider) {
+    var _a, _b;
+    const walletConnectProvider = {
+      ...this.persistedMethods,
+      ...provider,
+      isSilk: false,
+      connected: true,
+      on: ((_a = provider.on) == null ? void 0 : _a.bind(provider)) ?? (() => {
+      }),
+      removeListener: ((_b = provider.removeListener) == null ? void 0 : _b.bind(provider)) ?? (() => {
+      }),
+      request: provider.request.bind(provider)
+    };
+    window.silk = walletConnectProvider;
+    window.waap = walletConnectProvider;
+  }
+  /**
+   * Attempts to auto-connect using previously stored login method
+   * @param method - The RPC method being called
+   * @returns Promise<unknown> if auto-connect succeeds, null if it should fall through to normal flow
+   */
+  async attemptAutoConnect(method) {
+    if (method !== "eth_requestAccounts" && method !== "eth_accounts") {
+      return null;
+    }
+    this.walletMessageManager.pingIframe().then(async () => {
+      await handleWalletRequestAndResponse(
+        {
+          method: SILK_METHOD2.auto_conn,
+          params: [window.location.origin]
+        },
+        false,
+        this.walletMessageManager,
+        this.internalEventEmitter
+      );
+    });
+    const loginMethod = this.getLoginMethod();
+    if (loginMethod === "injected" && window.ethereum) {
+      try {
+        this.setupAutoConnectInjected(window.ethereum);
+        return window.ethereum.request({
+          method: "eth_requestAccounts"
+        });
+      } catch (error) {
+        console.warn("Injected wallet auto-connect failed:", error);
+        this.cleanupInvalidLoginState();
+        return null;
+      }
+    } else if (loginMethod === "walletconnect") {
+      try {
+        if (!this.walletConnectProvider) {
+          this.walletConnectProvider = await SilkWalletConnect.getInstance();
+        }
+        const isConnected = await SilkWalletConnect.waitForReadyAndCheckConnection();
+        if (isConnected) {
+          const provider = SilkWalletConnect.getWalletProvider();
+          this.setupAutoConnectWalletConnect(provider);
+          return provider.request({
+            method: "eth_requestAccounts"
+          });
+        } else {
+          console.log(
+            "WalletConnect not connected, cleaning up and falling through to normal flow"
+          );
+          this.cleanupInvalidLoginState();
+          return null;
+        }
+      } catch (error) {
+        console.warn("WalletConnect auto-connect failed:", error);
+        this.cleanupInvalidLoginState();
+        return null;
+      }
+    }
+    return null;
+  }
+  getLoginMethod() {
+    if (typeof window === "undefined" || typeof localStorage === "undefined") {
+      return null;
+    }
+    try {
+      const stored = localStorage.getItem(`${window.location.origin}-connected`);
+      if (!stored) {
+        return null;
+      }
+      if (!["waap", "human", "injected", "walletconnect"].includes(stored)) {
+        this.cleanupInvalidLoginState();
+        return null;
+      }
+      switch (stored) {
+        case "injected":
+          if (!window.ethereum) {
+            this.cleanupInvalidLoginState();
+            return null;
+          }
+          return "injected";
+        case "walletconnect":
+          try {
+            if (!SilkWalletConnect.isConnected()) {
+              this.cleanupInvalidLoginState();
+              return null;
+            }
+            return "walletconnect";
+          } catch (error) {
+            this.cleanupInvalidLoginState();
+            return null;
+          }
+        case "waap":
+          return "waap";
+        case "human":
+          return "human";
+        default:
+          this.cleanupInvalidLoginState();
+          return null;
+      }
+    } catch (error) {
+      console.warn("Error checking login method:", error);
+      this.cleanupInvalidLoginState();
+      return null;
+    }
+  }
+  async toggleDarkMode() {
+    this.config.styles.darkMode = !this.config.styles.darkMode;
+    this.walletMessageManager.pingIframe().then(() => {
+      return handleWalletRequestAndResponse(
+        {
+          method: SILK_METHOD2.set_custom_config,
+          params: [this.config]
+        },
+        false,
+        this.walletMessageManager,
+        this.internalEventEmitter
+      );
+    }).catch((error) => {
+      console.error("Error setting custom config in Silk iframe:", error);
+    });
+  }
+  async safe() {
+    this.walletMessageManager.pingIframe().then(() => {
+      return handleWalletRequestAndResponse(
+        { method: SILK_METHOD2.safe },
+        true,
+        this.walletMessageManager,
+        this.internalEventEmitter
+      );
+    });
+  }
+  async orcid() {
+    this.walletMessageManager.pingIframe().then(() => {
+      return handleWalletRequestAndResponse(
+        { method: SILK_METHOD2.orcid },
+        true,
+        this.walletMessageManager,
+        this.internalEventEmitter
+      );
+    });
+  }
+  /**
+   * INTERNAL METHOD: Gas tank administration operations
+   * This method is ONLY accessible from the Dev Portal domain
+   * It's not included in the public typing to hide it from regular dApps
+   */
+  async portal(feature, operation, payload) {
+    await this.walletMessageManager.pingIframe();
+    let methodName;
+    switch (operation) {
+      case "get":
+        methodName = feature === "gastank" ? SILK_METHOD2.gastank_get_settings : SILK_METHOD2.customization_get;
+        break;
+      case "update":
+        methodName = feature === "gastank" ? SILK_METHOD2.gastank_update_settings : SILK_METHOD2.customization_update;
+        break;
+      case "topup":
+        methodName = SILK_METHOD2.gastank_topup;
+        break;
+      case "init":
+        methodName = SILK_METHOD2.project_init;
+        break;
+    }
+    const interactionRequired = operation !== "get" && feature !== "customization";
+    return handleWalletRequestAndResponse(
+      {
+        method: methodName,
+        params: [payload, window.location.origin]
+      },
+      interactionRequired,
+      // Only open modal for update operations
+      this.walletMessageManager,
+      this.internalEventEmitter
+    );
+  }
+  async requestEmail() {
+    await this.walletMessageManager.pingIframe();
+    return handleWalletRequestAndResponse(
+      { method: SILK_METHOD2.silk_requestEmail },
+      true,
+      this.walletMessageManager,
+      this.internalEventEmitter
+    );
+  }
+  /**
+   * Request a Permission Token from the user.
+   * Allows pre-authorized transactions without individual confirmations.
+   * @param params - Permission token parameters (allowed addresses, chain, limits, expiry)
+   * @returns Promise<RequestPermissionTokenResult>
+   */
+  async requestPermissionToken(params) {
+    await this.walletMessageManager.pingIframe();
+    return handleWalletRequestAndResponse(
+      {
+        method: SILK_METHOD2.waap_requestPermissionToken,
+        params: [params]
+      },
+      true,
+      // Requires UI for user approval
+      this.walletMessageManager,
+      this.internalEventEmitter
+    );
+  }
+  /**
+   * Prompt the user to mint a Zeronym SBT.
+   * @returns string or null - The address of the owner of the SBT, or null
+   * if the user already minted the SBT.
+   */
+  async requestSBT(type) {
+    await this.walletMessageManager.pingIframe();
+    return handleWalletRequestAndResponse(
+      {
+        method: SILK_METHOD2.silk_requestSbt,
+        params: [type]
+      },
+      true,
+      this.walletMessageManager,
+      this.internalEventEmitter
+    );
+  }
+};
+
+// src/ui/WaapComponent.ts
+var WAAP_COMPONENT_TAG_NAME = "waap-wallet";
+var WAAP_COMPONENT_CONTAINER_ID = "waap-component-container";
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && typeof HTMLElement !== "undefined";
+var WaapWalletElement;
+if (isBrowser) {
+  WaapWalletElement = class extends HTMLElement {
+    constructor() {
+      super();
+      if (!this.style.display || this.style.display === "") {
+        this.style.display = "flex";
+        this.style.alignItems = "center";
+        this.style.justifyContent = "center";
+      }
+      if (!this.style.width || this.style.width === "") {
+        this.style.width = "100%";
+      }
+      if (!this.style.height || this.style.height === "") {
+        this.style.height = "100%";
+      }
+      this.id = WAAP_COMPONENT_CONTAINER_ID;
+    }
+    connectedCallback() {
+      this.setAttribute("data-waap-mounted", "true");
+    }
+    disconnectedCallback() {
+      this.removeAttribute("data-waap-mounted");
+    }
+  };
+  if (typeof customElements !== "undefined" && !customElements.get(WAAP_COMPONENT_TAG_NAME)) {
+    customElements.define(WAAP_COMPONENT_TAG_NAME, WaapWalletElement);
+  }
+} else {
+  WaapWalletElement = class {
+  };
+}
+function hasWaapComponent() {
+  if (!isBrowser) return false;
+  return !!document.getElementById(WAAP_COMPONENT_CONTAINER_ID) || !!document.querySelector(WAAP_COMPONENT_TAG_NAME);
+}
+function getWaapComponentContainer() {
+  if (!isBrowser) return null;
+  return document.getElementById(WAAP_COMPONENT_CONTAINER_ID) || document.querySelector(WAAP_COMPONENT_TAG_NAME);
+}
+
+// src/ui/index.ts
+var LEGACY_IFRAME_CONTAINER_ID = "silk-wallet-iframe-container";
+var LEGACY_IFRAME_WRAPPER_ID = "silk-wallet-iframe-wrapper";
+var LEGACY_IFRAME_ID = "silk-wallet-iframe";
+var NEW_IFRAME_CONTAINER_ID = "waap-wallet-iframe-container";
+var NEW_IFRAME_WRAPPER_ID = "waap-wallet-iframe-wrapper";
+var NEW_IFRAME_ID = "waap-wallet-iframe";
+var getIframeContainer = () => {
+  return document.getElementById(NEW_IFRAME_CONTAINER_ID) || document.getElementById(LEGACY_IFRAME_CONTAINER_ID);
+};
+var getIframeWrapper = () => {
+  return document.getElementById(NEW_IFRAME_WRAPPER_ID) || document.getElementById(LEGACY_IFRAME_WRAPPER_ID);
+};
+var getIframe = () => {
+  return document.getElementById(NEW_IFRAME_ID) || document.getElementById(LEGACY_IFRAME_ID);
+};
+var iframeContainerId = NEW_IFRAME_CONTAINER_ID;
+var iframeWrapperId = NEW_IFRAME_WRAPPER_ID;
+var iframeId = NEW_IFRAME_ID;
+var createIframeElement = (useStaging) => {
+  const iframe = window.document.createElement("iframe");
+  iframe.id = iframeId;
+  iframe.src = `${useStaging ? silkWalletAppOrigin2Staging2 : silkWalletAppOrigin22}/iframe`;
+  console.log("iframe.src: ", iframe.src);
+  iframe.style.width = "100%";
+  iframe.style.height = "100%";
+  iframe.style.border = "none";
+  iframe.style.borderRadius = "24px";
+  iframe.style.backgroundColor = "transparent";
+  iframe.style.background = "transparent";
+  iframe.style.padding = "0";
+  iframe.style.margin = "0";
+  return iframe;
+};
+var setupIframeMessageListener = (useStaging, iframe) => {
+  const handleIframeMessage = (event) => {
+    const expectedOrigin = useStaging ? silkWalletAppOrigin2Staging2 : silkWalletAppOrigin22;
+    if (event.origin !== expectedOrigin) return;
+    if (!event.data || typeof event.data !== "object") return;
+    if (event.data.type !== "silk-iframe-size") return;
+    const contentHeight = event.data.height;
+    const contentWidth = event.data.width;
+    const maxDimension = 2e3;
+    const minDimension = 50;
+    if (typeof contentHeight !== "number" || typeof contentWidth !== "number")
+      return;
+    if (contentHeight < minDimension || contentHeight > maxDimension) return;
+    if (contentWidth < minDimension || contentWidth > maxDimension) return;
+    if (!Number.isFinite(contentHeight) || !Number.isFinite(contentWidth))
+      return;
+    const iframeWrapper = getIframeWrapper();
+    if (!iframeWrapper) return;
+    iframeWrapper.style.height = `${Math.floor(contentHeight)}px`;
+    iframeWrapper.style.width = `${Math.floor(contentWidth)}px`;
+  };
+  window.addEventListener("message", handleIframeMessage);
+  iframe.__silkCleanup = () => {
+    window.removeEventListener("message", handleIframeMessage);
+  };
+};
+var createComponentModeIframe = (useStaging) => {
+  const componentContainer = getWaapComponentContainer();
+  if (!componentContainer) {
+    throw new Error("WaaP component not found in DOM");
+  }
+  if (getIframe()) {
+    return;
+  }
+  const iframeWrapper = window.document.createElement("div");
+  iframeWrapper.id = iframeWrapperId;
+  iframeWrapper.style.position = "relative";
+  iframeWrapper.style.display = "flex";
+  iframeWrapper.style.alignItems = "center";
+  iframeWrapper.style.justifyContent = "center";
+  iframeWrapper.style.padding = "0";
+  iframeWrapper.style.margin = "0";
+  iframeWrapper.style.height = "600px";
+  iframeWrapper.style.width = "380px";
+  const iframe = createIframeElement(useStaging);
+  setupIframeMessageListener(useStaging, iframe);
+  setTimeout(() => {
+    const wrapper = getIframeWrapper();
+    if (wrapper) {
+      wrapper.style.height = "600px";
+      wrapper.style.width = "380px";
+    }
+  }, 100);
+  iframeWrapper.appendChild(iframe);
+  componentContainer.appendChild(iframeWrapper);
+};
+var createModalModeIframe = (useStaging) => {
+  if (getIframeContainer()) {
+    return;
+  }
+  const container = window.document.createElement("div");
+  container.id = iframeContainerId;
+  container.style.position = "fixed";
+  container.style.top = "0";
+  container.style.left = "0";
+  container.style.right = "0";
+  container.style.bottom = "0";
+  container.style.width = "100%";
+  container.style.height = "100%";
+  container.style.display = "flex";
+  container.style.alignItems = "center";
+  container.style.justifyContent = "center";
+  container.style.backgroundColor = "rgba(0, 0, 0, 0.5)";
+  container.style.zIndex = "9999999999";
+  container.style.display = "none";
+  const iframeWrapper = window.document.createElement("div");
+  iframeWrapper.id = iframeWrapperId;
+  iframeWrapper.style.position = "relative";
+  iframeWrapper.style.display = "flex";
+  iframeWrapper.style.alignItems = "center";
+  iframeWrapper.style.justifyContent = "center";
+  iframeWrapper.style.padding = "0";
+  iframeWrapper.style.margin = "0";
+  iframeWrapper.style.height = "600px";
+  iframeWrapper.style.width = "380px";
+  container.appendChild(iframeWrapper);
+  const iframe = createIframeElement(useStaging);
+  setupIframeMessageListener(useStaging, iframe);
+  setTimeout(() => {
+    const wrapper = getIframeWrapper();
+    if (wrapper) {
+      wrapper.style.height = "600px";
+      wrapper.style.width = "380px";
+    }
+  }, 100);
+  iframeWrapper.appendChild(iframe);
+  window.document.body.appendChild(container);
+};
+var createSilkIframe = (useStaging) => {
+  if (hasWaapComponent()) {
+    createComponentModeIframe(useStaging);
+  } else {
+    createModalModeIframe(useStaging);
+  }
+};
+var initWaaP = (params = {}) => {
+  createSilkIframe(!!params.useStaging);
+  const iframe = getIframe();
+  if (!iframe) {
+    throw new Error("WaaP iframe does not exist on page");
+  }
+  const isComponentMode = hasWaapComponent();
+  if (params.walletConnectProjectId) {
+    SilkWalletConnect.setProjectId(params.walletConnectProjectId);
+  }
+  const { referralCode, config, project, asyncTxs, asyncSigning } = params;
+  if (asyncSigning && !asyncTxs) {
+    console.warn(
+      "[WaaP SDK] `asyncSigning` is deprecated. Use `asyncTxs` instead."
+    );
+  }
+  const contentWindow = iframe.contentWindow;
+  const isLegacyAsyncSigning = !!asyncSigning && !asyncTxs;
+  const silkEthereumProvider = new EthereumProvider(
+    contentWindow,
+    referralCode,
+    config || {},
+    project || {},
+    params.useStaging,
+    asyncTxs || asyncSigning || false,
+    isLegacyAsyncSigning
+  );
+  let currentMode = isComponentMode ? "component" : "modal";
+  silkEthereumProvider.uiMessageManager.on("show_modal" /* show_modal */, () => {
+    const nowComponentMode = hasWaapComponent();
+    const newMode = nowComponentMode ? "component" : "modal";
+    const iframeWrapper = getIframeWrapper();
+    if (newMode !== currentMode && iframeWrapper) {
+      currentMode = newMode;
+      if (nowComponentMode) {
+        const componentContainer = getWaapComponentContainer();
+        if (componentContainer) {
+          componentContainer.appendChild(iframeWrapper);
+        }
+      } else {
+        let modalContainer = getIframeContainer();
+        if (!modalContainer) {
+          modalContainer = window.document.createElement("div");
+          modalContainer.id = iframeContainerId;
+          modalContainer.style.position = "fixed";
+          modalContainer.style.top = "0";
+          modalContainer.style.left = "0";
+          modalContainer.style.right = "0";
+          modalContainer.style.bottom = "0";
+          modalContainer.style.width = "100%";
+          modalContainer.style.height = "100%";
+          modalContainer.style.display = "flex";
+          modalContainer.style.alignItems = "center";
+          modalContainer.style.justifyContent = "center";
+          modalContainer.style.backgroundColor = "rgba(0, 0, 0, 0.5)";
+          modalContainer.style.zIndex = "9999999999";
+          window.document.body.appendChild(modalContainer);
+        }
+        modalContainer.appendChild(iframeWrapper);
+      }
+    }
+    const container = getIframeContainer();
+    if (nowComponentMode && iframeWrapper) {
+      iframeWrapper.style.display = "flex";
+    } else if (container) {
+      container.style.display = "flex";
+    }
+  });
+  silkEthereumProvider.uiMessageManager.on("hide_modal" /* hide_modal */, () => {
+    const isComponentMode2 = hasWaapComponent();
+    const iframeWrapper = getIframeWrapper();
+    const container = getIframeContainer();
+    if (isComponentMode2 && iframeWrapper) {
+      iframeWrapper.style.display = "none";
+    } else if (container) {
+      container.style.display = "none";
+    }
+  });
+  window.silk = silkEthereumProvider;
+  window.waap = silkEthereumProvider;
+  return silkEthereumProvider;
+};
+
+// src/lib/provider/EthereumProviderExtension.ts
+import {
+  JSON_RPC_METHOD as JSON_RPC_METHOD2,
+  SILK_METHOD as SILK_METHOD3
+} from "@human.tech/waap-interface-core";
+import { EventEmitter as EventEmitter3 } from "events";
+var EthereumProviderExtension = class extends EventEmitter3 {
+  isSilk = true;
+  connected = false;
+  config;
+  constructor(customConfig) {
+    super();
+    this.config = {
+      ...defaultConfig,
+      ...customConfig || {}
+    };
+  }
+  // Send a message to the background script via `chrome.runtime.sendMessage`
+  sendToExtension(args) {
+    return new Promise((resolve, reject) => {
+      window.postMessage({ type: "FROM_PAGE", request: args }, "*");
+      window.addEventListener("message", (event) => {
+        if (event.data.type === "FROM_EXTENSION") {
+          if (event.data.error) reject(event.data.error);
+          else resolve(event.data.result);
+        }
+      });
+    });
+  }
+  // EIP-1193 `request` method implementation
+  async request(args) {
+    var _a, _b;
+    if (!Object.keys(JSON_RPC_METHOD2).includes(args.method)) {
+      return Promise.reject({ error: `Not implemented (${args.method})` });
+    }
+    const response = await this.sendToExtension(args);
+    if ((args.method === JSON_RPC_METHOD2.wallet_switchEthereumChain || args.method === JSON_RPC_METHOD2.wallet_addEthereumChain) && response === null) {
+      this.emit(
+        "chainChanged",
+        (_b = (_a = args.params) == null ? void 0 : _a[0]) == null ? void 0 : _b.chainId
+      );
+    }
+    return response;
+  }
+  // Enable method that dApps use to request accounts
+  async enable() {
+    return this.request({ method: "eth_requestAccounts" });
+  }
+  // Check if the provider is connected
+  isConnected() {
+    return this.connected;
+  }
+  // Example of a custom method to handle login requests
+  async login() {
+    return this.sendToExtension({ method: SILK_METHOD3.login });
+  }
+  // Example of requesting an SBT (Soulbound Token)
+  async requestSBT(type) {
+    return this.sendToExtension({
+      method: SILK_METHOD3.silk_requestSbt,
+      params: [type]
+    });
+  }
+  // Example of toggling dark mode as part of custom config
+  async toggleDarkMode() {
+    this.config.styles.darkMode = !this.config.styles.darkMode;
+    await this.sendToExtension({
+      method: SILK_METHOD3.set_custom_config,
+      params: [this.config]
+    });
+  }
+  async safe() {
+    return this.sendToExtension({ method: SILK_METHOD3.safe });
+  }
+};
+
+// src/lib/sui/SuiWallet.ts
+import { EventEmitter as EventEmitter4 } from "events";
+import {
+  SILK_METHOD as SILK_METHOD4
+} from "@human.tech/waap-interface-core";
+var WAAP_ICON = "data:image/webp;base64,UklGRpoDAABXRUJQVlA4WAoAAAAQAAAAYwAAYwAAQUxQSDMDAAABJyAQSOFmFxERA8TatqpGoimANbEAxlBAPhSgQP9FyXv3vkcFEf134EZS5DREhGvTM8z0ki8stMRvK4cm8bk5rIu3xNbvkgPk4K6ti5IHquRQnLi6KrdBb81hdyF1jTLM1CW425943iba38/djOcG+dg85p/KXGd/g7+xAzJ2VPWTS8R+q65uA1ZcwG3iZ4urjw9Lh4xn83n3gZmQQ3VMVGEO6D403jdr81Ml1OISAAf7RGImBHISwQ5zCJonTuEyOyP7Sga4cDcjMPgXuiK9cUpaGrIDJtH4iAB25utB8O0DDztOKTr8u9hpX0jrx6k8UM5eAlqsynNxlX9tPRLQEtySKwcDOIDnMqEcek1UnylVNac4r0mlypNvhmCNODlhUXuT4fxTQyrDKY0uyV+gi0iiLLpY76A08C/IX8GQoYb8PcVxK7HkZkT5IjAF4gZicOfJW1ovJjyAlYVPlM6BkkHGI0fniAIZIXC0CbAM92BB8SBznU0ITYLr9XkfnKlDgV8170HGMWwitY51+zxcgkftLD4RLh4HSTIa3QzRWKxlaHZTz21s6GLxnBmjogkVilW4kuaMMMGUfgkZ1JhrBSEANrEDMwucAXgbTqIExY3FYRMdtkQRDFjD6BKtJ2GWTopGRY4P9DBkdE4rp9LJHuYhju45oeVZVv3zNmVdZiIOffHDppOz0Q34p0e/+nXy7JmF1846lmF2ZombLt8pgZpbPNeqpJSVJ0bGd4cH8dUNflNPfdQVXUkC95UQS0ZGfDmOJgjs3IyVOExZBEsxONd080gYK/ftQ2nbYaqGW89Hu7M6avmzXEjhO4G8O8ae8gwWtwZsyp8v8j/ys5H7bM+unOfurO4bbbL4v865Nb8s98Ld2X9yg6tLBQanMP8fhplOMMN8fiNDzTvNOMXGuYzejo12vY7s3clhXwgDPuBIcxi9QZftbKVxAjLCcVQdRxGR1QknhCs3GuieMLzfrrC9RhfJgVpcXRn71nZfEjsiYy/Ca1J7ch0clK64ReH3G/s2cekpP+BIx2YteMvSoLy6G9FCgd1nvF/VoVRtJoNJNLQ0RM3BXY9WgPbcHF78swAAVlA4IEAAAACwBQCdASpkAGQAPpFIoUylpCMiIKgAsBIJaW7hc+AAY2upvcReWAa6m9xF5YBrqb3EXlgGngAA/v81aVcAAAAA";
+var WaaPSuiWallet = class {
+  name = "WaaP";
+  version = "1.0.0";
+  icon = WAAP_ICON;
+  _accounts = [];
+  _chains = ["sui:mainnet", "sui:testnet", "sui:devnet"];
+  walletMessageManager;
+  uiMessageManager;
+  internalEventEmitter = new EventEmitter4();
+  changeListeners = /* @__PURE__ */ new Set();
+  /**
+   * Creates a new WaaPSuiWallet instance.
+   *
+   * @param iframeWindow - The contentWindow of the WaaP iframe
+   * @param options - Initialization options
+   */
+  constructor(iframeWindow, options = {}) {
+    const useStaging = options.useStaging ?? false;
+    this.walletMessageManager = new WalletMessageManager_default(iframeWindow, useStaging);
+    this.uiMessageManager = new UIMessageManager();
+    if (options.referralCode) {
+      this.walletMessageManager.pingIframe().then(() => {
+        this.postRequestAndWait({
+          method: SILK_METHOD4.set_points_referral_code,
+          params: [options.referralCode],
+          interactionRequired: false
+        }).catch((err) => console.error("Error setting referral code:", err));
+      });
+    }
+    if (options.project) {
+      this.walletMessageManager.pingIframe().then(() => {
+        this.postRequestAndWait({
+          method: SILK_METHOD4.set_project,
+          params: [options.project, window.location.origin],
+          interactionRequired: false
+        }).catch((err) => console.error("Error setting project:", err));
+      });
+    }
+    if (options.config) {
+      this.walletMessageManager.pingIframe().then(() => {
+        this.postRequestAndWait({
+          method: SILK_METHOD4.set_custom_config,
+          params: [options.config],
+          interactionRequired: false
+        }).catch((err) => console.error("Error setting custom config:", err));
+      });
+    }
+    this.walletMessageManager.addListener({
+      handleResponse: (response) => {
+        this.internalEventEmitter.emit(response.id, response);
+      },
+      handleRequest: (request) => {
+        if (request.method === SILK_METHOD4.show_modal) {
+          this.uiMessageManager.emit("show_modal" /* show_modal */);
+        } else if (request.method === SILK_METHOD4.hide_modal) {
+          this.uiMessageManager.emit("hide_modal" /* hide_modal */);
+        }
+      },
+      onAccountChanged: async (newAccount) => {
+        try {
+          const result = await this.refreshAccounts();
+          this.notifyChange({ accounts: result.accounts });
+        } catch (error) {
+          console.error("Failed to refresh Sui accounts:", error);
+          this._accounts = [];
+          this.notifyChange({ accounts: [] });
+        }
+      }
+    });
+  }
+  /**
+   * Refresh accounts by making a silent connect request.
+   * Used internally when account changes are detected.
+   */
+  async refreshAccounts() {
+    var _a;
+    try {
+      await this.walletMessageManager.pingIframe();
+      const response = await this.postRequestAndWait({
+        method: "sui_connect",
+        params: [{ silent: true }],
+        interactionRequired: false
+      });
+      if (response.error) {
+        this._accounts = [];
+        return { accounts: [] };
+      }
+      const accounts = ((_a = response.data) == null ? void 0 : _a.accounts) || [];
+      this._accounts = accounts;
+      return { accounts: this._accounts };
+    } catch (error) {
+      this._accounts = [];
+      return { accounts: [] };
+    }
+  }
+  /**
+   * Supported chains.
+   */
+  get chains() {
+    return this._chains;
+  }
+  /**
+   * Connected accounts.
+   */
+  get accounts() {
+    return this._accounts;
+  }
+  /**
+   * UI message manager for showing/hiding modal.
+   */
+  get ui() {
+    return this.uiMessageManager;
+  }
+  /**
+   * Connect to the wallet.
+   */
+  async connect(input) {
+    var _a;
+    await this.walletMessageManager.pingIframe();
+    const response = await this.postRequestAndWait({
+      method: "sui_connect",
+      params: [input || {}],
+      interactionRequired: !(input == null ? void 0 : input.silent)
+    });
+    if (response.error) {
+      throw new Error(response.error.message || "Failed to connect");
+    }
+    const accounts = ((_a = response.data) == null ? void 0 : _a.accounts) || [];
+    this._accounts = accounts;
+    this.notifyChange({ accounts: this._accounts });
+    return { accounts: this._accounts };
+  }
+  /**
+   * Disconnect from the wallet.
+   */
+  async disconnect() {
+    await this.walletMessageManager.pingIframe();
+    await this.postRequestAndWait({
+      method: "sui_disconnect",
+      params: [],
+      interactionRequired: false
+    });
+    this._accounts = [];
+    this.notifyChange({ accounts: [] });
+  }
+  /**
+   * Sign a personal message.
+   *
+   * @param input - Sign personal message input
+   * @returns Signed message result with bytes and signature
+   */
+  async signPersonalMessage(input) {
+    await this.walletMessageManager.pingIframe();
+    const accountAddress = input.account.address;
+    const isConnected = this._accounts.some((a) => a.address === accountAddress);
+    if (!isConnected) {
+      throw new Error(`Account ${accountAddress} is not connected`);
+    }
+    const response = await this.postRequestAndWait({
+      method: "sui_signPersonalMessage",
+      params: [{
+        message: Array.from(input.message),
+        account: accountAddress,
+        chain: input.chain
+      }],
+      interactionRequired: true
+    });
+    if (response.error) {
+      throw new Error(response.error.message || "Failed to sign message");
+    }
+    return {
+      bytes: response.data.bytes,
+      signature: response.data.signature
+    };
+  }
+  /**
+   * Extract the destination addresses from BCS-serialized Sui transaction bytes.
+   *
+   * Unlike EVM transactions where `to` is a top-level field, Sui transaction
+   * destinations are embedded in BCS-encoded programmable transaction blocks.
+   * We deserialize with Transaction.from() and inspect TransferObjects commands.
+   *
+   * Only TransferObjects destinations are extracted — MoveCall package addresses
+   * are not user-facing recipients and should not be validated against a PT's
+   * allowedAddresses list.
+   *
+   * Returns an empty array if no TransferObjects are found or deserialization fails.
+   */
+  async extractTransferAddresses(txBytes) {
+    try {
+      const { Transaction } = await import("@mysten/sui/transactions");
+      const tx = Transaction.from(txBytes);
+      const data = tx.getData();
+      const addresses = [];
+      for (const command of data.commands) {
+        if (command.$kind !== "TransferObjects") continue;
+        const addrArg = command.TransferObjects.address;
+        if (addrArg.$kind !== "Input") continue;
+        const inputIndex = addrArg.Input;
+        const input = data.inputs[inputIndex];
+        if (!input || input.$kind !== "Pure") continue;
+        const bytes = Uint8Array.from(atob(input.Pure.bytes), (c) => c.charCodeAt(0));
+        if (bytes.length !== 32) continue;
+        const hex = "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+        addresses.push(hex);
+      }
+      return addresses;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Helper to resolve transaction bytes from various input formats.
+   * If the input is a Transaction/TransactionBlock object, it builds it.
+   */
+  async resolveTransactionBytes(tx, chain = "sui:mainnet") {
+    if (tx instanceof Uint8Array) {
+      return tx;
+    } else if (Array.isArray(tx)) {
+      return new Uint8Array(tx);
+    } else if (typeof tx === "string") {
+      try {
+        return Uint8Array.from(atob(tx), (c) => c.charCodeAt(0));
+      } catch {
+        throw new Error("Transaction string must be base64 encoded bytes. If you have a serialized transaction JSON, please build it to bytes first.");
+      }
+    } else if (tx && typeof tx === "object") {
+      if (typeof tx.build === "function") {
+        try {
+          const { getFullnodeUrl, SuiClient } = await import("@mysten/sui/client");
+          let network = "mainnet";
+          if (chain === "sui:testnet") network = "testnet";
+          else if (chain === "sui:devnet") network = "devnet";
+          else if (chain === "sui:localnet") network = "localnet";
+          const url = getFullnodeUrl(network);
+          const client = new SuiClient({ url });
+          const builtBytes = await tx.build({ client });
+          return builtBytes;
+        } catch (e) {
+          console.warn("[SuiWallet] Failed to build transaction object:", e);
+          throw new Error(`Failed to build transaction: ${e instanceof Error ? e.message : String(e)}`);
+        }
+      }
+      if (typeof tx.serialize === "function") {
+        try {
+          const serialized = await tx.serialize();
+          if (typeof serialized === "string") {
+            return Uint8Array.from(atob(serialized), (c) => c.charCodeAt(0));
+          } else if (serialized instanceof Uint8Array) {
+            return serialized;
+          }
+        } catch (e) {
+          console.warn("[SuiWallet] serialize() failed:", e);
+        }
+      }
+      if (typeof tx.toJSON === "function") {
+        try {
+          const json = await tx.toJSON();
+          if (typeof json === "string") {
+            try {
+              return Uint8Array.from(atob(json), (c) => c.charCodeAt(0));
+            } catch {
+              try {
+                const parsed = JSON.parse(json);
+                if (parsed.bytes && typeof parsed.bytes === "string") {
+                  return Uint8Array.from(atob(parsed.bytes), (c) => c.charCodeAt(0));
+                }
+              } catch {
+              }
+            }
+          }
+        } catch (e) {
+          console.warn("[SuiWallet] toJSON() failed:", e);
+        }
+      }
+      if (typeof tx.getData === "function") {
+        try {
+          const data = tx.getData();
+          if (data instanceof Uint8Array) return data;
+        } catch (e) {
+          console.warn("[SuiWallet] getData() failed:", e);
+        }
+      }
+      throw new Error(`Unsupported transaction format. Keys: ${Object.keys(tx).join(", ")}`);
+    } else {
+      throw new Error(`Unsupported transaction format: ${typeof tx}. Please pass Uint8Array bytes or a Transaction object.`);
+    }
+  }
+  /**
+   * Sign a transaction.
+   *
+   * @param input - Sign transaction input with transaction
+   * @returns Signed transaction result with bytes and signature
+   */
+  async signTransaction(input) {
+    await this.walletMessageManager.pingIframe();
+    const accountAddress = input.account.address;
+    const isConnected = this._accounts.some((a) => a.address === accountAddress);
+    if (!isConnected) {
+      throw new Error(`Account ${accountAddress} is not connected`);
+    }
+    const txBytes = await this.resolveTransactionBytes(input.transaction, input.chain);
+    const response = await this.postRequestAndWait({
+      method: "sui_signTransaction",
+      params: [{
+        transaction: Array.from(txBytes),
+        account: accountAddress,
+        chain: input.chain
+      }],
+      interactionRequired: true
+    });
+    if (response.error) {
+      throw new Error(response.error.message || "Failed to sign transaction");
+    }
+    return {
+      bytes: response.data.bytes,
+      signature: response.data.signature
+    };
+  }
+  /**
+   * Sign and execute a transaction.
+   *
+   * @param input - Sign and execute transaction input
+   */
+  async signAndExecuteTransaction(input) {
+    await this.walletMessageManager.pingIframe();
+    const accountAddress = input.account.address;
+    const isConnected = this._accounts.some((a) => a.address === accountAddress);
+    if (!isConnected) {
+      throw new Error(`Account ${accountAddress} is not connected`);
+    }
+    const txBytes = await this.resolveTransactionBytes(input.transaction, input.chain);
+    const toAddresses = await this.extractTransferAddresses(txBytes);
+    const response = await this.postRequestAndWait({
+      method: "sui_signAndExecuteTransaction",
+      params: [{
+        transaction: Array.from(txBytes),
+        account: accountAddress,
+        chain: input.chain,
+        options: input.options,
+        requestType: input.requestType,
+        toAddresses: toAddresses.length > 0 ? toAddresses : void 0
+      }],
+      interactionRequired: true
+    });
+    if (response.error) {
+      throw new Error(response.error.message || "Failed to sign and execute transaction");
+    }
+    return response.data;
+  }
+  /**
+   * Switch the active chain.
+   */
+  async switchChain(input) {
+    await this.walletMessageManager.pingIframe();
+    if (!this._chains.includes(input.chain)) {
+      throw new Error(`Chain ${input.chain} is not supported`);
+    }
+    const response = await this.postRequestAndWait({
+      method: "sui_switchChain",
+      params: [input],
+      interactionRequired: false
+    });
+    if (response.error) {
+      throw new Error(response.error.message || "Failed to switch chain");
+    }
+    this.notifyChange({ chains: this._chains, accounts: this._accounts });
+  }
+  /**
+   * Subscribe to wallet change events.
+   *
+   * @param event - Event name (currently only 'change')
+   * @param listener - Event listener callback
+   * @returns Unsubscribe function
+   */
+  on(event, listener) {
+    if (event === "change") {
+      this.changeListeners.add(listener);
+      return () => {
+        this.changeListeners.delete(listener);
+      };
+    }
+    return () => {
+    };
+  }
+  /**
+   * Wallet Standard features property.
+   * Required by @mysten/wallet-standard registerWallet.
+   */
+  get features() {
+    return {
+      "standard:connect": {
+        version: "1.0.0",
+        connect: this.connect.bind(this)
+      },
+      "standard:disconnect": {
+        version: "1.0.0",
+        disconnect: this.disconnect.bind(this)
+      },
+      "standard:events": {
+        version: "1.0.0",
+        on: this.on.bind(this)
+      },
+      "sui:signPersonalMessage": {
+        version: "1.1.0",
+        signPersonalMessage: this.signPersonalMessage.bind(this)
+      },
+      "sui:signTransaction": {
+        version: "2.0.0",
+        signTransaction: this.signTransaction.bind(this)
+      },
+      "sui:signAndExecuteTransaction": {
+        version: "1.0.0",
+        signAndExecuteTransaction: this.signAndExecuteTransaction.bind(this)
+      },
+      "sui:signTransactionBlock": {
+        version: "2.0.0",
+        signTransactionBlock: this.signTransactionBlock.bind(this)
+      },
+      "sui:signAndExecuteTransactionBlock": {
+        version: "1.0.0",
+        signAndExecuteTransactionBlock: this.signAndExecuteTransactionBlock.bind(this)
+      },
+      "sui:switchChain": {
+        version: "1.0.0",
+        switchChain: this.switchChain.bind(this)
+      }
+    };
+  }
+  /**
+   * Legacy method for signing a transaction block.
+   * Maps to signTransaction.
+   */
+  async signTransactionBlock(input) {
+    return this.signTransaction({
+      transaction: input.transactionBlock,
+      account: input.account,
+      chain: input.chain
+    });
+  }
+  /**
+   * Legacy method for signing and executing a transaction block.
+   * Maps to signAndExecuteTransaction.
+   */
+  async signAndExecuteTransactionBlock(input) {
+    return this.signAndExecuteTransaction({
+      transaction: input.transactionBlock,
+      account: input.account,
+      chain: input.chain,
+      options: input.options,
+      requestType: input.requestType
+    });
+  }
+  /**
+   * Request a Permission Token from the user.
+   * Allows pre-authorised batches of Sui transactions without individual confirmations.
+   *
+   * @param params - Allowed addresses, chainId (e.g. "sui:mainnet"), spend limit, expiry
+   */
+  async requestPermissionToken(params) {
+    await this.walletMessageManager.pingIframe();
+    const response = await this.postRequestAndWait({
+      method: SILK_METHOD4.waap_requestPermissionToken,
+      params: [params],
+      interactionRequired: true
+    });
+    if (response.error) {
+      throw new Error(response.error.message || "Failed to request permission token");
+    }
+    return response.data;
+  }
+  /**
+   * Request the user's email address.
+   *
+   * @returns Promise resolving to the user's email address
+   */
+  async requestEmail() {
+    await this.walletMessageManager.pingIframe();
+    const response = await this.postRequestAndWait({
+      method: SILK_METHOD4.silk_requestEmail,
+      params: [],
+      interactionRequired: true
+    });
+    if (response.error) {
+      throw new Error(response.error.message || "Failed to request email");
+    }
+    return response.data;
+  }
+  /**
+   * Post a request to the iframe and wait for response.
+   */
+  async postRequestAndWait(args) {
+    const id = await this.walletMessageManager.postSilkRequest({
+      method: args.method,
+      params: args.params,
+      interactionRequired: args.interactionRequired
+    });
+    return new Promise((resolve) => {
+      this.internalEventEmitter.once(id, (response) => {
+        resolve(response);
+      });
+    });
+  }
+  /**
+   * Notify all change listeners.
+   */
+  notifyChange(properties) {
+    Array.from(this.changeListeners).forEach((listener) => {
+      listener(properties);
+    });
+  }
+};
+
+// src/lib/sui/init.ts
+import {
+  silkWalletAppOrigin2 as silkWalletAppOrigin23,
+  silkWalletAppOrigin2Staging as silkWalletAppOrigin2Staging3
+} from "@human.tech/waap-constants";
+var IFRAME_CONTAINER_ID = "waap-wallet-iframe-container";
+var IFRAME_ID = "waap-wallet-iframe";
+var LEGACY_IFRAME_CONTAINER_ID2 = "silk-wallet-iframe-container";
+var LEGACY_IFRAME_ID2 = "silk-wallet-iframe";
+var getIframeContainer2 = () => {
+  return document.getElementById(IFRAME_CONTAINER_ID) || document.getElementById(LEGACY_IFRAME_CONTAINER_ID2);
+};
+var getIframe2 = () => {
+  return document.getElementById(IFRAME_ID) || document.getElementById(LEGACY_IFRAME_ID2);
+};
+var IFRAME_WRAPPER_ID = "waap-wallet-iframe-wrapper";
+var LEGACY_IFRAME_WRAPPER_ID2 = "silk-wallet-iframe-wrapper";
+var getIframeWrapper2 = () => {
+  return document.getElementById(IFRAME_WRAPPER_ID) || document.getElementById(LEGACY_IFRAME_WRAPPER_ID2);
+};
+var setupIframeMessageListener2 = (useStaging) => {
+  const handleIframeMessage = (event) => {
+    const expectedOrigin = useStaging ? silkWalletAppOrigin2Staging3 : silkWalletAppOrigin23;
+    if (event.origin !== expectedOrigin) return;
+    if (!event.data || typeof event.data !== "object") return;
+    if (event.data.type !== "silk-iframe-size") return;
+    const contentHeight = event.data.height;
+    const contentWidth = event.data.width;
+    const maxDimension = 2e3;
+    const minDimension = 50;
+    if (typeof contentHeight !== "number" || typeof contentWidth !== "number")
+      return;
+    if (contentHeight < minDimension || contentHeight > maxDimension) return;
+    if (contentWidth < minDimension || contentWidth > maxDimension) return;
+    if (!Number.isFinite(contentHeight) || !Number.isFinite(contentWidth))
+      return;
+    const iframeWrapper = getIframeWrapper2();
+    if (!iframeWrapper) return;
+    iframeWrapper.style.height = `${Math.floor(contentHeight)}px`;
+    iframeWrapper.style.width = `${Math.floor(contentWidth)}px`;
+  };
+  window.addEventListener("message", handleIframeMessage);
+};
+var createWaapIframe = (useStaging) => {
+  if (getIframeContainer2()) {
+    return;
+  }
+  const container = document.createElement("div");
+  container.id = IFRAME_CONTAINER_ID;
+  container.style.cssText = `
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    width: 100%;
+    height: 100%;
+    display: none;
+    align-items: center;
+    justify-content: center;
+    background-color: rgba(0, 0, 0, 0.5);
+    z-index: 9999999999;
+  `;
+  const wrapper = document.createElement("div");
+  wrapper.id = IFRAME_WRAPPER_ID;
+  wrapper.style.cssText = `
+    position: relative;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 0;
+    margin: 0;
+    height: 600px;
+    width: 380px;
+  `;
+  container.appendChild(wrapper);
+  const iframe = document.createElement("iframe");
+  iframe.id = IFRAME_ID;
+  iframe.src = `${useStaging ? silkWalletAppOrigin2Staging3 : silkWalletAppOrigin23}/iframe`;
+  iframe.style.cssText = `
+    width: 100%;
+    height: 100%;
+    border: none;
+    border-radius: 24px;
+    background: transparent;
+  `;
+  wrapper.appendChild(iframe);
+  setupIframeMessageListener2(useStaging);
+  document.body.appendChild(container);
+};
+function initWaaPSui(options = {}) {
+  const useStaging = options.useStaging ?? false;
+  createWaapIframe(useStaging);
+  const container = getIframeContainer2();
+  const iframe = getIframe2();
+  if (!container || !iframe) {
+    throw new Error("Failed to create WaaP iframe");
+  }
+  const contentWindow = iframe.contentWindow;
+  const suiWallet = new WaaPSuiWallet(contentWindow, options);
+  suiWallet.ui.on("show_modal" /* show_modal */, () => {
+    container.style.display = "flex";
+    const dappKitOverlays = document.querySelectorAll('[data-dapp-kit][class*="overlay"]');
+    dappKitOverlays.forEach((overlay) => {
+      overlay.style.display = "none";
+    });
+  });
+  suiWallet.ui.on("hide_modal" /* hide_modal */, () => {
+    container.style.display = "none";
+    const dappKitOverlays = document.querySelectorAll('[data-dapp-kit][class*="overlay"]');
+    dappKitOverlays.forEach((overlay) => {
+      overlay.style.display = "";
+    });
+  });
+  return suiWallet;
+}
+
+// src/lib/sui/register.ts
+import { registerWallet } from "@mysten/wallet-standard";
+function registerWaaPSuiWallet(iframeWindow, options = {}) {
+  const wallet = new WaaPSuiWallet(iframeWindow, options);
+  registerWallet(wallet);
+  return wallet;
+}
+
+// src/index.ts
+import {
+  SILK_METHOD as SILK_METHOD5,
+  SILK_METHOD as SILK_METHOD6
+} from "@human.tech/waap-interface-core";
+
+// src/hooks/useWaapTransaction.ts
+import { useEffect, useState, useCallback, useRef } from "react";
+function useWaapTransaction(options) {
+  const [pendingTransactions, setPendingTransactions] = useState(/* @__PURE__ */ new Map());
+  const optionsRef = useRef(options);
+  useEffect(() => {
+    optionsRef.current = options;
+  }, [options]);
+  useEffect(() => {
+    const provider = window.waap || window.silk;
+    if (!provider) {
+      console.warn(
+        "[useWaapTransaction] WaaP provider not found. Make sure initWaaP() was called."
+      );
+      return;
+    }
+    const handleSignComplete = (event) => {
+      var _a, _b;
+      setPendingTransactions((prev) => {
+        const next = new Map(prev);
+        next.set(event.txHash, {
+          status: "signed",
+          txHash: event.txHash,
+          pendingTxId: event.txHash,
+          signature: event.signature,
+          serializedTx: event.serializedTx
+        });
+        return next;
+      });
+      (_b = (_a = optionsRef.current) == null ? void 0 : _a.onSigned) == null ? void 0 : _b.call(_a, event);
+    };
+    const handleTxPending = (event) => {
+      var _a, _b;
+      setPendingTransactions((prev) => {
+        const next = new Map(prev);
+        const existing = next.get(event.txHash);
+        if (existing) {
+          next.set(event.txHash, {
+            ...existing,
+            status: "tx_pending"
+          });
+        }
+        return next;
+      });
+      (_b = (_a = optionsRef.current) == null ? void 0 : _a.onTxPending) == null ? void 0 : _b.call(_a, event);
+    };
+    const handleConfirmed = (event) => {
+      var _a, _b;
+      setPendingTransactions((prev) => {
+        const next = new Map(prev);
+        const existing = next.get(event.txHash);
+        if (existing) {
+          next.set(event.txHash, {
+            ...existing,
+            status: "confirmed",
+            receipt: event.receipt
+          });
+        }
+        return next;
+      });
+      (_b = (_a = optionsRef.current) == null ? void 0 : _a.onConfirmed) == null ? void 0 : _b.call(_a, event);
+    };
+    const handleTxFailed = (event) => {
+      var _a, _b;
+      setPendingTransactions((prev) => {
+        const next = new Map(prev);
+        const existing = next.get(event.txHash);
+        if (existing) {
+          next.set(event.txHash, {
+            ...existing,
+            status: "failed",
+            error: event.error,
+            stage: event.stage
+          });
+        }
+        return next;
+      });
+      (_b = (_a = optionsRef.current) == null ? void 0 : _a.onFailed) == null ? void 0 : _b.call(_a, event);
+    };
+    provider.on("waap_sign_complete", handleSignComplete);
+    provider.on("waap_tx_pending", handleTxPending);
+    provider.on("waap_tx_confirmed", handleConfirmed);
+    provider.on("waap_tx_failed", handleTxFailed);
+    return () => {
+      var _a, _b, _c, _d;
+      (_a = provider.removeListener) == null ? void 0 : _a.call(provider, "waap_sign_complete", handleSignComplete);
+      (_b = provider.removeListener) == null ? void 0 : _b.call(provider, "waap_tx_pending", handleTxPending);
+      (_c = provider.removeListener) == null ? void 0 : _c.call(provider, "waap_tx_confirmed", handleConfirmed);
+      (_d = provider.removeListener) == null ? void 0 : _d.call(provider, "waap_tx_failed", handleTxFailed);
+    };
+  }, []);
+  const sendTransaction = useCallback(
+    async (txRequest) => {
+      const provider = window.waap || window.silk;
+      if (!provider) {
+        throw new Error("WaaP provider not found");
+      }
+      return provider.request({
+        method: "eth_sendTransaction",
+        params: txRequest
+      });
+    },
+    []
+  );
+  const signTransaction = useCallback(
+    async (txRequest) => {
+      const provider = window.waap || window.silk;
+      if (!provider) {
+        throw new Error("WaaP provider not found");
+      }
+      return provider.request({
+        method: "eth_signTransaction",
+        params: txRequest
+      });
+    },
+    []
+  );
+  const isAnyPending = Array.from(pendingTransactions.values()).some(
+    (tx) => tx.status === "signed" || tx.status === "tx_pending"
+  );
+  return {
+    sendTransaction,
+    signTransaction,
+    pendingTransactions,
+    isAnyPending
+  };
+}
+export {
+  EthereumProvider,
+  EthereumProviderExtension,
+  SILK_METHOD5 as SILK_METHOD,
+  SilkWalletConnect,
+  UIMessageManager,
+  UI_EVENT_NAMES,
+  SILK_METHOD6 as WAAP_METHOD,
+  WaapWalletElement as WaaP,
+  WaaPSuiWallet,
+  SilkWalletConnect as WaaPWalletConnect,
+  WalletMessageManager,
+  handleWalletRequestAndResponse,
+  initWaaP,
+  initWaaPSui,
+  registerWaaPSuiWallet,
+  rpcMethodRequiresUI,
+  useWaapTransaction
+};