@anywalletkit/wallet-tron 0.0.0-stage → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1845 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CAIP2_GENESIS: () => CAIP2_GENESIS,
+  CONTRACT_TYPES: () => CONTRACT_TYPES,
+  DEFAULT_FEE_LIMIT_SUN: () => DEFAULT_FEE_LIMIT_SUN,
+  FEE_LIMIT_MARGIN: () => FEE_LIMIT_MARGIN,
+  HistoryUnavailableError: () => HistoryUnavailableError,
+  MAX_EXPIRATION_MS: () => MAX_EXPIRATION_MS,
+  MAX_MEMO_BYTES: () => MAX_MEMO_BYTES,
+  MEMO_FIELD: () => MEMO_FIELD,
+  NonCanonicalError: () => NonCanonicalError,
+  SimulationError: () => SimulationError,
+  TRANSFER_TOPIC: () => TRANSFER_TOPIC,
+  TRON_ACCOUNT_BRANCH: () => TRON_ACCOUNT_BRANCH,
+  TRON_BASE_PATH: () => TRON_BASE_PATH,
+  UnsafeTransactionError: () => UnsafeTransactionError,
+  WalletAccountReadOnlyTron: () => WalletAccountReadOnlyTron,
+  WalletAccountTron: () => WalletAccountTron,
+  WalletManagerTron: () => WalletManagerTron,
+  ZERO_ADDRESS: () => ZERO_ADDRESS,
+  ZERO_ADDRESS_HEX: () => ZERO_ADDRESS_HEX,
+  addressFromPublicKey: () => addressFromPublicKey,
+  assertNodeBuild: () => assertNodeBuild,
+  attachMemo: () => attachMemo,
+  bandwidthPoints: () => bandwidthPoints,
+  createClient: () => createClient,
+  createTronHistory: () => createTronHistory,
+  decodeAddressWord: () => decodeAddressWord,
+  decodeHistoryCursor: () => decodeCursor,
+  decodeRawData: () => decodeRawData,
+  decodeRevertReason: () => decodeRevertReason,
+  decodeUint: () => decodeUint,
+  default: () => WalletManagerTron,
+  describeTransaction: () => describeTransaction,
+  encodeHistoryCursor: () => encodeCursor,
+  encodeMemoRecord: () => encodeMemoRecord,
+  encodeParameters: () => encodeParameters,
+  encodeRawData: () => encodeRawData,
+  hashMessage: () => hashMessage,
+  hexToText: () => hexToText,
+  isContractCall: () => isContractCall,
+  isDecodedContractType: () => isDecodedContractType,
+  isHexAddress: () => isHexAddress,
+  isPrebuilt: () => isPrebuilt,
+  mapHistoryTransactionRow: () => mapTransactionRow,
+  mapHistoryTrc20Only: () => mapTrc20Only,
+  memoBytes: () => memoBytes,
+  rawMismatch: () => rawMismatch,
+  readFields: () => readFields,
+  recoverMessageAddress: () => recoverMessageAddress,
+  selector: () => selector,
+  splitCalldata: () => splitCalldata,
+  toBase58Address: () => toBase58Address,
+  toHexAddress: () => toHexAddress,
+  tronExplorerTxUrl: () => tronExplorerTxUrl,
+  verifyRawTransaction: () => verifyRawTransaction
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/types.ts
+var CAIP2_GENESIS = {
+  mainnet: "tron:0x2b6653dc",
+  shasta: "tron:0x94a9059e",
+  nile: "tron:0xcd8690dc"
+};
+
+// src/errors.ts
+var UnsafeTransactionError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "UnsafeTransactionError";
+    this.code = code;
+  }
+};
+var SimulationError = class extends Error {
+  reason;
+  energy;
+  constructor(reason, energy = 0) {
+    super(`Transaction simulation failed: ${reason}`);
+    this.name = "SimulationError";
+    this.reason = reason;
+    this.energy = energy;
+  }
+};
+
+// src/address.ts
+var import_secp256k1 = require("@noble/curves/secp256k1.js");
+var import_sha3 = require("@noble/hashes/sha3.js");
+var import_sha2 = require("@noble/hashes/sha2.js");
+var import_utils = require("@noble/hashes/utils.js");
+var import_base = require("@scure/base");
+var b58check = (0, import_base.createBase58check)(import_sha2.sha256);
+var ADDRESS_PREFIX = 65;
+function addressFromPublicKey(compressed) {
+  const xy = import_secp256k1.secp256k1.Point.fromBytes(compressed).toBytes(false).slice(1);
+  const hash = (0, import_sha3.keccak_256)(xy);
+  const bytes = new Uint8Array(21);
+  bytes[0] = ADDRESS_PREFIX;
+  bytes.set(hash.slice(12), 1);
+  return b58check.encode(bytes);
+}
+function isHexAddress(a) {
+  return /^(0x)?41[0-9a-fA-F]{40}$/.test(a);
+}
+function toHexAddress(address) {
+  if (isHexAddress(address)) return address.replace(/^0x/, "").toLowerCase();
+  const bytes = b58check.decode(address);
+  if (bytes.length !== 21 || bytes[0] !== ADDRESS_PREFIX) throw new Error(`Invalid Tron address: ${address}`);
+  return (0, import_utils.bytesToHex)(bytes);
+}
+function toBase58Address(address) {
+  if (!isHexAddress(address)) {
+    toHexAddress(address);
+    return address;
+  }
+  return b58check.encode((0, import_utils.hexToBytes)(address.replace(/^0x/, "")));
+}
+function toEvmHex(address) {
+  return toHexAddress(address).slice(2);
+}
+
+// src/abi.ts
+var import_sha32 = require("@noble/hashes/sha3.js");
+var import_utils2 = require("@noble/hashes/utils.js");
+function selector(signature) {
+  return (0, import_utils2.bytesToHex)((0, import_sha32.keccak_256)(new TextEncoder().encode(signature))).slice(0, 8);
+}
+function encodeParameters(params) {
+  return params.map(({ type, value }) => {
+    if (type === "address") return toEvmHex(String(value)).padStart(64, "0");
+    if (/^u?int\d*$/.test(type)) {
+      let v = BigInt(value);
+      if (v < 0n) v = (1n << 256n) + v;
+      return v.toString(16).padStart(64, "0");
+    }
+    if (type === "bool") return (value ? "1" : "0").padStart(64, "0");
+    if (type === "bytes32") return String(value).replace(/^0x/, "").padEnd(64, "0");
+    throw new Error(`encodeParameters: unsupported type ${type}`);
+  }).join("");
+}
+function decodeUint(hex) {
+  const h = hex.replace(/^0x/, "");
+  return h ? BigInt("0x" + h) : 0n;
+}
+function decodeAddressWord(word) {
+  return "41" + word.replace(/^0x/, "").padStart(64, "0").slice(24);
+}
+function splitCalldata(data) {
+  const h = data.replace(/^0x/, "").toLowerCase();
+  const selector2 = h.slice(0, 8);
+  const words = [];
+  for (let i = 8; i + 64 <= h.length; i += 64) words.push(h.slice(i, i + 64));
+  return { selector: selector2, words };
+}
+function decodeRevertReason(hex) {
+  if (!hex) return void 0;
+  const h = hex.replace(/^0x/, "");
+  if (!h) return void 0;
+  const { selector: selector2, words } = splitCalldata(h);
+  if (selector2 === "08c379a0" && words.length >= 2) {
+    const len = Number(decodeUint(words[1]));
+    const start = 8 + 64 * 2;
+    const bytes = h.slice(start, start + len * 2);
+    try {
+      return new TextDecoder().decode(Uint8Array.from(bytes.match(/.{2}/g) ?? [], (b) => parseInt(b, 16)));
+    } catch {
+    }
+  }
+  if (selector2 === "4e487b71" && words.length >= 1) return `Panic(0x${decodeUint(words[0]).toString(16)})`;
+  return h;
+}
+function hexToText(hex) {
+  const h = hex.replace(/^0x/, "");
+  if (!/^[0-9a-fA-F]*$/.test(h) || h.length % 2) return hex;
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(h.match(/.{2}/g) ?? [], (b) => parseInt(b, 16)));
+  } catch {
+    return hex;
+  }
+}
+
+// src/client.ts
+var import_core = require("@anywalletkit/core");
+function httpTransport(base, headers) {
+  const root = base.replace(/\/+$/, "");
+  return async (path, body) => {
+    const res = await fetch(`${root}${path}`, {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json", ...headers },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) throw new import_core.NetworkError(`${path}: HTTP ${res.status}`, { provider: root });
+    return res.json();
+  };
+}
+function createClient(config) {
+  if (config.provider === void 0) return void 0;
+  const list = (Array.isArray(config.provider) ? config.provider : [config.provider]).map(
+    (p) => typeof p === "string" ? httpTransport(p, config.headers) : p
+  );
+  if (list.length === 0) throw new Error("The 'provider' option cannot be set to an empty list.");
+  if (list.length === 1) return list[0];
+  const attempts = list.length + (config.retries ?? 3);
+  return async (path, body) => {
+    let lastError;
+    for (let i = 0; i < attempts; i++) {
+      try {
+        return await list[i % list.length](path, body);
+      } catch (e) {
+        lastError = e;
+      }
+    }
+    throw new import_core.NetworkError(`All Tron providers failed for ${path}`, { cause: lastError });
+  };
+}
+function assertNoError(res, what) {
+  const r = res;
+  const hexMsg = (m) => m && /^[0-9a-f]+$/i.test(m) ? Buffer_from_hex(m) : m;
+  if (r?.Error) throw new Error(`${what}: ${r.Error}`);
+  if (r?.result && typeof r.result === "object" && r.result.result === false) throw new Error(`${what}: ${r.result.code ?? ""} ${hexMsg(r.result.message) ?? ""}`.trim());
+  if (r?.code && r.code !== "SUCCESS" && !("txID" in r)) throw new Error(`${what}: ${r.code} ${hexMsg(r.message) ?? ""}`.trim());
+}
+function Buffer_from_hex(hex) {
+  try {
+    return new TextDecoder().decode(Uint8Array.from(hex.match(/.{2}/g) ?? [], (b) => parseInt(b, 16)));
+  } catch {
+    return hex;
+  }
+}
+
+// src/shape.ts
+var isPrebuilt = (tx) => typeof tx === "object" && tx !== null && typeof tx.txID === "string";
+var isContractCall = (tx) => typeof tx === "object" && tx !== null && typeof tx.functionSelector === "string";
+
+// src/raw.ts
+var import_sha22 = require("@noble/hashes/sha2.js");
+var import_utils3 = require("@noble/hashes/utils.js");
+var NonCanonicalError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NonCanonicalError";
+  }
+};
+var MAX_VARINT_BYTES = 10;
+var MAX_TAG_BYTES = 5;
+function readVarint(bytes, at, what = "value") {
+  const max = what === "tag" ? MAX_TAG_BYTES : MAX_VARINT_BYTES;
+  let shift = 0n;
+  let value = 0n;
+  let i = at;
+  for (; ; ) {
+    if (i >= bytes.length) throw new Error("truncated varint");
+    const b = bytes[i++];
+    const n = i - at;
+    value |= BigInt(b & 127) << shift;
+    if ((b & 128) === 0) {
+      if (n > 1 && b === 0) throw new NonCanonicalError(`non-minimal ${what} varint`);
+      if (n === MAX_VARINT_BYTES && b > 1) throw new NonCanonicalError(`${what} varint exceeds 64 bits`);
+      if (what === "tag" && value >= 1n << 32n) throw new NonCanonicalError("tag exceeds 32 bits");
+      return { value, next: i };
+    }
+    if (n >= max) throw new NonCanonicalError(`${what} varint longer than ${max} bytes`);
+    shift += 7n;
+  }
+}
+function readFields(bytes) {
+  const out = [];
+  let i = 0;
+  while (i < bytes.length) {
+    const tag = readVarint(bytes, i, "tag");
+    i = tag.next;
+    const number = Number(tag.value >> 3n);
+    const wire = Number(tag.value & 7n);
+    if (number === 0) throw new Error("field 0");
+    switch (wire) {
+      case 0: {
+        const v = readVarint(bytes, i);
+        i = v.next;
+        out.push({ number, wire, value: v.value });
+        break;
+      }
+      case 1: {
+        if (i + 8 > bytes.length) throw new Error("truncated fixed64");
+        out.push({ number, wire, value: bytes.subarray(i, i + 8) });
+        i += 8;
+        break;
+      }
+      case 2: {
+        const len = readVarint(bytes, i, "length");
+        const start = len.next;
+        if (len.value > BigInt(bytes.length - start)) throw new Error("truncated length-delimited field");
+        const end = start + Number(len.value);
+        out.push({ number, wire, value: bytes.subarray(start, end) });
+        i = end;
+        break;
+      }
+      case 5: {
+        if (i + 4 > bytes.length) throw new Error("truncated fixed32");
+        out.push({ number, wire, value: bytes.subarray(i, i + 4) });
+        i += 4;
+        break;
+      }
+      default:
+        throw new Error(`unsupported wire type ${wire}`);
+    }
+  }
+  return out;
+}
+function assertSingular(fields, singular, what) {
+  const want = new Set(singular);
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of fields) {
+    if (!want.has(f.number)) continue;
+    if (seen.has(f.number)) throw new NonCanonicalError(`${what}: field ${f.number} appears more than once`);
+    seen.add(f.number);
+  }
+}
+var equalBytes = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
+function encodeVarint(n) {
+  if (n < 0n) n = (1n << 64n) + n;
+  const out = [];
+  do {
+    let b = Number(n & 0x7fn);
+    n >>= 7n;
+    if (n !== 0n) b |= 128;
+    out.push(b);
+  } while (n !== 0n);
+  return out;
+}
+var tagOf = (number, wire) => encodeVarint(BigInt(number << 3 | wire));
+var fieldVarint = (number, v) => [...tagOf(number, 0), ...encodeVarint(v)];
+var fieldBytes = (number, v) => [...tagOf(number, 2), ...encodeVarint(BigInt(v.length)), ...v];
+var CONTRACT_TYPES = {
+  0: "AccountCreateContract",
+  1: "TransferContract",
+  2: "TransferAssetContract",
+  3: "VoteAssetContract",
+  4: "VoteWitnessContract",
+  5: "WitnessCreateContract",
+  6: "AssetIssueContract",
+  8: "WitnessUpdateContract",
+  9: "ParticipateAssetIssueContract",
+  10: "AccountUpdateContract",
+  11: "FreezeBalanceContract",
+  12: "UnfreezeBalanceContract",
+  13: "WithdrawBalanceContract",
+  14: "UnfreezeAssetContract",
+  15: "UpdateAssetContract",
+  16: "ProposalCreateContract",
+  17: "ProposalApproveContract",
+  18: "ProposalDeleteContract",
+  19: "SetAccountIdContract",
+  20: "CustomContract",
+  30: "CreateSmartContract",
+  31: "TriggerSmartContract",
+  32: "GetContract",
+  33: "UpdateSettingContract",
+  41: "ExchangeCreateContract",
+  42: "ExchangeInjectContract",
+  43: "ExchangeWithdrawContract",
+  44: "ExchangeTransactionContract",
+  45: "UpdateEnergyLimitContract",
+  46: "AccountPermissionUpdateContract",
+  48: "ClearABIContract",
+  49: "UpdateBrokerageContract",
+  51: "ShieldedTransferContract",
+  52: "MarketSellAssetContract",
+  53: "MarketCancelOrderContract",
+  54: "FreezeBalanceV2Contract",
+  55: "UnfreezeBalanceV2Contract",
+  56: "WithdrawExpireUnfreezeContract",
+  57: "DelegateResourceContract",
+  58: "UnDelegateResourceContract",
+  59: "CancelAllUnfreezeV2Contract"
+};
+var CONTRACT_ENUM = Object.fromEntries(Object.entries(CONTRACT_TYPES).map(([n, name]) => [name, Number(n)]));
+var TYPE_URL_PREFIX = "type.googleapis.com/protocol.";
+var RESOURCES = ["BANDWIDTH", "ENERGY", "TRON_POWER"];
+var PARAMETERS = {
+  TransferContract: { 1: ["owner_address", "address"], 2: ["to_address", "address"], 3: ["amount", "int"] },
+  TransferAssetContract: { 1: ["asset_name", "bytes"], 2: ["owner_address", "address"], 3: ["to_address", "address"], 4: ["amount", "int"] },
+  TriggerSmartContract: { 1: ["owner_address", "address"], 2: ["contract_address", "address"], 3: ["call_value", "int"], 4: ["data", "bytes"], 5: ["call_token_value", "int"], 6: ["token_id", "int"] },
+  FreezeBalanceV2Contract: { 1: ["owner_address", "address"], 2: ["frozen_balance", "int"], 3: ["resource", "resource"] },
+  UnfreezeBalanceV2Contract: { 1: ["owner_address", "address"], 2: ["unfreeze_balance", "int"], 3: ["resource", "resource"] },
+  FreezeBalanceContract: { 1: ["owner_address", "address"], 2: ["frozen_balance", "int"], 3: ["frozen_duration", "int"], 10: ["resource", "resource"], 15: ["receiver_address", "address"] },
+  UnfreezeBalanceContract: { 1: ["owner_address", "address"], 10: ["resource", "resource"], 15: ["receiver_address", "address"] },
+  WithdrawBalanceContract: { 1: ["owner_address", "address"] },
+  WithdrawExpireUnfreezeContract: { 1: ["owner_address", "address"] },
+  CancelAllUnfreezeV2Contract: { 1: ["owner_address", "address"] },
+  DelegateResourceContract: { 1: ["owner_address", "address"], 2: ["resource", "resource"], 3: ["balance", "int"], 4: ["receiver_address", "address"], 5: ["lock", "bool"], 6: ["lock_period", "int"] },
+  UnDelegateResourceContract: { 1: ["owner_address", "address"], 2: ["resource", "resource"], 3: ["balance", "int"], 4: ["receiver_address", "address"] }
+};
+var signed = (v) => v >= 1n << 63n ? v - (1n << 64n) : v;
+var int = (v) => {
+  const s = signed(v);
+  return s <= BigInt(Number.MAX_SAFE_INTEGER) && s >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(s) : s.toString();
+};
+var num = (v) => Number(signed(v).toString());
+var asBytes = (f, what) => {
+  if (!(f.value instanceof Uint8Array) || f.wire !== 2) throw new Error(`${what}: expected bytes`);
+  return f.value;
+};
+var asInt = (f, what) => {
+  if (typeof f.value !== "bigint") throw new Error(`${what}: expected varint`);
+  return f.value;
+};
+function decodeParameter(type, bytes) {
+  const schema = PARAMETERS[type];
+  const value = {};
+  const undecoded = [];
+  const fields = readFields(bytes);
+  if (!schema) {
+    assertSingular(fields, [1], type);
+    const owner = fields.find((f) => f.number === 1 && f.wire === 2 && f.value.length === 21 && f.value[0] === 65);
+    if (owner) value.owner_address = (0, import_utils3.bytesToHex)(owner.value);
+    value.raw_parameter_hex = (0, import_utils3.bytesToHex)(bytes);
+    return { value, undecoded: [...new Set(fields.filter((f) => f !== owner).map((f) => f.number))] };
+  }
+  assertSingular(fields, Object.keys(schema).map(Number), type);
+  for (const f of fields) {
+    const entry = schema[f.number];
+    if (!entry) {
+      undecoded.push(f.number);
+      continue;
+    }
+    const [name, kind] = entry;
+    const what = `${type}.${name}`;
+    switch (kind) {
+      case "address": {
+        const b = asBytes(f, what);
+        if (b.length !== 21 || b[0] !== 65) throw new Error(`${what}: not a Tron address`);
+        value[name] = (0, import_utils3.bytesToHex)(b);
+        break;
+      }
+      case "bytes":
+        value[name] = (0, import_utils3.bytesToHex)(asBytes(f, what));
+        break;
+      case "string":
+        value[name] = new TextDecoder().decode(asBytes(f, what));
+        break;
+      case "int":
+        value[name] = int(asInt(f, what));
+        break;
+      case "bool":
+        value[name] = asInt(f, what) !== 0n;
+        break;
+      case "resource": {
+        const r = num(asInt(f, what));
+        value[name] = RESOURCES[r] ?? `RESOURCE_${r}`;
+        break;
+      }
+    }
+  }
+  return { value, undecoded: [...new Set(undecoded)] };
+}
+var CONTRACT_FIELDS = [1, 2, 3, 4, 5];
+function decodeContract(bytes) {
+  let enumType;
+  let typeUrl;
+  let parameter;
+  let permissionId;
+  const fields = readFields(bytes);
+  assertSingular(fields, CONTRACT_FIELDS, "Contract");
+  for (const f of fields) {
+    switch (f.number) {
+      case 1:
+        enumType = num(asInt(f, "Contract.type"));
+        break;
+      case 2: {
+        const any = readFields(asBytes(f, "Contract.parameter"));
+        assertSingular(any, [1, 2], "Contract.parameter");
+        for (const a of any) {
+          if (a.number === 1) typeUrl = new TextDecoder().decode(asBytes(a, "Any.type_url"));
+          else if (a.number === 2) parameter = asBytes(a, "Any.value");
+          else throw new Error(`Contract.parameter: unknown Any field ${a.number}`);
+        }
+        break;
+      }
+      case 5:
+        permissionId = num(asInt(f, "Contract.Permission_id"));
+        break;
+      case 3:
+      case 4:
+        break;
+      // provider, ContractName: informational
+      default:
+        throw new Error(`Contract: unknown field ${f.number}`);
+    }
+  }
+  const fromUrl = typeUrl?.startsWith(TYPE_URL_PREFIX) ? typeUrl.slice(TYPE_URL_PREFIX.length) : void 0;
+  const fromEnum = enumType !== void 0 ? CONTRACT_TYPES[enumType] : void 0;
+  if (fromUrl && fromEnum && fromUrl !== fromEnum) throw new Error(`contract type_url ${fromUrl} disagrees with type ${fromEnum}`);
+  const type = fromUrl ?? fromEnum ?? (enumType !== void 0 ? `Unknown(${enumType})` : typeUrl ?? "Unknown");
+  const paramBytes = parameter ?? new Uint8Array();
+  const { value, undecoded } = decodeParameter(type, paramBytes);
+  if (PARAMETERS[type]) {
+    if (undecoded.length) throw new Error(`${type}: field(s) ${undecoded.join(", ")} are not part of the contract`);
+    if (!equalBytes(encodeParameter(type, value), paramBytes)) throw new NonCanonicalError(`${type}: parameter bytes are not the canonical encoding of what they decode to`);
+  }
+  const out = { type, parameter: { value, type_url: typeUrl ?? `${TYPE_URL_PREFIX}${type}` }, undecoded };
+  if (permissionId !== void 0) out.Permission_id = permissionId;
+  return out;
+}
+function isDecodedContractType(type) {
+  return PARAMETERS[type] !== void 0;
+}
+var RAW_SINGULAR = [1, 3, 4, 8, 10, 12, 14, 18];
+function decodeRawData(raw) {
+  const bytes = typeof raw === "string" ? (0, import_utils3.hexToBytes)(raw.replace(/^0x/, "")) : raw;
+  const data = { contract: [] };
+  const unknown = [];
+  const fields = readFields(bytes);
+  assertSingular(fields, RAW_SINGULAR, "Transaction.raw");
+  for (const f of fields) {
+    switch (f.number) {
+      case 1:
+        data.ref_block_bytes = (0, import_utils3.bytesToHex)(asBytes(f, "ref_block_bytes"));
+        break;
+      case 3:
+        data.ref_block_num = num(asInt(f, "ref_block_num"));
+        break;
+      case 4:
+        data.ref_block_hash = (0, import_utils3.bytesToHex)(asBytes(f, "ref_block_hash"));
+        break;
+      case 8:
+        data.expiration = num(asInt(f, "expiration"));
+        break;
+      case 10:
+        data.data = (0, import_utils3.bytesToHex)(asBytes(f, "data"));
+        break;
+      case 11:
+        data.contract.push(decodeContract(asBytes(f, "contract")));
+        break;
+      case 14:
+        data.timestamp = num(asInt(f, "timestamp"));
+        break;
+      case 18:
+        data.fee_limit = num(asInt(f, "fee_limit"));
+        break;
+      case 9:
+      case 12:
+        break;
+      // auths, scripts: carried by the node, nothing the wallet acts on
+      default:
+        unknown.push(f.number);
+    }
+  }
+  return { raw_data: data, unknownFields: [...new Set(unknown)] };
+}
+function encodeParameter(type, value) {
+  const schema = PARAMETERS[type];
+  if (!schema) {
+    const hex = value.raw_parameter_hex;
+    if (typeof hex === "string") return (0, import_utils3.hexToBytes)(hex);
+    return typeof value.owner_address === "string" ? Uint8Array.from(fieldBytes(1, (0, import_utils3.hexToBytes)(toHexAddress(value.owner_address)))) : new Uint8Array();
+  }
+  const out = [];
+  for (const number of Object.keys(schema).map(Number).sort((a, b) => a - b)) {
+    const [name, kind] = schema[number];
+    const v = value[name];
+    if (v === void 0 || v === null) continue;
+    switch (kind) {
+      case "address":
+        out.push(...fieldBytes(number, (0, import_utils3.hexToBytes)(toHexAddress(String(v)))));
+        break;
+      case "bytes":
+        out.push(...fieldBytes(number, (0, import_utils3.hexToBytes)(String(v).replace(/^0x/, ""))));
+        break;
+      case "string":
+        out.push(...fieldBytes(number, new TextEncoder().encode(String(v))));
+        break;
+      case "int": {
+        const n = BigInt(v);
+        if (n !== 0n) out.push(...fieldVarint(number, n));
+        break;
+      }
+      case "bool":
+        if (v) out.push(...fieldVarint(number, 1n));
+        break;
+      case "resource": {
+        const r = typeof v === "number" ? v : RESOURCES.indexOf(v);
+        if (r < 0) throw new Error(`unknown resource ${String(v)}`);
+        if (r !== 0) out.push(...fieldVarint(number, BigInt(r)));
+        break;
+      }
+    }
+  }
+  return Uint8Array.from(out);
+}
+function encodeRawData(raw) {
+  const out = [];
+  if (raw.ref_block_bytes) out.push(...fieldBytes(1, (0, import_utils3.hexToBytes)(raw.ref_block_bytes)));
+  if (raw.ref_block_num) out.push(...fieldVarint(3, BigInt(raw.ref_block_num)));
+  if (raw.ref_block_hash) out.push(...fieldBytes(4, (0, import_utils3.hexToBytes)(raw.ref_block_hash)));
+  if (raw.expiration) out.push(...fieldVarint(8, BigInt(raw.expiration)));
+  if (raw.data) out.push(...fieldBytes(10, (0, import_utils3.hexToBytes)(raw.data)));
+  for (const c of raw.contract ?? []) {
+    const type = c.type;
+    const enumType = CONTRACT_ENUM[type];
+    const typeUrl = c.parameter.type_url ?? `${TYPE_URL_PREFIX}${type}`;
+    const any = Uint8Array.from([...fieldBytes(1, new TextEncoder().encode(typeUrl)), ...fieldBytes(2, encodeParameter(type, c.parameter.value))]);
+    const contract = [];
+    if (enumType !== void 0 && enumType !== 0) contract.push(...fieldVarint(1, BigInt(enumType)));
+    contract.push(...fieldBytes(2, any));
+    const pid = c.Permission_id;
+    if (pid) contract.push(...fieldVarint(5, BigInt(pid)));
+    out.push(...fieldBytes(11, Uint8Array.from(contract)));
+  }
+  if (raw.timestamp) out.push(...fieldVarint(14, BigInt(raw.timestamp)));
+  if (raw.fee_limit) out.push(...fieldVarint(18, BigInt(raw.fee_limit)));
+  return Uint8Array.from(out);
+}
+var norm = (key, v) => {
+  if (v === void 0 || v === null) return "";
+  if (typeof v === "boolean") return v ? "1" : "";
+  if (typeof v === "bigint" || typeof v === "number") return v === 0 || v === 0n ? "" : v.toString();
+  const s = String(v);
+  if (key.endsWith("_address")) {
+    try {
+      return toHexAddress(s);
+    } catch {
+      return s.toLowerCase();
+    }
+  }
+  if (/^\d+$/.test(s)) return s === "0" ? "" : s;
+  return s.replace(/^0x/, "").toLowerCase();
+};
+function rawMismatch(json, decoded) {
+  if (!json) return null;
+  const top = ["ref_block_bytes", "ref_block_hash", "expiration", "timestamp", "fee_limit", "data"];
+  for (const k of top) if (norm(k, json[k]) !== norm(k, decoded[k])) return `raw_data.${k}: JSON says ${JSON.stringify(json[k] ?? null)}, bytes say ${JSON.stringify(decoded[k] ?? null)}`;
+  const jc = json.contract ?? [];
+  if (jc.length !== decoded.contract.length) return `raw_data.contract: JSON lists ${jc.length} contract(s), bytes carry ${decoded.contract.length}`;
+  for (let i = 0; i < jc.length; i++) {
+    const a = jc[i];
+    const b = decoded.contract[i];
+    if (a.type !== b.type) return `contract[${i}].type: JSON says ${a.type}, bytes say ${b.type}`;
+    const av = a.parameter?.value ?? {};
+    const bv = b.parameter.value;
+    const hasSchema = isDecodedContractType(b.type);
+    for (const key of /* @__PURE__ */ new Set([...Object.keys(av), ...Object.keys(bv)])) {
+      if (key === "raw_parameter_hex") continue;
+      if (!hasSchema && key !== "owner_address") continue;
+      if (norm(key, av[key]) !== norm(key, bv[key])) return `contract[${i}].${key}: JSON says ${JSON.stringify(av[key] ?? null)}, bytes say ${JSON.stringify(bv[key] ?? null)}`;
+    }
+  }
+  return null;
+}
+function verifyRawTransaction(tx) {
+  const hex = typeof tx.raw_data_hex === "string" ? tx.raw_data_hex.replace(/^0x/, "") : "";
+  if (!hex || hex.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(hex)) throw new UnsafeTransactionError("raw-undecodable", "The transaction has no raw_data_hex; a Tron signature covers those bytes, so nothing else can be signed.");
+  const bytes = (0, import_utils3.hexToBytes)(hex);
+  const txID = (0, import_utils3.bytesToHex)((0, import_sha22.sha256)(bytes));
+  if (typeof tx.txID !== "string" || tx.txID.replace(/^0x/, "").toLowerCase() !== txID) {
+    throw new UnsafeTransactionError("txid-mismatch", `txID ${String(tx.txID)} is not sha256(raw_data_hex) (${txID}); refusing to sign a hash that does not belong to these bytes.`);
+  }
+  let decoded;
+  try {
+    decoded = decodeRawData(bytes);
+  } catch (e) {
+    if (e instanceof NonCanonicalError) throw new UnsafeTransactionError("raw-noncanonical", `raw_data_hex is not the canonical encoding of a Transaction.raw (${e.message}); the node could read these bytes differently from the wallet, so they are not signed.`);
+    throw new UnsafeTransactionError("raw-undecodable", `raw_data_hex is not a well-formed Transaction.raw (${e.message}); refusing to sign what cannot be read.`);
+  }
+  const mismatch = rawMismatch(tx.raw_data, decoded.raw_data);
+  if (mismatch) throw new UnsafeTransactionError("raw-mismatch", `The transaction's JSON does not match the bytes that would be signed \u2014 ${mismatch}.`);
+  return { ...decoded, bytes, txID };
+}
+
+// src/describe.ts
+var ZERO_ADDRESS = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
+var ZERO_ADDRESS_HEX = "41" + "0".repeat(40);
+var MAX_UINT256 = (1n << 256n) - 1n;
+var UNLIMITED_THRESHOLD = 1n << 255n;
+var SELECTORS = {
+  a9059cbb: "transfer",
+  "095ea7b3": "approve",
+  "23b872dd": "transferFrom"
+};
+var isZero = (hex) => hex.toLowerCase() === ZERO_ADDRESS_HEX;
+var b58 = (a) => a ? toBase58Address(a) : void 0;
+var isUnlimited = (v) => v === MAX_UINT256 || v >= UNLIMITED_THRESHOLD;
+function warn(list, code, message) {
+  list.push({ code, message });
+}
+function describeCalldata(d, contract, data, warnings) {
+  const { selector: selector2, words } = splitCalldata(data);
+  d.selector = selector2;
+  d.contract = toBase58Address(contract);
+  const fn = SELECTORS[selector2];
+  if (fn === "transfer" && words.length >= 2) {
+    d.kind = "trc20-transfer";
+    d.token = d.contract;
+    d.to = toBase58Address(decodeAddressWord(words[0]));
+    d.amount = decodeUint(words[1]);
+    if (isZero(decodeAddressWord(words[0]))) warn(warnings, "zero-address", "Tokens would be sent to the zero address (burned).");
+  } else if (fn === "approve" && words.length >= 2) {
+    d.kind = "trc20-approve";
+    d.token = d.contract;
+    d.spender = toBase58Address(decodeAddressWord(words[0]));
+    d.amount = decodeUint(words[1]);
+    if (isUnlimited(d.amount)) warn(warnings, "unlimited-approve", `Unlimited TRC-20 approval for ${d.spender}.`);
+  } else {
+    d.kind = "contract-call";
+    if (fn === "transferFrom" && words.length >= 3) {
+      d.from = toBase58Address(decodeAddressWord(words[0]));
+      d.to = toBase58Address(decodeAddressWord(words[1]));
+      d.amount = decodeUint(words[2]);
+      d.token = d.contract;
+    }
+  }
+}
+function describeContractCall(tx, warnings) {
+  const d = { kind: "contract-call", warnings };
+  let data = selector(tx.functionSelector);
+  try {
+    data += encodeParameters(tx.parameters ?? []);
+  } catch {
+  }
+  describeCalldata(d, tx.contractAddress, data, warnings);
+  if (tx.options?.callValue) d.callValue = BigInt(tx.options.callValue);
+  if (tx.options?.feeLimit !== void 0) d.feeLimit = tx.options.feeLimit;
+  return d;
+}
+function describeRaw(tx, warnings, ctx) {
+  const d = { kind: "unknown", warnings };
+  let raw;
+  let undecodedFields = [];
+  if (typeof tx.raw_data_hex === "string" && tx.raw_data_hex.length > 0) {
+    try {
+      const decoded = decodeRawData(tx.raw_data_hex);
+      raw = decoded.raw_data;
+      undecodedFields = [...decoded.unknownFields.map((n) => -n), ...decoded.raw_data.contract.flatMap((c) => isDecodedContractType(c.type) ? c.undecoded : [])];
+    } catch (e) {
+      warn(warnings, "raw-undecodable", `raw_data_hex is not a well-formed Transaction.raw (${e.message}); the wallet cannot say what this transaction does and will not sign it.`);
+      return d;
+    }
+  } else {
+    raw = tx.raw_data;
+    warn(warnings, "no-raw-hex", "The transaction carries no raw_data_hex: this description comes from the unsigned JSON copy and the wallet will not sign it.");
+  }
+  const contracts = raw?.contract ?? [];
+  if (contracts.length !== 1) warn(warnings, "multi-contract", `The transaction carries ${contracts.length} contracts; the wallet signs exactly one.`);
+  const contract = contracts[0];
+  const v = contract?.parameter?.value ?? {};
+  const from = b58(v.owner_address);
+  if (from) d.from = from;
+  switch (contract?.type) {
+    case "TransferContract": {
+      d.kind = "trx-transfer";
+      const to = toHexAddress(String(v.to_address));
+      d.to = toBase58Address(to);
+      d.amount = BigInt(v.amount ?? 0);
+      if (isZero(to)) warn(warnings, "zero-address", "TRX would be sent to the zero address (burned).");
+      break;
+    }
+    case "TransferAssetContract": {
+      d.kind = "trc10-transfer";
+      const to = toHexAddress(String(v.to_address));
+      d.to = toBase58Address(to);
+      d.amount = BigInt(v.amount ?? 0);
+      if (typeof v.asset_name === "string") d.token = hexToText(v.asset_name);
+      if (isZero(to)) warn(warnings, "zero-address", "Tokens would be sent to the zero address (burned).");
+      break;
+    }
+    case "TriggerSmartContract": {
+      describeCalldata(d, String(v.contract_address), String(v.data ?? ""), warnings);
+      if (v.call_value) d.callValue = BigInt(v.call_value);
+      break;
+    }
+    case "FreezeBalanceV2Contract":
+    case "FreezeBalanceContract":
+      d.kind = "freeze";
+      d.amount = BigInt(v.frozen_balance ?? 0);
+      d.resource = v.resource ?? "BANDWIDTH";
+      break;
+    case "UnfreezeBalanceV2Contract":
+    case "UnfreezeBalanceContract":
+      d.kind = "unfreeze";
+      if (v.unfreeze_balance !== void 0) d.amount = BigInt(v.unfreeze_balance);
+      d.resource = v.resource ?? "BANDWIDTH";
+      break;
+    default:
+      d.kind = "unknown";
+      if (!contract) break;
+      if (isDecodedContractType(contract.type)) {
+        const fields = Object.entries(v).filter(([k]) => k !== "owner_address").map(([k, x]) => `${k}=${k.endsWith("_address") ? b58(String(x)) : String(x)}`);
+        warn(warnings, "undecoded", `${contract.type}: no summary for this contract type; decoded fields: ${fields.join(", ") || "none"}.`);
+      } else {
+        warn(warnings, "undecoded", `${contract.type}: this contract type is not decoded by the wallet \u2014 only its owner is known; its parameters are not shown, and the dApp's own description of them is not checked.`);
+      }
+  }
+  if (contract?.type === "AccountPermissionUpdateContract") warn(warnings, "account-permission", "AccountPermissionUpdateContract changes which keys control this account \u2014 a signature here can hand the account to someone else.");
+  if (undecodedFields.length) warn(warnings, "undecoded", `${contract?.type ?? "transaction"}: field(s) ${undecodedFields.map((n) => n < 0 ? `raw.${-n}` : String(n)).join(", ")} were not decoded; the sheet cannot show their meaning.`);
+  if (raw?.fee_limit !== void 0) d.feeLimit = raw.fee_limit;
+  if (raw?.data) {
+    d.memo = hexToText(raw.data);
+    warn(warnings, "memo-fee", "A memo is attached: the network charges the memo fee (1 TRX by default).");
+  }
+  if (raw?.expiration !== void 0) {
+    d.expiration = raw.expiration;
+    if (raw.expiration <= (ctx.now ?? Date.now())) warn(warnings, "expired", "The transaction has already expired.");
+  }
+  return d;
+}
+function describeTransaction(tx, ctx = {}) {
+  const warnings = [];
+  let d;
+  if (isPrebuilt(tx)) d = describeRaw(tx, warnings, ctx);
+  else if (isContractCall(tx)) d = describeContractCall(tx, warnings);
+  else {
+    const { to, value } = tx;
+    const hex = toHexAddress(to);
+    d = { kind: "trx-transfer", warnings, to: toBase58Address(hex), amount: BigInt(value) };
+    if (isZero(hex)) warn(warnings, "zero-address", "TRX would be sent to the zero address (burned).");
+  }
+  const memo = !isPrebuilt(tx) ? tx.memo : void 0;
+  if (memo) {
+    d.memo = memo;
+    warn(warnings, "memo-fee", "A memo is attached: the network charges the memo fee (1 TRX by default).");
+  }
+  if (ctx.recipientExists === false && (d.kind === "trx-transfer" || d.kind === "trc20-transfer") && d.to) {
+    warn(warnings, "unactivated-recipient", d.kind === "trx-transfer" ? `${d.to} does not exist yet: the transfer also pays the account creation fee (1.1 TRX without staked bandwidth).` : `${d.to} does not exist yet: a fresh TRC-20 holder costs more energy.`);
+  }
+  return d;
+}
+
+// src/read-only-account.ts
+var import_core2 = require("@anywalletkit/core");
+var import_secp256k12 = require("@noble/curves/secp256k1.js");
+var import_sha33 = require("@noble/hashes/sha3.js");
+var import_utils6 = require("@noble/hashes/utils.js");
+
+// src/build-check.ts
+var import_utils4 = require("@noble/hashes/utils.js");
+var TYPE_URL_PREFIX2 = "type.googleapis.com/protocol.";
+var BUILD_FIELDS = [1, 3, 4, 8, 11, 14, 18];
+var PARAM_KEYS = {
+  TransferContract: ["owner_address", "to_address", "amount"],
+  TriggerSmartContract: ["owner_address", "contract_address", "call_value", "data"]
+};
+var fail = (what) => {
+  throw new UnsafeTransactionError("build-mismatch", `The node built a different transaction than requested \u2014 ${what}. Nothing was signed.`);
+};
+var big = (v) => v === void 0 || v === null ? 0n : BigInt(v);
+var sameAddress = (a, b) => {
+  try {
+    return typeof a === "string" && toHexAddress(a) === toHexAddress(b);
+  } catch {
+    return false;
+  }
+};
+function assertNodeBuild(tx, expected, memo) {
+  const v = verifyRawTransaction(tx);
+  const allowed = new Set(memo ? [...BUILD_FIELDS, 10] : BUILD_FIELDS);
+  const top = readFields(v.bytes);
+  const extra = top.filter((f) => !allowed.has(f.number)).map((f) => f.number);
+  if (extra.length) fail(`raw_data carries field(s) ${[...new Set(extra)].join(", ")}`);
+  const contracts = top.filter((f) => f.number === 11);
+  if (contracts.length !== 1) fail(`${contracts.length} contracts instead of one`);
+  const wrapper = readFields(contracts[0].value).filter((f) => f.number !== 1 && f.number !== 2).map((f) => f.number);
+  if (wrapper.length) fail(`the contract carries field(s) ${wrapper.join(", ")}${wrapper.includes(5) ? " (Permission_id)" : ""}`);
+  const c = v.raw_data.contract[0];
+  if (c.type !== expected.type) fail(`${c.type} instead of ${expected.type}`);
+  if (c.parameter.type_url !== TYPE_URL_PREFIX2 + expected.type) fail(`type_url ${c.parameter.type_url}`);
+  const p = c.parameter.value;
+  const unknownKeys = Object.keys(p).filter((k) => !PARAM_KEYS[expected.type].includes(k));
+  if (unknownKeys.length) fail(`${expected.type} carries ${unknownKeys.join(", ")}`);
+  if (!sameAddress(p.owner_address, expected.owner)) fail("the owner is not this account");
+  if (expected.type === "TransferContract") {
+    if (!sameAddress(p.to_address, expected.to)) fail(`recipient ${String(p.to_address)} instead of ${toHexAddress(expected.to)}`);
+    if (big(p.amount) !== expected.amount) fail(`amount ${String(p.amount)} instead of ${expected.amount}`);
+    if (v.raw_data.fee_limit !== void 0) fail(`a TRX transfer with fee_limit ${v.raw_data.fee_limit}`);
+  } else {
+    if (!sameAddress(p.contract_address, expected.contract)) fail(`contract ${String(p.contract_address)} instead of ${toHexAddress(expected.contract)}`);
+    const want = expected.data.replace(/^0x/, "").toLowerCase();
+    if (String(p.data ?? "").toLowerCase() !== want) fail("the calldata differs from the requested call");
+    if (big(p.call_value) !== expected.callValue) fail(`call_value ${String(p.call_value ?? 0)} instead of ${expected.callValue}`);
+    if (big(v.raw_data.fee_limit) !== expected.feeLimit) fail(`fee_limit ${String(v.raw_data.fee_limit ?? 0)} instead of ${expected.feeLimit}`);
+  }
+  const data = v.raw_data.data;
+  if (memo ? data !== (0, import_utils4.bytesToHex)(memo) : data !== void 0) fail(memo ? "the memo differs" : "an unrequested memo");
+}
+
+// src/memo.ts
+var import_sha23 = require("@noble/hashes/sha2.js");
+var import_utils5 = require("@noble/hashes/utils.js");
+var MEMO_FIELD = 10;
+var MAX_MEMO_BYTES = 512;
+function walkRecords(bytes) {
+  const out = [];
+  let i = 0;
+  const varint = () => {
+    let shift = 0n;
+    let v = 0n;
+    for (; ; ) {
+      if (i >= bytes.length) throw new Error("truncated varint");
+      const b = bytes[i++];
+      v |= BigInt(b & 127) << shift;
+      if ((b & 128) === 0) return v;
+      shift += 7n;
+      if (shift > 63n) throw new Error("varint too long");
+    }
+  };
+  while (i < bytes.length) {
+    const start = i;
+    const tag = varint();
+    const field = Number(tag >> 3n);
+    const wire = Number(tag & 7n);
+    if (field === 0) throw new Error("field 0");
+    switch (wire) {
+      case 0:
+        varint();
+        break;
+      case 1:
+        i += 8;
+        break;
+      case 2: {
+        const len = Number(varint());
+        i += len;
+        break;
+      }
+      case 5:
+        i += 4;
+        break;
+      default:
+        throw new Error(`unsupported wire type ${wire}`);
+    }
+    if (i > bytes.length) throw new Error("truncated record");
+    out.push({ field, start, end: i });
+  }
+  return out;
+}
+function encodeVarint2(n) {
+  const out = [];
+  do {
+    let b = n & 127;
+    n >>>= 7;
+    if (n !== 0) b |= 128;
+    out.push(b);
+  } while (n !== 0);
+  return out;
+}
+function memoBytes(memo, encoding = "utf8") {
+  if (encoding === "utf8") return new TextEncoder().encode(memo);
+  const h = memo.startsWith("0x") ? memo.slice(2) : memo;
+  if (!h || h.length % 2 || /[^0-9a-f]/i.test(h)) throw new UnsafeTransactionError("memo", "A hex memo must be non-empty, even-length hex.");
+  return (0, import_utils5.hexToBytes)(h.toLowerCase());
+}
+function encodeMemoRecord(memo, encoding = "utf8") {
+  const bytes = memoBytes(memo, encoding);
+  if (bytes.length === 0) throw new UnsafeTransactionError("memo", "A memo must not be empty.");
+  if (bytes.length > MAX_MEMO_BYTES) throw new UnsafeTransactionError("memo", `Memo is ${bytes.length} bytes; the limit is ${MAX_MEMO_BYTES}.`);
+  return Uint8Array.from([MEMO_FIELD << 3 | 2, ...encodeVarint2(bytes.length), ...bytes]);
+}
+function attachMemo(tx, memo, encoding = "utf8") {
+  if (tx.raw_data?.data) throw new UnsafeTransactionError("memo", "The transaction already carries a memo (raw_data.data).");
+  if (tx.signature?.length) throw new UnsafeTransactionError("memo", "Cannot attach a memo to an already signed transaction.");
+  const raw = (0, import_utils5.hexToBytes)(tx.raw_data_hex);
+  let records;
+  try {
+    records = walkRecords(raw);
+  } catch (e) {
+    throw new UnsafeTransactionError("memo", `raw_data_hex is not a well-formed protobuf message (${e.message}); refusing to attach a memo.`);
+  }
+  if (records.some((r) => r.field === MEMO_FIELD)) throw new UnsafeTransactionError("memo", "raw_data_hex already contains field 10 (data).");
+  const record = encodeMemoRecord(memo, encoding);
+  const after = records.find((r) => r.field > MEMO_FIELD);
+  const at = after ? after.start : raw.length;
+  const out = new Uint8Array(raw.length + record.length);
+  out.set(raw.subarray(0, at), 0);
+  out.set(record, at);
+  out.set(raw.subarray(at), at + record.length);
+  return {
+    ...tx,
+    txID: (0, import_utils5.bytesToHex)((0, import_sha23.sha256)(out)),
+    raw_data_hex: (0, import_utils5.bytesToHex)(out),
+    raw_data: { ...tx.raw_data, data: (0, import_utils5.bytesToHex)(memoBytes(memo, encoding)) }
+  };
+}
+
+// src/read-only-account.ts
+var DEFAULT_FEE_LIMIT_SUN = 15e6;
+var FEE_LIMIT_MARGIN = 1.2;
+var SIGNATURE_BYTES = 65;
+var RESULT_RESERVE_BYTES = 64;
+var varintLen = (n) => n < 128 ? 1 : n < 16384 ? 2 : 3;
+function bandwidthPoints(rawDataHex, signatures = 1) {
+  const raw = Math.ceil(rawDataHex.replace(/^0x/, "").length / 2);
+  return 1 + varintLen(raw) + raw + signatures * (1 + 1 + SIGNATURE_BYTES) + RESULT_RESERVE_BYTES;
+}
+var PARAM_DEFAULTS = {
+  getMemoFee: 1000000n,
+  getCreateAccountFee: 100000n,
+  getCreateNewAccountFeeInSystemContract: 1000000n,
+  getCreateNewAccountBandwidthRate: 1n
+};
+function hashMessage(message) {
+  const bytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+  const prefix = new TextEncoder().encode(`TRON Signed Message:
+${bytes.length}`);
+  const all = new Uint8Array(prefix.length + bytes.length);
+  all.set(prefix, 0);
+  all.set(bytes, prefix.length);
+  return (0, import_sha33.keccak_256)(all);
+}
+function recoverMessageAddress(message, signature) {
+  try {
+    const sig = (0, import_utils6.hexToBytes)(signature.replace(/^0x/, ""));
+    if (sig.length !== 65) return void 0;
+    let v = sig[64];
+    if (v >= 27) v -= 27;
+    if (v > 1) return void 0;
+    const recovered = new Uint8Array(65);
+    recovered[0] = v;
+    recovered.set(sig.slice(0, 64), 1);
+    return addressFromPublicKey(import_secp256k12.secp256k1.recoverPublicKey(recovered, hashMessage(message), { prehash: false }));
+  } catch {
+    return void 0;
+  }
+}
+var contractOf = (tx) => {
+  let c = tx.raw_data?.contract?.[0];
+  if (typeof tx.raw_data_hex === "string" && tx.raw_data_hex.length) {
+    try {
+      c = decodeRawData(tx.raw_data_hex).raw_data.contract[0];
+    } catch {
+    }
+  }
+  return { type: c?.type, value: c?.parameter?.value ?? {} };
+};
+var WalletAccountReadOnlyTron = class {
+  /** base58 T… */
+  address;
+  /** Hex form (`41…`). */
+  addressHex;
+  chain;
+  _config;
+  _client;
+  constructor(address, config = {}) {
+    this.address = toBase58Address(address);
+    this.addressHex = toHexAddress(address);
+    this._config = config;
+    this._client = createClient(config);
+    const net = config.network ?? "mainnet";
+    this.chain = CAIP2_GENESIS[net] ?? (net.startsWith("tron:") ? net : `tron:${net}`);
+  }
+  requireClient(what) {
+    if (!this._client) throw new import_core2.NetworkError(`The wallet must be connected to a provider to ${what}.`);
+    return this._client;
+  }
+  async post(path, body, what) {
+    const res = await this.requireClient(what)(path, body);
+    assertNoError(res, what);
+    return res;
+  }
+  /** The base58 address. */
+  async getAddress() {
+    return this.address;
+  }
+  /** TRX balance in sun; 0 for an account that does not exist yet. */
+  async getBalance() {
+    const acc = await this.post("/wallet/getaccount", { address: this.addressHex, visible: false }, "retrieve balances");
+    return BigInt(acc.balance ?? 0);
+  }
+  /** Read-only contract call. Returns constant_result hex strings. */
+  async constantCall(contract, functionSelector, parameters, what, extra = {}) {
+    return this.post(
+      "/wallet/triggerconstantcontract",
+      { owner_address: this.addressHex, contract_address: toHexAddress(contract), function_selector: functionSelector, parameter: encodeParameters(parameters), visible: false, ...extra },
+      what
+    );
+  }
+  /** TRC-20 `balanceOf` in the token's base units. */
+  async getTokenBalance(token) {
+    const r = await this.constantCall(token, "balanceOf(address)", [{ type: "address", value: this.address }], "retrieve token balances");
+    return decodeUint(r.constant_result?.[0] ?? "0");
+  }
+  /** Several TRC-20 balances in parallel, keyed by the tokens as given. */
+  async getTokenBalances(tokens) {
+    const out = {};
+    await Promise.all(tokens.map(async (t) => {
+      out[t] = await this.getTokenBalance(t);
+    }));
+    return out;
+  }
+  /** TRC-20 `allowance(owner, spender)` in base units. */
+  async getAllowance(token, spender) {
+    const r = await this.constantCall(token, "allowance(address,address)", [{ type: "address", value: this.address }, { type: "address", value: spender }], "read allowances");
+    return decodeUint(r.constant_result?.[0] ?? "0");
+  }
+  /** Does an account exist on chain (`/wallet/getaccount` non-empty)? */
+  async accountExists(address) {
+    const acc = await this.post("/wallet/getaccount", { address: toHexAddress(address), visible: false }, "check the recipient account");
+    return Object.keys(acc).length > 0;
+  }
+  // ── Building ────────────────────────────────────────────────────────────────
+  /**
+   * Ask the node for `raw_data`. Contract calls are simulated first so `fee_limit`
+   * can be derived from the energy they need (×1.2, capped at `transactionMaxFee`)
+   * when the caller gives none; the simulation rides along so nobody pays for a second one.
+   */
+  async buildWithSimulation(tx) {
+    if (isPrebuilt(tx)) return { built: tx };
+    if (isContractCall(tx)) {
+      const { contractAddress, functionSelector, parameters = [], options = {} } = tx;
+      const sim = await this.simulateCall({ contractAddress, functionSelector, parameters, options });
+      let feeLimit = options.feeLimit;
+      if (feeLimit === void 0) {
+        const energyPrice = Number(await this.getChainParameter("getEnergyFee"));
+        feeLimit = sim.ok && sim.energy > 0 ? Math.ceil(sim.energy * energyPrice * FEE_LIMIT_MARGIN) : DEFAULT_FEE_LIMIT_SUN;
+        const max = this._config.transactionMaxFee;
+        if (max !== void 0 && feeLimit > Number(max)) feeLimit = Number(max);
+      }
+      const r = await this.post("/wallet/triggersmartcontract", {
+        owner_address: this.addressHex,
+        contract_address: toHexAddress(contractAddress),
+        function_selector: functionSelector,
+        parameter: encodeParameters(parameters),
+        fee_limit: feeLimit,
+        call_value: options.callValue ?? 0,
+        visible: false
+      }, "build a contract call");
+      if (!r.transaction) throw new Error("triggersmartcontract returned no transaction");
+      const built2 = tx.memo ? attachMemo(r.transaction, tx.memo, tx.memoEncoding) : r.transaction;
+      assertNodeBuild(built2, {
+        type: "TriggerSmartContract",
+        owner: this.addressHex,
+        contract: contractAddress,
+        data: selector(functionSelector) + encodeParameters(parameters),
+        callValue: BigInt(options.callValue ?? 0),
+        feeLimit: BigInt(feeLimit)
+      }, tx.memo ? memoBytes(tx.memo, tx.memoEncoding) : void 0);
+      return { built: built2, sim };
+    }
+    const { to, value, memo, memoEncoding } = tx;
+    const node = await this.post("/wallet/createtransaction", { owner_address: this.addressHex, to_address: toHexAddress(to), amount: Number(BigInt(value)), visible: false }, "build a transfer");
+    const built = memo ? attachMemo(node, memo, memoEncoding) : node;
+    assertNodeBuild(built, { type: "TransferContract", owner: this.addressHex, to, amount: BigInt(value) }, memo ? memoBytes(memo, memoEncoding) : void 0);
+    return { built };
+  }
+  async buildTransaction(tx) {
+    return (await this.buildWithSimulation(tx)).built;
+  }
+  // ── Simulation ──────────────────────────────────────────────────────────────
+  /** Constant call by selector + params (unbuilt contract call). Never throws on a revert. */
+  async simulateCall(tx) {
+    return this.constantSimulation({
+      owner_address: this.addressHex,
+      contract_address: toHexAddress(tx.contractAddress),
+      function_selector: tx.functionSelector,
+      parameter: encodeParameters(tx.parameters ?? []),
+      call_value: tx.options?.callValue ?? 0,
+      visible: false
+    });
+  }
+  async constantSimulation(body) {
+    const res = await this.requireClient("simulate transactions")("/wallet/triggerconstantcontract", body);
+    if (res?.Error) return { ok: false, energy: 0, reason: res.Error };
+    const energy = res.energy_used ?? 0;
+    if (res.result && res.result.result === false) {
+      return { ok: false, energy, reason: `${res.result.code ?? "CONTRACT_VALIDATE_ERROR"}${res.result.message ? `: ${hexToText(res.result.message)}` : ""}` };
+    }
+    const ret = res.transaction?.ret?.[0];
+    const failed = ret?.ret === "FAILED" || ret?.contractRet !== void 0 && ret.contractRet !== "SUCCESS";
+    if (failed) {
+      const reason = decodeRevertReason(res.constant_result?.[0]) ?? ret?.contractRet ?? "REVERT";
+      const prefix = ret?.contractRet && ret.contractRet !== "REVERT" ? `${ret.contractRet}: ` : "";
+      return { ok: false, energy, reason: prefix + reason, constantResult: res.constant_result };
+    }
+    return { ok: true, energy, constantResult: res.constant_result };
+  }
+  /**
+   * Predict the outcome without signing: contract calls run through
+   * `/wallet/triggerconstantcontract` (revert reason ABI-decoded); TRX transfers check
+   * that the balance covers amount + fees. Transport failures throw, predicted failures don't.
+   */
+  async simulateTransaction(tx) {
+    this.requireClient("simulate transactions");
+    if (isContractCall(tx)) return this.simulateCall(tx);
+    if (!isPrebuilt(tx)) {
+      const { to, value } = tx;
+      return this.simulateNativeTransfer(BigInt(value));
+    }
+    return this.simulateRaw(tx);
+  }
+  async simulateRaw(tx) {
+    const { type, value } = contractOf(tx);
+    if (type === "TriggerSmartContract") {
+      return this.constantSimulation({
+        owner_address: value.owner_address,
+        contract_address: value.contract_address,
+        data: value.data,
+        call_value: value.call_value ?? 0,
+        visible: tx.visible ?? false
+      });
+    }
+    if (type === "TransferContract") return this.simulateNativeTransfer(BigInt(value.amount ?? 0), tx);
+    return { ok: true, energy: 0 };
+  }
+  async simulateNativeTransfer(amount, built) {
+    const balance = await this.getBalance();
+    const burn = built ? (await this.estimateRaw(built)).trxBurn : 0n;
+    if (balance < amount + burn) return { ok: false, energy: 0, reason: `Insufficient TRX: need ${amount + burn} sun, have ${balance}` };
+    return { ok: true, energy: 0 };
+  }
+  // ── Fees ────────────────────────────────────────────────────────────────────
+  async getResources() {
+    return this.post("/wallet/getaccountresource", { address: this.addressHex, visible: false }, "read account resources");
+  }
+  async getChainParameters() {
+    const r = await this.post("/wallet/getchainparameters", {}, "read chain parameters");
+    const out = { ...PARAM_DEFAULTS };
+    for (const p of r.chainParameter ?? []) if (p.value !== void 0) out[p.key] = BigInt(p.value);
+    return out;
+  }
+  async getChainParameter(key) {
+    const p = (await this.getChainParameters())[key];
+    if (p === void 0) throw new Error(`Chain parameter ${key} not found`);
+    return p;
+  }
+  /**
+   * Resource-by-resource cost of a node-built transaction. `energy` comes from a
+   * constant call unless the caller already has one (`sim`).
+   */
+  async estimateRaw(tx, sim) {
+    const { type, value } = contractOf(tx);
+    const [params, res] = await Promise.all([this.getChainParameters(), this.getResources()]);
+    const energyPrice = params.getEnergyFee ?? 0n;
+    const bandwidthPrice = params.getTransactionFee ?? 0n;
+    const energy = type === "TriggerSmartContract" ? (sim ?? await this.simulateRaw(tx)).energy : 0;
+    const bandwidth = bandwidthPoints(tx.raw_data_hex, Math.max(1, tx.signature?.length ?? 1));
+    const bandwidthFree = Math.max(0, (res.freeNetLimit ?? 0) - (res.freeNetUsed ?? 0));
+    const bandwidthStaked = Math.max(0, (res.NetLimit ?? 0) - (res.NetUsed ?? 0));
+    const energyStaked = Math.max(0, (res.EnergyLimit ?? 0) - (res.EnergyUsed ?? 0));
+    let accountCreationFee = 0n;
+    let creating = false;
+    if ((type === "TransferContract" || type === "TransferAssetContract") && value.to_address) {
+      creating = !await this.accountExists(String(value.to_address));
+      if (creating) {
+        const rate = Number(params.getCreateNewAccountBandwidthRate ?? 1n);
+        accountCreationFee = params.getCreateNewAccountFeeInSystemContract + (bandwidthStaked >= bandwidth * rate ? 0n : params.getCreateAccountFee);
+      }
+    }
+    const bandwidthBurn = creating || bandwidthStaked >= bandwidth || bandwidthFree >= bandwidth ? 0n : BigInt(bandwidth) * bandwidthPrice;
+    const energyBurn = BigInt(Math.max(0, energy - energyStaked)) * energyPrice;
+    const memoFee = tx.raw_data?.data ? params.getMemoFee : 0n;
+    return {
+      bandwidth,
+      energy,
+      trxBurn: bandwidthBurn + energyBurn + accountCreationFee + memoFee,
+      breakdown: { bandwidthFree, bandwidthStaked, energyStaked, energyPrice, bandwidthPrice, memoFee, accountCreationFee, bandwidthBurn, energyBurn }
+    };
+  }
+  /** Build (if needed) and price a transaction: bandwidth, energy and the sun the sender burns. */
+  async estimateFee(tx) {
+    this.requireClient("estimate fees");
+    const { built, sim } = await this.buildWithSimulation(tx);
+    return this.estimateRaw(built, sim);
+  }
+  async quoteTransaction(tx, sim) {
+    const estimate = await this.estimateRaw(tx, sim);
+    return { fee: estimate.trxBurn, activationFee: estimate.breakdown.accountCreationFee, estimate };
+  }
+  /** `fee` = the sun the sender burns, after staked / free resources. */
+  async quoteSendTransaction(tx) {
+    this.requireClient("quote transactions");
+    const { built, sim } = await this.buildWithSimulation(tx);
+    return this.quoteTransaction(built, sim);
+  }
+  trc20TransferParams(recipient, amount) {
+    return [{ type: "address", value: recipient }, { type: "uint256", value: BigInt(amount) }];
+  }
+  asTransaction(o) {
+    const memo = o.memo ? { memo: o.memo, ...o.memoEncoding ? { memoEncoding: o.memoEncoding } : {} } : {};
+    return o.token ? { contractAddress: o.token, functionSelector: "transfer(address,uint256)", parameters: this.trc20TransferParams(o.recipient, o.amount), options: { callValue: 0 }, ...memo } : { to: o.recipient, value: o.amount, ...memo };
+  }
+  /** Fee of a transfer in sun, including account activation when the recipient is new. */
+  async quoteTransfer(o) {
+    this.requireClient("quote transfer operations");
+    return this.quoteSendTransaction(this.asTransaction(o));
+  }
+  // ── Describe ────────────────────────────────────────────────────────────────
+  /** `describeTransaction` plus the `unactivated-recipient` check against the node. */
+  async describeTransactionOnline(tx, ctx = {}) {
+    const offline = describeTransaction(tx, ctx);
+    if (ctx.recipientExists !== void 0 || !offline.to || offline.kind !== "trx-transfer" && offline.kind !== "trc20-transfer") return offline;
+    return describeTransaction(tx, { ...ctx, recipientExists: await this.accountExists(offline.to) });
+  }
+  /** The receipt, or `undefined` while the transaction is unconfirmed. */
+  async getTransactionReceipt(hash) {
+    const info = await this.post("/wallet/gettransactioninfobyid", { value: hash }, "fetch transaction receipts");
+    if (!info || Object.keys(info).length === 0) return void 0;
+    const receipt = info.receipt;
+    const failed = info.result === "FAILED" || receipt?.result !== void 0 && receipt.result !== "SUCCESS";
+    return { hash, status: failed ? 0 : 1, blockNumber: BigInt(info.blockNumber ?? 0), fee: BigInt(info.fee ?? 0), raw: info };
+  }
+  /** Verify a TIP-191 signature produced by `sign` (0x + r||s||v, v = 27|28 or 0|1). */
+  async verify(message, signature) {
+    return recoverMessageAddress(message, signature) === this.address;
+  }
+};
+
+// src/account.ts
+var import_core3 = require("@anywalletkit/core");
+var import_utils7 = require("@noble/hashes/utils.js");
+var MAX_EXPIRATION_MS = 24 * 60 * 60 * 1e3;
+var WalletAccountTron = class _WalletAccountTron extends WalletAccountReadOnlyTron {
+  /** ref block / expiration come from the node, so building needs the network. */
+  needsNetwork = true;
+  /** Derivation path, or `external` for an external signer. */
+  path;
+  /** Compressed secp256k1 key (33 bytes); needed synchronously for the address. */
+  publicKey;
+  /** The signer that holds the key. */
+  signer;
+  _disposed = false;
+  _readOnly;
+  constructor(signer, publicKey, path, config = {}) {
+    super(addressFromPublicKey(publicKey), config);
+    this.signer = (0, import_core3.requireCurve)(signer, "secp256k1");
+    this.publicKey = publicKey;
+    this.path = path;
+  }
+  /** Wrap a raw derived key (takes ownership; zeroized on dispose). Kept for callers that derive themselves. */
+  static fromPrivateKey(privateKey, publicKey, path, config = {}) {
+    return new _WalletAccountTron(import_core3.LocalSigner.fromPrivateKey("secp256k1", privateKey, publicKey, path), publicKey, path, config);
+  }
+  /** Account index for the standard m/44'/195'/0'/0/i path. */
+  get index() {
+    const m = /^m\/44'\/195'\/0'\/0\/(\d+)$/.exec(this.path);
+    return m ? Number(m[1]) : void 0;
+  }
+  key() {
+    if (this._disposed) throw new import_core3.SignerError("This account has been disposed.");
+  }
+  /** Recoverable secp256k1 signature over a 32-byte digest from the signer: r‖s‖recovery (recovery 0/1). */
+  async signDigest(digest, context) {
+    this.key();
+    return this.signer.sign(digest, { scheme: "ecdsa-recoverable", context });
+  }
+  /** TIP-191 message signature: 0x + r||s||(27 + recovery) hex (tronweb `signMessageV2` encoding). */
+  async sign(message) {
+    const sig = await this.signDigest(hashMessage(message), "tron-message");
+    return "0x" + (0, import_utils7.bytesToHex)(sig.subarray(0, 64)) + (27 + sig[64]).toString(16).padStart(2, "0");
+  }
+  /**
+   * Sign a prebuilt transaction (ours or a dApp's) and attach `signature: [r||s||recovery]`
+   * (recovery as 00/01, tronweb encoding). The signature covers `sha256(raw_data_hex)`, so
+   * that is what is checked and signed: `txID` must equal it, the JSON `raw_data` must agree
+   * with the bytes field by field, and the hard checks ({@link assertSafe}) run on the bytes.
+   * A transaction whose JSON says "1 TRX to me" while the bytes say otherwise is refused
+   * (`raw-mismatch`), as is a `txID` that does not belong to the bytes (`txid-mismatch`).
+   */
+  async signRaw(tx) {
+    this.key();
+    const verified = verifyRawTransaction(tx);
+    this.assertSafe({ ...tx, raw_data: verified.raw_data });
+    const sig = await this.signDigest((0, import_utils7.hexToBytes)(verified.txID), "tron-tx");
+    return { ...tx, signature: [(0, import_utils7.bytesToHex)(sig.subarray(0, 64)) + sig[64].toString(16).padStart(2, "0")] };
+  }
+  // ── Hard checks (before anything is signed) ─────────────────────────────────
+  /**
+   * Refuse to sign what cannot be right: a foreign owner, a missing or expired
+   * (or >24h) expiration, no ref block, more than one contract, a TRX / TRC-20
+   * transfer to the zero address (unless `allowBurn`), a `fee_limit` above
+   * `transactionMaxFee`.
+   */
+  assertSafe(tx, now = Date.now()) {
+    const contracts = tx.raw_data?.contract ?? [];
+    if (contracts.length !== 1) throw new UnsafeTransactionError("multi-contract", `Expected exactly one contract in the transaction, got ${contracts.length}.`);
+    const owner = contracts[0]?.parameter?.value?.owner_address;
+    if (!owner || toHexAddress(owner) !== this.addressHex) throw new UnsafeTransactionError("owner-mismatch", "The transaction owner does not match the wallet account address.");
+    if (!tx.raw_data.ref_block_bytes || !tx.raw_data.ref_block_hash) throw new UnsafeTransactionError("missing-ref-block", "The transaction has no reference block (ref_block_bytes / ref_block_hash).");
+    const exp = tx.raw_data.expiration;
+    if (exp === void 0 || exp <= now) throw new UnsafeTransactionError("expired", "The transaction has no expiration or has already expired.");
+    if (exp > now + MAX_EXPIRATION_MS) throw new UnsafeTransactionError("expiration-too-far", "The transaction expiration is more than 24 hours away.");
+    const max = this._config.transactionMaxFee;
+    if (max !== void 0 && tx.raw_data.fee_limit !== void 0 && BigInt(tx.raw_data.fee_limit) > BigInt(max)) {
+      throw new UnsafeTransactionError("fee-limit", `fee_limit ${tx.raw_data.fee_limit} exceeds transactionMaxFee ${max}.`);
+    }
+    if (!this._config.allowBurn) {
+      const d = describeTransaction(tx, { now });
+      if (d.warnings.some((w) => w.code === "zero-address")) throw new UnsafeTransactionError("zero-address", "Refusing to send to the zero address (set allowBurn to override).");
+    }
+  }
+  maxFeeCheck(fee, limit, op) {
+    if (limit !== void 0 && fee > BigInt(limit)) throw new Error(`Exceeded maximum fee cost for ${op} operation${op === "transfer" ? "s" : ""}.`);
+  }
+  /** Build → hard checks → simulate → estimate → fee cap. Shared by sign / send / transfer. */
+  async prepare(tx, maxFee, op) {
+    const { built, sim: fromBuild } = await this.buildWithSimulation(tx);
+    this.assertSafe(isPrebuilt(tx) ? { ...built, raw_data: verifyRawTransaction(built).raw_data } : built);
+    let sim = fromBuild;
+    if (this._config.simulate !== false) {
+      sim ??= await this.simulateRaw(built);
+      if (!sim.ok) throw new SimulationError(sim.reason ?? "unknown", sim.energy);
+    }
+    const quote = await this.quoteTransaction(built, sim);
+    this.maxFeeCheck(quote.fee, maxFee, op);
+    return { built, quote };
+  }
+  /** Build (via the node), check, simulate and sign; returns broadcast-ready transaction JSON. */
+  async signTransaction(tx) {
+    this.key();
+    this.requireClient("sign transactions");
+    const { built } = await this.prepare(tx, this._config.transactionMaxFee, "transaction");
+    return JSON.stringify(await this.signRaw(built));
+  }
+  async broadcast(signed2) {
+    const r = await this.post("/wallet/broadcasttransaction", signed2, "broadcast");
+    if (r.result !== true) throw new Error(`Broadcast failed: ${r.code ?? ""} ${r.message ?? ""}`.trim());
+    return r.txid ?? signed2.txID;
+  }
+  async sendTransaction(tx) {
+    this.key();
+    this.requireClient("send transactions");
+    const parsed = typeof tx === "string" ? JSON.parse(tx) : tx;
+    const { built, quote } = await this.prepare(parsed, this._config.transactionMaxFee, "transaction");
+    const signed2 = isPrebuilt(parsed) && parsed.signature?.length ? built : await this.signRaw(built);
+    return { hash: await this.broadcast(signed2), fee: quote.fee, activationFee: quote.activationFee, estimate: quote.estimate };
+  }
+  /** TRX (no `token`) or TRC-20 `transfer(address,uint256)`. */
+  async transfer(o) {
+    this.key();
+    this.requireClient("transfer tokens");
+    const { built, quote } = await this.prepare(this.asTransaction(o), this._config.transferMaxFee, "transfer");
+    return { hash: await this.broadcast(await this.signRaw(built)), fee: quote.fee, activationFee: quote.activationFee, estimate: quote.estimate };
+  }
+  /** The same address as a {@link WalletAccountReadOnlyTron}. */
+  toReadOnlyAccount() {
+    this._readOnly ??= new WalletAccountReadOnlyTron(this.address, this._config);
+    return this._readOnly;
+  }
+  /** Dispose the signer (zeroizes a local key). Idempotent. */
+  dispose() {
+    this._disposed = true;
+    this.signer.dispose();
+  }
+};
+
+// src/manager.ts
+var import_core4 = require("@anywalletkit/core");
+var TRON_BASE_PATH = "m/44'/195'";
+var TRON_ACCOUNT_BRANCH = `${TRON_BASE_PATH}/0'/0`;
+var WalletManagerTron = class extends import_core4.WalletManager {
+  constructor(seedOrSigner, config = {}) {
+    super(seedOrSigner, config);
+  }
+  async getAccount(index = 0) {
+    return this.getAccountByPath(`${TRON_ACCOUNT_BRANCH}/${index}`);
+  }
+  async getAccountByPath(path) {
+    const full = path.startsWith("m/") || path === "external" ? path : `${TRON_BASE_PATH}/${path}`;
+    const cached = this._accounts.get(full);
+    if (cached) return cached;
+    const external = this.externalSigner();
+    if (external) return this.fromSigner(external, full);
+    const signer = import_core4.LocalSigner.leafFromSeed(this.seedBytes(), "secp256k1", full);
+    const account = new WalletAccountTron(signer, signer.publicKey, full, this._config);
+    this._accounts.set(full, account);
+    return account;
+  }
+  /** Resolve `path` against an injected signer: the signer itself, or a child when it can derive there. */
+  async fromSigner(signer, path) {
+    this.requireSigner("secp256k1");
+    let leaf = signer;
+    let key = "external";
+    if ((0, import_core4.isSeedSigner)(signer)) {
+      if (path === signer.path) key = path;
+      else if (path.startsWith(`${signer.path}/`)) {
+        leaf = await (signer.deriveLeaf ?? signer.derive).call(signer, path.slice(signer.path.length + 1));
+        key = path;
+      } else throw new import_core4.SignerError(`The injected signer sits at ${signer.path}; it cannot provide ${path}.`);
+    } else if (path !== `${TRON_ACCOUNT_BRANCH}/0` && path !== "external") {
+      throw new import_core4.SignerError(`An external signer has one account; ${path} is not derivable from it.`);
+    }
+    const cached = this._accounts.get(key);
+    if (cached) return cached;
+    const account = new WalletAccountTron(leaf, await leaf.getPublicKey(), key, this._config);
+    this._accounts.set(key, account);
+    return account;
+  }
+  /** A read-only account for any address, with this manager's config. */
+  getReadOnlyAccount(address) {
+    return new WalletAccountReadOnlyTron(address, this._config);
+  }
+  /** getTransactionFee chain parameter; normal = ×1.1, fast = ×2.0; slow = ×1.0. */
+  async getFeeRates() {
+    const probe = new WalletAccountReadOnlyTron("T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb", this._config);
+    probe.requireClient("get fee rates");
+    const fee = await probe.getChainParameter("getTransactionFee");
+    return { slow: fee, normal: fee * 110n / 100n, fast: fee * 200n / 100n };
+  }
+};
+
+// src/history.ts
+var HistoryUnavailableError = class extends Error {
+  chain;
+  reason;
+  attempts;
+  constructor(chain, reason, attempts = []) {
+    super(`History unavailable for ${chain}: ${reason}`);
+    this.name = "HistoryUnavailableError";
+    this.chain = chain;
+    this.reason = reason;
+    this.attempts = attempts;
+  }
+};
+var DEFAULT_LIMIT = 25;
+var MAX_LIMIT = 200;
+var DEFAULT_TIMEOUT_MS = 15e3;
+var DEFAULT_URLS = { mainnet: "https://api.trongrid.io", shasta: "https://api.shasta.trongrid.io", nile: "https://nile.trongrid.io" };
+var TRANSFER_TOPIC = "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function b64encode(s) {
+  let out = "";
+  for (let i = 0; i < s.length; i += 3) {
+    const c = [s.charCodeAt(i), s.charCodeAt(i + 1), s.charCodeAt(i + 2)];
+    for (const x of c) if (x > 255) throw new Error("cursor must be ASCII");
+    const n = c[0] << 16 | (c[1] || 0) << 8 | (c[2] || 0);
+    out += B64[n >> 18 & 63] + B64[n >> 12 & 63] + (Number.isNaN(c[1]) ? "=" : B64[n >> 6 & 63]) + (Number.isNaN(c[2]) ? "=" : B64[n & 63]);
+  }
+  return out;
+}
+function b64decode(s) {
+  const clean = s.replace(/[^A-Za-z0-9+/]/g, "");
+  let out = "";
+  for (let i = 0; i < clean.length; i += 4) {
+    const c = [0, 1, 2, 3].map((k) => i + k < clean.length ? B64.indexOf(clean[i + k]) : -1);
+    if (c[0] < 0 || c[1] < 0) throw new Error("bad base64");
+    const n = c[0] << 18 | c[1] << 12 | (c[2] < 0 ? 0 : c[2]) << 6 | (c[3] < 0 ? 0 : c[3]);
+    out += String.fromCharCode(n >> 16 & 255);
+    if (c[2] >= 0) out += String.fromCharCode(n >> 8 & 255);
+    if (c[3] >= 0) out += String.fromCharCode(n & 255);
+  }
+  return out;
+}
+function encodeCursor(c) {
+  return b64encode(JSON.stringify(c));
+}
+function decodeCursor(s) {
+  let parsed;
+  try {
+    parsed = JSON.parse(b64decode(s));
+  } catch {
+    throw new Error("@anywalletkit/wallet-tron: malformed history cursor");
+  }
+  const c = parsed;
+  if (!c || c.v !== 1 || typeof c.w !== "number" || !Array.isArray(c.x) || !Array.isArray(c.e)) throw new Error("@anywalletkit/wallet-tron: malformed history cursor");
+  return { v: 1, w: c.w, x: c.x.filter((x) => typeof x === "string"), e: c.e.filter((x) => x === "tx" || x === "trc20") };
+}
+var TokenBucket = class {
+  constructor(rate, burst = Math.max(1, Math.ceil(rate))) {
+    this.rate = rate;
+    this.burst = burst;
+    this.tokens = burst;
+  }
+  rate;
+  burst;
+  tokens;
+  last = Date.now();
+  chain = Promise.resolve();
+  acquire() {
+    const next = this.chain.then(() => this.take());
+    this.chain = next.catch(() => void 0);
+    return next;
+  }
+  refill() {
+    const now = Date.now();
+    this.tokens = Math.min(this.burst, this.tokens + (now - this.last) / 1e3 * this.rate);
+    this.last = now;
+  }
+  async take() {
+    this.refill();
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return;
+    }
+    await new Promise((r) => setTimeout(r, Math.ceil((1 - this.tokens) / this.rate * 1e3)));
+    this.refill();
+    this.tokens = Math.max(0, this.tokens - 1);
+  }
+};
+function timeoutSignal(ms) {
+  const ctor = globalThis.AbortSignal;
+  return typeof ctor?.timeout === "function" ? ctor.timeout(ms) : void 0;
+}
+var big2 = (v) => {
+  if (typeof v === "bigint") return v;
+  if (typeof v === "number" && Number.isFinite(v)) return BigInt(Math.trunc(v));
+  if (typeof v === "string" && /^-?\d+$/.test(v)) return BigInt(v);
+  return 0n;
+};
+var b582 = (a) => {
+  if (typeof a !== "string" || a.length === 0) return void 0;
+  try {
+    return toBase58Address(a);
+  } catch {
+    return a;
+  }
+};
+var wordToAddress = (word) => toBase58Address("41" + word.slice(-40).toLowerCase());
+var SELF_TYPES_WITH_RECEIVER = {
+  DelegateResourceContract: "receiver_address",
+  UnDelegateResourceContract: "receiver_address",
+  AccountPermissionUpdateContract: "owner_address"
+};
+function mapTransactionRow(chain, address, tx, extra = {}) {
+  const contract = tx.raw_data.contract[0];
+  const v = contract?.parameter.value ?? {};
+  const type = contract?.type ?? "Unknown";
+  const owner = b582(v.owner_address) ?? address;
+  const transfers = [];
+  let call;
+  let to = null;
+  let nativeValue = 0n;
+  switch (type) {
+    case "TransferContract": {
+      to = b582(v.to_address) ?? null;
+      nativeValue = big2(v.amount);
+      if (to && nativeValue > 0n) transfers.push({ token: null, from: owner, to, amount: nativeValue });
+      break;
+    }
+    case "TransferAssetContract": {
+      to = b582(v.to_address) ?? null;
+      const asset = typeof v.asset_name === "string" ? v.asset_name : void 0;
+      const amount = big2(v.amount);
+      if (to && asset && amount > 0n) transfers.push({ token: asset, from: owner, to, amount, symbol: `TRC-10 #${asset}`, decimals: 0 });
+      break;
+    }
+    case "TriggerSmartContract": {
+      const contractAddress = b582(v.contract_address);
+      nativeValue = big2(v.call_value);
+      if (contractAddress) {
+        to = contractAddress;
+        call = { to: contractAddress };
+        const data = typeof v.data === "string" ? v.data.toLowerCase() : "";
+        if (data.length >= 8) {
+          call.selector = `0x${data.slice(0, 8)}`;
+          call.data = `0x${data}`;
+        }
+        if (nativeValue > 0n) transfers.push({ token: null, from: owner, to: contractAddress, amount: nativeValue });
+      }
+      break;
+    }
+    default: {
+      const receiverKey = SELF_TYPES_WITH_RECEIVER[type];
+      const receiver = receiverKey ? b582(v[receiverKey]) : void 0;
+      call = { to: receiver ?? owner, method: type };
+      to = receiver ?? owner;
+    }
+  }
+  for (const it of tx.internal_transactions ?? []) {
+    if (it.rejected) continue;
+    const from = b582(it.caller_address), dest = b582(it.transferTo_address);
+    if (!from || !dest) continue;
+    for (const cv of it.callValueInfo ?? []) {
+      const amount = big2(cv.callValue);
+      if (amount > 0n && !cv.tokenId) transfers.push({ token: null, from, to: dest, amount });
+    }
+  }
+  const trc20 = extra.trc20 ?? [];
+  if (trc20.length > 0) {
+    for (const row of trc20) if (row.type === "Transfer") transfers.push(trc20Transfer(row));
+  } else if (extra.info?.log && extra.info.log.length > 0) {
+    for (const log of extra.info.log) {
+      if (log.topics[0]?.toLowerCase() !== TRANSFER_TOPIC || log.topics.length < 3) continue;
+      transfers.push({ token: toBase58Address("41" + log.address.toLowerCase().slice(-40)), from: wordToAddress(log.topics[1]), to: wordToAddress(log.topics[2]), amount: BigInt(`0x${log.data || "0"}`), standard: "trc20" });
+    }
+  } else if (call?.selector === "0xa9059cbb" && call.data && call.data.length >= 2 + 8 + 128) {
+    const words = call.data.slice(10);
+    transfers.push({ token: call.to, from: owner, to: wordToAddress(words.slice(0, 64)), amount: BigInt(`0x${words.slice(64, 128)}`), standard: "trc20" });
+  }
+  if (call?.selector === "0xa9059cbb" && !call.method) call.method = "transfer";
+  const ret = tx.ret?.[0];
+  const result = extra.info?.receipt?.result ?? ret?.contractRet;
+  const status = result === void 0 ? tx.blockNumber ? "confirmed" : "pending" : result === "SUCCESS" ? "confirmed" : "failed";
+  const feeNum = extra.info?.fee ?? (typeof ret?.fee === "number" ? ret.fee : void 0) ?? (tx.net_fee !== void 0 || tx.energy_fee !== void 0 ? (tx.net_fee ?? 0) + (tx.energy_fee ?? 0) : void 0);
+  const ts = tx.block_timestamp ?? extra.info?.blockTimeStamp ?? tx.raw_data.timestamp;
+  const blockNumber = tx.blockNumber ?? extra.info?.blockNumber;
+  const raw = { tx, trc20 };
+  if (contract?.type === "TransferAssetContract" && owner !== address && to === address) {
+    raw.spam = true;
+    raw.spamReason = "trc10-airdrop";
+  }
+  if (extra.info) raw.info = extra.info;
+  const out = { chain, hash: tx.txID, time: ts ? Math.floor(ts / 1e3) : 0, status, address, from: owner, to: call?.to ?? to, nativeValue, transfers, raw };
+  if (feeNum !== void 0) out.fee = BigInt(Math.trunc(feeNum));
+  if (call) out.call = call;
+  if (blockNumber !== void 0) out.block = BigInt(blockNumber);
+  return out;
+}
+function trc20Transfer(row) {
+  const t = { token: row.token_info.address, from: row.from, to: row.to, amount: big2(row.value), standard: "trc20" };
+  if (row.token_info.symbol !== void 0) t.symbol = row.token_info.symbol;
+  if (row.token_info.decimals !== void 0) t.decimals = row.token_info.decimals;
+  return t;
+}
+function mapTrc20Only(chain, address, rows) {
+  const first = rows[0];
+  const transfers = rows.filter((r) => r.type === "Transfer").map(trc20Transfer);
+  const primary = transfers.find((t) => t.from === address || t.to === address) ?? transfers[0];
+  const out = {
+    chain,
+    hash: first.transaction_id,
+    time: Math.floor(first.block_timestamp / 1e3),
+    status: "confirmed",
+    address,
+    from: primary?.from ?? first.from,
+    to: primary?.to ?? first.to,
+    nativeValue: 0n,
+    transfers,
+    raw: { trc20: rows }
+  };
+  if (transfers.length === 0) {
+    out.call = { to: first.token_info.address, method: first.type.toLowerCase() };
+    out.to = first.token_info.address;
+  }
+  return out;
+}
+function tronExplorerTxUrl(hash, network = "mainnet") {
+  const host = network === "mainnet" ? "tronscan.org" : `${network}.tronscan.org`;
+  return `https://${host}/#/transaction/${hash}`;
+}
+function createTronHistory(options = {}) {
+  const network = options.network ?? "mainnet";
+  const chain = CAIP2_GENESIS[network] ?? CAIP2_GENESIS.mainnet;
+  const apiUrl = (options.apiUrl ?? DEFAULT_URLS[network]).replace(/\/+$/, "");
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  if (typeof fetchFn !== "function") throw new Error("@anywalletkit/wallet-tron: no global fetch; pass `fetch` in the options");
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const bucket = new TokenBucket(options.rateLimit ?? (options.apiKey ? 10 : 1));
+  const headers = () => ({ accept: "application/json", ...options.apiKey ? { "TRON-PRO-API-KEY": options.apiKey } : {} });
+  async function request(path, init) {
+    await bucket.acquire();
+    const url = `${apiUrl}${path}`;
+    let res;
+    try {
+      const signal = timeoutSignal(timeoutMs);
+      res = await fetchFn(url, {
+        ...init ? { method: "POST", body: JSON.stringify(init.body) } : {},
+        headers: { ...headers(), ...init ? { "content-type": "application/json" } : {} },
+        ...signal ? { signal } : {}
+      });
+    } catch (e) {
+      throw new HistoryUnavailableError(chain, `${path}: ${e instanceof Error ? e.message : String(e)}`, [`trongrid: ${e instanceof Error ? e.message : String(e)}`]);
+    }
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      body = void 0;
+    }
+    const b = body;
+    if (!res.ok || b?.success === false || typeof b?.Error === "string") {
+      const msg = b?.error ?? b?.Error ?? `HTTP ${res.status}`;
+      throw new HistoryUnavailableError(chain, `${path}: ${msg}`, [`trongrid: HTTP ${res.status} ${msg}`]);
+    }
+    return body;
+  }
+  async function list(path, params) {
+    const q = Object.entries(params).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`).join("&");
+    const body = await request(`${path}?${q}`);
+    return body?.data ?? [];
+  }
+  return {
+    chain,
+    async listActivity(address, query = {}) {
+      const limit = Math.min(MAX_LIMIT, Math.max(1, Math.floor(query.limit ?? DEFAULT_LIMIT)));
+      const cursor = query.cursor ? decodeCursor(query.cursor) : void 0;
+      const exhausted = new Set(cursor?.e ?? []);
+      const skip = new Set(cursor?.x ?? []);
+      const common = { limit, order_by: "block_timestamp,desc", max_timestamp: cursor?.w };
+      if (query.since !== void 0) common.min_timestamp = query.since * 1e3;
+      const txRows = exhausted.has("tx") ? [] : await list(`/v1/accounts/${encodeURIComponent(address)}/transactions`, common);
+      const trc20Rows = exhausted.has("trc20") ? [] : await list(`/v1/accounts/${encodeURIComponent(address)}/transactions/trc20`, common);
+      const tails = [];
+      if (!exhausted.has("tx") && txRows.length >= limit) tails.push(txRows[txRows.length - 1].block_timestamp ?? 0);
+      if (!exhausted.has("trc20") && trc20Rows.length >= limit) tails.push(trc20Rows[trc20Rows.length - 1].block_timestamp);
+      const cutoff = tails.length ? Math.max(...tails) : Number.NEGATIVE_INFINITY;
+      const byId = /* @__PURE__ */ new Map();
+      for (const r of txRows) {
+        if (skip.has(r.txID)) continue;
+        const e = byId.get(r.txID) ?? { ts: r.block_timestamp ?? 0, trc20: [] };
+        e.tx = r;
+        byId.set(r.txID, e);
+      }
+      for (const r of trc20Rows) {
+        if (skip.has(r.transaction_id)) continue;
+        const e = byId.get(r.transaction_id) ?? { ts: r.block_timestamp, trc20: [] };
+        e.trc20.push(r);
+        byId.set(r.transaction_id, e);
+      }
+      let entries = [...byId.entries()].sort((a, b) => b[1].ts - a[1].ts);
+      let inWindow = entries.filter(([, e]) => e.ts > cutoff);
+      if (inWindow.length === 0 && entries.length > 0) inWindow = entries.filter(([, e]) => e.ts === cutoff);
+      entries = inWindow.slice(0, limit);
+      const items = entries.map(([, e]) => e.tx ? mapTransactionRow(chain, address, e.tx, { trc20: e.trc20 }) : mapTrc20Only(chain, address, e.trc20));
+      const emitted = new Set(entries.map(([id]) => id));
+      const done = (id) => emitted.has(id) || skip.has(id);
+      if (!exhausted.has("tx") && txRows.length < limit && txRows.every((r) => done(r.txID))) exhausted.add("tx");
+      if (!exhausted.has("trc20") && trc20Rows.length < limit && trc20Rows.every((r) => done(r.transaction_id))) exhausted.add("trc20");
+      const page = { items };
+      const more = exhausted.size < 2;
+      if (more && entries.length > 0) {
+        const last = entries[entries.length - 1][1].ts;
+        const x = entries.filter(([, e]) => e.ts === last).map(([id]) => id);
+        if (last === cursor?.w) for (const id of skip) x.push(id);
+        page.cursor = encodeCursor({ v: 1, w: last, x, e: [...exhausted] });
+      }
+      return page;
+    },
+    async getTransaction(hash, address) {
+      const tx = await request("/wallet/gettransactionbyid", { method: "POST", body: { value: hash } });
+      if (!tx || typeof tx.txID !== "string") return void 0;
+      const info = await request("/wallet/gettransactioninfobyid", { method: "POST", body: { value: hash } });
+      return mapTransactionRow(chain, address, tx, info && typeof info.id === "string" ? { info } : {});
+    },
+    explorerTxUrl(hash) {
+      return tronExplorerTxUrl(hash, network);
+    }
+  };
+}
+//# sourceMappingURL=index.cjs.map