@talken/talkenkit 2.5.0 → 2.5.1

package/dist/{chunk-REVMSQIO.js → chunk-UHZL3WSM.js}

@@ -7,7 +7,7 @@ import {
   TALKEN_API_ENDPOINTS,
   TOKEN_EXPIRY,
   getCredentialManager
-} from "./chunk-ALBABQ53.js";
+} from "./chunk-PN6K4CMZ.js";
 
 // src/wallets/walletConnectors/abcWallet/abcWallet.ts
 import { setTalkenApiClient as setTalkenApiClient2 } from "@talken/talkenkit";
@@ -1092,6 +1092,7 @@ var ErrorCode = {
   UNAUTHORIZED: 4100,
   UNSUPPORTED_METHOD: 4200,
   DISCONNECTED: 4900,
+  INVALID_PARAMS: -32602,
   INTERNAL_ERROR: -32603
 };
 var ProviderRpcError = class extends Error {
@@ -1157,77 +1158,240 @@ var AbcAccessKeyProvider = class extends EventEmitter {
       case "eth_signTypedData":
       case "eth_signTypedData_v4":
         return this.signTypedData(params);
+      case "eth_signAuthorization":
+        return this.signAuthorization(params);
       case "eth_estimateGas":
-        return this.rpcCall("eth_estimateGas", params);
+        return this.estimateGas(params);
       case "eth_getTransactionCount":
-        return this.rpcCall("eth_getTransactionCount", params);
+        return this.getTransactionCount(params);
+      case "eth_call":
+        return this.ethCall(params);
+      case "eth_getBalance":
+        return this.getBalance(params);
       case "wallet_getCapabilities":
-        return {};
+        return {
+          supportsTypedDataV4: true,
+          supports7702Authorization: true,
+          supports5792Batch: false,
+          supportsPaymasterService: false,
+          supportsPermit2RelayHints: true,
+          walletType: "abc-embedded"
+        };
       default:
-        return this.rpcCall(method, params);
+        throw new ProviderRpcError(
+          ErrorCode.UNSUPPORTED_METHOD,
+          `Method not supported: ${method}`
+        );
     }
   }
-  // ── Signing via access-key (server-side, no PIN) ──────────
+  // ── 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) {
-    if (!this.wallet) {
-      throw new ProviderRpcError(
-        ErrorCode.UNAUTHORIZED,
-        "Wallet not connected"
-      );
-    }
+    this.ensureWallet();
     const tx = params?.[0];
     if (!tx) {
       throw new ProviderRpcError(
-        ErrorCode.INTERNAL_ERROR,
+        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 result = await this.apiPost("/tx/relay-execute", {
+    const hexValue = tx.value || "0x0";
+    const amountWei = BigInt(hexValue).toString();
+    const result = await this.apiPost("/wallet/tx/evm", {
       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" }
+      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) {
-    if (!this.wallet) {
+    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,
-        "Wallet not connected"
+        `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;
-    const message = p?.[0];
-    const result = await this.apiPost("/agent/sessions/sign", {
-      operation: "signMessage",
-      chainId: this.chainId,
-      payload: { message }
+    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;
   }
-  async signTypedData(params) {
+  /**
+   * 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 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
+    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?.signature;
+    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;
   }
-  // ── HTTP helpers ──────────────────────────────────────────
   async apiPost(path, body) {
     const url = `${this.apiBaseUrl}${path}`;
     const res = await fetch(url, {
@@ -1248,15 +1412,14 @@ var AbcAccessKeyProvider = class extends EventEmitter {
     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;
-  }
 };
 
 // src/wallets/walletConnectors/abcWallet/abcProvider.ts
-import { getTalkenApiClient } from "@talken/talkenkit";
+import {
+  getShowPendingTransaction,
+  getTalkenApiClient,
+  getUpdateTransactionResult
+} from "@talken/talkenkit";
 import { parseGwei } from "viem";
 var EventEmitter2 = class {
   constructor() {
@@ -1501,10 +1664,12 @@ var AbcEvmProvider = class extends EventEmitter2 {
         return this.eth_getTransactionCount(
           Array.isArray(params) ? params : []
         );
-      case "eth_blockNumber":
       case "eth_call":
-      case "eth_gasPrice":
+        return this.eth_call(params);
       case "eth_getBalance":
+        return this.eth_getBalance(params);
+      case "eth_blockNumber":
+      case "eth_gasPrice":
       case "eth_getBlockByHash":
       case "eth_getBlockByNumber":
       case "eth_getCode":
@@ -1627,10 +1792,20 @@ var AbcEvmProvider = class extends EventEmitter2 {
     const hexValue = tx.value || "0x0";
     const amountWei = BigInt(hexValue).toString();
     const email = this.getRecoveryEmail();
+    const chainKey = getChainKey(this.chainId);
+    const showPending = getShowPendingTransaction();
+    if (showPending) {
+      showPending({
+        txHash: "",
+        network: chainKey,
+        chain: "evm",
+        explorerUrl: void 0
+      });
+    }
     const api = this.getTalkenApiClientOrThrow();
     const result = await this.withSigningCredentialRetry(
       () => api.evm.sendTransaction({
-        chainKey: getChainKey(this.chainId),
+        chainKey,
         to: tx.to,
         amountWei,
         pin: pinHash,
@@ -1638,9 +1813,20 @@ var AbcEvmProvider = class extends EventEmitter2 {
         gasLimit: tx.gas || tx.gasLimit,
         maxFeePerGas: tx.maxFeePerGas,
         maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+        waitForReceipt: true,
         ...email && { email }
       })
     );
+    const updateResult = getUpdateTransactionResult();
+    if (updateResult) {
+      updateResult({
+        txHash: result.txHash,
+        network: chainKey,
+        chain: "evm",
+        receipt: result.receipt ?? null,
+        explorerUrl: getExplorerTxUrl(this.chainId, result.txHash)
+      });
+    }
     return result.txHash;
   }
   /**
@@ -1971,6 +2157,60 @@ var AbcEvmProvider = class extends EventEmitter2 {
       return "0x5208";
     }
   }
+  /**
+   * Execute read-only eth_call via talken-api
+   */
+  async eth_call(params) {
+    const p = Array.isArray(params) ? params : [];
+    const tx = p[0];
+    if (!tx?.to || !tx?.data) {
+      throw new ProviderRpcError2(
+        ErrorCode2.INVALID_PARAMS,
+        "eth_call requires to and data"
+      );
+    }
+    try {
+      const api = this.getTalkenApiClientOrThrow();
+      const response = await api.evm.ethCall({
+        network: getNetworkName(this.chainId),
+        to: tx.to,
+        data: tx.data,
+        from: tx.from || this.wallet?.address
+      });
+      return response?.result ?? response?.data ?? "0x";
+    } catch (error) {
+      throw new ProviderRpcError2(
+        ErrorCode2.INTERNAL_ERROR,
+        `eth_call failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Get native balance via talken-api
+   */
+  async eth_getBalance(params) {
+    const p = Array.isArray(params) ? params : [];
+    const address = p[0] || this.wallet?.address;
+    if (!address) {
+      throw new ProviderRpcError2(
+        ErrorCode2.INVALID_PARAMS,
+        "Missing address parameter"
+      );
+    }
+    try {
+      const api = this.getTalkenApiClientOrThrow();
+      const response = await api.evm.getBalance(
+        getNetworkName(this.chainId),
+        address
+      );
+      return response?.balance ?? "0x0";
+    } catch (error) {
+      throw new ProviderRpcError2(
+        ErrorCode2.INTERNAL_ERROR,
+        `eth_getBalance failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   /**
    * Check if connected
    */
@@ -2349,6 +2589,21 @@ var TalkenEvmModule = class {
     const qs = new URLSearchParams({ network, address }).toString();
     return this.client.get(`${TALKEN_API_ENDPOINTS.NONCE}?${qs}`);
   }
+  /**
+   * Get native balance for address
+   * GET /wallet/address/balance?network=&address=
+   */
+  async getBalance(network, address) {
+    const qs = new URLSearchParams({ network, address }).toString();
+    return this.client.get(`${TALKEN_API_ENDPOINTS.ADDRESS_BALANCE}?${qs}`);
+  }
+  /**
+   * Execute read-only eth_call
+   * POST /wallet/contract/eth-call { network, to, data, from? }
+   */
+  async ethCall(params) {
+    return this.client.post(TALKEN_API_ENDPOINTS.ETH_CALL, params);
+  }
 };
 var TalkenSolanaModule = class {
   constructor(client) {
@@ -2520,6 +2775,24 @@ var TalkenTronModule = class {
       params
     );
   }
+  /**
+   * Get TRON account info (balance, resource, permissions)
+   * GET /wallet/tron?mode=account&network=&address=
+   */
+  async getAccount(network, address) {
+    return this.client.get(
+      `${TALKEN_API_ENDPOINTS.TRON_UTIL}?mode=account&network=${encodeURIComponent(network)}&address=${encodeURIComponent(address)}`
+    );
+  }
+  /**
+   * Get TRC20 token balance
+   * GET /wallet/tron?mode=trc20Balance&network=&address=&contractAddress=
+   */
+  async getTrc20Balance(network, address, contractAddress) {
+    return this.client.get(
+      `${TALKEN_API_ENDPOINTS.TRON_UTIL}?mode=trc20Balance&network=${encodeURIComponent(network)}&address=${encodeURIComponent(address)}&contractAddress=${encodeURIComponent(contractAddress)}`
+    );
+  }
 };
 var TalkenWalletscanModule = class {
   constructor(client) {
@@ -2949,13 +3222,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"
@@ -3076,8 +3395,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) {
@@ -4587,7 +4910,11 @@ function createAbcBitcoinConnector(config) {
 }
 
 // src/wallets/walletConnectors/abcWallet/abcSolanaProvider.ts
-import { getTalkenApiClient as getTalkenApiClient12 } from "@talken/talkenkit";
+import {
+  getShowPendingTransaction as getShowPendingTransaction2,
+  getTalkenApiClient as getTalkenApiClient12,
+  getUpdateTransactionResult as getUpdateTransactionResult2
+} from "@talken/talkenkit";
 
 // src/utils/apiClientFactory.ts
 function createWalletscanApi() {
@@ -4923,6 +5250,15 @@ var AbcSolanaProvider = class extends EventEmitter4 {
       });
       const api = this.getTalkenApiClientOrThrow();
       const apiNetwork = this.wallet.network === "solana" ? "solana" : "solana_devnet";
+      const showPending = getShowPendingTransaction2();
+      if (showPending) {
+        showPending({
+          txHash: "",
+          network: apiNetwork,
+          chain: "solana",
+          explorerUrl: void 0
+        });
+      }
       if (params.mintAddress) {
         const walletscanApi = createWalletscanApi();
         const tokenMeta = await walletscanApi.getContractTokenWithTimeout({
@@ -4938,9 +5274,11 @@ var AbcSolanaProvider = class extends EventEmitter4 {
           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");
@@ -4955,9 +5293,11 @@ var AbcSolanaProvider = class extends EventEmitter4 {
         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:", {
@@ -5030,10 +5370,38 @@ var AbcSolanaProvider = class extends EventEmitter4 {
       );
     }
   }
+  updateTransactionResult(result, network) {
+    const updateResult = getUpdateTransactionResult2();
+    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}`
+    });
+  }
 };
 
 // src/wallets/walletConnectors/abcWallet/abcTronProvider.ts
-import { getTalkenApiClient as getTalkenApiClient13 } from "@talken/talkenkit";
+import {
+  getShowPendingTransaction as getShowPendingTransaction3,
+  getTalkenApiClient as getTalkenApiClient13,
+  getUpdateTransactionResult as getUpdateTransactionResult3
+} from "@talken/talkenkit";
 import { keccak256 } from "viem";
 function isTalkenApiClient2(client) {
   return typeof client?.tron?.transferTrx === "function";
@@ -5354,6 +5722,7 @@ ${msgBytes.length}`
         toAddress: params.toAddress,
         amountSun: amountRaw,
         pin: pinHash,
+        waitForConfirmation: true,
         ...email && { email }
       } : {
         kind: "trc20",
@@ -5363,10 +5732,21 @@ ${msgBytes.length}`
         amount: amountRaw,
         feeLimit: params.feeLimit,
         pin: pinHash,
+        waitForConfirmation: true,
         ...email && { email }
       };
+      const showPending = getShowPendingTransaction3();
+      if (showPending) {
+        showPending({
+          txHash: "",
+          network: this.network.type,
+          chain: "tron",
+          explorerUrl: void 0
+        });
+      }
       const result = await api.tron.transferTrx(request);
       const txHash = result.txHash;
+      this.updateTransactionResult(result);
       console.log(
         `[TronProvider] \u2705 ${txType === "NATIVE" ? "TRX" : "TRC-20"} transaction complete via TalkenApiClient:`,
         txHash
@@ -5413,6 +5793,33 @@ ${msgBytes.length}`
       network: this.network.type
     };
   }
+  updateTransactionResult(result) {
+    const updateResult = getUpdateTransactionResult3();
+    if (!updateResult)
+      return;
+    let receipt = result.receipt;
+    if (!receipt && result.confirmation) {
+      const conf = result.confirmation;
+      const info = conf?.info ?? conf;
+      const tx = conf?.transaction ?? conf;
+      const blockNumber = info?.blockNumber ?? info?.result?.blockNumber ?? null;
+      const rcpt = info?.receipt ?? info?.result?.receipt;
+      const ret = tx?.ret ?? tx?.result?.ret;
+      const contractRet = Array.isArray(ret) ? ret[0]?.contractRet : void 0;
+      receipt = {
+        status: contractRet === "SUCCESS" ? 1 : contractRet ? 0 : null,
+        blockNumber,
+        gasUsed: rcpt?.energy_usage_total != null ? String(rcpt.energy_usage_total) : null
+      };
+    }
+    updateResult({
+      txHash: result.txHash,
+      network: this.network.type,
+      chain: "tron",
+      receipt,
+      explorerUrl: `${this.network.explorer}/#/transaction/${result.txHash}`
+    });
+  }
 };
 
 // src/wallets/walletConnectors/abcWallet/walletGeneration.ts