@moon-x/core 0.13.0 → 0.14.0

package/dist/lib/index.js

@@ -38,11 +38,13 @@ __export(lib_exports, {
   authState: () => authState,
   broadcastEthereumRaw: () => broadcastEthereumRaw,
   broadcastSolanaSigned: () => broadcastSolanaSigned,
+  broadcastTronSigned: () => broadcastTronSigned,
   bs58ToBytes: () => bs58ToBytes,
   buildChainIndex: () => buildChainIndex,
   buildUrl: () => buildUrl,
   canonicalAlgorithmFor: () => canonicalAlgorithmFor,
   createManualSiweMessage: () => createManualSiweMessage,
+  decodeTronRawData: () => decodeTronRawData,
   entryCaip2: () => entryCaip2,
   estimateEvmGas: () => estimateEvmGas,
   estimateEvmGasReserve: () => estimateEvmGasReserve,
@@ -59,6 +61,7 @@ __export(lib_exports, {
   getTransferInfoFromInstructions: () => getTransferInfoFromInstructions,
   isChainSupported: () => isChainSupported,
   isEvmEntry: () => isEvmEntry,
+  isTronEntry: () => isTronEntry,
   normalizeChainItem: () => normalizeChainItem,
   normalizeChainKey: () => normalizeChainKey,
   parseDerivationPath: () => parseDerivationPath,
@@ -70,10 +73,12 @@ __export(lib_exports, {
   resolvePasskeyMetadata: () => resolvePasskeyMetadata,
   resolveRpcUrl: () => resolveRpcUrl,
   resolveSolanaChainEntry: () => resolveSolanaChainEntry,
+  resolveTronChainEntry: () => resolveTronChainEntry,
   resolveWsUrl: () => resolveWsUrl,
   sanitizeUserData: () => sanitizeUserData,
   serializeEthereumTransaction: () => serializeEthereumTransaction,
   toB64url: () => toB64url,
+  tronAddressFromPublicKey: () => tronAddressFromPublicKey,
   validateChainConfig: () => validateChainConfig,
   verifyIdToken: () => verifyIdToken
 });
@@ -515,6 +520,9 @@ function isChainSupported(chains, chainId) {
 function isEvmEntry(entry) {
   return "chain" in entry;
 }
+function isTronEntry(entry) {
+  return !isEvmEntry(entry) && entry.id.split(":")[0].toLowerCase() === "tron";
+}
 function normalizeChainItem(item) {
   if ("chain" in item) return item;
   if (typeof item.id === "number") {
@@ -543,8 +551,14 @@ function aliasesFor(entry) {
     }
   } else {
     keys.push(entry.id);
-    const cluster = entry.id.split(":")[1];
-    if (cluster) keys.push(`solana:${cluster}`, `sol:${cluster}`, cluster);
+    const [ns, cluster] = entry.id.split(":");
+    if (cluster) {
+      if (ns.toLowerCase() === "tron") {
+        keys.push(`tron:${cluster}`, `trx:${cluster}`);
+      } else {
+        keys.push(`solana:${cluster}`, `sol:${cluster}`, cluster);
+      }
+    }
   }
   return keys;
 }
@@ -583,10 +597,20 @@ function resolveSolanaChainEntry(chains, selector, defaultSelector) {
   const asSolana = (k) => {
     if (k == null) return void 0;
     const e = index.byAlias.get(normalizeChainKey(k));
-    return e && !isEvmEntry(e) ? e : void 0;
+    return e && !isEvmEntry(e) && !isTronEntry(e) ? e : void 0;
   };
   if (selector != null) return asSolana(selector);
-  return asSolana(defaultSelector) ?? index.entries.find((e) => !isEvmEntry(e));
+  return asSolana(defaultSelector) ?? index.entries.find((e) => !isEvmEntry(e) && !isTronEntry(e));
+}
+function resolveTronChainEntry(chains, selector, defaultSelector) {
+  const index = buildChainIndex(chains ?? []);
+  const asTron = (k) => {
+    if (k == null) return void 0;
+    const e = index.byAlias.get(normalizeChainKey(k));
+    return e && isTronEntry(e) ? e : void 0;
+  };
+  if (selector != null) return asTron(selector);
+  return asTron(defaultSelector) ?? index.entries.find(isTronEntry);
 }
 function resolveEvmChainEntry(opts) {
   const index = buildChainIndex(opts.chains ?? []);
@@ -1522,6 +1546,195 @@ async function getSOLTransfersFromInstructions(base64Transaction, logs, solPrice
   return transfers;
 }
 
+// src/lib/tron/tron-address.ts
+var import_secp256k1 = require("@noble/curves/secp256k1");
+var import_sha3 = require("@noble/hashes/sha3");
+var import_sha256 = require("@noble/hashes/sha256");
+async function tronAddressFromPublicKey(publicKeyHex) {
+  const { default: bs58 } = await import("bs58");
+  const clean = publicKeyHex.replace(/^0x/, "");
+  const uncompressed = import_secp256k1.secp256k1.ProjectivePoint.fromHex(clean).toRawBytes(
+    false
+  );
+  const hash = (0, import_sha3.keccak_256)(uncompressed.subarray(1));
+  const payload = new Uint8Array(21);
+  payload[0] = 65;
+  payload.set(hash.subarray(12), 1);
+  const checksum = (0, import_sha256.sha256)((0, import_sha256.sha256)(payload)).subarray(0, 4);
+  const full = new Uint8Array(25);
+  full.set(payload);
+  full.set(checksum, 21);
+  return bs58.encode(full);
+}
+
+// src/lib/tron/decode-raw-data.ts
+var import_sha2562 = require("@noble/hashes/sha256");
+function readVarint(buf, pos) {
+  let result = BigInt(0);
+  let shift = BigInt(0);
+  for (; ; ) {
+    const b = buf[pos++];
+    if (b === void 0) throw new Error("truncated varint");
+    result |= BigInt(b & 127) << shift;
+    if ((b & 128) === 0) return [result, pos];
+    shift += BigInt(7);
+  }
+}
+function readFields(buf) {
+  const fields = [];
+  let pos = 0;
+  while (pos < buf.length) {
+    const [tag, p1] = readVarint(buf, pos);
+    const num = Number(tag >> BigInt(3));
+    const wire = Number(tag & BigInt(7));
+    pos = p1;
+    if (wire === 0) {
+      const [v, p2] = readVarint(buf, pos);
+      fields.push({ num, wire, varint: v });
+      pos = p2;
+    } else if (wire === 2) {
+      const [len, p2] = readVarint(buf, pos);
+      const end = p2 + Number(len);
+      if (end > buf.length) throw new Error("truncated field");
+      fields.push({ num, wire, bytes: buf.subarray(p2, end) });
+      pos = end;
+    } else if (wire === 5 || wire === 1) {
+      const n = wire === 5 ? 4 : 8;
+      if (pos + n > buf.length) throw new Error("truncated fixed field");
+      fields.push({ num, wire, bytes: buf.subarray(pos, pos + n) });
+      pos += n;
+    } else {
+      throw new Error(`unsupported wire type ${wire}`);
+    }
+  }
+  return fields;
+}
+var toHex = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+async function addressFromBytes(b) {
+  const { default: bs58 } = await import("bs58");
+  const checksum = (0, import_sha2562.sha256)((0, import_sha2562.sha256)(b)).subarray(0, 4);
+  const full = new Uint8Array(b.length + 4);
+  full.set(b);
+  full.set(checksum, b.length);
+  return bs58.encode(full);
+}
+async function fieldValue(f, addressy) {
+  if (f.wire === 0) return f.varint.toString();
+  const b = f.bytes;
+  if (addressy && b.length === 21 && b[0] === 65) return addressFromBytes(b);
+  return toHex(b);
+}
+var CONTRACT_TYPES = {
+  0: "AccountCreateContract",
+  1: "TransferContract",
+  2: "TransferAssetContract",
+  4: "VoteWitnessContract",
+  11: "FreezeBalanceContract",
+  12: "UnfreezeBalanceContract",
+  13: "WithdrawBalanceContract",
+  31: "TriggerSmartContract",
+  54: "FreezeBalanceV2Contract",
+  55: "UnfreezeBalanceV2Contract",
+  57: "DelegateResourceContract",
+  58: "UnDelegateResourceContract"
+};
+var CONTRACT_FIELDS = {
+  TransferContract: { 1: "owner_address", 2: "to_address", 3: "amount" },
+  TransferAssetContract: {
+    1: "asset_name",
+    2: "owner_address",
+    3: "to_address",
+    4: "amount"
+  },
+  TriggerSmartContract: {
+    1: "owner_address",
+    2: "contract_address",
+    3: "call_value",
+    4: "data",
+    5: "call_token_value",
+    6: "token_id"
+  }
+};
+async function decodeContract(buf) {
+  const out = {};
+  let typeName = "";
+  let anyValue;
+  for (const f of readFields(buf)) {
+    if (f.num === 1 && f.wire === 0) {
+      const n = Number(f.varint);
+      typeName = CONTRACT_TYPES[n] ?? `ContractType(${n})`;
+      out.type = typeName;
+    } else if (f.num === 2 && f.bytes) {
+      for (const a of readFields(f.bytes)) {
+        if (a.num === 1 && a.bytes) {
+          out.type_url = new TextDecoder().decode(a.bytes);
+        } else if (a.num === 2 && a.bytes) {
+          anyValue = a.bytes;
+        }
+      }
+    } else if (f.num === 5) {
+      out.Permission_id = await fieldValue(f, false);
+    }
+  }
+  if (anyValue) {
+    const names = CONTRACT_FIELDS[typeName];
+    if (names) {
+      const value = {};
+      for (const f of readFields(anyValue)) {
+        const name = names[f.num] ?? `field_${f.num}`;
+        value[name] = await fieldValue(f, name.endsWith("_address"));
+      }
+      out.parameter = value;
+    } else {
+      out.parameter_hex = toHex(anyValue);
+    }
+  }
+  return out;
+}
+async function decodeTronRawData(rawDataHex) {
+  const clean = rawDataHex.replace(/^0x/i, "");
+  if (!/^[0-9a-fA-F]*$/.test(clean) || clean.length % 2 !== 0) {
+    throw new Error("raw_data_hex is not valid hex");
+  }
+  const buf = Uint8Array.from(
+    clean.match(/.{2}/g)?.map((h) => parseInt(h, 16)) ?? []
+  );
+  const out = {};
+  const contracts = [];
+  for (const f of readFields(buf)) {
+    switch (f.num) {
+      case 1:
+        out.ref_block_bytes = toHex(f.bytes);
+        break;
+      case 3:
+        out.ref_block_num = f.varint.toString();
+        break;
+      case 4:
+        out.ref_block_hash = toHex(f.bytes);
+        break;
+      case 8:
+        out.expiration = Number(f.varint);
+        break;
+      case 10:
+        out.data = new TextDecoder().decode(f.bytes);
+        break;
+      case 11:
+        contracts.push(await decodeContract(f.bytes));
+        break;
+      case 14:
+        out.timestamp = Number(f.varint);
+        break;
+      case 18:
+        out.fee_limit = f.varint.toString();
+        break;
+      default:
+        out[`field_${f.num}`] = f.wire === 0 ? f.varint.toString() : toHex(f.bytes);
+    }
+  }
+  out.contract = contracts;
+  return out;
+}
+
 // src/lib/build-url.ts
 var buildUrl = (baseUrl, sdkConfig, enableCaptcha, captchaSitekey) => {
   if (!sdkConfig.publishableKey) {
@@ -1664,11 +1877,40 @@ var broadcastSolanaSigned = async (rpcUrl, signedBase58) => {
   }
   return result.result;
 };
+var broadcastTronSigned = async (rpcUrl, signedTransaction) => {
+  const response = await fetch(
+    `${rpcUrl.replace(/\/$/, "")}/wallet/broadcasttransaction`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(signedTransaction)
+    }
+  );
+  const result = await response.json();
+  if (!result.result) {
+    let message = result.message ?? "";
+    if (/^[0-9a-fA-F]+$/.test(message) && message.length % 2 === 0) {
+      try {
+        message = new TextDecoder().decode(
+          Uint8Array.from(
+            message.match(/.{2}/g).map((h) => parseInt(h, 16))
+          )
+        );
+      } catch {
+      }
+    }
+    throw new Error(
+      `Tron broadcast failed: ${result.code ?? "UNKNOWN"} ${message}`.trim()
+    );
+  }
+  return result.txid ?? signedTransaction.txID;
+};
 
 // src/lib/wallet-algorithm.ts
 function canonicalAlgorithmFor(chain) {
   switch (chain) {
     case "ethereum":
+    case "tron":
       return "ecdsa";
     case "solana":
       return "exportable-ed25519";
@@ -1719,11 +1961,13 @@ var bs58ToBytes = async (value) => {
   authState,
   broadcastEthereumRaw,
   broadcastSolanaSigned,
+  broadcastTronSigned,
   bs58ToBytes,
   buildChainIndex,
   buildUrl,
   canonicalAlgorithmFor,
   createManualSiweMessage,
+  decodeTronRawData,
   entryCaip2,
   estimateEvmGas,
   estimateEvmGasReserve,
@@ -1740,6 +1984,7 @@ var bs58ToBytes = async (value) => {
   getTransferInfoFromInstructions,
   isChainSupported,
   isEvmEntry,
+  isTronEntry,
   normalizeChainItem,
   normalizeChainKey,
   parseDerivationPath,
@@ -1751,10 +1996,12 @@ var bs58ToBytes = async (value) => {
   resolvePasskeyMetadata,
   resolveRpcUrl,
   resolveSolanaChainEntry,
+  resolveTronChainEntry,
   resolveWsUrl,
   sanitizeUserData,
   serializeEthereumTransaction,
   toB64url,
+  tronAddressFromPublicKey,
   validateChainConfig,
   verifyIdToken
 });

package/dist/lib/index.mjs

@@ -7,11 +7,13 @@ import {
   authState,
   broadcastEthereumRaw,
   broadcastSolanaSigned,
+  broadcastTronSigned,
   bs58ToBytes,
   buildChainIndex,
   buildUrl,
   canonicalAlgorithmFor,
   createManualSiweMessage,
+  decodeTronRawData,
   entryCaip2,
   estimateEvmGas,
   estimateEvmGasReserve,
@@ -28,6 +30,7 @@ import {
   getTransferInfoFromInstructions,
   isChainSupported,
   isEvmEntry,
+  isTronEntry,
   normalizeChainItem,
   normalizeChainKey,
   parseDerivationPath,
@@ -39,13 +42,15 @@ import {
   resolvePasskeyMetadata,
   resolveRpcUrl,
   resolveSolanaChainEntry,
+  resolveTronChainEntry,
   resolveWsUrl,
   sanitizeUserData,
   serializeEthereumTransaction,
   toB64url,
+  tronAddressFromPublicKey,
   validateChainConfig,
   verifyIdToken
-} from "../chunk-QBEPYAYB.mjs";
+} from "../chunk-7UGU27T3.mjs";
 import "../chunk-LP55IGPN.mjs";
 export {
   DEFAULT_AUTH_URL,
@@ -56,11 +61,13 @@ export {
   authState,
   broadcastEthereumRaw,
   broadcastSolanaSigned,
+  broadcastTronSigned,
   bs58ToBytes,
   buildChainIndex,
   buildUrl,
   canonicalAlgorithmFor,
   createManualSiweMessage,
+  decodeTronRawData,
   entryCaip2,
   estimateEvmGas,
   estimateEvmGasReserve,
@@ -77,6 +84,7 @@ export {
   getTransferInfoFromInstructions,
   isChainSupported,
   isEvmEntry,
+  isTronEntry,
   normalizeChainItem,
   normalizeChainKey,
   parseDerivationPath,
@@ -88,10 +96,12 @@ export {
   resolvePasskeyMetadata,
   resolveRpcUrl,
   resolveSolanaChainEntry,
+  resolveTronChainEntry,
   resolveWsUrl,
   sanitizeUserData,
   serializeEthereumTransaction,
   toB64url,
+  tronAddressFromPublicKey,
   validateChainConfig,
   verifyIdToken
 };

package/dist/react/index.d.mts

@@ -29,9 +29,13 @@ interface MoonXHookSDK {
     sendSolanaTransactionHeadless: (params: unknown) => Promise<unknown>;
     getSolanaBalance: (params: unknown) => Promise<unknown>;
     getSolanaTokenAccountsByOwner?: (params: unknown) => Promise<unknown>;
-    getWallets: (walletType: "ethereum" | "solana") => Promise<unknown>;
-    createWallet: (walletType: "ethereum" | "solana", options?: unknown) => Promise<unknown>;
-    importKey: (walletType: "ethereum" | "solana", key: string) => Promise<unknown>;
+    signTronMessageHeadless?: (params: unknown) => Promise<unknown>;
+    signTronTransactionHeadless?: (params: unknown) => Promise<unknown>;
+    sendTronTransactionHeadless?: (params: unknown) => Promise<unknown>;
+    getTronBalance?: (params: unknown) => Promise<unknown>;
+    getWallets: (walletType: "ethereum" | "solana" | "tron") => Promise<unknown>;
+    createWallet: (walletType: "ethereum" | "solana" | "tron", options?: unknown) => Promise<unknown>;
+    importKey: (walletType: "ethereum" | "solana" | "tron", key: string) => Promise<unknown>;
     getUser: () => Promise<unknown>;
     logout: () => Promise<unknown>;
     getPasskeyStatus: () => Promise<unknown>;
@@ -114,7 +118,7 @@ declare const useUser: () => {
     refreshUser: () => Promise<void>;
 };
 
-declare const useWallets: (walletType: "ethereum" | "solana") => {
+declare const useWallets: (walletType: "ethereum" | "solana" | "tron") => {
     wallets: unknown[];
     loading: boolean;
     error: Error | null;
@@ -127,7 +131,7 @@ declare const useLogout: () => {
 };
 
 declare const useCreateWallet: () => {
-    createWallet: (walletType: "ethereum" | "solana", options?: {
+    createWallet: (walletType: "ethereum" | "solana" | "tron", options?: {
         createAdditional?: boolean;
         walletIndex?: number;
     }) => Promise<{
@@ -136,7 +140,7 @@ declare const useCreateWallet: () => {
 };
 
 declare const useImportKey: () => {
-    importKey: (walletType: "ethereum" | "solana", key: string) => Promise<{
+    importKey: (walletType: "ethereum" | "solana" | "tron", key: string) => Promise<{
         wallet: PublicWallet;
     }>;
 };

package/dist/react/index.d.ts

@@ -29,9 +29,13 @@ interface MoonXHookSDK {
     sendSolanaTransactionHeadless: (params: unknown) => Promise<unknown>;
     getSolanaBalance: (params: unknown) => Promise<unknown>;
     getSolanaTokenAccountsByOwner?: (params: unknown) => Promise<unknown>;
-    getWallets: (walletType: "ethereum" | "solana") => Promise<unknown>;
-    createWallet: (walletType: "ethereum" | "solana", options?: unknown) => Promise<unknown>;
-    importKey: (walletType: "ethereum" | "solana", key: string) => Promise<unknown>;
+    signTronMessageHeadless?: (params: unknown) => Promise<unknown>;
+    signTronTransactionHeadless?: (params: unknown) => Promise<unknown>;
+    sendTronTransactionHeadless?: (params: unknown) => Promise<unknown>;
+    getTronBalance?: (params: unknown) => Promise<unknown>;
+    getWallets: (walletType: "ethereum" | "solana" | "tron") => Promise<unknown>;
+    createWallet: (walletType: "ethereum" | "solana" | "tron", options?: unknown) => Promise<unknown>;
+    importKey: (walletType: "ethereum" | "solana" | "tron", key: string) => Promise<unknown>;
     getUser: () => Promise<unknown>;
     logout: () => Promise<unknown>;
     getPasskeyStatus: () => Promise<unknown>;
@@ -114,7 +118,7 @@ declare const useUser: () => {
     refreshUser: () => Promise<void>;
 };
 
-declare const useWallets: (walletType: "ethereum" | "solana") => {
+declare const useWallets: (walletType: "ethereum" | "solana" | "tron") => {
     wallets: unknown[];
     loading: boolean;
     error: Error | null;
@@ -127,7 +131,7 @@ declare const useLogout: () => {
 };
 
 declare const useCreateWallet: () => {
-    createWallet: (walletType: "ethereum" | "solana", options?: {
+    createWallet: (walletType: "ethereum" | "solana" | "tron", options?: {
         createAdditional?: boolean;
         walletIndex?: number;
     }) => Promise<{
@@ -136,7 +140,7 @@ declare const useCreateWallet: () => {
 };
 
 declare const useImportKey: () => {
-    importKey: (walletType: "ethereum" | "solana", key: string) => Promise<{
+    importKey: (walletType: "ethereum" | "solana" | "tron", key: string) => Promise<{
         wallet: PublicWallet;
     }>;
 };

package/dist/react/index.js

@@ -552,6 +552,14 @@ var nacl = __toESM(require("tweetnacl"));
 var import_web3 = require("@solana/web3.js");
 var import_bn = __toESM(require("bn.js"));
 
+// src/lib/tron/tron-address.ts
+var import_secp256k1 = require("@noble/curves/secp256k1");
+var import_sha3 = require("@noble/hashes/sha3");
+var import_sha256 = require("@noble/hashes/sha256");
+
+// src/lib/tron/decode-raw-data.ts
+var import_sha2562 = require("@noble/hashes/sha256");
+
 // src/react/use-passkey-status.ts
 var import_react8 = require("react");
 var sharedHasPasskey = null;

package/dist/react/index.mjs

@@ -1,7 +1,7 @@
 import {
   formatPasskeyLabel,
   resolvePasskeyMetadata
-} from "../chunk-QBEPYAYB.mjs";
+} from "../chunk-7UGU27T3.mjs";
 import "../chunk-LP55IGPN.mjs";
 import {
   SDKProvider,

package/dist/react/tron.d.mts

@@ -0,0 +1,16 @@
+import { TronGetBalanceParams, TronGetBalanceResult, TronSendTransactionParams, TronSendTransactionResult, TronSignMessageParams, TronSignMessageResult, TronSignTransactionParams, TronSignTransactionResult } from '../types/index.mjs';
+
+declare const useSignMessage: () => {
+    signMessage: (params: TronSignMessageParams) => Promise<TronSignMessageResult>;
+};
+declare const useSignTransaction: () => {
+    signTransaction: (params: TronSignTransactionParams) => Promise<TronSignTransactionResult>;
+};
+declare const useSendTransaction: () => {
+    sendTransaction: (params: TronSendTransactionParams) => Promise<TronSendTransactionResult>;
+};
+declare const useGetBalance: () => {
+    getBalance: (params: TronGetBalanceParams) => Promise<TronGetBalanceResult>;
+};
+
+export { useGetBalance, useSendTransaction, useSignMessage, useSignTransaction };

package/dist/react/tron.d.ts

@@ -0,0 +1,16 @@
+import { TronGetBalanceParams, TronGetBalanceResult, TronSendTransactionParams, TronSendTransactionResult, TronSignMessageParams, TronSignMessageResult, TronSignTransactionParams, TronSignTransactionResult } from '../types/index.js';
+
+declare const useSignMessage: () => {
+    signMessage: (params: TronSignMessageParams) => Promise<TronSignMessageResult>;
+};
+declare const useSignTransaction: () => {
+    signTransaction: (params: TronSignTransactionParams) => Promise<TronSignTransactionResult>;
+};
+declare const useSendTransaction: () => {
+    sendTransaction: (params: TronSendTransactionParams) => Promise<TronSendTransactionResult>;
+};
+declare const useGetBalance: () => {
+    getBalance: (params: TronGetBalanceParams) => Promise<TronGetBalanceResult>;
+};
+
+export { useGetBalance, useSendTransaction, useSignMessage, useSignTransaction };

package/dist/react/tron.js

@@ -0,0 +1,95 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/tron.ts
+var tron_exports = {};
+__export(tron_exports, {
+  useGetBalance: () => useGetBalance,
+  useSendTransaction: () => useSendTransaction,
+  useSignMessage: () => useSignMessage,
+  useSignTransaction: () => useSignTransaction
+});
+module.exports = __toCommonJS(tron_exports);
+
+// src/react/sdk-context.ts
+var import_react = require("react");
+var SDKContext = (0, import_react.createContext)(null);
+var SDKProvider = SDKContext.Provider;
+var useMoonXSDK = () => {
+  const sdk = (0, import_react.useContext)(SDKContext);
+  if (!sdk) {
+    throw new Error(
+      "MoonX hook called outside a <MoonXProvider> \u2014 wrap your app in the provider from @moon-x/react-sdk (web) or @moon-x/react-native-sdk (RN)."
+    );
+  }
+  return sdk;
+};
+
+// src/react/tron.ts
+var useSignMessage = () => {
+  const sdk = useMoonXSDK();
+  return {
+    signMessage: (params) => {
+      if (!sdk.signTronMessageHeadless) {
+        throw new Error("Tron signing is not available on this SDK instance");
+      }
+      return sdk.signTronMessageHeadless(params);
+    }
+  };
+};
+var useSignTransaction = () => {
+  const sdk = useMoonXSDK();
+  return {
+    signTransaction: (params) => {
+      if (!sdk.signTronTransactionHeadless) {
+        throw new Error("Tron signing is not available on this SDK instance");
+      }
+      return sdk.signTronTransactionHeadless(params);
+    }
+  };
+};
+var useSendTransaction = () => {
+  const sdk = useMoonXSDK();
+  return {
+    sendTransaction: (params) => {
+      if (!sdk.sendTronTransactionHeadless) {
+        throw new Error("Tron send is not available on this SDK instance");
+      }
+      return sdk.sendTronTransactionHeadless(params);
+    }
+  };
+};
+var useGetBalance = () => {
+  const sdk = useMoonXSDK();
+  return {
+    getBalance: (params) => {
+      if (!sdk.getTronBalance) {
+        throw new Error("Tron balance is not available on this SDK instance");
+      }
+      return sdk.getTronBalance(params);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useGetBalance,
+  useSendTransaction,
+  useSignMessage,
+  useSignTransaction
+});