decane-connect-kit 2.2.7 → 2.3.0

package/dist/index.cjs

@@ -207,9 +207,11 @@ __export(index_exports, {
   WrongPasswordError: () => WrongPasswordError,
   createDecane: () => createDecane,
   createDecaneConnect: () => createDecaneConnect,
+  createEthereumProvider: () => createEthereumProvider,
   startEmailAuth: () => startEmailAuth,
   useChainSwitch: () => useChainSwitch,
   useDecane: () => useDecane,
+  useEthereumProvider: () => useEthereumProvider,
   useSendTransaction: () => useSendTransaction,
   useSignMessage: () => useSignMessage,
   useSignTypedData: () => useSignTypedData,
@@ -2293,6 +2295,22 @@ var TeeClient = class {
   sessionExpiresIn() {
     return this.sessionExpiresInSec;
   }
+  /** The opaque session handle, so a live session can be persisted and resumed after a reload. */
+  getHandle() {
+    return this.handle;
+  }
+  /**
+   * Adopt a handle from a persisted session (page reload) instead of opening a
+   * new one. The session was already attested when first opened, and the handle
+   * is bound to that CVM session — a swapped CVM would simply not recognise it —
+   * so re-attestation is skipped. If the handle has expired server-side, the
+   * first sign() 401s and clears it, falling back to a normal reconnect.
+   */
+  adoptHandle(handle, assertionPerSignature) {
+    this.handle = handle;
+    this.assertionPerSignature = assertionPerSignature;
+    this.attested = true;
+  }
   async ensureAttested() {
     if (this.attested) return;
     const nonce = crypto.getRandomValues(new Uint8Array(16));
@@ -2473,9 +2491,33 @@ var SessionManager = class {
     this.solanaAddress = null;
     this.expiresAt = null;
     this.timeoutId = null;
-    if (typeof window !== "undefined") {
-      window.addEventListener("pagehide", () => this.end());
-    }
+  }
+  setExpiryTimer(effectiveMs) {
+    if (this.timeoutId) clearTimeout(this.timeoutId);
+    this.timeoutId = setTimeout(() => {
+      this.end();
+      this.events.emit("session-expired");
+    }, Math.max(0, effectiveMs));
+  }
+  /** The live session handle, for persisting a resumable session across reloads. */
+  getHandle() {
+    return this.tee?.getHandle() ?? null;
+  }
+  /**
+   * Resume a persisted session without re-authenticating: adopt the handle,
+   * addresses, and expiry from storage. No key material or prompt involved — the
+   * TEE still holds the shares behind this handle. If the handle turns out to be
+   * dead (server restarted, TTL passed), the next sign() fails and the caller
+   * reconnects; nothing here can sign on its own.
+   */
+  resume(handle, addresses, expiresAtMs) {
+    this.tee = new TeeClient(this.teeUrl);
+    this.tee.adoptHandle(handle, this.requireAssertionPerSignature);
+    this.evmAddress = addresses.evm;
+    this.solanaAddress = addresses.solana;
+    this.expiresAt = expiresAtMs;
+    this.setExpiryTimer(expiresAtMs - Date.now());
+    this.events.emit("session-started");
   }
   /**
    * Opens the TEE session and resolves which addresses this wallet really has.
@@ -2736,6 +2778,17 @@ async function signEvmTransaction(tee, chain, tx, jwt) {
 async function signEvmMessage(tee, chain, message, jwt) {
   return tee.sign({ chain, kind: "message", payload: message }, jwt);
 }
+async function signEvmAuthorization(tee, chainId, address, nonce, jwt) {
+  const serialized = await tee.sign(
+    { chain: `evm:${chainId}`, kind: "authorization", payload: JSON.stringify({ chainId, address, nonce }) },
+    jwt
+  );
+  const hex = serialized.startsWith("0x") ? serialized.slice(2) : serialized;
+  const r = "0x" + hex.slice(0, 64);
+  const s = "0x" + hex.slice(64, 128);
+  const v = parseInt(hex.slice(128, 130), 16);
+  return { yParity: v >= 27 ? v - 27 : v, r, s };
+}
 async function signEvmTypedData(tee, chain, typedData, jwt) {
   const payload = JSON.stringify(
     typedData,
@@ -2744,6 +2797,194 @@ async function signEvmTypedData(tee, chain, typedData, jwt) {
   return tee.sign({ chain, kind: "typedData", payload }, jwt);
 }
 
+// src/social/balance.ts
+var DEFAULT_RPCS = {
+  "evm:1": "https://ethereum.publicnode.com",
+  "evm:137": "https://polygon.publicnode.com",
+  "evm:8453": "https://base.publicnode.com",
+  "evm:10": "https://optimism.publicnode.com",
+  "evm:42161": "https://arbitrum-one.publicnode.com",
+  "evm:56": "https://bsc.publicnode.com",
+  "evm:11155111": "https://ethereum-sepolia.publicnode.com",
+  "evm:84532": "https://base-sepolia.publicnode.com",
+  "evm:31337": "http://localhost:8545"
+};
+var EVM_SYMBOLS = {
+  "evm:137": "MATIC",
+  "evm:56": "BNB"
+};
+function solanaEndpoint(chain, rpcUrls) {
+  if (rpcUrls?.[chain]) return rpcUrls[chain];
+  const cluster = chain.slice("solana:".length);
+  return cluster === "devnet" ? "https://api.devnet.solana.com" : "https://api.mainnet-beta.solana.com";
+}
+async function fetchBalance(opts) {
+  const { kind, address, chain, rpcUrls } = opts;
+  if (kind === "evm") {
+    const rpcUrl = rpcUrls?.[chain] ?? DEFAULT_RPCS[chain];
+    if (!rpcUrl) {
+      throw new Error(
+        `No RPC URL for ${chain}. Pass rpcUrls: { '${chain}': 'https://...' } in social config.`
+      );
+    }
+    const { JsonRpcProvider, formatEther } = await import("ethers");
+    const wei = await new JsonRpcProvider(rpcUrl).getBalance(address);
+    return { raw: wei, formatted: formatEther(wei), symbol: EVM_SYMBOLS[chain] ?? "ETH", decimals: 18 };
+  }
+  const { Connection, PublicKey, LAMPORTS_PER_SOL } = await import("@solana/web3.js");
+  const lamports = await new Connection(solanaEndpoint(chain, rpcUrls)).getBalance(
+    new PublicKey(address)
+  );
+  return {
+    raw: BigInt(lamports),
+    formatted: String(lamports / LAMPORTS_PER_SOL),
+    symbol: "SOL",
+    decimals: 9
+  };
+}
+function formatBalanceDisplay(value) {
+  if (value == null) return "\u2014";
+  const n = Number(value);
+  if (!Number.isFinite(n)) return value;
+  return n === 0 ? "0" : n < 1e-4 ? "<0.0001" : n.toFixed(4).replace(/\.?0+$/, "");
+}
+
+// src/social/eip1193.ts
+function toHex(n) {
+  return "0x" + n.toString(16);
+}
+function hexToBytes2(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(clean.substr(i * 2, 2), 16);
+  return bytes;
+}
+function asBigInt(v) {
+  if (v == null) return void 0;
+  if (typeof v === "bigint") return v;
+  if (typeof v === "number") return BigInt(v);
+  if (typeof v === "string") return BigInt(v);
+  return void 0;
+}
+function createEthereumProvider(client, opts = {}) {
+  let chainId = opts.chainId ?? 1;
+  const listeners = /* @__PURE__ */ new Map();
+  function emit(event, ...args) {
+    listeners.get(event)?.forEach((h) => {
+      try {
+        h(...args);
+      } catch {
+      }
+    });
+  }
+  client.on("connected", () => {
+    const evm = client.getAddresses()?.evm;
+    emit("connect", { chainId: toHex(chainId) });
+    if (evm) emit("accountsChanged", [evm]);
+  });
+  client.on("disconnected", () => {
+    emit("accountsChanged", []);
+    emit("disconnect", { code: 4900, message: "Wallet disconnected" });
+  });
+  const chainStr = () => `evm:${chainId}`;
+  async function rpc(method, params) {
+    const url = opts.rpcUrls?.[`evm:${chainId}`] ?? DEFAULT_RPCS[`evm:${chainId}`];
+    if (!url) {
+      throw Object.assign(new Error(`No RPC for chain ${chainId}. Pass rpcUrls.`), { code: 4900 });
+    }
+    let res;
+    try {
+      res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: Date.now(), method, params })
+      });
+    } catch (e) {
+      throw Object.assign(new Error(`RPC request failed: ${e.message}`), { code: 4900 });
+    }
+    const json = await res.json();
+    if (json.error) throw Object.assign(new Error(json.error.message), { code: json.error.code });
+    return json.result;
+  }
+  async function request(args) {
+    const params = Array.isArray(args.params) ? args.params : args.params ? [args.params] : [];
+    const addr = () => client.getAddresses()?.evm ?? null;
+    switch (args.method) {
+      case "eth_requestAccounts":
+      case "eth_accounts": {
+        const a = addr();
+        return a ? [a] : [];
+      }
+      case "eth_chainId":
+        return toHex(chainId);
+      case "net_version":
+        return String(chainId);
+      case "personal_sign": {
+        const message = params[0];
+        const bytes = typeof message === "string" && message.startsWith("0x") ? hexToBytes2(message) : message;
+        return client.signMessage({ chain: chainStr(), message: bytes });
+      }
+      case "eth_signTypedData_v4":
+      case "eth_signTypedData": {
+        const raw = params[1];
+        const td = typeof raw === "string" ? JSON.parse(raw) : raw;
+        return client.signTypedData({
+          chain: chainStr(),
+          domain: td.domain,
+          types: td.types,
+          message: td.message,
+          primaryType: td.primaryType
+        });
+      }
+      case "eth_sendTransaction": {
+        const tx = params[0];
+        return client.sendTransaction({
+          chain: chainStr(),
+          to: tx.to,
+          value: asBigInt(tx.value),
+          data: tx.data ?? tx.input,
+          gasLimit: asBigInt(tx.gas ?? tx.gasLimit)
+        });
+      }
+      case "eth_signAuthorization":
+      case "wallet_sign7702Authorization": {
+        if (!client.signAuthorization) {
+          throw Object.assign(new Error("EIP-7702 is not supported by the connected signer."), { code: 4200 });
+        }
+        const p = params[0];
+        const cid = p.chainId != null ? Number(asBigInt(p.chainId)) : chainId;
+        const address = p.address ?? p.contractAddress;
+        const nonce = p.nonce != null ? Number(asBigInt(p.nonce)) : 0;
+        return client.signAuthorization({ chainId: cid, address, nonce });
+      }
+      case "wallet_switchEthereumChain": {
+        const p = params[0];
+        chainId = Number(asBigInt(p.chainId));
+        emit("chainChanged", toHex(chainId));
+        return null;
+      }
+      case "wallet_addEthereumChain":
+        return null;
+      default:
+        return rpc(args.method, params);
+    }
+  }
+  const provider = {
+    request,
+    on(event, handler) {
+      if (!listeners.has(event)) listeners.set(event, /* @__PURE__ */ new Set());
+      listeners.get(event).add(handler);
+      return this;
+    },
+    removeListener(event, handler) {
+      listeners.get(event)?.delete(handler);
+      return this;
+    },
+    isDecane: true
+  };
+  return provider;
+}
+
 // src/social/signers/solana.ts
 var import_web3 = require("@solana/web3.js");
 function b64(bytes) {
@@ -2981,58 +3222,6 @@ async function buildPortableBackup(deviceShare, recoveryShare, password, address
   };
 }
 
-// src/social/balance.ts
-var DEFAULT_RPCS = {
-  "evm:1": "https://ethereum.publicnode.com",
-  "evm:137": "https://polygon.publicnode.com",
-  "evm:8453": "https://base.publicnode.com",
-  "evm:10": "https://optimism.publicnode.com",
-  "evm:42161": "https://arbitrum-one.publicnode.com",
-  "evm:56": "https://bsc.publicnode.com",
-  "evm:11155111": "https://ethereum-sepolia.publicnode.com",
-  "evm:84532": "https://base-sepolia.publicnode.com",
-  "evm:31337": "http://localhost:8545"
-};
-var EVM_SYMBOLS = {
-  "evm:137": "MATIC",
-  "evm:56": "BNB"
-};
-function solanaEndpoint(chain, rpcUrls) {
-  if (rpcUrls?.[chain]) return rpcUrls[chain];
-  const cluster = chain.slice("solana:".length);
-  return cluster === "devnet" ? "https://api.devnet.solana.com" : "https://api.mainnet-beta.solana.com";
-}
-async function fetchBalance(opts) {
-  const { kind, address, chain, rpcUrls } = opts;
-  if (kind === "evm") {
-    const rpcUrl = rpcUrls?.[chain] ?? DEFAULT_RPCS[chain];
-    if (!rpcUrl) {
-      throw new Error(
-        `No RPC URL for ${chain}. Pass rpcUrls: { '${chain}': 'https://...' } in social config.`
-      );
-    }
-    const { JsonRpcProvider, formatEther } = await import("ethers");
-    const wei = await new JsonRpcProvider(rpcUrl).getBalance(address);
-    return { raw: wei, formatted: formatEther(wei), symbol: EVM_SYMBOLS[chain] ?? "ETH", decimals: 18 };
-  }
-  const { Connection, PublicKey, LAMPORTS_PER_SOL } = await import("@solana/web3.js");
-  const lamports = await new Connection(solanaEndpoint(chain, rpcUrls)).getBalance(
-    new PublicKey(address)
-  );
-  return {
-    raw: BigInt(lamports),
-    formatted: String(lamports / LAMPORTS_PER_SOL),
-    symbol: "SOL",
-    decimals: 9
-  };
-}
-function formatBalanceDisplay(value) {
-  if (value == null) return "\u2014";
-  const n = Number(value);
-  if (!Number.isFinite(n)) return value;
-  return n === 0 ? "0" : n < 1e-4 ? "<0.0001" : n.toFixed(4).replace(/\.?0+$/, "");
-}
-
 // src/social/client.ts
 var DEFAULT_API_BASE = "https://backend.decane.app";
 var DEFAULT_TEE_URL = "https://4405742df08d19abc549a05ade2a7154d98bd87f-8443.dstack-pha-prod9.phala.network";
@@ -3060,6 +3249,29 @@ function clearPersisted(key) {
   } catch {
   }
 }
+function sessionPersistKey(apiKey) {
+  return `decane:sess:${apiKey.slice(0, 20)}`;
+}
+function loadSession(key) {
+  try {
+    const raw = typeof sessionStorage !== "undefined" ? sessionStorage.getItem(key) : null;
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+function saveSession(key, s) {
+  try {
+    sessionStorage.setItem(key, JSON.stringify(s));
+  } catch {
+  }
+}
+function clearSessionPersist(key) {
+  try {
+    sessionStorage.removeItem(key);
+  } catch {
+  }
+}
 async function createDecaneConnect(config) {
   if (!config.appId) throw new Error("decane-connect-kit: appId is required");
   if (!config.apiKey) throw new Error("decane-connect-kit: apiKey is required");
@@ -3082,6 +3294,40 @@ async function createDecaneConnect(config) {
   );
   let auth = null;
   let persisted = loadPersisted(PERSIST_KEY);
+  let ethProvider = null;
+  const persistSession = config.persistSession !== false;
+  const SESSION_KEY = sessionPersistKey(config.apiKey);
+  function persistLiveSession() {
+    if (!persistSession) return;
+    const handle = session.getHandle();
+    const expiresAt = session.expiresAtTimestamp();
+    if (!handle || !auth || !expiresAt) return;
+    saveSession(SESSION_KEY, {
+      handle,
+      jwt: auth.jwt,
+      userId: auth.userId,
+      addresses: auth.addresses,
+      expiresAt
+    });
+  }
+  function dropLiveSession() {
+    clearSessionPersist(SESSION_KEY);
+  }
+  if (persistSession) {
+    const saved = loadSession(SESSION_KEY);
+    if (saved?.handle && saved.expiresAt > Date.now() + 5e3) {
+      try {
+        session.resume(saved.handle, saved.addresses, saved.expiresAt);
+        auth = { jwt: saved.jwt, userId: saved.userId, addresses: saved.addresses };
+        persisted = { userId: saved.userId, addresses: saved.addresses };
+      } catch {
+        dropLiveSession();
+      }
+    } else if (saved) {
+      dropLiveSession();
+    }
+  }
+  events.on("session-expired", () => dropLiveSession());
   async function pinSetup() {
     if (!config.promptPin) throw new PromptPinNotConfiguredError();
     const pin = await config.promptPin();
@@ -3195,7 +3441,7 @@ async function createDecaneConnect(config) {
     let evmAddress;
     let solanaAddress;
     try {
-      evmAddress = new import_ethers2.Wallet(toHex(master)).address;
+      evmAddress = new import_ethers2.Wallet(toHex2(master)).address;
       solanaAddress = import_web32.Keypair.fromSeed(master).publicKey.toBase58();
       shareSet = await splitMaster(master, 1);
     } finally {
@@ -3365,6 +3611,7 @@ async function createDecaneConnect(config) {
     persisted = { userId, addresses };
     savePersisted(PERSIST_KEY, persisted);
     events.emit("connected");
+    persistLiveSession();
     return { addresses, isNewUser: false };
   }
   async function handleAuthResult(result) {
@@ -3380,6 +3627,7 @@ async function createDecaneConnect(config) {
     persisted = { userId: result.userId, addresses };
     savePersisted(PERSIST_KEY, persisted);
     events.emit("connected");
+    persistLiveSession();
     return { addresses, isNewUser: result.isNewUser };
   }
   const client = {
@@ -3554,6 +3802,21 @@ async function createDecaneConnect(config) {
         auth?.jwt
       );
     },
+    async signAuthorization(req) {
+      const tee = session.requireActive();
+      return signEvmAuthorization(tee, req.chainId, req.address, req.nonce, auth?.jwt);
+    },
+    getEthereumProvider(opts) {
+      if (!ethProvider) {
+        const firstEvm = config.chains.find((c) => c.startsWith("evm:"));
+        const defaultChainId = firstEvm ? parseInt(firstEvm.slice(4), 10) : 1;
+        ethProvider = createEthereumProvider(client, {
+          chainId: opts?.chainId ?? defaultChainId,
+          rpcUrls: config.rpcUrls
+        });
+      }
+      return ethProvider;
+    },
     async signSolanaTransaction(serializedTx) {
       const tee = session.requireActive();
       let tx;
@@ -3574,6 +3837,7 @@ async function createDecaneConnect(config) {
       auth = null;
       persisted = null;
       clearPersisted(PERSIST_KEY);
+      dropLiveSession();
       events.emit("disconnected");
     },
     getAddresses() {
@@ -3716,14 +3980,14 @@ function b64uToBuffer(b64u) {
   const b644 = b64u.replace(/-/g, "+").replace(/_/g, "/");
   return Uint8Array.from(atob(b644), (c) => c.charCodeAt(0));
 }
-function toHex(bytes) {
+function toHex2(bytes) {
   return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 async function deriveAddressesFromShares(a, b) {
   const master = await combineShares(a, b);
   try {
     return {
-      evm: new import_ethers2.Wallet(toHex(master)).address,
+      evm: new import_ethers2.Wallet(toHex2(master)).address,
       solana: import_web32.Keypair.fromSeed(master).publicKey.toBase58()
     };
   } finally {
@@ -5610,7 +5874,15 @@ function DecaneKit({ config, children }) {
       sdk.on("wallet-unlocking", () => setSocialAuth((p) => ({ ...p, phase: "unlocking" })));
       sdk.on("connected", () => setSocialAuth((p) => ({ ...p, phase: null })));
       const saved = sdk.getAddresses();
-      if (saved) {
+      if (sdk.isUnlocked()) {
+        setSocialAuth((p) => ({
+          ...p,
+          addresses: saved,
+          isUnlocked: true,
+          needsReconnect: false,
+          sessionExpiresAt: sdk.sessionExpiresAt()
+        }));
+      } else if (saved) {
         setSocialAuth((p) => ({ ...p, addresses: saved, isUnlocked: false, needsReconnect: true }));
       }
       sdk.canSignInWithPasskey().then((can) => setSocialAuth((p) => ({ ...p, canUsePasskey: can }))).catch(() => {
@@ -5741,6 +6013,19 @@ function DecaneKit({ config, children }) {
     if (!sdk) throw new Error("Social wallet not connected");
     return sdk.getBalance(chain);
   }, []);
+  const socialGetEthereumProvider = (0, import_react5.useCallback)((opts) => {
+    const sdk = socialRef.current;
+    if (!sdk) throw new Error("Social wallet not connected");
+    return sdk.getEthereumProvider(opts);
+  }, []);
+  const socialSignAuthorization = (0, import_react5.useCallback)(
+    async (req) => {
+      const sdk = socialRef.current;
+      if (!sdk) throw new Error("Social wallet not connected");
+      return sdk.signAuthorization(req);
+    },
+    []
+  );
   const socialGetBalances = (0, import_react5.useCallback)(async () => {
     const sdk = socialRef.current;
     if (!sdk) throw new Error("Social wallet not connected");
@@ -5803,6 +6088,8 @@ function DecaneKit({ config, children }) {
         socialSendTransaction,
         socialGetBalance,
         socialGetBalances,
+        socialGetEthereumProvider,
+        socialSignAuthorization,
         socialSignSolanaTransaction,
         socialSignTypedData,
         socialRotateShares,
@@ -6025,6 +6312,8 @@ function useSocialWallet() {
     socialSignTypedData,
     socialGetBalance,
     socialGetBalances,
+    socialGetEthereumProvider,
+    socialSignAuthorization,
     socialRotateShares,
     socialExportPortableBackup,
     socialHasRecoveryShare,
@@ -6069,6 +6358,10 @@ function useSocialWallet() {
     (chain) => run(() => socialGetBalance(chain)),
     [socialGetBalance]
   );
+  const signAuthorization = (0, import_react6.useCallback)(
+    (req) => run(() => socialSignAuthorization(req)),
+    [socialSignAuthorization]
+  );
   const getBalances = (0, import_react6.useCallback)(
     () => run(() => socialGetBalances()),
     [socialGetBalances]
@@ -6142,6 +6435,10 @@ function useSocialWallet() {
     // Balances (native token; read-only, works while locked)
     getBalance,
     getBalances,
+    // EVM interop
+    signAuthorization,
+    // An EIP-1193 provider for viem/wagmi/ethers (memoized).
+    getEthereumProvider: socialGetEthereumProvider,
     // Recovery (2-of-3 Shamir share set)
     rotateShares,
     exportPortableBackup,
@@ -6199,6 +6496,18 @@ function useSocialBalance(chain) {
   }, [addrKey, chain]);
   return { balance, loading, error, refetch };
 }
+function useEthereumProvider(opts) {
+  const { socialAuth, socialGetEthereumProvider } = useDecaneContext();
+  const chainId = opts?.chainId;
+  return (0, import_react6.useMemo)(() => {
+    if (!socialAuth.addresses?.evm) return null;
+    try {
+      return socialGetEthereumProvider(chainId ? { chainId } : void 0);
+    } catch {
+      return null;
+    }
+  }, [socialAuth.addresses?.evm, chainId]);
+}
 function toDecaneError(err) {
   if (err instanceof DecaneError) return err;
   const msg = err instanceof Error ? err.message : err?.message != null ? String(err.message) : String(err);
@@ -6456,9 +6765,11 @@ function useSignTypedData() {
   WrongPasswordError,
   createDecane,
   createDecaneConnect,
+  createEthereumProvider,
   startEmailAuth,
   useChainSwitch,
   useDecane,
+  useEthereumProvider,
   useSendTransaction,
   useSignMessage,
   useSignTypedData,