@moon-x/core 0.12.0 → 0.14.0

package/dist/lib/index.d.ts

@@ -1,6 +1,6 @@
 export { C as CachedAssertion, g as generatePasskeyUserId } from '../passkey-cache-WnDFQ-v4.js';
 export { a as PasskeyFormFactor, P as PasskeyMetadata, b as PasskeyMetadataInput, f as formatPasskeyLabel, r as resolvePasskeyMetadata } from '../passkey-metadata-QqFF2SWQ.js';
-import { ChainEntry, ChainConfigItem, Chain, EvmChainEntry, SolanaChainEntry, WalletChain } from '../types/index.js';
+import { ChainEntry, ChainConfigItem, Chain, EvmChainEntry, TronChainEntry, SolanaChainEntry, WalletChain } from '../types/index.js';
 import { SiweMessage } from 'siwe';
 import { Connection, PublicKey } from '@solana/web3.js';
 
@@ -28,7 +28,7 @@ declare const authState: AuthenticationState;
 declare function sanitizeUserData(userData: any): any;
 
 /**
- * Verify ID token with MoonKey API and retrieve user info.
+ * Verify ID token with MoonX API and retrieve user info.
  */
 interface VerifyIdTokenResponse {
     success: boolean;
@@ -42,7 +42,7 @@ declare const fromB64url: (b64url: string) => Uint8Array;
 declare const toB64url: (bytes: Uint8Array) => string;
 
 /**
- * Chain utilities for MoonKey
+ * Chain utilities for MoonX
  */
 
 /**
@@ -131,6 +131,8 @@ declare function getChainById(chains: ChainConfigItem[], chainId: number): Chain
 declare function isChainSupported(chains: ChainConfigItem[], chainId: number): boolean;
 /** Type guard: is this normalized entry an EVM entry (carries a viem Chain)? */
 declare function isEvmEntry(entry: ChainEntry): entry is EvmChainEntry;
+/** Type guard: a string-id entry in the "tron" namespace (e.g. "tron:mainnet"). */
+declare function isTronEntry(entry: ChainEntry): entry is TronChainEntry;
 /**
  * Coerce a `ChainConfigItem` to its normalized form. A bare viem `Chain`
  * (numeric `id`) becomes an `EvmChainEntry`; `{ chain, … }` is already one;
@@ -176,6 +178,12 @@ declare function resolveChainEntry(chains: ChainConfigItem[] | undefined, select
  * hooks throw a clear "no RPC URL" error.
  */
 declare function resolveSolanaChainEntry(chains: ChainConfigItem[] | undefined, selector?: string | number, defaultSelector?: string | number): SolanaChainEntry | undefined;
+/**
+ * Resolve a TRON entry, mirroring `resolveSolanaChainEntry`'s precedence and
+ * fail-closed semantics: an explicit selector that doesn't name a configured
+ * tron entry returns undefined rather than falling through to another chain.
+ */
+declare function resolveTronChainEntry(chains: ChainConfigItem[] | undefined, selector?: string | number, defaultSelector?: string | number): TronChainEntry | undefined;
 /**
  * Resolve the EVM entry to use, honoring (highest priority first):
  * per-call `selector` → tx `requestedChainId` → `walletChainId` →
@@ -455,6 +463,24 @@ declare function getSOLTransfersFromInstructions(base64Transaction: string, logs
     usdValue?: string;
 }>>;
 
+/**
+ * Derive the base58check Tron address from a secp256k1 public key
+ * (compressed or uncompressed hex, with or without 0x):
+ * keccak256(uncompressed pubkey body)[12:] prefixed with 0x41, then
+ * base58check (double-sha256 checksum).
+ *
+ * Async because `bs58` is an optional ESM-only peer of `@moon-x/core`
+ * and is lazy-imported, same as `bs58ToBytes` in wire-codec.ts.
+ */
+declare function tronAddressFromPublicKey(publicKeyHex: string): Promise<string>;
+
+/**
+ * Decode raw_data_hex (the signed bytes) into a labeled preview object.
+ * Throws on malformed input - callers fall back to showing the raw
+ * payload rather than a possibly-wrong decode.
+ */
+declare function decodeTronRawData(rawDataHex: string): Promise<Record<string, unknown>>;
+
 interface BuildUrlConfig {
     publishableKey: string;
     config?: {
@@ -470,6 +496,15 @@ declare const DEFAULT_AUTH_URL = "https://iframe.moonx-dev.com";
 declare const serializeEthereumTransaction: (transaction: any) => Promise<string>;
 declare const broadcastEthereumRaw: (rpcUrl: string, signedSerialized: string) => Promise<string>;
 declare const broadcastSolanaSigned: (rpcUrl: string, signedBase58: string) => Promise<string>;
+/**
+ * Broadcast a signed Tron transaction (TronWeb JSON shape, signature
+ * attached) to a fullnode. Returns the txid. Tron reports failures as
+ * `{ result: false, code, message }` with `message` hex-encoded ASCII;
+ * decode it so callers see "Contract validate error: ..." instead of hex.
+ */
+declare const broadcastTronSigned: (rpcUrl: string, signedTransaction: {
+    txID: string;
+} & Record<string, unknown>) => Promise<string>;
 
 /**
  * Canonical algorithm name written to `app_user_wallet_keyshares.algorithm`.
@@ -477,6 +512,7 @@ declare const broadcastSolanaSigned: (rpcUrl: string, signedBase58: string) => P
  * Matches Sodot's Vertex API path segment exactly:
  *
  *   ethereum → "ecdsa"
+ *   tron     → "ecdsa"
  *   solana   → "exportable-ed25519"
  *
  * `Algorithm.name.toLowerCase()` from the Sodot SDK would give
@@ -519,4 +555,4 @@ declare const arrayLikeToBytes: (value: unknown) => Uint8Array;
  */
 declare const bs58ToBytes: (value: unknown) => Promise<Uint8Array>;
 
-export { type BuildUrlConfig, type ChainIndex, DEFAULT_AUTH_URL, EthereumSiweMessage, type EthereumSiweMessageProps, type EvmTransactionInput, type EvmTxPrepWallet, type ManualSiweMessageProps, SiwsMessage, SolanaTransactionParser, type VerifyIdTokenResponse, arrayLikeToBytes, authState, broadcastEthereumRaw, broadcastSolanaSigned, bs58ToBytes, buildChainIndex, buildUrl, canonicalAlgorithmFor, createManualSiweMessage, entryCaip2, estimateEvmGas, estimateEvmGasReserve, fromB64url, getChainById, getEvmGasPrice, getEvmMaxPriorityFeePerGas, getEvmNonce, getInstructionsForHTML, getRpcUrl, getSOLTransfersFromInstructions, getTransferInfoFromInstructions, isChainSupported, isEvmEntry, normalizeChainItem, normalizeChainKey, parseDerivationPath, prepareEvmSendTransaction, prepareEvmSignTransaction, resolveChainEntry, resolveEvmChain, resolveEvmChainEntry, resolveRpcUrl, resolveSolanaChainEntry, resolveWsUrl, sanitizeUserData, serializeEthereumTransaction, toB64url, validateChainConfig, verifyIdToken };
+export { type BuildUrlConfig, type ChainIndex, DEFAULT_AUTH_URL, EthereumSiweMessage, type EthereumSiweMessageProps, type EvmTransactionInput, type EvmTxPrepWallet, type ManualSiweMessageProps, SiwsMessage, SolanaTransactionParser, type VerifyIdTokenResponse, arrayLikeToBytes, authState, broadcastEthereumRaw, broadcastSolanaSigned, broadcastTronSigned, bs58ToBytes, buildChainIndex, buildUrl, canonicalAlgorithmFor, createManualSiweMessage, decodeTronRawData, entryCaip2, estimateEvmGas, estimateEvmGasReserve, fromB64url, getChainById, getEvmGasPrice, getEvmMaxPriorityFeePerGas, getEvmNonce, getInstructionsForHTML, getRpcUrl, getSOLTransfersFromInstructions, getTransferInfoFromInstructions, isChainSupported, isEvmEntry, isTronEntry, normalizeChainItem, normalizeChainKey, parseDerivationPath, prepareEvmSendTransaction, prepareEvmSignTransaction, resolveChainEntry, resolveEvmChain, resolveEvmChainEntry, resolveRpcUrl, resolveSolanaChainEntry, resolveTronChainEntry, resolveWsUrl, sanitizeUserData, serializeEthereumTransaction, toB64url, tronAddressFromPublicKey, validateChainConfig, verifyIdToken };

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
 });
@@ -124,12 +129,13 @@ function sanitizeUserData(userData) {
 }
 
 // src/utils/get-api-url.ts
-var getMoonKeyApiUrl = () => {
-  if (process.env?.NEXT_PUBLIC_MOONKEY_API_URL) {
-    return process.env.NEXT_PUBLIC_MOONKEY_API_URL;
+var getMoonXApiUrl = () => {
+  const apiUrlOverride = process.env?.NEXT_PUBLIC_MOONX_API_URL || process.env?.NEXT_PUBLIC_MOONKEY_API_URL;
+  if (apiUrlOverride) {
+    return apiUrlOverride;
   }
-  if (process.env?.NEXT_PUBLIC_MOONKEY_IFRAME_URL) {
-    const iframeUrl = process.env.NEXT_PUBLIC_MOONKEY_IFRAME_URL;
+  const iframeUrl = process.env?.NEXT_PUBLIC_MOONX_IFRAME_URL || process.env?.NEXT_PUBLIC_MOONKEY_IFRAME_URL;
+  if (iframeUrl) {
     if (iframeUrl.includes("staging") || iframeUrl.includes("auth-staging")) {
       return "https://api.moonx-dev.com";
     }
@@ -143,7 +149,7 @@ var getMoonKeyApiUrl = () => {
 // src/lib/auth/verify-id-token.ts
 var verifyIdToken = async (publishableKey, idToken) => {
   try {
-    const apiUrl = getMoonKeyApiUrl();
+    const apiUrl = getMoonXApiUrl();
     const response = await fetch(
       `${apiUrl}/v1/auth/users/public/id_token/verify`,
       {
@@ -514,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") {
@@ -542,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;
 }
@@ -582,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 ?? []);
@@ -1521,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) {
@@ -1663,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";
@@ -1718,11 +1961,13 @@ var bs58ToBytes = async (value) => {
   authState,
   broadcastEthereumRaw,
   broadcastSolanaSigned,
+  broadcastTronSigned,
   bs58ToBytes,
   buildChainIndex,
   buildUrl,
   canonicalAlgorithmFor,
   createManualSiweMessage,
+  decodeTronRawData,
   entryCaip2,
   estimateEvmGas,
   estimateEvmGasReserve,
@@ -1739,6 +1984,7 @@ var bs58ToBytes = async (value) => {
   getTransferInfoFromInstructions,
   isChainSupported,
   isEvmEntry,
+  isTronEntry,
   normalizeChainItem,
   normalizeChainKey,
   parseDerivationPath,
@@ -1750,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,14 +42,16 @@ import {
   resolvePasskeyMetadata,
   resolveRpcUrl,
   resolveSolanaChainEntry,
+  resolveTronChainEntry,
   resolveWsUrl,
   sanitizeUserData,
   serializeEthereumTransaction,
   toB64url,
+  tronAddressFromPublicKey,
   validateChainConfig,
   verifyIdToken
-} from "../chunk-L7GL3PFM.mjs";
-import "../chunk-GQKIA37O.mjs";
+} from "../chunk-7UGU27T3.mjs";
+import "../chunk-LP55IGPN.mjs";
 export {
   DEFAULT_AUTH_URL,
   EthereumSiweMessage,
@@ -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/ethereum.js

@@ -34,11 +34,11 @@ module.exports = __toCommonJS(ethereum_exports);
 var import_react = require("react");
 var SDKContext = (0, import_react.createContext)(null);
 var SDKProvider = SDKContext.Provider;
-var useMoonKeySDK = () => {
+var useMoonXSDK = () => {
   const sdk = (0, import_react.useContext)(SDKContext);
   if (!sdk) {
     throw new Error(
-      "MoonKey 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)."
+      "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;
@@ -46,43 +46,43 @@ var useMoonKeySDK = () => {
 
 // src/react/ethereum.ts
 var useSignMessage = () => {
-  const sdk = useMoonKeySDK();
+  const sdk = useMoonXSDK();
   return {
     signMessage: (params) => sdk.signEthereumMessageHeadless(params)
   };
 };
 var useSignTransaction = () => {
-  const sdk = useMoonKeySDK();
+  const sdk = useMoonXSDK();
   return {
     signTransaction: (params) => sdk.signEthereumTransactionHeadless(params)
   };
 };
 var useSignTypedData = () => {
-  const sdk = useMoonKeySDK();
+  const sdk = useMoonXSDK();
   return {
     signTypedData: (params) => sdk.signEthereumTypedDataHeadless(params)
   };
 };
 var useSignHash = () => {
-  const sdk = useMoonKeySDK();
+  const sdk = useMoonXSDK();
   return {
     signHash: (params) => sdk.signEthereumHashHeadless(params)
   };
 };
 var useSign7702Authorization = () => {
-  const sdk = useMoonKeySDK();
+  const sdk = useMoonXSDK();
   return {
     signAuthorization: (params) => sdk.signEthereum7702AuthorizationHeadless(params)
   };
 };
 var useSendTransaction = () => {
-  const sdk = useMoonKeySDK();
+  const sdk = useMoonXSDK();
   return {
     sendTransaction: (params) => sdk.sendEthereumTransactionHeadless(params)
   };
 };
 var useGetBalance = () => {
-  const sdk = useMoonKeySDK();
+  const sdk = useMoonXSDK();
   return {
     getBalance: (params) => sdk.getEthereumBalance(params)
   };

package/dist/react/ethereum.mjs

@@ -1,46 +1,46 @@
 import {
-  useMoonKeySDK
-} from "../chunk-BJKWC4MG.mjs";
+  useMoonXSDK
+} from "../chunk-PEIBEYMA.mjs";
 
 // src/react/ethereum.ts
 var useSignMessage = () => {
-  const sdk = useMoonKeySDK();
+  const sdk = useMoonXSDK();
   return {
     signMessage: (params) => sdk.signEthereumMessageHeadless(params)
   };
 };
 var useSignTransaction = () => {
-  const sdk = useMoonKeySDK();
+  const sdk = useMoonXSDK();
   return {
     signTransaction: (params) => sdk.signEthereumTransactionHeadless(params)
   };
 };
 var useSignTypedData = () => {
-  const sdk = useMoonKeySDK();
+  const sdk = useMoonXSDK();
   return {
     signTypedData: (params) => sdk.signEthereumTypedDataHeadless(params)
   };
 };
 var useSignHash = () => {
-  const sdk = useMoonKeySDK();
+  const sdk = useMoonXSDK();
   return {
     signHash: (params) => sdk.signEthereumHashHeadless(params)
   };
 };
 var useSign7702Authorization = () => {
-  const sdk = useMoonKeySDK();
+  const sdk = useMoonXSDK();
   return {
     signAuthorization: (params) => sdk.signEthereum7702AuthorizationHeadless(params)
   };
 };
 var useSendTransaction = () => {
-  const sdk = useMoonKeySDK();
+  const sdk = useMoonXSDK();
   return {
     sendTransaction: (params) => sdk.sendEthereumTransactionHeadless(params)
   };
 };
 var useGetBalance = () => {
-  const sdk = useMoonKeySDK();
+  const sdk = useMoonXSDK();
   return {
     getBalance: (params) => sdk.getEthereumBalance(params)
   };