@talken/talkenkit 2.4.30 → 2.5.1

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

@@ -5,54 +5,59 @@ import {
   fetchWithSessionCheck,
   handleUnauthorizedResponse,
   refreshAccessToken
-} from "../chunk-ACLPF2UW.js";
+} from "../chunk-LIGH2LEU.js";
 import {
   generateMpcWallets,
   recoverMpcWallets,
   validateMpcWallets
-} from "../chunk-JADQLTFW.js";
-import {
-  AbcTronProvider,
-  TRON_NETWORKS,
-  TronProviderError
-} from "../chunk-YV6IZWGE.js";
-import {
-  AbcBitcoinConnector,
-  createAbcBitcoinConnector
-} from "../chunk-BXH3GDX5.js";
-import {
-  AbcBitcoinProvider,
-  BITCOIN_NETWORKS,
-  BitcoinProviderError
-} from "../chunk-3LF7FVL6.js";
+} from "../chunk-H2AZTZMM.js";
 import {
   AbcSolanaProvider,
   SolanaProviderError
-} from "../chunk-IN3HEGZM.js";
+} from "../chunk-645DT4TS.js";
 import "../chunk-JGXJY3SB.js";
+import {
+  GasApi
+} from "../chunk-YPM7FC4M.js";
 import {
   SolanaApi
 } from "../chunk-OTLZVWY7.js";
 import {
   WalletscanApi
-} from "../chunk-NULM3THX.js";
+} from "../chunk-HWRZGGGN.js";
 import {
   TokenApi
-} from "../chunk-MO2AXXLI.js";
-import {
-  GasApi
-} from "../chunk-YPM7FC4M.js";
+} from "../chunk-FKI5AZVH.js";
 import {
   ConfigApi
-} from "../chunk-VDWJ3NQ5.js";
+} from "../chunk-25ZDAJ3L.js";
+import {
+  AbcTronProvider,
+  TRON_NETWORKS,
+  TronProviderError
+} from "../chunk-URS2KVYK.js";
+import {
+  AbcBitcoinConnector,
+  createAbcBitcoinConnector
+} from "../chunk-YKFI6ZGM.js";
+import {
+  AbcBitcoinProvider,
+  BITCOIN_NETWORKS,
+  BitcoinProviderError
+} from "../chunk-RGYZNNB6.js";
 import {
   abcWallet
-} from "../chunk-XNA5NIFE.js";
+} from "../chunk-6TAU7OQK.js";
 import {
   abcConnector
-} from "../chunk-HHZ3JZRH.js";
+} from "../chunk-4YEALKXG.js";
 import "../chunk-R6ZE7JAZ.js";
 import "../chunk-GFWUFYT2.js";
+import {
+  TalkenApiClient,
+  createTalkenApiClient
+} from "../chunk-KIYXONNH.js";
+import "../chunk-4JZPP3S7.js";
 import {
   BitcoinNetwork,
   SolanaNetwork,
@@ -66,7 +71,8 @@ import {
   AbcEvmProvider,
   createAbcEvmProvider,
   createAbcProvider
-} from "../chunk-OMOYFHBT.js";
+} from "../chunk-L6FCF3FH.js";
+import "../chunk-OASBABPG.js";
 import {
   calculateExpiryTimestamp,
   clearAuthState,
@@ -84,11 +90,7 @@ import {
   saveToStorage,
   validateEmail,
   validatePin
-} from "../chunk-A66MTFML.js";
-import {
-  TalkenApiClient,
-  createTalkenApiClient
-} from "../chunk-BHEVY4QY.js";
+} from "../chunk-PF65YS3T.js";
 import {
   AbcError,
   AbcErrorCode,
@@ -96,7 +98,7 @@ import {
 } from "../chunk-4P3SPC44.js";
 import {
   getCredentialManager
-} from "../chunk-6WF4SXLB.js";
+} from "../chunk-QKK3OPQA.js";
 import {
   ABC_EVENTS,
   ABC_FEATURES,
@@ -118,7 +120,7 @@ import {
   STORAGE_VERSION,
   SUCCESS_MESSAGES,
   TOKEN_EXPIRY
-} from "../chunk-DPTDOCWL.js";
+} from "../chunk-RX2VOIUB.js";
 export {
   ABC_EVENTS,
   ABC_FEATURES,

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

@@ -5,8 +5,8 @@ import {
   fetchWithSessionCheck,
   handleUnauthorizedResponse,
   refreshAccessToken
-} from "../chunk-ACLPF2UW.js";
-import "../chunk-DPTDOCWL.js";
+} from "../chunk-LIGH2LEU.js";
+import "../chunk-RX2VOIUB.js";
 export {
   SessionExpiredError,
   dispatchSessionExpired,

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

@@ -40,6 +40,8 @@ export interface AbcWalletConfig {
     defaultBitcoinNetwork?: BitcoinNetwork;
     /** Project identifier */
     projectId?: string;
+    /** Access-key for server-side signing (no PIN, used in TG Mini App) */
+    accessKey?: string;
 }
 /**
  * Authentication provider types
@@ -885,6 +887,7 @@ export interface TalkenTxEvmRequest {
     maxFeePerGas?: string;
     maxPriorityFeePerGas?: string;
     email?: string;
+    waitForReceipt?: boolean;
 }
 export interface TalkenTxSvmRequest {
     toAddress: string;
@@ -895,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';
@@ -956,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-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
+};