@talken/talkenkit 2.4.30 → 2.5.0

package/dist/wallets/walletConnectors/{chunk-XNA5NIFE.js → chunk-QSP2A4LA.js}

@@ -1,7 +1,7 @@
 "use client";
 import {
   abcConnector
-} from "./chunk-HHZ3JZRH.js";
+} from "./chunk-HWXOTEC3.js";
 import {
   resolveTalkenApiUrl
 } from "./chunk-GFWUFYT2.js";
@@ -21,6 +21,7 @@ var abcWallet = (specificOptions) => ({ projectId }) => {
     debug: specificOptions?.environment === "development"
   });
   setTalkenApiClient(talkenApi);
+  const accessKey = specificOptions?.accessKey || (typeof localStorage !== "undefined" ? localStorage.getItem("talken_ak") : null) || null;
   const config = {
     talkenApiUrl,
     apiKey: specificOptions?.apiKey,
@@ -30,7 +31,8 @@ var abcWallet = (specificOptions) => ({ projectId }) => {
     defaultChainId: specificOptions?.defaultChainId,
     defaultSolanaNetwork: specificOptions?.defaultSolanaNetwork,
     defaultBitcoinNetwork: specificOptions?.defaultBitcoinNetwork,
-    projectId
+    projectId,
+    ...accessKey && { accessKey }
   };
   return {
     id: ABC_WALLET_METADATA.id,
@@ -43,6 +45,7 @@ var abcWallet = (specificOptions) => ({ projectId }) => {
     // No download URLs for embedded wallet
     downloadUrls: void 0,
     // Create connector - wrapper function required by Wallet type
+    // If accessKey exists, abcConnector will use AbcAccessKeyProvider internally
     createConnector: (_walletDetails) => abcConnector({ config }),
     // Embedded wallet always available
     hidden: () => false

package/dist/wallets/walletConnectors/chunk-S2SQYPGR.js

@@ -0,0 +1,220 @@
+"use client";
+import {
+  getChainKey
+} from "./chunk-K66HU6GX.js";
+import {
+  hexToNumber,
+  numberToHex
+} from "./chunk-A66MTFML.js";
+
+// src/wallets/walletConnectors/abcWallet/abcAccessKeyProvider.ts
+var EventEmitter = class {
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+  }
+  on(event, listener) {
+    if (!this.events.has(event))
+      this.events.set(event, []);
+    this.events.get(event).push(listener);
+    return this;
+  }
+  off(event, listener) {
+    const listeners = this.events.get(event);
+    if (listeners) {
+      const idx = listeners.indexOf(listener);
+      if (idx !== -1)
+        listeners.splice(idx, 1);
+    }
+    return this;
+  }
+  removeListener(event, listener) {
+    return this.off(event, listener);
+  }
+  emit(event, ...args) {
+    const listeners = this.events.get(event);
+    if (listeners) {
+      for (const listener of listeners)
+        listener(...args);
+      return true;
+    }
+    return false;
+  }
+  removeAllListeners(event) {
+    if (event)
+      this.events.delete(event);
+    else
+      this.events.clear();
+    return this;
+  }
+};
+var ErrorCode = {
+  USER_REJECTED: 4001,
+  UNAUTHORIZED: 4100,
+  UNSUPPORTED_METHOD: 4200,
+  DISCONNECTED: 4900,
+  INTERNAL_ERROR: -32603
+};
+var ProviderRpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "ProviderRpcError";
+  }
+};
+var AbcAccessKeyProvider = class extends EventEmitter {
+  constructor(accessKey, apiBaseUrl) {
+    super();
+    this.wallet = null;
+    this.chainId = 1;
+    this.connected = false;
+    this.accessKey = accessKey;
+    this.apiBaseUrl = apiBaseUrl || (typeof window !== "undefined" ? window.__TALKEN_API_URL__ || "" : "");
+  }
+  // ── Wallet management ─────────────────────────────────────
+  setWallet(wallet) {
+    this.wallet = wallet;
+    this.chainId = wallet.chainId || 1;
+    this.connected = true;
+  }
+  clearWallet() {
+    this.wallet = null;
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected && !!this.wallet;
+  }
+  getWallet() {
+    return this.wallet;
+  }
+  getChainId() {
+    return this.chainId;
+  }
+  setAccessKey(key) {
+    this.accessKey = key;
+  }
+  // ── EIP-1193 request ──────────────────────────────────────
+  async request(args) {
+    const { method, params } = args;
+    switch (method) {
+      case "eth_requestAccounts":
+      case "eth_accounts":
+        return this.wallet ? [this.wallet.address] : [];
+      case "eth_chainId":
+        return numberToHex(this.chainId);
+      case "wallet_switchEthereumChain": {
+        const p = params?.[0];
+        if (p?.chainId) {
+          this.chainId = hexToNumber(p.chainId);
+          this.emit("chainChanged", numberToHex(this.chainId));
+        }
+        return null;
+      }
+      case "eth_sendTransaction":
+        return this.sendTransaction(params);
+      case "personal_sign":
+        return this.personalSign(params);
+      case "eth_signTypedData":
+      case "eth_signTypedData_v4":
+        return this.signTypedData(params);
+      case "eth_estimateGas":
+        return this.rpcCall("eth_estimateGas", params);
+      case "eth_getTransactionCount":
+        return this.rpcCall("eth_getTransactionCount", params);
+      case "wallet_getCapabilities":
+        return {};
+      default:
+        return this.rpcCall(method, params);
+    }
+  }
+  // ── Signing via access-key (server-side, no PIN) ──────────
+  async sendTransaction(params) {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    const tx = params?.[0];
+    if (!tx) {
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        "Missing transaction params"
+      );
+    }
+    const chainKey = getChainKey(this.chainId);
+    const result = await this.apiPost("/tx/relay-execute", {
+      chainKey,
+      user: this.wallet.address,
+      tokenIn: "0x0000000000000000000000000000000000000000",
+      amountIn: tx.value || "0",
+      target: tx.to,
+      targetCalldata: tx.data || "0x",
+      deadline: Math.floor(Date.now() / 1e3) + 600,
+      auth: { method: "auto" }
+    });
+    return result?.txHash || result?.hash;
+  }
+  async personalSign(params) {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    const p = params;
+    const message = p?.[0];
+    const result = await this.apiPost("/agent/sessions/sign", {
+      operation: "signMessage",
+      chainId: this.chainId,
+      payload: { message }
+    });
+    return result?.signature;
+  }
+  async signTypedData(params) {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    const p = params;
+    const typedData = typeof p?.[1] === "string" ? JSON.parse(p[1]) : p?.[1];
+    const result = await this.apiPost("/agent/sessions/sign", {
+      operation: "signTypedData",
+      chainId: this.chainId,
+      payload: typedData
+    });
+    return result?.signature;
+  }
+  // ── HTTP helpers ──────────────────────────────────────────
+  async apiPost(path, body) {
+    const url = `${this.apiBaseUrl}${path}`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Access-Key": this.accessKey
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ message: res.statusText }));
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        err?.error?.message || err?.message || `API error: ${res.status}`
+      );
+    }
+    const json = await res.json();
+    return json?.data || json;
+  }
+  async rpcCall(method, params) {
+    const chainKey = getChainKey(this.chainId);
+    const result = await this.apiPost("/rpc", { chainKey, method, params });
+    return result?.result ?? result;
+  }
+};
+
+export {
+  AbcAccessKeyProvider
+};