@unicitylabs/sphere-sdk 0.3.8 → 0.3.9

package/dist/connect/index.js

@@ -0,0 +1,747 @@
+// constants.ts
+var STORAGE_KEYS_GLOBAL = {
+  /** Encrypted BIP39 mnemonic */
+  MNEMONIC: "mnemonic",
+  /** Encrypted master private key */
+  MASTER_KEY: "master_key",
+  /** BIP32 chain code */
+  CHAIN_CODE: "chain_code",
+  /** HD derivation path (full path like m/44'/0'/0'/0/0) */
+  DERIVATION_PATH: "derivation_path",
+  /** Base derivation path (like m/44'/0'/0' without chain/index) */
+  BASE_PATH: "base_path",
+  /** Derivation mode: bip32, wif_hmac, legacy_hmac */
+  DERIVATION_MODE: "derivation_mode",
+  /** Wallet source: mnemonic, file, unknown */
+  WALLET_SOURCE: "wallet_source",
+  /** Wallet existence flag */
+  WALLET_EXISTS: "wallet_exists",
+  /** Current active address index */
+  CURRENT_ADDRESS_INDEX: "current_address_index",
+  /** Nametag cache per address (separate from tracked addresses registry) */
+  ADDRESS_NAMETAGS: "address_nametags",
+  /** Active addresses registry (JSON: TrackedAddressesStorage) */
+  TRACKED_ADDRESSES: "tracked_addresses",
+  /** Last processed Nostr wallet event timestamp (unix seconds), keyed per pubkey */
+  LAST_WALLET_EVENT_TS: "last_wallet_event_ts",
+  /** Group chat: joined groups */
+  GROUP_CHAT_GROUPS: "group_chat_groups",
+  /** Group chat: messages */
+  GROUP_CHAT_MESSAGES: "group_chat_messages",
+  /** Group chat: members */
+  GROUP_CHAT_MEMBERS: "group_chat_members",
+  /** Group chat: processed event IDs for deduplication */
+  GROUP_CHAT_PROCESSED_EVENTS: "group_chat_processed_events",
+  /** Group chat: last used relay URL (stale data detection) */
+  GROUP_CHAT_RELAY_URL: "group_chat_relay_url",
+  /** Cached token registry JSON (fetched from remote) */
+  TOKEN_REGISTRY_CACHE: "token_registry_cache",
+  /** Timestamp of last token registry cache update (ms since epoch) */
+  TOKEN_REGISTRY_CACHE_TS: "token_registry_cache_ts",
+  /** Cached price data JSON (from CoinGecko or other provider) */
+  PRICE_CACHE: "price_cache",
+  /** Timestamp of last price cache update (ms since epoch) */
+  PRICE_CACHE_TS: "price_cache_ts"
+};
+var STORAGE_KEYS_ADDRESS = {
+  /** Pending transfers for this address */
+  PENDING_TRANSFERS: "pending_transfers",
+  /** Transfer outbox for this address */
+  OUTBOX: "outbox",
+  /** Conversations for this address */
+  CONVERSATIONS: "conversations",
+  /** Messages for this address */
+  MESSAGES: "messages",
+  /** Transaction history for this address */
+  TRANSACTION_HISTORY: "transaction_history",
+  /** Pending V5 finalization tokens (unconfirmed instant split tokens) */
+  PENDING_V5_TOKENS: "pending_v5_tokens"
+};
+var STORAGE_KEYS = {
+  ...STORAGE_KEYS_GLOBAL,
+  ...STORAGE_KEYS_ADDRESS
+};
+var DEFAULT_BASE_PATH = "m/44'/0'/0'";
+var DEFAULT_DERIVATION_PATH = `${DEFAULT_BASE_PATH}/0/0`;
+var HOST_READY_TYPE = "sphere-connect:host-ready";
+var HOST_READY_TIMEOUT = 3e4;
+
+// connect/protocol.ts
+var SPHERE_CONNECT_NAMESPACE = "sphere-connect";
+var SPHERE_CONNECT_VERSION = "1.0";
+var RPC_METHODS = {
+  GET_IDENTITY: "sphere_getIdentity",
+  GET_BALANCE: "sphere_getBalance",
+  GET_ASSETS: "sphere_getAssets",
+  GET_FIAT_BALANCE: "sphere_getFiatBalance",
+  GET_TOKENS: "sphere_getTokens",
+  GET_HISTORY: "sphere_getHistory",
+  L1_GET_BALANCE: "sphere_l1GetBalance",
+  L1_GET_HISTORY: "sphere_l1GetHistory",
+  RESOLVE: "sphere_resolve",
+  SUBSCRIBE: "sphere_subscribe",
+  UNSUBSCRIBE: "sphere_unsubscribe",
+  DISCONNECT: "sphere_disconnect"
+};
+var INTENT_ACTIONS = {
+  SEND: "send",
+  L1_SEND: "l1_send",
+  DM: "dm",
+  PAYMENT_REQUEST: "payment_request",
+  RECEIVE: "receive",
+  SIGN_MESSAGE: "sign_message"
+};
+var ERROR_CODES = {
+  // Standard JSON-RPC
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  // Sphere Connect (4xxx)
+  NOT_CONNECTED: 4001,
+  PERMISSION_DENIED: 4002,
+  USER_REJECTED: 4003,
+  SESSION_EXPIRED: 4004,
+  ORIGIN_BLOCKED: 4005,
+  RATE_LIMITED: 4006,
+  INSUFFICIENT_BALANCE: 4100,
+  INVALID_RECIPIENT: 4101,
+  TRANSFER_FAILED: 4102,
+  INTENT_CANCELLED: 4200
+};
+function isSphereConnectMessage(msg) {
+  if (!msg || typeof msg !== "object") return false;
+  const m = msg;
+  return m.ns === SPHERE_CONNECT_NAMESPACE && m.v === SPHERE_CONNECT_VERSION;
+}
+function createRequestId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+}
+
+// connect/permissions.ts
+var PERMISSION_SCOPES = {
+  IDENTITY_READ: "identity:read",
+  BALANCE_READ: "balance:read",
+  TOKENS_READ: "tokens:read",
+  HISTORY_READ: "history:read",
+  L1_READ: "l1:read",
+  EVENTS_SUBSCRIBE: "events:subscribe",
+  RESOLVE_PEER: "resolve:peer",
+  TRANSFER_REQUEST: "transfer:request",
+  L1_TRANSFER: "l1:transfer",
+  DM_REQUEST: "dm:request",
+  PAYMENT_REQUEST: "payment:request",
+  SIGN_REQUEST: "sign:request"
+};
+var ALL_PERMISSIONS = Object.values(PERMISSION_SCOPES);
+var DEFAULT_PERMISSIONS = [
+  PERMISSION_SCOPES.IDENTITY_READ
+];
+var METHOD_PERMISSIONS = {
+  [RPC_METHODS.GET_IDENTITY]: PERMISSION_SCOPES.IDENTITY_READ,
+  [RPC_METHODS.GET_BALANCE]: PERMISSION_SCOPES.BALANCE_READ,
+  [RPC_METHODS.GET_ASSETS]: PERMISSION_SCOPES.BALANCE_READ,
+  [RPC_METHODS.GET_FIAT_BALANCE]: PERMISSION_SCOPES.BALANCE_READ,
+  [RPC_METHODS.GET_TOKENS]: PERMISSION_SCOPES.TOKENS_READ,
+  [RPC_METHODS.GET_HISTORY]: PERMISSION_SCOPES.HISTORY_READ,
+  [RPC_METHODS.L1_GET_BALANCE]: PERMISSION_SCOPES.L1_READ,
+  [RPC_METHODS.L1_GET_HISTORY]: PERMISSION_SCOPES.L1_READ,
+  [RPC_METHODS.RESOLVE]: PERMISSION_SCOPES.RESOLVE_PEER,
+  [RPC_METHODS.SUBSCRIBE]: PERMISSION_SCOPES.EVENTS_SUBSCRIBE,
+  [RPC_METHODS.UNSUBSCRIBE]: PERMISSION_SCOPES.EVENTS_SUBSCRIBE
+};
+var INTENT_PERMISSIONS = {
+  [INTENT_ACTIONS.SEND]: PERMISSION_SCOPES.TRANSFER_REQUEST,
+  [INTENT_ACTIONS.L1_SEND]: PERMISSION_SCOPES.L1_TRANSFER,
+  [INTENT_ACTIONS.DM]: PERMISSION_SCOPES.DM_REQUEST,
+  [INTENT_ACTIONS.PAYMENT_REQUEST]: PERMISSION_SCOPES.PAYMENT_REQUEST,
+  [INTENT_ACTIONS.RECEIVE]: PERMISSION_SCOPES.IDENTITY_READ,
+  [INTENT_ACTIONS.SIGN_MESSAGE]: PERMISSION_SCOPES.SIGN_REQUEST
+};
+function hasMethodPermission(granted, method) {
+  const required = METHOD_PERMISSIONS[method];
+  if (!required) return false;
+  return granted.has(required);
+}
+function hasIntentPermission(granted, action) {
+  const required = INTENT_PERMISSIONS[action];
+  if (!required) return false;
+  return granted.has(required);
+}
+function validatePermissions(permissions) {
+  const validScopes = new Set(ALL_PERMISSIONS);
+  return permissions.every((p) => validScopes.has(p));
+}
+
+// connect/host/ConnectHost.ts
+var DEFAULT_SESSION_TTL_MS = 864e5;
+var DEFAULT_MAX_RPS = 20;
+var ConnectHost = class {
+  sphere;
+  transport;
+  config;
+  session = null;
+  grantedPermissions = /* @__PURE__ */ new Set();
+  // Event subscription management
+  eventSubscriptions = /* @__PURE__ */ new Map();
+  // eventName → unsub
+  // Rate limiting
+  rateLimitCounter = 0;
+  rateLimitResetAt = 0;
+  unsubscribeTransport = null;
+  constructor(config) {
+    this.sphere = config.sphere;
+    this.transport = config.transport;
+    this.config = config;
+    this.unsubscribeTransport = this.transport.onMessage(this.handleMessage.bind(this));
+  }
+  /** Get current active session */
+  getSession() {
+    return this.session;
+  }
+  /** Revoke the current session */
+  revokeSession() {
+    if (this.session) {
+      this.session.active = false;
+      this.cleanupEventSubscriptions();
+      this.session = null;
+      this.grantedPermissions.clear();
+    }
+  }
+  /** Destroy the host, clean up all resources */
+  destroy() {
+    this.revokeSession();
+    if (this.unsubscribeTransport) {
+      this.unsubscribeTransport();
+      this.unsubscribeTransport = null;
+    }
+  }
+  // ===========================================================================
+  // Message Handling
+  // ===========================================================================
+  async handleMessage(msg) {
+    try {
+      if (msg.type === "handshake" && msg.direction === "request") {
+        await this.handleHandshake(msg);
+        return;
+      }
+      if (msg.type === "request") {
+        await this.handleRpcRequest(msg);
+        return;
+      }
+      if (msg.type === "intent") {
+        await this.handleIntentRequest(msg);
+        return;
+      }
+    } catch (error) {
+      console.warn("[ConnectHost] Error handling message:", error);
+    }
+  }
+  // ===========================================================================
+  // Handshake
+  // ===========================================================================
+  async handleHandshake(msg) {
+    const dapp = msg.dapp;
+    if (!dapp) {
+      this.sendHandshakeResponse([], void 0, void 0);
+      return;
+    }
+    const requestedPermissions = msg.permissions;
+    const { approved, grantedPermissions } = await this.config.onConnectionRequest(
+      dapp,
+      requestedPermissions
+    );
+    if (!approved) {
+      this.sendHandshakeResponse([], void 0, void 0);
+      return;
+    }
+    const sessionId = createRequestId();
+    const allPermissions = [.../* @__PURE__ */ new Set([...DEFAULT_PERMISSIONS, ...grantedPermissions])];
+    const ttl = this.config.sessionTtlMs ?? DEFAULT_SESSION_TTL_MS;
+    this.session = {
+      id: sessionId,
+      dapp,
+      permissions: allPermissions,
+      createdAt: Date.now(),
+      expiresAt: ttl > 0 ? Date.now() + ttl : 0,
+      active: true
+    };
+    this.grantedPermissions = new Set(allPermissions);
+    const identity = this.getPublicIdentity();
+    this.sendHandshakeResponse(allPermissions, sessionId, identity);
+  }
+  sendHandshakeResponse(permissions, sessionId, identity) {
+    this.transport.send({
+      ns: SPHERE_CONNECT_NAMESPACE,
+      v: SPHERE_CONNECT_VERSION,
+      type: "handshake",
+      direction: "response",
+      permissions,
+      sessionId,
+      identity
+    });
+  }
+  // ===========================================================================
+  // RPC Requests (query)
+  // ===========================================================================
+  async handleRpcRequest(msg) {
+    if (!this.session?.active) {
+      this.sendError(msg.id, ERROR_CODES.NOT_CONNECTED, "Not connected");
+      return;
+    }
+    if (this.session.expiresAt > 0 && Date.now() > this.session.expiresAt) {
+      this.revokeSession();
+      this.sendError(msg.id, ERROR_CODES.SESSION_EXPIRED, "Session expired");
+      return;
+    }
+    if (!this.checkRateLimit()) {
+      this.sendError(msg.id, ERROR_CODES.RATE_LIMITED, "Too many requests");
+      return;
+    }
+    if (msg.method === RPC_METHODS.DISCONNECT) {
+      this.revokeSession();
+      this.sendResult(msg.id, { disconnected: true });
+      return;
+    }
+    if (!hasMethodPermission(this.grantedPermissions, msg.method)) {
+      this.sendError(msg.id, ERROR_CODES.PERMISSION_DENIED, `Permission denied for ${msg.method}`);
+      return;
+    }
+    try {
+      const result = await this.executeMethod(msg.method, msg.params ?? {});
+      this.sendResult(msg.id, result);
+    } catch (error) {
+      this.sendError(msg.id, ERROR_CODES.INTERNAL_ERROR, error.message);
+    }
+  }
+  // ===========================================================================
+  // Intent Requests
+  // ===========================================================================
+  async handleIntentRequest(msg) {
+    if (!this.session?.active) {
+      this.sendIntentError(msg.id, ERROR_CODES.NOT_CONNECTED, "Not connected");
+      return;
+    }
+    if (this.session.expiresAt > 0 && Date.now() > this.session.expiresAt) {
+      this.revokeSession();
+      this.sendIntentError(msg.id, ERROR_CODES.SESSION_EXPIRED, "Session expired");
+      return;
+    }
+    if (!hasIntentPermission(this.grantedPermissions, msg.action)) {
+      this.sendIntentError(msg.id, ERROR_CODES.PERMISSION_DENIED, `Permission denied for intent: ${msg.action}`);
+      return;
+    }
+    const response = await this.config.onIntent(msg.action, msg.params, this.session);
+    if (response.error) {
+      this.sendIntentError(msg.id, response.error.code, response.error.message);
+    } else {
+      this.sendIntentResult(msg.id, response.result);
+    }
+  }
+  // ===========================================================================
+  // Method Router
+  // ===========================================================================
+  async executeMethod(method, params) {
+    switch (method) {
+      case RPC_METHODS.GET_IDENTITY:
+        return this.getPublicIdentity();
+      case RPC_METHODS.GET_BALANCE:
+        return this.sphere.payments.getBalance(params.coinId);
+      case RPC_METHODS.GET_ASSETS:
+        return this.sphere.payments.getAssets(params.coinId);
+      case RPC_METHODS.GET_FIAT_BALANCE:
+        return { fiatBalance: await this.sphere.payments.getFiatBalance() };
+      case RPC_METHODS.GET_TOKENS:
+        return this.stripTokenSdkData(
+          this.sphere.payments.getTokens(
+            params.coinId ? { coinId: params.coinId } : void 0
+          )
+        );
+      case RPC_METHODS.GET_HISTORY:
+        return this.sphere.payments.getHistory();
+      case RPC_METHODS.L1_GET_BALANCE:
+        if (!this.sphere.payments.l1) {
+          throw new Error("L1 module not available");
+        }
+        return this.sphere.payments.l1.getBalance();
+      case RPC_METHODS.L1_GET_HISTORY:
+        if (!this.sphere.payments.l1) {
+          throw new Error("L1 module not available");
+        }
+        return this.sphere.payments.l1.getHistory(params.limit);
+      case RPC_METHODS.RESOLVE:
+        if (!params.identifier) {
+          throw new Error("Missing required parameter: identifier");
+        }
+        return this.sphere.resolve(params.identifier);
+      case RPC_METHODS.SUBSCRIBE:
+        return this.handleSubscribe(params.event);
+      case RPC_METHODS.UNSUBSCRIBE:
+        return this.handleUnsubscribe(params.event);
+      default:
+        throw new Error(`Unknown method: ${method}`);
+    }
+  }
+  // ===========================================================================
+  // Event Subscriptions
+  // ===========================================================================
+  handleSubscribe(eventName) {
+    if (!eventName) throw new Error("Missing required parameter: event");
+    if (this.eventSubscriptions.has(eventName)) {
+      return { subscribed: true, event: eventName };
+    }
+    const unsub = this.sphere.on(eventName, (data) => {
+      this.transport.send({
+        ns: SPHERE_CONNECT_NAMESPACE,
+        v: SPHERE_CONNECT_VERSION,
+        type: "event",
+        event: eventName,
+        data
+      });
+    });
+    this.eventSubscriptions.set(eventName, unsub);
+    return { subscribed: true, event: eventName };
+  }
+  handleUnsubscribe(eventName) {
+    if (!eventName) throw new Error("Missing required parameter: event");
+    const unsub = this.eventSubscriptions.get(eventName);
+    if (unsub) {
+      unsub();
+      this.eventSubscriptions.delete(eventName);
+    }
+    return { unsubscribed: true, event: eventName };
+  }
+  cleanupEventSubscriptions() {
+    for (const [, unsub] of this.eventSubscriptions) {
+      unsub();
+    }
+    this.eventSubscriptions.clear();
+  }
+  // ===========================================================================
+  // Helpers
+  // ===========================================================================
+  getPublicIdentity() {
+    const id = this.sphere.identity;
+    if (!id) return void 0;
+    return {
+      chainPubkey: id.chainPubkey,
+      l1Address: id.l1Address,
+      directAddress: id.directAddress,
+      nametag: id.nametag
+    };
+  }
+  stripTokenSdkData(tokens) {
+    return tokens.map((t) => {
+      const token = t;
+      const { sdkData, ...publicFields } = token;
+      return publicFields;
+    });
+  }
+  sendResult(id, result) {
+    this.transport.send({
+      ns: SPHERE_CONNECT_NAMESPACE,
+      v: SPHERE_CONNECT_VERSION,
+      type: "response",
+      id,
+      result
+    });
+  }
+  sendError(id, code, message) {
+    this.transport.send({
+      ns: SPHERE_CONNECT_NAMESPACE,
+      v: SPHERE_CONNECT_VERSION,
+      type: "response",
+      id,
+      error: { code, message }
+    });
+  }
+  sendIntentResult(id, result) {
+    this.transport.send({
+      ns: SPHERE_CONNECT_NAMESPACE,
+      v: SPHERE_CONNECT_VERSION,
+      type: "intent_result",
+      id,
+      result
+    });
+  }
+  sendIntentError(id, code, message) {
+    this.transport.send({
+      ns: SPHERE_CONNECT_NAMESPACE,
+      v: SPHERE_CONNECT_VERSION,
+      type: "intent_result",
+      id,
+      error: { code, message }
+    });
+  }
+  checkRateLimit() {
+    const maxRps = this.config.maxRequestsPerSecond ?? DEFAULT_MAX_RPS;
+    const now = Date.now();
+    if (now > this.rateLimitResetAt) {
+      this.rateLimitCounter = 0;
+      this.rateLimitResetAt = now + 1e3;
+    }
+    this.rateLimitCounter++;
+    return this.rateLimitCounter <= maxRps;
+  }
+};
+
+// connect/client/ConnectClient.ts
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_INTENT_TIMEOUT = 12e4;
+var ConnectClient = class {
+  transport;
+  dapp;
+  requestedPermissions;
+  timeout;
+  intentTimeout;
+  sessionId = null;
+  grantedPermissions = [];
+  identity = null;
+  connected = false;
+  pendingRequests = /* @__PURE__ */ new Map();
+  eventHandlers = /* @__PURE__ */ new Map();
+  unsubscribeTransport = null;
+  // Handshake resolver (one-shot)
+  handshakeResolver = null;
+  constructor(config) {
+    this.transport = config.transport;
+    this.dapp = config.dapp;
+    this.requestedPermissions = config.permissions ?? [...ALL_PERMISSIONS];
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.intentTimeout = config.intentTimeout ?? DEFAULT_INTENT_TIMEOUT;
+  }
+  // ===========================================================================
+  // Connection
+  // ===========================================================================
+  /** Connect to the wallet. Returns session info and public identity. */
+  async connect() {
+    this.unsubscribeTransport = this.transport.onMessage(this.handleMessage.bind(this));
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.handshakeResolver = null;
+        reject(new Error("Connection timeout"));
+      }, this.timeout);
+      this.handshakeResolver = { resolve, reject, timer };
+      this.transport.send({
+        ns: SPHERE_CONNECT_NAMESPACE,
+        v: SPHERE_CONNECT_VERSION,
+        type: "handshake",
+        direction: "request",
+        permissions: this.requestedPermissions,
+        dapp: this.dapp
+      });
+    });
+  }
+  /** Disconnect from the wallet */
+  async disconnect() {
+    if (this.connected) {
+      try {
+        await this.query(RPC_METHODS.DISCONNECT);
+      } catch {
+      }
+    }
+    this.cleanup();
+  }
+  /** Whether currently connected */
+  get isConnected() {
+    return this.connected;
+  }
+  /** Granted permission scopes */
+  get permissions() {
+    return this.grantedPermissions;
+  }
+  /** Current session ID */
+  get session() {
+    return this.sessionId;
+  }
+  /** Public identity received during handshake */
+  get walletIdentity() {
+    return this.identity;
+  }
+  // ===========================================================================
+  // Query (read data)
+  // ===========================================================================
+  /** Send a query request and return the result */
+  async query(method, params) {
+    if (!this.connected) throw new Error("Not connected");
+    const id = createRequestId();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Query timeout: ${method}`));
+      }, this.timeout);
+      this.pendingRequests.set(id, {
+        resolve,
+        reject,
+        timer
+      });
+      this.transport.send({
+        ns: SPHERE_CONNECT_NAMESPACE,
+        v: SPHERE_CONNECT_VERSION,
+        type: "request",
+        id,
+        method,
+        params
+      });
+    });
+  }
+  // ===========================================================================
+  // Intent (trigger wallet UI)
+  // ===========================================================================
+  /** Send an intent request. The wallet will open its UI for user confirmation. */
+  async intent(action, params) {
+    if (!this.connected) throw new Error("Not connected");
+    const id = createRequestId();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Intent timeout: ${action}`));
+      }, this.intentTimeout);
+      this.pendingRequests.set(id, {
+        resolve,
+        reject,
+        timer
+      });
+      this.transport.send({
+        ns: SPHERE_CONNECT_NAMESPACE,
+        v: SPHERE_CONNECT_VERSION,
+        type: "intent",
+        id,
+        action,
+        params
+      });
+    });
+  }
+  // ===========================================================================
+  // Events
+  // ===========================================================================
+  /** Subscribe to a wallet event. Returns unsubscribe function. */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+      if (this.connected) {
+        this.query(RPC_METHODS.SUBSCRIBE, { event }).catch(() => {
+        });
+      }
+    }
+    this.eventHandlers.get(event).add(handler);
+    return () => {
+      const handlers = this.eventHandlers.get(event);
+      if (handlers) {
+        handlers.delete(handler);
+        if (handlers.size === 0) {
+          this.eventHandlers.delete(event);
+          if (this.connected) {
+            this.query(RPC_METHODS.UNSUBSCRIBE, { event }).catch(() => {
+            });
+          }
+        }
+      }
+    };
+  }
+  // ===========================================================================
+  // Message Handling
+  // ===========================================================================
+  handleMessage(msg) {
+    if (msg.type === "handshake" && msg.direction === "response") {
+      this.handleHandshakeResponse(msg);
+      return;
+    }
+    if (msg.type === "response") {
+      this.handlePendingResponse(msg.id, msg.result, msg.error);
+      return;
+    }
+    if (msg.type === "intent_result") {
+      this.handlePendingResponse(msg.id, msg.result, msg.error);
+      return;
+    }
+    if (msg.type === "event") {
+      const handlers = this.eventHandlers.get(msg.event);
+      if (handlers) {
+        for (const handler of handlers) {
+          try {
+            handler(msg.data);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  handleHandshakeResponse(msg) {
+    if (!this.handshakeResolver) return;
+    clearTimeout(this.handshakeResolver.timer);
+    if (msg.sessionId && msg.identity) {
+      this.sessionId = msg.sessionId;
+      this.grantedPermissions = msg.permissions;
+      this.identity = msg.identity;
+      this.connected = true;
+      this.handshakeResolver.resolve({
+        sessionId: msg.sessionId,
+        permissions: this.grantedPermissions,
+        identity: msg.identity
+      });
+    } else {
+      this.handshakeResolver.reject(new Error("Connection rejected by wallet"));
+    }
+    this.handshakeResolver = null;
+  }
+  handlePendingResponse(id, result, error) {
+    const pending = this.pendingRequests.get(id);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this.pendingRequests.delete(id);
+    if (error) {
+      const err = new Error(error.message);
+      err.code = error.code;
+      err.data = error.data;
+      pending.reject(err);
+    } else {
+      pending.resolve(result);
+    }
+  }
+  // ===========================================================================
+  // Cleanup
+  // ===========================================================================
+  cleanup() {
+    if (this.unsubscribeTransport) {
+      this.unsubscribeTransport();
+      this.unsubscribeTransport = null;
+    }
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Disconnected"));
+    }
+    this.pendingRequests.clear();
+    this.eventHandlers.clear();
+    this.connected = false;
+    this.sessionId = null;
+    this.grantedPermissions = [];
+    this.identity = null;
+  }
+};
+export {
+  ALL_PERMISSIONS,
+  ConnectClient,
+  ConnectHost,
+  DEFAULT_PERMISSIONS,
+  ERROR_CODES,
+  HOST_READY_TIMEOUT,
+  HOST_READY_TYPE,
+  INTENT_ACTIONS,
+  INTENT_PERMISSIONS,
+  METHOD_PERMISSIONS,
+  PERMISSION_SCOPES,
+  RPC_METHODS,
+  SPHERE_CONNECT_NAMESPACE,
+  SPHERE_CONNECT_VERSION,
+  createRequestId,
+  hasIntentPermission,
+  hasMethodPermission,
+  isSphereConnectMessage,
+  validatePermissions
+};
+//# sourceMappingURL=index.js.map