@talken/talkenkit 2.5.0 → 2.5.2

package/dist/wallets/walletConnectors/abcWallet/types.d.ts

@@ -887,6 +887,7 @@ export interface TalkenTxEvmRequest {
     maxFeePerGas?: string;
     maxPriorityFeePerGas?: string;
     email?: string;
+    waitForReceipt?: boolean;
 }
 export interface TalkenTxSvmRequest {
     toAddress: string;
@@ -897,6 +898,7 @@ export interface TalkenTxSvmRequest {
     mintAddress?: string;
     amount?: string;
     decimals?: number;
+    waitForConfirmation?: boolean;
 }
 export type TalkenBtcNetwork = 'bitcoin' | 'bitcoin_testnet';
 export type TalkenBtcAction = 'transfer' | 'generate' | 'signHash' | 'finalize';
@@ -958,9 +960,16 @@ export interface TalkenTxTvmRequest {
     confirmMaxAttempts?: number;
     email?: string;
 }
+export interface TalkenTxReceipt {
+    status: number | null;
+    blockNumber: number | null;
+    gasUsed: string | null;
+}
 export interface TalkenTxResponse {
     txHash: string;
     rawTransaction?: string;
+    receipt?: TalkenTxReceipt;
+    confirmation?: any;
 }
 export interface TalkenGasEstimateRequest {
     network: string;

package/dist/wallets/walletConnectors/abcWallet/utils.js

@@ -16,9 +16,9 @@ import {
   saveToStorage,
   validateEmail,
   validatePin
-} from "../chunk-A66MTFML.js";
+} from "../chunk-PF65YS3T.js";
 import "../chunk-4P3SPC44.js";
-import "../chunk-DPTDOCWL.js";
+import "../chunk-RX2VOIUB.js";
 export {
   calculateExpiryTimestamp,
   clearAuthState,

package/dist/wallets/walletConnectors/abcWallet/walletGeneration.js

@@ -3,11 +3,11 @@ import {
   generateMpcWallets,
   recoverMpcWallets,
   validateMpcWallets
-} from "../chunk-JADQLTFW.js";
+} from "../chunk-H2AZTZMM.js";
 import "../chunk-O4AU63LK.js";
 import "../chunk-4P3SPC44.js";
-import "../chunk-6WF4SXLB.js";
-import "../chunk-DPTDOCWL.js";
+import "../chunk-QKK3OPQA.js";
+import "../chunk-RX2VOIUB.js";
 export {
   generateMpcWallets,
   recoverMpcWallets,

package/dist/wallets/walletConnectors/{chunk-VDWJ3NQ5.js → chunk-25ZDAJ3L.js}

@@ -1,7 +1,7 @@
 "use client";
 import {
   TALKEN_API_ENDPOINTS
-} from "./chunk-DPTDOCWL.js";
+} from "./chunk-RX2VOIUB.js";
 
 // src/wallets/walletConnectors/abcWallet/api/ConfigApi.ts
 import { getTalkenApiClient } from "@talken/talkenkit";

package/dist/wallets/walletConnectors/{chunk-HWXOTEC3.js → chunk-2A5XTST5.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-GFWUFYT2.js";
 import {
   AbcAccessKeyProvider
-} from "./chunk-S2SQYPGR.js";
+} from "./chunk-4JZPP3S7.js";
 import {
   setGlobalDefaultBitcoinNetwork,
   setGlobalDefaultChainId,
@@ -15,20 +15,20 @@ import {
 } from "./chunk-O4AU63LK.js";
 import {
   createAbcEvmProvider
-} from "./chunk-TQHS6APN.js";
+} from "./chunk-L6FCF3FH.js";
 import {
   clearAuthState,
   clearStorage,
   loadAuthState,
   loadFromStorage,
   saveAuthState
-} from "./chunk-A66MTFML.js";
+} from "./chunk-PF65YS3T.js";
 import {
   createTalkenApiClient
-} from "./chunk-BHEVY4QY.js";
+} from "./chunk-NP5PWUVU.js";
 import {
   getCredentialManager
-} from "./chunk-6WF4SXLB.js";
+} from "./chunk-QKK3OPQA.js";
 
 // src/wallets/walletConnectors/abcWallet/abcConnector.ts
 import { getTalkenApiClient } from "@talken/talkenkit";
@@ -73,13 +73,59 @@ function abcConnector(options) {
           if (!authState || !authState.isAuthenticated || !authState.wallet) {
             throw new Error("ABC_LOGIN_REQUIRED");
           }
-          provider.setWallet(authState.wallet);
-          if (authState.accessToken && authState.refreshToken && authState.expiresAt) {
-            talkenApi.setTokens(
-              authState.accessToken,
-              authState.refreshToken,
-              authState.expiresAt
-            );
+          if (isAccessKeyMode) {
+            let w = authState.wallet;
+            if (!w.uid || !w.sessionId) {
+              try {
+                const apiUrl = resolveTalkenApiUrl(config.talkenApiUrl);
+                const res = await fetch(`${apiUrl}/wallet/mpc`, {
+                  method: "POST",
+                  headers: {
+                    "Content-Type": "application/json",
+                    "X-Access-Key": config.accessKey
+                  },
+                  body: JSON.stringify({ action: "info" })
+                });
+                const data = await res.json();
+                const acct = data?.data?.accounts?.[0] || data?.data;
+                if (acct?.ethAddress || acct?.address) {
+                  w = {
+                    address: acct.ethAddress || acct.address || w.address,
+                    chainId: w.chainId || config.defaultChainId || 1,
+                    uid: acct.uid || data?.data?.uid || "",
+                    sessionId: acct.sid || acct.sessionId || "",
+                    keyId: acct.keyId || (acct.wid != null ? String(acct.wid) : "") || (data?.data?.wid != null ? String(data.data.wid) : ""),
+                    encryptedShare: acct.encryptedShare || acct.pvencstr || "",
+                    sid: acct.sid || "",
+                    type: "evm",
+                    email: authState.user?.email || acct.email || data?.data?.email || ""
+                  };
+                  saveAuthState({ ...authState, wallet: w });
+                }
+              } catch (_) {
+              }
+            }
+            const fullWallet = {
+              address: w.address,
+              chainId: w.chainId || config.defaultChainId || 1,
+              uid: w.uid || "",
+              sessionId: w.sessionId || "",
+              keyId: w.keyId || "",
+              encryptedShare: w.encryptedShare || "",
+              sid: w.sid || "",
+              type: "evm",
+              email: w.email || authState.user?.email || ""
+            };
+            provider.setWallet(fullWallet);
+          } else {
+            provider.setWallet(authState.wallet);
+            if (authState.accessToken && authState.refreshToken && authState.expiresAt) {
+              talkenApi.setTokens(
+                authState.accessToken,
+                authState.refreshToken,
+                authState.expiresAt
+              );
+            }
           }
           const accounts = await provider.request({
             method: "eth_requestAccounts"
@@ -200,8 +246,12 @@ function abcConnector(options) {
        */
       async isAuthorized() {
         try {
-          if (isAccessKeyMode && provider.isConnected()) {
-            return true;
+          if (isAccessKeyMode) {
+            if (provider.isConnected())
+              return true;
+            const hasKey = !!config.accessKey || typeof localStorage !== "undefined" && !!localStorage.getItem("talken_ak");
+            const authState2 = loadAuthState();
+            return hasKey && !!authState2?.wallet?.address;
           }
           const authState = loadAuthState();
           if (!authState || !authState.isAuthenticated) {

package/dist/wallets/walletConnectors/chunk-4JZPP3S7.js

@@ -0,0 +1,380 @@
+"use client";
+import {
+  getChainKey,
+  getNetworkName
+} from "./chunk-OASBABPG.js";
+import {
+  hexToNumber,
+  numberToHex
+} from "./chunk-PF65YS3T.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,
+  INVALID_PARAMS: -32602,
+  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_signAuthorization":
+        return this.signAuthorization(params);
+      case "eth_estimateGas":
+        return this.estimateGas(params);
+      case "eth_getTransactionCount":
+        return this.getTransactionCount(params);
+      case "eth_call":
+        return this.ethCall(params);
+      case "eth_getBalance":
+        return this.getBalance(params);
+      case "wallet_getCapabilities":
+        return {
+          supportsTypedDataV4: true,
+          supports7702Authorization: true,
+          supports5792Batch: false,
+          supportsPaymasterService: false,
+          supportsPermit2RelayHints: true,
+          walletType: "abc-embedded"
+        };
+      default:
+        throw new ProviderRpcError(
+          ErrorCode.UNSUPPORTED_METHOD,
+          `Method not supported: ${method}`
+        );
+    }
+  }
+  // ── Signing (same endpoints as AbcEvmProvider, no PIN) ────
+  /**
+   * Send transaction via POST /wallet/tx/evm
+   * PIN/email auto-injected server-side from access-key delegated credentials.
+   */
+  async sendTransaction(params) {
+    this.ensureWallet();
+    const tx = params?.[0];
+    if (!tx) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Missing transaction params"
+      );
+    }
+    if (!tx.to) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Contract deployment (missing `to`) is not supported in access-key mode"
+      );
+    }
+    const chainKey = getChainKey(this.chainId);
+    const hexValue = tx.value || "0x0";
+    const amountWei = BigInt(hexValue).toString();
+    const result = await this.apiPost("/wallet/tx/evm", {
+      chainKey,
+      to: tx.to,
+      amountWei,
+      data: tx.data || "0x",
+      ...tx.gas && { gasLimit: tx.gas },
+      ...tx.gasLimit && { gasLimit: tx.gasLimit },
+      ...tx.maxFeePerGas && { maxFeePerGas: tx.maxFeePerGas },
+      ...tx.maxPriorityFeePerGas && {
+        maxPriorityFeePerGas: tx.maxPriorityFeePerGas
+      }
+      // No pin, no email — auto-injected by enrichWithDelegatedCredentials
+    });
+    return result?.txHash || result?.hash;
+  }
+  /**
+   * Personal sign via POST /wallet/sign/evm/personal
+   */
+  async personalSign(params) {
+    const wallet = this.ensureWallet();
+    const p = params;
+    if (!Array.isArray(p) || p.length < 2) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid personal_sign params"
+      );
+    }
+    const [message, address] = p;
+    if (address && address.toLowerCase() !== wallet.address.toLowerCase()) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        `Address mismatch: requested ${address}, connected ${wallet.address}`
+      );
+    }
+    const network = getNetworkName(this.chainId);
+    const result = await this.apiPost("/wallet/sign/evm/personal", {
+      network,
+      message,
+      address: wallet.address
+      // No pin — auto-injected
+    });
+    return result?.signature ?? result?.serializedTx ?? "";
+  }
+  /**
+   * Sign typed data via POST /wallet/sign/evm/typed
+   */
+  async signTypedData(params) {
+    const wallet = this.ensureWallet();
+    const p = params;
+    if (!Array.isArray(p) || p.length < 2) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid signTypedData params"
+      );
+    }
+    const [address, typedData] = p;
+    if (address && address.toLowerCase() !== wallet.address.toLowerCase()) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        `Address mismatch: requested ${address}, connected ${wallet.address}`
+      );
+    }
+    const network = getNetworkName(this.chainId);
+    const result = await this.apiPost("/wallet/sign/evm/typed", {
+      network,
+      typedData: typeof typedData === "string" ? typedData : JSON.stringify(typedData)
+      // No pin — auto-injected
+    });
+    return result?.signature;
+  }
+  /**
+   * Sign EIP-7702 authorization via POST /wallet/sign/authorization
+   * Params: [address, authorization] — matches PIN mode (abcProvider.ts)
+   */
+  async signAuthorization(params) {
+    const wallet = this.ensureWallet();
+    const p = params;
+    if (!Array.isArray(p) || p.length < 2) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Expected [address, authorization]"
+      );
+    }
+    const [address, auth] = p;
+    if (address && address.toLowerCase() !== wallet.address.toLowerCase()) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        `Address mismatch: requested ${address}, connected ${wallet.address}`
+      );
+    }
+    if (!auth) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Missing authorization object"
+      );
+    }
+    const network = getNetworkName(this.chainId);
+    const result = await this.apiPost("/wallet/sign/authorization", {
+      network,
+      authorization: {
+        chainId: auth.chainId,
+        address: auth.address,
+        nonce: auth.nonce?.toString()
+      }
+      // No pin — auto-injected
+    });
+    return result?.authorization || result;
+  }
+  // ── Helpers ───────────────────────────────────────────────
+  ensureWallet() {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    return this.wallet;
+  }
+  /** GET /wallet/address/balance — API uses `network` param (WaaS network name) */
+  async getBalance(params) {
+    const p = params;
+    const address = p?.[0] || this.wallet?.address;
+    const network = getNetworkName(this.chainId);
+    const result = await this.apiGet(
+      `/wallet/address/balance?network=${network}&address=${address}`
+    );
+    return result?.balance ?? "0x0";
+  }
+  /** GET /wallet/nonce — API uses `network` param (WaaS network name) */
+  async getTransactionCount(params) {
+    const p = params;
+    const address = p?.[0] || this.wallet?.address;
+    const network = getNetworkName(this.chainId);
+    const result = await this.apiGet(
+      `/wallet/nonce?network=${network}&address=${address}`
+    );
+    const nonce = result?.nonce ?? 0;
+    return `0x${Number(nonce).toString(16)}`;
+  }
+  /** POST /wallet/contract/eth-call */
+  async ethCall(params) {
+    const p = params;
+    const tx = p?.[0];
+    const network = getNetworkName(this.chainId);
+    const result = await this.apiPost("/wallet/contract/eth-call", {
+      network,
+      to: tx?.to,
+      data: tx?.data,
+      from: tx?.from || this.wallet?.address
+    });
+    return result?.result ?? result?.data ?? "0x";
+  }
+  /** POST /wallet/tx/evm with dry-run for gas estimation */
+  async estimateGas(params) {
+    const p = params;
+    const tx = p?.[0];
+    try {
+      const result = await this.apiPost("/wallet/contract/eth-call", {
+        network: getNetworkName(this.chainId),
+        to: tx?.to,
+        data: tx?.data,
+        from: tx?.from || this.wallet?.address,
+        value: tx?.value,
+        estimateGas: true
+      });
+      return result?.gasEstimate ?? result?.gas ?? "0x5208";
+    } catch {
+      return "0x5208";
+    }
+  }
+  async apiGet(path) {
+    const url = `${this.apiBaseUrl}${path}`;
+    const res = await fetch(url, {
+      headers: { "X-Access-Key": this.accessKey }
+    });
+    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 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;
+  }
+};
+
+export {
+  AbcAccessKeyProvider
+};

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

@@ -1,16 +1,16 @@
 "use client";
 import {
   abcConnector
-} from "./chunk-HWXOTEC3.js";
+} from "./chunk-BRXYKYKT.js";
 import {
   resolveTalkenApiUrl
 } from "./chunk-GFWUFYT2.js";
 import {
   createTalkenApiClient
-} from "./chunk-BHEVY4QY.js";
+} from "./chunk-NP5PWUVU.js";
 import {
   ABC_WALLET_METADATA
-} from "./chunk-DPTDOCWL.js";
+} from "./chunk-RX2VOIUB.js";
 
 // src/wallets/walletConnectors/abcWallet/abcWallet.ts
 import { setTalkenApiClient } from "@talken/talkenkit";

package/dist/wallets/walletConnectors/{chunk-IN3HEGZM.js → chunk-645DT4TS.js}

@@ -1,13 +1,17 @@
 "use client";
 import {
   WalletscanApi
-} from "./chunk-NULM3THX.js";
+} from "./chunk-HWRZGGGN.js";
 import {
   getCredentialManager
-} from "./chunk-6WF4SXLB.js";
+} from "./chunk-QKK3OPQA.js";
 
 // src/wallets/walletConnectors/abcWallet/abcSolanaProvider.ts
-import { getTalkenApiClient } from "@talken/talkenkit";
+import {
+  getShowPendingTransaction,
+  getTalkenApiClient,
+  getUpdateTransactionResult
+} from "@talken/talkenkit";
 
 // src/utils/apiClientFactory.ts
 function createWalletscanApi() {
@@ -331,6 +335,15 @@ var AbcSolanaProvider = class extends EventEmitter {
       });
       const api = this.getTalkenApiClientOrThrow();
       const apiNetwork = this.wallet.network === "solana" ? "solana" : "solana_devnet";
+      const showPending = getShowPendingTransaction();
+      if (showPending) {
+        showPending({
+          txHash: "",
+          network: apiNetwork,
+          chain: "solana",
+          explorerUrl: void 0
+        });
+      }
       if (params.mintAddress) {
         const walletscanApi = createWalletscanApi();
         const tokenMeta = await walletscanApi.getContractTokenWithTimeout({
@@ -346,9 +359,11 @@ var AbcSolanaProvider = class extends EventEmitter {
           amount: String(rawAmount),
           decimals,
           network: apiNetwork,
-          pin: pinHash
+          pin: pinHash,
+          waitForConfirmation: true
         });
         console.log("[AbcSolanaProvider] SPL transfer result:", result2);
+        this.updateTransactionResult(result2, apiNetwork);
         return { signature: result2.txHash };
       }
       const { LAMPORTS_PER_SOL } = await import("@solana/web3.js");
@@ -363,9 +378,11 @@ var AbcSolanaProvider = class extends EventEmitter {
         toAddress: params.toAddress,
         amountLamports: String(amountLamports),
         network: apiNetwork,
-        pin: pinHash
+        pin: pinHash,
+        waitForConfirmation: true
       });
       console.log("[AbcSolanaProvider] native transfer result:", result);
+      this.updateTransactionResult(result, apiNetwork);
       return { signature: result.txHash };
     } catch (error) {
       console.error("[AbcSolanaProvider] transfer FAILED:", {
@@ -438,6 +455,30 @@ var AbcSolanaProvider = class extends EventEmitter {
       );
     }
   }
+  updateTransactionResult(result, network) {
+    const updateResult = getUpdateTransactionResult();
+    if (!updateResult)
+      return;
+    let receipt = result.receipt;
+    if (!receipt && result.confirmation) {
+      const data = result.confirmation?.data?.result ?? result.confirmation?.result ?? result.confirmation;
+      const slot = data?.slot;
+      const meta = data?.meta;
+      receipt = {
+        status: meta?.err === null ? 1 : 0,
+        blockNumber: slot ?? null,
+        gasUsed: meta?.fee != null ? String(meta.fee) : null
+      };
+    }
+    const cluster = network.includes("devnet") ? "?cluster=devnet" : "";
+    updateResult({
+      txHash: result.txHash,
+      network,
+      chain: "solana",
+      receipt,
+      explorerUrl: `https://explorer.solana.com/tx/${result.txHash}${cluster}`
+    });
+  }
 };
 
 export {