decane-connect-kit 2.2.8 → 2.3.1

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,
@@ -2776,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 { chainId, address, nonce, yParity: v >= 27 ? v - 27 : v, r, s };
+}
 async function signEvmTypedData(tee, chain, typedData, jwt) {
   const payload = JSON.stringify(
     typedData,
@@ -2784,6 +2797,191 @@ 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": {
+        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) {
@@ -3021,58 +3219,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";
@@ -3145,6 +3291,7 @@ 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() {
@@ -3291,7 +3438,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 {
@@ -3652,6 +3799,30 @@ async function createDecaneConnect(config) {
         auth?.jwt
       );
     },
+    async signAuthorization(req) {
+      const tee = session.requireActive();
+      const delegate = req.address ?? req.contractAddress;
+      if (!delegate) throw new CallSequenceError("signAuthorization requires `address` (the delegate contract).");
+      return signEvmAuthorization(tee, req.chainId, delegate, req.nonce, auth?.jwt);
+    },
+    // The current session's access token (the Decane JWT), for authenticating
+    // the user to your own backend — e.g. a sponsored-bundler proxy. Verify it
+    // server-side against https://backend.decane.app/.well-known/jwks.json.
+    // Null when there is no live session.
+    getAccessToken() {
+      return auth?.jwt ?? null;
+    },
+    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;
@@ -3815,14 +3986,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 {
@@ -5848,6 +6019,22 @@ 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 socialGetAccessToken = (0, import_react5.useCallback)(() => {
+    return socialRef.current?.getAccessToken() ?? null;
+  }, []);
   const socialGetBalances = (0, import_react5.useCallback)(async () => {
     const sdk = socialRef.current;
     if (!sdk) throw new Error("Social wallet not connected");
@@ -5910,6 +6097,9 @@ function DecaneKit({ config, children }) {
         socialSendTransaction,
         socialGetBalance,
         socialGetBalances,
+        socialGetEthereumProvider,
+        socialSignAuthorization,
+        socialGetAccessToken,
         socialSignSolanaTransaction,
         socialSignTypedData,
         socialRotateShares,
@@ -6132,6 +6322,9 @@ function useSocialWallet() {
     socialSignTypedData,
     socialGetBalance,
     socialGetBalances,
+    socialGetEthereumProvider,
+    socialSignAuthorization,
+    socialGetAccessToken,
     socialRotateShares,
     socialExportPortableBackup,
     socialHasRecoveryShare,
@@ -6176,6 +6369,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]
@@ -6249,6 +6446,13 @@ 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,
+    // The Decane JWT — authenticate the user to your own backend (bundler proxy,
+    // etc.); verify server-side against backend.decane.app/.well-known/jwks.json.
+    getAccessToken: socialGetAccessToken,
     // Recovery (2-of-3 Shamir share set)
     rotateShares,
     exportPortableBackup,
@@ -6306,6 +6510,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);
@@ -6563,9 +6779,11 @@ function useSignTypedData() {
   WrongPasswordError,
   createDecane,
   createDecaneConnect,
+  createEthereumProvider,
   startEmailAuth,
   useChainSwitch,
   useDecane,
+  useEthereumProvider,
   useSendTransaction,
   useSignMessage,
   useSignTypedData,