@anywalletkit/wallet-tron 0.0.0-stage → 0.2.1

package/dist/index.d.cts

@@ -0,0 +1,636 @@
+import { IWalletAccountReadOnly, TransferResult, IWalletAccount, Signer, WalletManager, FeeRates } from '@anywalletkit/core';
+export { FullNodeTxInfo, HistoryFetch, HistoryUnavailableError, TRANSFER_TOPIC, TronChainTx, TronGridTrc20, TronGridTx, TronHistoryCursor, TronHistoryOptions, TronHistoryPage, TronHistoryRaw, TronHistorySource, TronNetwork, createTronHistory, decodeCursor as decodeHistoryCursor, encodeCursor as encodeHistoryCursor, mapTransactionRow as mapHistoryTransactionRow, mapTrc20Only as mapHistoryTrc20Only, tronExplorerTxUrl } from './history.cjs';
+
+/** JSON-RPC-ish HTTP transport: POST `path` with a JSON body, returns parsed JSON. */
+type TronFetch = (path: string, body: unknown) => Promise<unknown>;
+/** One full-node base url (e.g. "https://api.trongrid.io") or a ready transport. */
+type TronProvider = string | TronFetch;
+/**
+ * Options for a Tron wallet manager or account: full-node endpoints, network, fee limits and the
+ * pre-sign checks.
+ */
+interface TronConfig {
+    /** Full-node url(s) / transport(s). A list fails over in order. Omit for an offline (sign-only) wallet. */
+    provider?: TronProvider | TronProvider[];
+    /** Extra attempts across the provider list after the first failure (default 3). */
+    retries?: number;
+    /** Optional headers for every request (e.g. `TRON-PRO-API-KEY`). */
+    headers?: Record<string, string>;
+    /** Max fee (sun) for `transfer`. */
+    transferMaxFee?: bigint | number;
+    /** Max fee (sun) for `sendTransaction` / `signTransaction`. */
+    transactionMaxFee?: bigint | number;
+    /** CAIP-2 suffix; default mainnet genesis "0x2b6653dc". */
+    network?: 'mainnet' | 'shasta' | 'nile' | string;
+    /** Run `simulateTransaction` before signing in `sendTransaction` / `transfer` (default true). */
+    simulate?: boolean;
+    /** Allow TRX / TRC-20 transfers to the zero address (default false — refused as a burn). */
+    allowBurn?: boolean;
+}
+/** Native TRX transfer. `value` in sun. `memo` → `raw_data.data` (charged the memo fee). */
+interface TronNativeTransfer {
+    to: string;
+    value: bigint | number | string;
+    memo?: string; /** 'hex' = binary memo given as 0x-hex (default 'utf8'). */
+    memoEncoding?: 'utf8' | 'hex';
+}
+/** Smart-contract call. */
+interface TronContractCall {
+    contractAddress: string;
+    /** e.g. "transfer(address,uint256)" */
+    functionSelector: string;
+    parameters?: Array<{
+        type: string;
+        value: unknown;
+    }>;
+    options?: {
+        feeLimit?: number;
+        callValue?: number;
+    };
+    /** Attached as `raw_data.data` (e.g. a THORChain swap memo on a TRC-20 transfer). */
+    memo?: string;
+    /** 'hex' = binary memo given as 0x-hex, e.g. a Chainflip vault-swap note (default 'utf8'). */
+    memoEncoding?: 'utf8' | 'hex';
+}
+/** A transaction as the full node returns it (`/wallet/createtransaction`, `/wallet/triggersmartcontract`). */
+interface TronRawTransaction {
+    txID: string;
+    raw_data_hex: string;
+    raw_data: {
+        contract: Array<{
+            type: string;
+            parameter: {
+                value: Record<string, unknown>;
+                type_url?: string;
+            };
+        }>;
+        ref_block_bytes?: string;
+        ref_block_hash?: string;
+        expiration?: number;
+        timestamp?: number;
+        fee_limit?: number;
+        /** Memo, hex-encoded. Charged `getMemoFee` when present. */
+        data?: string;
+    };
+    /** Execution result the node attaches (also returned by `triggerconstantcontract` on revert: `ret: 'FAILED'`). */
+    ret?: Array<{
+        ret?: string;
+        contractRet?: string;
+    }>;
+    visible?: boolean;
+    signature?: string[];
+}
+/**
+ * Anything `sendTransaction` accepts: a TRX transfer, a contract call, or a transaction prebuilt by
+ * a provider.
+ */
+type TronTransaction = TronNativeTransfer | TronContractCall | TronRawTransaction;
+/** A TRX or TRC-20 transfer. Amount in sun or the token's base units. */
+interface TronTransferOptions {
+    /** TRC-20 contract (base58 T… or hex 41…). Omit for native TRX. */
+    token?: string;
+    /** Address that receives (base58 `T…` or hex `41…`). */
+    recipient: string;
+    amount: bigint | number | string;
+    /** Attached as `raw_data.data`; the network charges `getMemoFee` (1 TRX). */
+    memo?: string;
+    /** 'hex' = binary memo given as 0x-hex, e.g. a Chainflip vault-swap note (default 'utf8'). */
+    memoEncoding?: 'utf8' | 'hex';
+}
+/** What a transaction will cost, resource by resource. All sun values are what the SENDER burns. */
+interface TronFeeBreakdown {
+    /** Free bandwidth points left on the account (`freeNetLimit − freeNetUsed`). */
+    bandwidthFree: number;
+    /** Staked bandwidth points left (`NetLimit − NetUsed`). */
+    bandwidthStaked: number;
+    /** Staked energy left (`EnergyLimit − EnergyUsed`). */
+    energyStaked: number;
+    /** sun per energy unit (`getEnergyFee`). */
+    energyPrice: bigint;
+    /** sun per bandwidth byte (`getTransactionFee`). */
+    bandwidthPrice: bigint;
+    /** sun burned for a memo (`getMemoFee`), 0 without one. */
+    memoFee: bigint;
+    /**
+     * sun burned to create the recipient account: `getCreateNewAccountFeeInSystemContract` (1 TRX)
+     * plus `getCreateAccountFee` (0.1 TRX) when staked bandwidth cannot cover the creation; 0 when it exists.
+     */
+    accountCreationFee: bigint;
+    /** sun burned for bandwidth not covered by staked/free allowance. */
+    bandwidthBurn: bigint;
+    /** sun burned for energy not covered by staked energy. */
+    energyBurn: bigint;
+}
+/**
+ * Resources a transaction consumes and the TRX burned for what the account's free bandwidth and
+ * staked energy do not cover.
+ */
+interface TronFeeEstimate {
+    /** Bandwidth points the transaction consumes (serialized size + signature + 64-byte result reserve). */
+    bandwidth: number;
+    /** Energy the call consumes (`energy_used` from a constant call); 0 for non-contract transactions. */
+    energy: number;
+    /** Total sun the sender pays on top of the amount. */
+    trxBurn: bigint;
+    breakdown: TronFeeBreakdown;
+}
+/** Fee of a transaction in sun (TRX burned), with the estimate behind it. */
+interface TronQuote {
+    /** = `estimate.trxBurn`. */
+    fee: bigint;
+    /** = `estimate.breakdown.accountCreationFee` (TransferContract to a new account). */
+    activationFee: bigint;
+    estimate: TronFeeEstimate;
+}
+/** Outcome of a constant call (`/wallet/triggerconstantcontract`) or a balance pre-check. */
+interface TronSimulation {
+    ok: boolean;
+    /** `energy_used` reported by the node (0 for non-contract transactions). */
+    energy: number;
+    /** Decoded revert reason / node message when `ok` is false. */
+    reason?: string;
+    /** Raw `constant_result` entries. */
+    constantResult?: string[] | undefined;
+}
+/** What a Tron transaction does. */
+type TronTxKind = 'trx-transfer' | 'trc10-transfer' | 'trc20-transfer' | 'trc20-approve' | 'contract-call' | 'freeze' | 'unfreeze' | 'unknown';
+/** Problems a Tron description is flagged with. */
+type TronTxWarningCode = 'unlimited-approve' | 'zero-address' | 'unactivated-recipient' | 'memo-fee' | 'expired'
+/** Prebuilt transaction without `raw_data_hex`: described from the unsigned JSON copy, cannot be signed. */
+ | 'no-raw-hex'
+/** `raw_data_hex` is not a well-formed Transaction.raw: nothing can be said about it. */
+ | 'raw-undecodable'
+/** A contract type or parameter fields the wallet has no decoder for: only the raw bytes are known. */
+ | 'undecoded'
+/** More than one contract in the transaction (the node refuses these; the wallet does too). */
+ | 'multi-contract'
+/** AccountPermissionUpdateContract: changes who controls the account. */
+ | 'account-permission';
+/** One flagged problem, with a sentence a wallet can show. */
+interface TronTxWarning {
+    code: TronTxWarningCode;
+    message: string;
+}
+/** What a transaction does, decoded offline (see `describeTransaction`). Addresses are base58. */
+interface TronTxDescription {
+    /** What it does. */
+    kind: TronTxKind;
+    warnings: TronTxWarning[];
+    /** Sender (owner_address) when known. */
+    from?: string;
+    /** TRX / TRC-20 recipient. */
+    to?: string;
+    /** sun (TRX) or token base units (TRC-20) or frozen/unfrozen sun. */
+    amount?: bigint;
+    /** TRC-20 contract. */
+    token?: string;
+    /** Spender of a TRC-20 approval. */
+    spender?: string;
+    /** Called contract (contract-call). */
+    contract?: string;
+    /** 4-byte selector, hex. */
+    selector?: string;
+    /** sun attached to the call. */
+    callValue?: bigint;
+    feeLimit?: number;
+    /** Decoded memo (`raw_data.data`). */
+    memo?: string;
+    /** Freeze / unfreeze resource. */
+    resource?: 'BANDWIDTH' | 'ENERGY';
+    expiration?: number;
+}
+/** Outcome of a confirmed Tron transaction. */
+interface TronReceipt {
+    hash: string;
+    /** 1 success, 0 failed. */
+    status: 0 | 1;
+    blockNumber: bigint;
+    fee: bigint;
+    /** Raw `/wallet/gettransactioninfobyid` payload. */
+    raw: Record<string, unknown>;
+}
+/** CAIP-2 ids of the Tron networks, by name. */
+declare const CAIP2_GENESIS: Record<string, string>;
+
+/** Why a transaction was refused before signing. */
+type UnsafeTransactionCode = 'expired' | 'expiration-too-far' | 'missing-ref-block' | 'owner-mismatch' | 'zero-address' | 'fee-limit' | 'multi-contract' | 'memo'
+/** `txID` is not sha256(raw_data_hex). */
+ | 'txid-mismatch'
+/** The JSON `raw_data` disagrees with the bytes that would be signed. */
+ | 'raw-mismatch'
+/** No `raw_data_hex`, or bytes that are not a well-formed Transaction.raw. */
+ | 'raw-undecodable'
+/** Bytes a strict protobuf reader would not produce (over-long tag, non-minimal varint, repeated singular field, parameter that does not re-encode to itself): java-tron could read them differently. */
+ | 'raw-noncanonical'
+/** A node-built transaction is not what was requested (type, owner, recipient, amount, contract, calldata, call value, fee limit, extra fields) — scan F7. */
+ | 'build-mismatch';
+/** A transaction failed a hard check and was not signed. */
+declare class UnsafeTransactionError extends Error {
+    readonly code: UnsafeTransactionCode;
+    constructor(code: UnsafeTransactionCode, message: string);
+}
+/** A constant call (or balance pre-check) predicted failure; nothing was signed or broadcast. */
+declare class SimulationError extends Error {
+    readonly reason: string;
+    readonly energy: number;
+    constructor(reason: string, energy?: number);
+}
+
+/** Compressed secp256k1 pubkey → base58 T… address (keccak of X||Y, last 20 bytes, 0x41 prefix, sha256d checksum). */
+declare function addressFromPublicKey(compressed: Uint8Array): string;
+/** True for a hex Tron address (`41` plus 20 bytes, optional `0x`). */
+declare function isHexAddress(a: string): boolean;
+/** Any accepted form → 21-byte hex "41…" (lowercase, no 0x). */
+declare function toHexAddress(address: string): string;
+/** Any accepted form → base58 T… */
+declare function toBase58Address(address: string): string;
+
+/** 4-byte selector of "name(type,…)". */
+declare function selector(signature: string): string;
+/** Minimal static ABI encoder: address, uintN/intN, bool, bytes32. Enough for TRC-20 calls. */
+declare function encodeParameters(params: Array<{
+    type: string;
+    value: unknown;
+}>): string;
+/** A hex word as a bigint (empty hex is 0). */
+declare function decodeUint(hex: string): bigint;
+/** 32-byte ABI word → 21-byte Tron hex address ("41" + last 20 bytes). */
+declare function decodeAddressWord(word: string): string;
+/** Split calldata hex into selector + 32-byte words (partial trailing word dropped). */
+declare function splitCalldata(data: string): {
+    selector: string;
+    words: string[];
+};
+/** ABI-decode `Error(string)` / `Panic(uint256)` revert data; falls back to the hex itself. */
+declare function decodeRevertReason(hex: string | undefined): string | undefined;
+/** Hex → UTF-8 text when it decodes cleanly, else the hex. */
+declare function hexToText(hex: string): string;
+
+/** One transport, or a failover transport over the list. */
+declare function createClient(config: TronConfig): TronFetch | undefined;
+
+/** Type guard: a transaction prebuilt by a node or provider (has `txID`). */
+declare const isPrebuilt: (tx: unknown) => tx is TronRawTransaction;
+/** Type guard: a contract call (`functionSelector`). */
+declare const isContractCall: (tx: unknown) => tx is TronContractCall;
+
+/** Tron's zero address (20 zero bytes behind the 0x41 prefix). */
+declare const ZERO_ADDRESS = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
+/** The all-zero Tron address in hex; value sent there is lost. */
+declare const ZERO_ADDRESS_HEX: string;
+/** What an offline description can be told to sharpen its warnings. */
+interface DescribeContext {
+    /**
+     * Whether the recipient account already exists on chain. Offline callers do not know;
+     * `WalletAccountReadOnlyTron.describeTransactionOnline` fills it from `/wallet/getaccount`.
+     */
+    recipientExists?: boolean;
+    /** Unix ms "now" for the expiry warning (default Date.now()). */
+    now?: number;
+}
+/**
+ * What a transaction does — decoded offline, no network. Works on the three input shapes
+ * (`{to, value}`, contract call, node-built raw transaction). Only the `unactivated-recipient`
+ * warning needs the chain; pass `ctx.recipientExists` or use `describeTransactionOnline`.
+ */
+declare function describeTransaction(tx: TronTransaction, ctx?: DescribeContext): TronTxDescription;
+
+/**
+ * Fee limit for contract calls when no estimate is available (the simulation itself
+ * failed and the caller gave none) — `buildTransaction` otherwise derives it from energy.
+ */
+declare const DEFAULT_FEE_LIMIT_SUN = 15000000;
+/** Head-room over the simulated energy cost when deriving `fee_limit` (×1.2). */
+declare const FEE_LIMIT_MARGIN = 1.2;
+/**
+ * Bandwidth points a transaction consumes: its serialized size with signatures plus the 64-byte
+ * result reserve.
+ */
+declare function bandwidthPoints(rawDataHex: string, signatures?: number): number;
+interface Resources {
+    freeNetLimit?: number;
+    freeNetUsed?: number;
+    NetLimit?: number;
+    NetUsed?: number;
+    EnergyLimit?: number;
+    EnergyUsed?: number;
+}
+interface ConstantCallResponse {
+    Error?: string;
+    constant_result?: string[];
+    energy_used?: number;
+    transaction?: TronRawTransaction;
+    result?: {
+        result?: boolean;
+        code?: string;
+        message?: string;
+    };
+}
+/** keccak256("\x19TRON Signed Message:\n" + byteLength + message) — TIP-191 (tronweb `signMessageV2`). */
+declare function hashMessage(message: string | Uint8Array): Uint8Array;
+/** Address that produced a TIP-191 signature (`0x` + r||s||v, v = 27|28 or 0|1), or undefined. */
+declare function recoverMessageAddress(message: string | Uint8Array, signature: string): string | undefined;
+/**
+ * A Tron address without a key: TRX and TRC-20 balances, allowances, resources, fee estimates,
+ * simulation, receipts and signature checks.
+ */
+declare class WalletAccountReadOnlyTron implements IWalletAccountReadOnly {
+    /** base58 T… */
+    readonly address: string;
+    /** Hex form (`41…`). */
+    readonly addressHex: string;
+    readonly chain: string;
+    protected readonly _config: TronConfig;
+    protected readonly _client: TronFetch | undefined;
+    constructor(address: string, config?: TronConfig);
+    protected requireClient(what: string): TronFetch;
+    protected post<T>(path: string, body: unknown, what: string): Promise<T>;
+    /** The base58 address. */
+    getAddress(): Promise<string>;
+    /** TRX balance in sun; 0 for an account that does not exist yet. */
+    getBalance(): Promise<bigint>;
+    /** Read-only contract call. Returns constant_result hex strings. */
+    protected constantCall(contract: string, functionSelector: string, parameters: Array<{
+        type: string;
+        value: unknown;
+    }>, what: string, extra?: Record<string, unknown>): Promise<ConstantCallResponse>;
+    /** TRC-20 `balanceOf` in the token's base units. */
+    getTokenBalance(token: string): Promise<bigint>;
+    /** Several TRC-20 balances in parallel, keyed by the tokens as given. */
+    getTokenBalances(tokens: string[]): Promise<Record<string, bigint>>;
+    /** TRC-20 `allowance(owner, spender)` in base units. */
+    getAllowance(token: string, spender: string): Promise<bigint>;
+    /** Does an account exist on chain (`/wallet/getaccount` non-empty)? */
+    accountExists(address: string): Promise<boolean>;
+    /**
+     * 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.
+     */
+    protected buildWithSimulation(tx: TronTransaction): Promise<{
+        built: TronRawTransaction;
+        sim?: TronSimulation;
+    }>;
+    protected buildTransaction(tx: TronTransaction): Promise<TronRawTransaction>;
+    /** Constant call by selector + params (unbuilt contract call). Never throws on a revert. */
+    protected simulateCall(tx: TronContractCall): Promise<TronSimulation>;
+    private constantSimulation;
+    /**
+     * 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.
+     */
+    simulateTransaction(tx: TronTransaction): Promise<TronSimulation>;
+    protected simulateRaw(tx: TronRawTransaction): Promise<TronSimulation>;
+    private simulateNativeTransfer;
+    protected getResources(): Promise<Resources>;
+    protected getChainParameters(): Promise<Record<string, bigint>>;
+    protected getChainParameter(key: string): Promise<bigint>;
+    /**
+     * Resource-by-resource cost of a node-built transaction. `energy` comes from a
+     * constant call unless the caller already has one (`sim`).
+     */
+    protected estimateRaw(tx: TronRawTransaction, sim?: TronSimulation): Promise<TronFeeEstimate>;
+    /** Build (if needed) and price a transaction: bandwidth, energy and the sun the sender burns. */
+    estimateFee(tx: TronTransaction): Promise<TronFeeEstimate>;
+    protected quoteTransaction(tx: TronRawTransaction, sim?: TronSimulation): Promise<TronQuote>;
+    /** `fee` = the sun the sender burns, after staked / free resources. */
+    quoteSendTransaction(tx: TronTransaction): Promise<TronQuote>;
+    protected trc20TransferParams(recipient: string, amount: bigint | number | string): ({
+        type: string;
+        value: string;
+    } | {
+        type: string;
+        value: bigint;
+    })[];
+    protected asTransaction(o: TronTransferOptions): TronTransaction;
+    /** Fee of a transfer in sun, including account activation when the recipient is new. */
+    quoteTransfer(o: TronTransferOptions): Promise<TronQuote>;
+    /** `describeTransaction` plus the `unactivated-recipient` check against the node. */
+    describeTransactionOnline(tx: TronTransaction, ctx?: DescribeContext): Promise<TronTxDescription>;
+    /** The receipt, or `undefined` while the transaction is unconfirmed. */
+    getTransactionReceipt(hash: string): Promise<TronReceipt | undefined>;
+    /** Verify a TIP-191 signature produced by `sign` (0x + r||s||v, v = 27|28 or 0|1). */
+    verify(message: string | Uint8Array, signature: string): Promise<boolean>;
+}
+
+interface TronTransferResult extends TransferResult {
+    /** Account creation fee included in `fee` (TRX transfer to a new account). */
+    activationFee?: bigint;
+    estimate?: TronFeeEstimate;
+}
+/** Longest expiration the node accepts for a transaction (`Constant.MAXIMUM_TIME_UNTIL_EXPIRATION`). */
+declare const MAX_EXPIRATION_MS: number;
+/**
+ * Signing Tron account. The key lives in a secp256k1 {@link Signer} (a local key
+ * zeroized by `dispose()`, or an external hardware / MPC / backend signer). The
+ * full node builds `raw_data`; we check it, simulate it, have the signer sign
+ * `txID` (= sha256(raw_data)) as recoverable ECDSA (context `tron-tx`) and broadcast.
+ */
+declare class WalletAccountTron extends WalletAccountReadOnlyTron implements IWalletAccount {
+    /** ref block / expiration come from the node, so building needs the network. */
+    readonly needsNetwork = true;
+    /** Derivation path, or `external` for an external signer. */
+    readonly path: string;
+    /** Compressed secp256k1 key (33 bytes); needed synchronously for the address. */
+    readonly publicKey: Uint8Array;
+    /** The signer that holds the key. */
+    readonly signer: Signer;
+    private _disposed;
+    private _readOnly;
+    constructor(signer: Signer, publicKey: Uint8Array, path: string, config?: TronConfig);
+    /** Wrap a raw derived key (takes ownership; zeroized on dispose). Kept for callers that derive themselves. */
+    static fromPrivateKey(privateKey: Uint8Array, publicKey: Uint8Array, path: string, config?: TronConfig): WalletAccountTron;
+    /** Account index for the standard m/44'/195'/0'/0/i path. */
+    get index(): number | undefined;
+    private key;
+    /** Recoverable secp256k1 signature over a 32-byte digest from the signer: r‖s‖recovery (recovery 0/1). */
+    private signDigest;
+    /** TIP-191 message signature: 0x + r||s||(27 + recovery) hex (tronweb `signMessageV2` encoding). */
+    sign(message: string | Uint8Array): Promise<string>;
+    /**
+     * 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`).
+     */
+    signRaw(tx: TronRawTransaction): Promise<TronRawTransaction>;
+    /**
+     * 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`.
+     */
+    protected assertSafe(tx: TronRawTransaction, now?: number): void;
+    private maxFeeCheck;
+    /** Build → hard checks → simulate → estimate → fee cap. Shared by sign / send / transfer. */
+    private prepare;
+    /** Build (via the node), check, simulate and sign; returns broadcast-ready transaction JSON. */
+    signTransaction(tx: TronTransaction): Promise<string>;
+    private broadcast;
+    sendTransaction(tx: TronTransaction | string): Promise<TronTransferResult>;
+    /** TRX (no `token`) or TRC-20 `transfer(address,uint256)`. */
+    transfer(o: TronTransferOptions): Promise<TronTransferResult>;
+    /** The same address as a {@link WalletAccountReadOnlyTron}. */
+    toReadOnlyAccount(): IWalletAccountReadOnly;
+    /** Dispose the signer (zeroizes a local key). Idempotent. */
+    dispose(): void;
+}
+
+/** Base derivation path; account `i` is at `m/44'/195'/0'/0/i` (TronLink). */
+declare const TRON_BASE_PATH = "m/44'/195'";
+/** The account branch `getAccount(i)` indexes: m/44'/195'/0'/0/i (TronLink default). */
+declare const TRON_ACCOUNT_BRANCH = "m/44'/195'/0'/0";
+/**
+ * One seed → Tron accounts at m/44'/195'/0'/0/i (BIP-44; TronLink default).
+ * Paths may be relative to m/44'/195' ("0'/0/3") or full.
+ *
+ * Built with a secp256k1 `Signer` instead of a seed, the manager wraps it:
+ * - a derivable `SeedSigner` sitting at `m/44'/195'/0'/0` yields `getAccount(i)` children;
+ * - a `SeedSigner` at a leaf, or any external signer, is `getAccount(0)` (path = the
+ *   signer's path, or 'external'); other indexes/paths throw.
+ */
+declare class WalletManagerTron extends WalletManager<WalletAccountTron, TronConfig> {
+    constructor(seedOrSigner: string | Uint8Array | Signer, config?: TronConfig);
+    getAccount(index?: number): Promise<WalletAccountTron>;
+    getAccountByPath(path: string): Promise<WalletAccountTron>;
+    /** Resolve `path` against an injected signer: the signer itself, or a child when it can derive there. */
+    private fromSigner;
+    /** A read-only account for any address, with this manager's config. */
+    getReadOnlyAccount(address: string): WalletAccountReadOnlyTron;
+    /** getTransactionFee chain parameter; normal = ×1.1, fast = ×2.0; slow = ×1.0. */
+    getFeeRates(): Promise<FeeRates>;
+}
+
+/**
+ * Memo = `Transaction.raw.data` (protobuf field 10, bytes). The full node builds
+ * `raw_data_hex` for us; we splice the field in ourselves rather than re-encoding
+ * the contracts.
+ *
+ * Where it goes matters: java-tron recomputes `txID` as sha256 of the raw_data it
+ * re-serializes from the parsed message, and protobuf-java writes fields in
+ * field-number order. A memo appended after `contract` (field 11) would therefore
+ * hash differently on the node than what we signed. So the record is inserted at
+ * its canonical position — after every field numbered ≤ 10, before the first > 10
+ * (ref_block_bytes 1 … expiration 8, auths 9, DATA 10, contract 11, scripts 12,
+ * timestamp 14, fee_limit 18). The JSON we broadcast carries the same bytes as
+ * `raw_data.data` (hex), the way tronweb's `addUpdateData` does.
+ */
+declare const MEMO_FIELD = 10;
+/** Upper bound we enforce on a memo (UTF-8 bytes). java-tron bounds only the whole transaction (500 KB); 512 keeps memos cheap and sane. */
+declare const MAX_MEMO_BYTES = 512;
+/**
+ * How a memo string becomes `raw_data.data` bytes: 'utf8' (a text memo — THORChain, exchanges) or 'hex' (binary
+ * payloads — a Chainflip vault swap's SCALE-encoded note, given as 0x-hex).
+ */
+type MemoEncoding = 'utf8' | 'hex';
+/**
+ * Bytes of a memo, from UTF-8 text or `0x` hex.
+ *
+ * @throws `UnsafeTransactionError` `memo` for invalid hex.
+ */
+declare function memoBytes(memo: string, encoding?: MemoEncoding): Uint8Array;
+/** The wire bytes of a memo record: tag (field 10, length-delimited = 0x52) ‖ varint(len) ‖ the memo bytes. */
+declare function encodeMemoRecord(memo: string, encoding?: MemoEncoding): Uint8Array;
+/**
+ * Splice `memo` into a node-built transaction: canonical-position `raw_data` field 10,
+ * fresh `txID` = sha256(raw_data), and `raw_data.data` (hex) for the JSON broadcast.
+ * A transaction that already carries a memo is refused (the node's own `data` would
+ * have to be re-signed anyway and we cannot know which the caller meant).
+ */
+declare function attachMemo(tx: TronRawTransaction, memo: string, encoding?: MemoEncoding): TronRawTransaction;
+
+interface Field {
+    number: number;
+    wire: number;
+    value: bigint | Uint8Array;
+}
+/**
+ * Bytes that a strict protobuf reader would not produce or that java-tron would read
+ * differently from this codec (scan F4). The wallet refuses them rather than guess:
+ * protobuf-java keeps only the low 32 bits of an over-long tag, so a field this codec
+ * would call "unknown 536870916" is `data` to the node.
+ */
+declare class NonCanonicalError extends Error {
+    constructor(message: string);
+}
+/** Every top-level field of a protobuf message, in wire order. Throws on malformed or non-canonical input. */
+declare function readFields(bytes: Uint8Array): Field[];
+/** `protocol.Transaction.Contract.ContractType`. */
+declare const CONTRACT_TYPES: Record<number, string>;
+/** One decoded `Transaction.Contract`. `value` has the node's JSON keys (hex addresses, hex bytes, numbers as JSON numbers or decimal strings). */
+interface TronDecodedContract {
+    type: string;
+    parameter: {
+        value: Record<string, unknown>;
+        type_url: string;
+    };
+    Permission_id?: number;
+    /** Field numbers inside the parameter the wallet has no schema for (or the whole parameter when the type is unknown). */
+    undecoded: number[];
+}
+/** A transaction's `raw_data`, decoded from its protobuf bytes. */
+interface TronDecodedRaw {
+    raw_data: Omit<TronRawTransaction['raw_data'], 'contract'> & {
+        contract: TronDecodedContract[];
+        ref_block_num?: number;
+    };
+    /** Top-level `Transaction.raw` field numbers this codec does not know. */
+    unknownFields: number[];
+}
+/** Whether the wallet decodes this contract type field by field (otherwise only its owner and raw bytes are known). */
+declare function isDecodedContractType(type: string): boolean;
+/** Decode `Transaction.raw` bytes (or hex). Throws a plain `Error` on malformed input; callers wrap it. */
+declare function decodeRawData(raw: Uint8Array | string): TronDecodedRaw;
+/**
+ * Serialize a `raw_data` object the way java-tron does (fields in number order, proto3
+ * defaults omitted). Round-trips with {@link decodeRawData}; `sha256` of the result is the txID.
+ */
+declare function encodeRawData(raw: TronRawTransaction['raw_data'] & {
+    ref_block_num?: number;
+}): Uint8Array;
+/** Decoded `raw_data` with the exact bytes that are signed and their hash. */
+interface VerifiedRaw extends TronDecodedRaw {
+    /** The bytes that get hashed and signed. */
+    bytes: Uint8Array;
+    /** Lowercase hex sha256 of `bytes` (= the txID the signature is over). */
+    txID: string;
+}
+/** First material difference between the dApp's JSON `raw_data` and what the bytes say, or `null`. */
+declare function rawMismatch(json: TronRawTransaction['raw_data'] | undefined, decoded: TronDecodedRaw['raw_data']): string | null;
+/**
+ * Everything that must hold before a prebuilt transaction is signed or shown:
+ * `raw_data_hex` present and well-formed, `txID == sha256(raw_data_hex)`, and the
+ * JSON copy (when there is one) agreeing with the bytes field by field. Returns the
+ * decoded bytes; the description and the hard checks run on that, never on the JSON.
+ */
+declare function verifyRawTransaction(tx: TronRawTransaction): VerifiedRaw;
+
+/** What the wallet asked the node to build. Addresses in any form; numbers in sun. */
+type ExpectedBuild = {
+    type: 'TransferContract';
+    owner: string;
+    to: string;
+    amount: bigint;
+} | {
+    type: 'TriggerSmartContract';
+    owner: string;
+    contract: string;
+    /** selector ‖ ABI-encoded parameters, hex (0x optional, any case). */
+    data: string;
+    callValue: bigint;
+    /** The `fee_limit` actually POSTed to `/wallet/triggersmartcontract`. */
+    feeLimit: bigint;
+};
+/**
+ * Refuse a node-built transaction unless its bytes are exactly one contract of the
+ * expected type with the expected owner, recipient / contract, amount / calldata,
+ * call value and fee limit — no Permission_id, no TRC-10 token on the call, no second
+ * contract, no field the request did not produce. `memo` = the bytes the wallet spliced
+ * into `raw_data.data` (none → the field must be absent).
+ */
+declare function assertNodeBuild(tx: TronRawTransaction, expected: ExpectedBuild, memo?: Uint8Array): void;
+
+export { CAIP2_GENESIS, CONTRACT_TYPES, DEFAULT_FEE_LIMIT_SUN, type DescribeContext, type ExpectedBuild, FEE_LIMIT_MARGIN, MAX_EXPIRATION_MS, MAX_MEMO_BYTES, MEMO_FIELD, type MemoEncoding, NonCanonicalError, SimulationError, TRON_ACCOUNT_BRANCH, TRON_BASE_PATH, type TronConfig, type TronContractCall, type TronDecodedContract, type TronDecodedRaw, type TronFeeBreakdown, type TronFeeEstimate, type TronFetch, type TronNativeTransfer, type TronProvider, type TronQuote, type TronRawTransaction, type TronReceipt, type TronSimulation, type TronTransaction, type TronTransferOptions, type TronTransferResult, type TronTxDescription, type TronTxKind, type TronTxWarning, type TronTxWarningCode, type UnsafeTransactionCode, UnsafeTransactionError, type VerifiedRaw, WalletAccountReadOnlyTron, WalletAccountTron, WalletManagerTron, ZERO_ADDRESS, ZERO_ADDRESS_HEX, addressFromPublicKey, assertNodeBuild, attachMemo, bandwidthPoints, createClient, decodeAddressWord, decodeRawData, decodeRevertReason, decodeUint, WalletManagerTron as default, describeTransaction, encodeMemoRecord, encodeParameters, encodeRawData, hashMessage, hexToText, isContractCall, isDecodedContractType, isHexAddress, isPrebuilt, memoBytes, rawMismatch, readFields, recoverMessageAddress, selector, splitCalldata, toBase58Address, toHexAddress, verifyRawTransaction };