@talken/talkenkit 2.4.29 → 2.5.0

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
+};

package/dist/wallets/walletConnectors/{chunk-4FKUVQCM.js → chunk-TQHS6APN.js}

@@ -2,11 +2,17 @@
 import {
   getChainKey,
   getNetworkName
-} from "./chunk-7QHCSJDN.js";
+} from "./chunk-K66HU6GX.js";
 import {
   hexToNumber,
   numberToHex
-} from "./chunk-LOSXI36Y.js";
+} from "./chunk-A66MTFML.js";
+import {
+  TalkenApiError
+} from "./chunk-4P3SPC44.js";
+import {
+  getCredentialManager
+} from "./chunk-6WF4SXLB.js";
 
 // src/wallets/walletConnectors/abcWallet/abcProvider.ts
 import { getTalkenApiClient } from "@talken/talkenkit";
@@ -72,13 +78,20 @@ var ErrorCode = {
   INTERNAL_ERROR: -32603
 };
 var AbcEvmProvider = class extends EventEmitter {
-  constructor(client) {
+  constructor(talkenApi) {
     super();
     this.wallet = null;
     this.chainId = 1;
     // Default to Ethereum mainnet
     this.connected = false;
-    this.client = client;
+    this.talkenApi = talkenApi;
+  }
+  getRecoveryEmail() {
+    const walletEmail = this.wallet?.email?.trim();
+    if (walletEmail) {
+      return walletEmail;
+    }
+    return getCredentialManager().getEmail() || void 0;
   }
   /**
    * Set wallet information
@@ -123,6 +136,74 @@ var AbcEvmProvider = class extends EventEmitter {
   setTalkenApi(talkenApi) {
     this.talkenApi = talkenApi;
   }
+  getTalkenApiClientOrThrow() {
+    const api = this.talkenApi || getTalkenApiClient();
+    if (!api) {
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        "TalkenApiClient not initialized"
+      );
+    }
+    return api;
+  }
+  /**
+   * Check if an error is a "Missing required wallet fields" 502 from the server.
+   * When the server's in-memory signing credential cache is cold, it needs
+   * a wallet.generate() call (idempotent create/recover) to repopulate.
+   */
+  isSigningCredentialError(error) {
+    return error instanceof TalkenApiError && error.statusCode === 502 && error.message.includes("Missing required wallet fields");
+  }
+  /**
+   * Refresh server-side signing credentials.
+   *
+   * Strategy (in priority order):
+   * 1. PIN hash in memory → wallet.generate() to repopulate server cache
+   * 2. Neither available → throw UNAUTHORIZED
+   *
+   * Note: sessionStorage-cached credentials (evmCreds) are automatically
+   * attached to every signing request by TalkenApiClient, so the server
+   * can use them as fallback without a separate refresh call.
+   */
+  async refreshSigningCredentials() {
+    const credMgr = getCredentialManager();
+    const pinHash = credMgr.getPinHash();
+    const email = this.getRecoveryEmail();
+    if (pinHash && email) {
+      const api = this.getTalkenApiClientOrThrow();
+      console.log(
+        "[AbcProvider] Refreshing signing credentials via wallet.generate..."
+      );
+      await api.wallet.generate(pinHash, email);
+      console.log("[AbcProvider] Signing credentials refreshed via PIN");
+      return;
+    }
+    console.warn(
+      "[AbcProvider] Cannot refresh signing credentials \u2014 PIN hash or email missing"
+    );
+    throw new ProviderRpcError(
+      ErrorCode.UNAUTHORIZED,
+      "Session expired. Please reconnect and verify your PIN."
+    );
+  }
+  /**
+   * Wrap a signing operation with auto-retry on "Missing required wallet fields" error.
+   * On first failure, refreshes the server's signing credential cache and retries once.
+   */
+  async withSigningCredentialRetry(operation) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (this.isSigningCredentialError(error)) {
+        console.log(
+          "[AbcProvider] Signing credentials missing on server \u2014 attempting refresh and retry"
+        );
+        await this.refreshSigningCredentials();
+        return await operation();
+      }
+      throw error;
+    }
+  }
   /**
    * Call request interceptor if configured
    * Called by specific signing/transaction methods that need user confirmation
@@ -295,7 +376,7 @@ var AbcEvmProvider = class extends EventEmitter {
         'Transaction must have "to" field'
       );
     }
-    const pinHash = localStorage.getItem("talkenkit_abc_pin_hash");
+    const pinHash = getCredentialManager().getPinHash();
     if (!pinHash) {
       throw new ProviderRpcError(
         ErrorCode.INTERNAL_ERROR,
@@ -304,17 +385,21 @@ var AbcEvmProvider = class extends EventEmitter {
     }
     const hexValue = tx.value || "0x0";
     const amountWei = BigInt(hexValue).toString();
-    const api = this.talkenApi || getTalkenApiClient();
-    const result = await api.evm.sendTransaction({
-      chainKey: getChainKey(this.chainId),
-      to: tx.to,
-      amountWei,
-      pin: pinHash,
-      data: tx.data || "0x",
-      gasLimit: tx.gas || tx.gasLimit,
-      maxFeePerGas: tx.maxFeePerGas,
-      maxPriorityFeePerGas: tx.maxPriorityFeePerGas
-    });
+    const email = this.getRecoveryEmail();
+    const api = this.getTalkenApiClientOrThrow();
+    const result = await this.withSigningCredentialRetry(
+      () => api.evm.sendTransaction({
+        chainKey: getChainKey(this.chainId),
+        to: tx.to,
+        amountWei,
+        pin: pinHash,
+        data: tx.data || "0x",
+        gasLimit: tx.gas || tx.gasLimit,
+        maxFeePerGas: tx.maxFeePerGas,
+        maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+        ...email && { email }
+      })
+    );
     return result.txHash;
   }
   /**
@@ -364,17 +449,23 @@ var AbcEvmProvider = class extends EventEmitter {
         }
       }
     }
-    const api = this.talkenApi || getTalkenApiClient();
-    const result = await api.evm.signTransaction({
-      network: getNetworkName(this.chainId),
-      to: tx.to,
-      value: tx.value || "0x0",
-      data: tx.data || "0x",
-      gasLimit: tx.gas || tx.gasLimit,
-      maxFeePerGas: tx.maxFeePerGas,
-      maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
-      nonce: tx.nonce ? String(Number.parseInt(tx.nonce, 16)) : void 0
-    });
+    const api = this.getTalkenApiClientOrThrow();
+    const pinHash = getCredentialManager().getPinHash() || void 0;
+    const email = this.getRecoveryEmail();
+    const result = await this.withSigningCredentialRetry(
+      () => api.evm.signTransaction({
+        network: getNetworkName(this.chainId),
+        to: tx.to,
+        value: tx.value || "0x0",
+        data: tx.data || "0x",
+        gasLimit: tx.gas || tx.gasLimit,
+        maxFeePerGas: tx.maxFeePerGas,
+        maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+        nonce: tx.nonce ? String(Number.parseInt(tx.nonce, 16)) : void 0,
+        ...pinHash && { pin: pinHash },
+        ...email && { email }
+      })
+    );
     return result.signature;
   }
   /**
@@ -404,15 +495,19 @@ var AbcEvmProvider = class extends EventEmitter {
         "Address does not match connected wallet"
       );
     }
-    const api = this.talkenApi || getTalkenApiClient();
+    const api = this.getTalkenApiClientOrThrow();
     const network = getNetworkName(this.chainId);
-    const pinHash = localStorage.getItem("talkenkit_abc_pin_hash") || void 0;
-    const result = await api.evm.signPersonal({
-      network,
-      message,
-      address,
-      pin: pinHash
-    });
+    const pinHash = getCredentialManager().getPinHash() || void 0;
+    const email = this.getRecoveryEmail();
+    const result = await this.withSigningCredentialRetry(
+      () => api.evm.signPersonal({
+        network,
+        message,
+        address,
+        pin: pinHash,
+        ...email && { email }
+      })
+    );
     return result.signature;
   }
   /**
@@ -452,15 +547,18 @@ var AbcEvmProvider = class extends EventEmitter {
         "Address does not match connected wallet"
       );
     }
-    const api = this.talkenApi || getTalkenApiClient();
+    const api = this.getTalkenApiClientOrThrow();
     const network = getNetworkName(this.chainId);
-    const pinHash = localStorage.getItem("talkenkit_abc_pin_hash") || void 0;
-    const result = await api.evm.signTypedData({
-      network,
-      typedData: typeof typedData === "string" ? typedData : JSON.stringify(typedData),
-      pin: pinHash,
-      email: this.wallet.email
-    });
+    const pinHash = getCredentialManager().getPinHash() || void 0;
+    const email = this.getRecoveryEmail();
+    const result = await this.withSigningCredentialRetry(
+      () => api.evm.signTypedData({
+        network,
+        typedData: typeof typedData === "string" ? typedData : JSON.stringify(typedData),
+        pin: pinHash,
+        ...email && { email }
+      })
+    );
     return result.signature;
   }
   /**
@@ -507,21 +605,25 @@ var AbcEvmProvider = class extends EventEmitter {
       );
     }
     await this.callInterceptor("eth_signAuthorization", params);
-    const api = this.talkenApi || getTalkenApiClient();
+    const api = this.getTalkenApiClientOrThrow();
     const network = getNetworkName(this.chainId);
-    const pinHash = localStorage.getItem("talkenkit_abc_pin_hash") || void 0;
+    const pinHash = getCredentialManager().getPinHash() || void 0;
+    const email = this.getRecoveryEmail();
     const chainIdValue = typeof authorization.chainId === "string" ? Number(BigInt(authorization.chainId)) : Number(authorization.chainId);
     const nonceValue = typeof authorization.nonce === "string" ? BigInt(authorization.nonce).toString() : String(authorization.nonce);
-    const result = await api.evm.signAuthorization({
-      network,
-      authorization: {
-        chainId: chainIdValue,
-        address: authorization.address,
-        nonce: nonceValue
-      },
-      pin: pinHash,
-      email: this.wallet.email
-    });
+    const authAddress = authorization.address;
+    const result = await this.withSigningCredentialRetry(
+      () => api.evm.signAuthorization({
+        network,
+        authorization: {
+          chainId: chainIdValue,
+          address: authAddress,
+          nonce: nonceValue
+        },
+        pin: pinHash,
+        ...email && { email }
+      })
+    );
     return result.authorization;
   }
   /**
@@ -566,10 +668,15 @@ var AbcEvmProvider = class extends EventEmitter {
     }
     const currentChainId = this.chainId;
     try {
-      const nonce = await this.client.getTransactionCount({
-        chainId: currentChainId,
+      const api = this.getTalkenApiClientOrThrow();
+      const response = await api.evm.getNonce(
+        getNetworkName(currentChainId),
         address
-      });
+      );
+      const nonce = response.result !== void 0 ? typeof response.result === "number" ? `0x${response.result.toString(16)}` : response.result : void 0;
+      if (!nonce) {
+        throw new Error("No result in nonce response");
+      }
       return nonce;
     } catch (error) {
       console.error(
@@ -601,14 +708,17 @@ var AbcEvmProvider = class extends EventEmitter {
       );
     }
     try {
-      const gasLimit = await this.client.estimateGas({
-        chainId: this.chainId,
-        from: tx.from || this.wallet?.address,
+      const response = await this.getTalkenApiClientOrThrow().evm.estimateGas({
+        network: getNetworkName(this.chainId),
+        from: tx.from || this.wallet?.address || "",
         to: tx.to,
         value: tx.value,
         data: tx.data
       });
-      return gasLimit;
+      if (!response.result) {
+        throw new Error("No result in gas estimate response");
+      }
+      return response.result;
     } catch (error) {
       console.warn(
         "[AbcEvmProvider] Gas estimation failed, using fallback:",
@@ -639,12 +749,8 @@ var AbcEvmProvider = class extends EventEmitter {
     return this.chainId;
   }
 };
-function createAbcEvmProvider(client, talkenApi) {
-  const provider = new AbcEvmProvider(client);
-  if (talkenApi) {
-    provider.setTalkenApi(talkenApi);
-  }
-  return provider;
+function createAbcEvmProvider(talkenApi) {
+  return new AbcEvmProvider(talkenApi);
 }
 var createAbcProvider = createAbcEvmProvider;