@radiant-core/sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,693 @@
+/** Shared public types for the Radiant SDK. */
+/** Supported Radiant networks. */
+type NetworkName = "mainnet" | "testnet" | "regtest";
+/**
+ * A reference carried by a token output. Reported by ElectrumX `listunspent`
+ * in display form ("txid:vout"). Any UTXO that carries refs is token-bearing
+ * and must NEVER be used as discretionary RXD funding.
+ */
+interface UtxoRef {
+    /** Display-order ref, "txid:vout". */
+    ref: string;
+    /** Indexer-classified type, e.g. "nft" | "ft" | "dmint". */
+    type: string;
+}
+/**
+ * A spendable output. `value` is in photons (BigInt). `script` is the output
+ * scriptPubKey as hex — required for ref-safety analysis and signing.
+ */
+interface Utxo {
+    /** Transaction id in display (big-endian) order. */
+    txid: string;
+    /** Output index. */
+    vout: number;
+    /** Value in photons. */
+    value: bigint;
+    /** Output scriptPubKey, hex. */
+    script: string;
+    /** Confirmation height; 0 (or undefined) means unconfirmed/mempool. */
+    height?: number;
+    /** Token refs attached to this output, if any (from the indexer). */
+    refs?: UtxoRef[];
+}
+/** A transaction output to be created. `value` is in photons. */
+interface TxOutput {
+    /** Output scriptPubKey, hex. */
+    script: string;
+    /** Value in photons. */
+    value: bigint;
+}
+/** Result of a ref-safe funding selection. */
+interface FundingSelection {
+    /** Chosen funding inputs (all guaranteed token-free). */
+    inputs: Utxo[];
+    /** Estimated fee in photons for the resulting transaction. */
+    fee: bigint;
+    /** Sum of selected input values, photons. */
+    total: bigint;
+    /** Change left over after target + fee, photons (>= 0). */
+    change: bigint;
+}
+/** ElectrumX scripthash balance reply. */
+interface ScriptHashBalance {
+    /** Confirmed balance in photons. */
+    confirmed: bigint;
+    /** Unconfirmed (mempool) delta in photons; may be negative. */
+    unconfirmed: bigint;
+}
+/** Resolved WAVE name record. */
+interface WaveResolution {
+    /** Normalised bare label that was resolved. */
+    name: string;
+    /** Whether the name is registered. */
+    registered: boolean;
+    /** Resolution target address, if the name resolves to one. */
+    address?: string;
+    /** Packed ref of the canonical registration, if any. */
+    ref?: string;
+    /** Owner scripthash hex, if known. */
+    owner?: string;
+    /** Expiry (unix seconds) from the zone record, if set. */
+    expires?: number;
+    /** Raw zone records (free-form). */
+    records?: Record<string, unknown>;
+    /** The unparsed indexer payload, for advanced callers. */
+    raw: unknown;
+}
+
+/** Typed error classes so callers can branch on failure modes. */
+/** Base class for every error thrown by the SDK. */
+declare class RadiantSdkError extends Error {
+    constructor(message: string);
+}
+/** Thrown when a request cannot be funded from the available UTXO set. */
+declare class InsufficientFundsError extends RadiantSdkError {
+    readonly requiredPhotons: bigint;
+    readonly availablePhotons: bigint;
+    constructor(requiredPhotons: bigint, availablePhotons: bigint);
+}
+/**
+ * Thrown when a token-bearing UTXO is about to be spent as discretionary RXD
+ * funding — doing so would silently burn the token. This is the SDK's primary
+ * safety backstop.
+ */
+declare class TokenBurnGuardError extends RadiantSdkError {
+    readonly txid: string;
+    readonly vout: number;
+    constructor(txid: string, vout: number);
+}
+/** Thrown for ElectrumX transport/protocol failures. */
+declare class ElectrumError extends RadiantSdkError {
+    readonly code?: number | undefined;
+    constructor(message: string, code?: number | undefined);
+}
+/** Thrown when an input/argument is malformed. */
+declare class ValidationError extends RadiantSdkError {
+}
+
+/**
+ * Network constants, default endpoints, and protocol parameters.
+ *
+ * Sources of truth (verified against the Radiant ecosystem, 2026-06):
+ * - Min-relay fee: 10,000 photons/byte on mainnet since the V2 upgrade
+ *   (block 410,000). Testnet/regtest use 1,000. Pin these; do not "tune" them.
+ * - HD coin type: SLIP-0044 512 (Radiant), default since radiantjs v3.0.0.
+ * - Public ElectrumX is reachable on :443 only (Caddy TLS terminates to the
+ *   indexer). 50010-50012 are firewalled off the public host.
+ * - WAVE/Glyph REST lives behind https://radiantcore.org/api.
+ */
+
+/** Base unit of Radiant. 1 RXD = 100,000,000 photons. */
+declare const PHOTONS_PER_RXD = 100000000n;
+/** SLIP-0044 registered coin type for Radiant. */
+declare const RADIANT_COIN_TYPE = 512;
+/**
+ * Min-relay fee rate in photons per byte, keyed by network.
+ * Mainnet = 10,000 since the V2 upgrade (block 410,000).
+ */
+declare const MIN_RELAY_FEE_RATE: Record<NetworkName, bigint>;
+/**
+ * Dust limit in photons. Outputs below this are non-standard. Token-carrying
+ * outputs typically ride at exactly the dust value.
+ */
+declare const DUST_LIMIT = 1000n;
+/** Default public ElectrumX WebSocket endpoints, keyed by network. */
+declare const DEFAULT_ELECTRUM_ENDPOINT: Record<NetworkName, string>;
+/** Default RXinDexer REST base used for WAVE name resolution. */
+declare const DEFAULT_REST_BASE = "https://radiantcore.org/api";
+/** Glyph protocol identifiers (the `p` field of a payload). */
+declare const GLYPH_PROTOCOL: {
+    readonly FT: 1;
+    readonly NFT: 2;
+    readonly MUTABLE: 5;
+    readonly CONTAINER: 7;
+    readonly ENCRYPTED: 8;
+    readonly WAVE: 11;
+};
+
+/**
+ * Photon <-> RXD conversion helpers.
+ *
+ * Internally the SDK uses photons as BigInt everywhere (1 RXD = 100,000,000
+ * photons). These helpers exist for display/input at the application edge.
+ * Never do balance math in floating point — use the BigInt photon value.
+ */
+/** Number of decimal places in a whole RXD (8). */
+declare const RXD_DECIMALS = 8;
+/**
+ * Convert an RXD amount to photons (BigInt). Accepts a number or a decimal
+ * string; the string form avoids float rounding for large/precise amounts.
+ *
+ * @example rxdToPhotons("1.5") === 150_000_000n
+ */
+declare function rxdToPhotons(rxd: string | number): bigint;
+/**
+ * Convert photons (BigInt) to a fixed-point RXD string with 8 decimals,
+ * trailing zeros trimmed (but at least one decimal kept).
+ *
+ * @example photonsToRxd(150_000_000n) === "1.5"
+ */
+declare function photonsToRxd(photons: bigint): string;
+
+/**
+ * Script-level primitives: scripthash computation (ElectrumX convention),
+ * token-bearing detection, zero-ref normalisation, and ref packing.
+ *
+ * These mirror the proven Photonic-Wallet implementations. They are pure and
+ * dependency-light (only radiantjs for hashing / address->script).
+ */
+
+/**
+ * ElectrumX scripthash: sha256(scriptBytes) reversed, hex.
+ * This is the key ElectrumX uses to index an output; it is NOT a txid order.
+ */
+declare function scriptHash(scriptHex: string): string;
+/**
+ * Build a P2PKH output script (hex) for an address. The script is
+ * network-independent — only the 20-byte pubkey hash matters — so the address
+ * is decoded by its version byte without imposing a network (this also avoids
+ * the testnet/regtest ambiguity, where both share version byte 0x6f). The
+ * `network` parameter is accepted for call-site symmetry but not required.
+ */
+declare function p2pkhScript(address: string, _network?: NetworkName): string;
+/** Convenience: ElectrumX scripthash for a plain (P2PKH) address. */
+declare function addressToScriptHash(address: string, network?: NetworkName): string;
+/**
+ * Returns true if a script carries a Glyph token, i.e. it contains an
+ * OP_PUSHINPUTREF-family opcode (0xd0-0xd8) in *opcode position*.
+ *
+ * Critically, this walks the script as an opcode stream and skips push
+ * payloads, so a 0xd0-0xd8 byte that merely appears inside a pubkey hash or a
+ * data push does NOT trigger a false positive. Spending such a UTXO as
+ * discretionary RXD funding would burn the token, so funding selection relies
+ * on this check.
+ */
+declare function isTokenBearing(scriptHex: string): boolean;
+/**
+ * Zero out the 36-byte operands of OP_PUSHINPUTREF-family opcodes, but only if
+ * the script also requires a signature (CHECKSIG). This reproduces how the
+ * indexer keys token-gated covenant scripts: a covenant is indexed under its
+ * zeroed-ref form, so to look up its UTXOs you must hash scriptHash(zeroRefs(s))
+ * rather than the raw script. Plain (non-checksig) ref scripts are returned
+ * unchanged.
+ */
+declare function zeroRefs(scriptHex: string): string;
+/**
+ * Pack an outpoint into a 36-byte Glyph ref (72 hex chars): 32-byte txid in
+ * internal (little-endian) order followed by a 4-byte little-endian vout.
+ * This is the form consumed by OP_PUSHINPUTREF <ref>.
+ */
+declare function packRef(txid: string, vout: number): string;
+/** Inverse of packRef: unpack a 72-hex ref into display "txid:vout". */
+declare function unpackRef(ref: string): {
+    txid: string;
+    vout: number;
+};
+
+/**
+ * ElectrumX WebSocket client.
+ *
+ * Speaks JSON-RPC 2.0 over a single wss connection, with automatic reconnect
+ * (exponential backoff + jitter), per-request timeouts, and scripthash
+ * subscriptions. Isomorphic: uses the global `WebSocket` in browsers / modern
+ * Node, and lazily imports the `ws` package on older Node.
+ *
+ * High-level helpers return SDK types (photons as BigInt). All scripthash
+ * methods also accept a plain address for convenience.
+ */
+
+/** A minimal structural type for the WebSocket implementations we accept. */
+interface MinimalWebSocket {
+    send(data: string): void;
+    close(): void;
+    addEventListener(type: string, listener: (ev: any) => void): void;
+    readonly readyState: number;
+}
+type WebSocketCtor = new (url: string) => MinimalWebSocket;
+/** Options for {@link ElectrumClient}. */
+interface ElectrumClientOptions {
+    /** Full wss/ws endpoint. Overrides `network`'s default if given. */
+    endpoint?: string;
+    /** Network whose default endpoint to use when `endpoint` is omitted. */
+    network?: NetworkName;
+    /** Per-request timeout in ms. Default 15,000. */
+    requestTimeoutMs?: number;
+    /** Auto-reconnect on close. Default true. */
+    reconnect?: boolean;
+    /** Inject a WebSocket constructor (tests, custom transports). */
+    webSocketCtor?: WebSocketCtor;
+}
+/**
+ * Connect-on-demand ElectrumX client.
+ *
+ * @example
+ * const client = new ElectrumClient({ network: "mainnet" });
+ * await client.connect();
+ * const bal = await client.getBalance(address);
+ */
+declare class ElectrumClient {
+    readonly endpoint: string;
+    private readonly requestTimeoutMs;
+    private readonly autoReconnect;
+    private readonly injectedCtor?;
+    private ws?;
+    private ctor?;
+    private nextId;
+    private readonly pending;
+    private readonly subscriptions;
+    private connectPromise?;
+    private reconnectAttempts;
+    private closedByUser;
+    constructor(options?: ElectrumClientOptions);
+    /** True if the socket is open and ready. */
+    get connected(): boolean;
+    /** Open the connection (idempotent). Resolves once the socket is ready. */
+    connect(): Promise<void>;
+    private resolveCtor;
+    private openSocket;
+    private onMessage;
+    private onClose;
+    /** Exponential backoff with full jitter, capped at RECONNECT_MAX_MS. */
+    private nextReconnectDelay;
+    /** Send a JSON-RPC request and await its result. */
+    request<T = unknown>(method: string, ...params: unknown[]): Promise<T>;
+    /** Negotiate protocol version. */
+    serverVersion(client?: string, protocol?: [string, string] | string): Promise<unknown>;
+    private toScriptHash;
+    /** Confirmed + unconfirmed balance (photons) for an address or scripthash. */
+    getBalance(addressOrScriptHash: string): Promise<ScriptHashBalance>;
+    /**
+     * Unspent outputs for an address or scripthash, as SDK {@link Utxo}s.
+     *
+     * NOTE: ElectrumX `listunspent` does not return the output script. When you
+     * pass a plain address we fill `script` with that address's P2PKH script
+     * (correct for ordinary wallet UTXOs). When you pass a raw scripthash we
+     * cannot reconstruct the script, so `script` is left empty — provide the
+     * address form if you intend to fund/sign from the result.
+     */
+    listUnspent(addressOrScriptHash: string): Promise<Utxo[]>;
+    /** Raw transaction history for an address or scripthash. */
+    getHistory(addressOrScriptHash: string): Promise<unknown[]>;
+    /** Fetch a raw transaction (hex, or verbose object when verbose=true). */
+    getTransaction(txid: string, verbose?: boolean): Promise<unknown>;
+    /**
+     * Subscribe to an address/scripthash; `onUpdate` fires with the new status
+     * hash whenever the set of outputs changes. Returns the current status.
+     */
+    subscribe(addressOrScriptHash: string, onUpdate: (status: string | null) => void): Promise<string | null>;
+    /** Stop receiving updates for a scripthash/address. */
+    unsubscribe(addressOrScriptHash: string): Promise<unknown>;
+    /**
+     * Broadcast a raw transaction (hex). Returns the txid. Treats the node's
+     * "transaction already in blockchain" as success (returns the computed txid
+     * is the caller's job; here we surface the node's reply).
+     */
+    broadcastTx(rawHex: string): Promise<string>;
+    /** Close the connection and stop reconnecting. */
+    close(): void;
+}
+
+/**
+ * HD key derivation for Radiant.
+ *
+ * Default path: m/44'/512'/account'/change/index — SLIP-0044 coin type 512,
+ * the radiantjs v3.0.0+ default. The legacy coin-type-0 path is opt-in.
+ *
+ * The wallet derives keys; it never talks to the network. Combine it with
+ * {@link ElectrumClient} and the tx builders to move funds.
+ */
+
+/** Options when constructing an {@link HDWallet}. */
+interface HDWalletOptions {
+    /** Network for address encoding. Default "mainnet". */
+    network?: NetworkName;
+    /** BIP39 passphrase ("25th word"). Default "". */
+    passphrase?: string;
+    /** Hardened account index. Default 0. */
+    account?: number;
+    /**
+     * SLIP-0044 coin type. Default 512 (Radiant). Pass 0 only to recover legacy
+     * wallets created before the coin-type-512 default.
+     */
+    coinType?: number;
+}
+/** A derived key bundle for one address index. */
+interface DerivedKey {
+    index: number;
+    change: number;
+    path: string;
+    /** WIF private key. */
+    wif: string;
+    /** Compressed public key, hex. */
+    publicKey: string;
+    /** Base58Check address. */
+    address: string;
+    /** ElectrumX scripthash for this address. */
+    scriptHash: string;
+}
+/**
+ * BIP44 HD wallet over a single account.
+ *
+ * @example
+ * const wallet = HDWallet.fromMnemonic(mnemonic, { network: "mainnet" });
+ * const { address, wif } = wallet.deriveKey(0);
+ */
+declare class HDWallet {
+    private readonly root;
+    readonly network: NetworkName;
+    readonly account: number;
+    readonly coinType: number;
+    private constructor();
+    /** Create a wallet from a BIP39 mnemonic phrase. */
+    static fromMnemonic(phrase: string, options?: HDWalletOptions): HDWallet;
+    /** Create a wallet from a raw seed (Buffer or hex string). */
+    static fromSeed(seed: Buffer | string, options?: HDWalletOptions): HDWallet;
+    /** Create a wallet from an extended private key (xprv). */
+    static fromXprv(xprv: string, options?: HDWalletOptions): HDWallet;
+    /** Generate a fresh random mnemonic phrase (BIP39, 12 words). */
+    static generateMnemonic(): string;
+    private static fromMaster;
+    /** Full derivation path for a given change/index under this account. */
+    pathFor(index: number, change?: number): string;
+    /** radiantjs PrivateKey at the given index (default external chain). */
+    privateKey(index: number, change?: number): any;
+    /** Derive a full key bundle (WIF, pubkey, address, scripthash) at an index. */
+    deriveKey(index: number, change?: number): DerivedKey;
+    /** Address at an index (external chain by default). */
+    address(index?: number, change?: number): string;
+    /** WIF private key at an index. */
+    wif(index?: number, change?: number): string;
+    /** Derive a batch of key bundles [start, start+count). */
+    deriveRange(start: number, count: number, change?: number): DerivedKey[];
+}
+/**
+ * Low-level WIF helpers for callers who already manage their own keys and do
+ * not need HD derivation.
+ */
+declare const Keys: {
+    /** Address (Base58Check) for a WIF private key. */
+    addressFromWif(wif: string, network?: NetworkName): string;
+    /** Compressed public key hex for a WIF private key. */
+    publicKeyFromWif(wif: string): string;
+    /** ElectrumX scripthash for a WIF private key's P2PKH address. */
+    scriptHashFromWif(wif: string, network?: NetworkName): string;
+};
+
+/**
+ * Ref-safe UTXO selection.
+ *
+ * THE invariant of this module (and the whole reason it exists): RXD funding is
+ * NEVER gathered by a pure value heuristic. A UTXO that carries a token ref
+ * (FT/NFT/dMint) looks like ordinary value to a naive selector, but spending it
+ * as discretionary funding silently and irreversibly BURNS the token. So every
+ * candidate is screened two ways — indexer-reported `refs`, and a local script
+ * scan (isTokenBearing) — before it can fund a transaction.
+ *
+ * Mirrors Photonic-Wallet's `selectRxdFunding` / `fundTx` behaviour.
+ */
+
+/** Options for {@link selectRxdFunding}. */
+interface SelectRxdFundingOptions {
+    /**
+     * Number of non-funding outputs the final tx will already have (e.g. the
+     * recipient/token output). Used for fee estimation. Default 1.
+     */
+    baseOutputCount?: number;
+    /**
+     * Bytes contributed by inputs the caller has already committed (e.g. a token
+     * input being spent deliberately). Added to the fee estimate. Default 0.
+     */
+    extraInputBytes?: bigint;
+    /** Whether a change output will be added (affects fee estimate). Default true. */
+    withChange?: boolean;
+}
+/**
+ * Is this UTXO safe to spend as plain RXD funding? It must carry no indexer
+ * refs and no OP_PUSHINPUTREF opcodes in its script.
+ */
+declare function isFundingSafe(utxo: Utxo): boolean;
+/**
+ * Filter a UTXO set down to token-free funding candidates.
+ * Use this any time you need "spendable RXD" rather than "all my UTXOs".
+ */
+declare function filterFundingCandidates(utxos: Utxo[]): Utxo[];
+/**
+ * Strict guard: throw {@link TokenBurnGuardError} on the first token-bearing
+ * UTXO. Use this when you have *already* segregated funding and want to assert
+ * the invariant loudly (e.g. before signing a hand-built transaction).
+ * {@link selectRxdFunding} does not need this — it excludes token UTXOs itself.
+ */
+declare function assertFundingSafe(utxos: Utxo[]): void;
+/** Estimate the fee (photons) for a tx with the given input/output counts. */
+declare function estimateFee(inputCount: number, outputCount: number, feeRate: bigint, extraInputBytes?: bigint): bigint;
+/**
+ * Select RXD funding inputs to cover `target` photons plus fees, **excluding
+ * every token-bearing UTXO** (the ref-safe guarantee). You can hand this the
+ * raw output of `listUnspent` — token UTXOs are dropped, never spent. Greedy:
+ * largest token-free UTXOs first, accumulating until target + fee is met. The
+ * fee grows with each input added.
+ *
+ * @throws {InsufficientFundsError} if token-free UTXOs cannot cover the target.
+ */
+declare function selectRxdFunding(utxos: Utxo[], target: bigint, feeRate: bigint, options?: SelectRxdFundingOptions): FundingSelection;
+/** Sum the photon value of a UTXO list. */
+declare function sumValue(utxos: Utxo[]): bigint;
+
+/**
+ * Transaction building primitive.
+ *
+ * A thin, faithful port of Photonic-Wallet's `buildTx`: it wraps radiantjs
+ * (which does the real script/sighash work) and adds two things the SDK needs —
+ * BigInt photon values and a per-input scriptSig hook used by the Glyph
+ * commit/reveal flow. Everything signs with SIGHASH_ALL | FORKID.
+ */
+
+/** An input to {@link buildTx}. Provide `script` for non-default (token) inputs. */
+interface BuildTxInput {
+    txid: string;
+    vout: number;
+    value: bigint;
+    /** Prevout scriptPubKey hex. If omitted, treated as P2PKH for `address`. */
+    script?: string;
+}
+/** Per-input scriptSig override, called after the default sig+pubkey is built. */
+type SetInputScript = (index: number, defaultScript: any) => any | string | void;
+interface BuildTxParams {
+    /** Change address and default signer/owner address. */
+    address: string;
+    /** Signing key(s) as WIF. A single WIF signs all inputs. */
+    wif: string | string[];
+    inputs: BuildTxInput[];
+    outputs: TxOutput[];
+    /** Append a change output back to `address`. Default true. */
+    addChange?: boolean;
+    /** Fee rate, photons/byte. */
+    feeRate: bigint;
+    /** Network (for address/change encoding). Default "mainnet". */
+    network?: NetworkName;
+    /** Override the scriptSig for specific inputs (Glyph reveal uses this). */
+    setInputScript?: SetInputScript;
+}
+/** A signed transaction ready to broadcast. */
+interface BuiltTx {
+    /** The radiantjs Transaction object (escape hatch). */
+    tx: any;
+    /** Serialised raw transaction hex. */
+    hex: string;
+    /** Transaction id (display order). */
+    txid: string;
+    /** Outputs, with resolved photon values (includes any change). */
+    outputs: {
+        script: string;
+        value: bigint;
+    }[];
+}
+/**
+ * Build and sign a transaction. Inputs with a `script` are added manually and
+ * signed via a scriptSig callback; inputs without are added as standard P2PKH.
+ */
+declare function buildTx(params: BuildTxParams): BuiltTx;
+/**
+ * Build a simple RXD payment: pay `amount` photons to `to`, funded ref-safely
+ * from `utxos`, change back to `address`.
+ */
+declare function buildRxdTransfer(params: {
+    address: string;
+    wif: string;
+    to: string;
+    amount: bigint;
+    utxos: Utxo[];
+    feeRate: bigint;
+    network?: NetworkName;
+}): BuiltTx;
+
+/**
+ * Glyph token operations: mint (FT/NFT) and transfer.
+ *
+ * Glyph uses a commit/reveal two-transaction pattern. The COMMIT output locks
+ * to a script that checks the payload hash and the Glyph magic; the REVEAL
+ * spends it, carrying the CBOR envelope in its input scriptSig, and produces
+ * the token output whose ref equals the commit outpoint. We reproduce the
+ * proven Photonic-Wallet on-chain templates here and drive them with the SDK's
+ * ref-safe funding selection.
+ *
+ * IMPORTANT: these are real consensus-level scripts. Validate any new mint flow
+ * on regtest/testnet before mainnet — see README.
+ */
+
+/** A Glyph payload: `p` is the protocol id list, plus free-form metadata. */
+interface GlyphPayload {
+    /** Glyph version. Default 2. */
+    v?: number;
+    /** Protocol ids, e.g. [1]=FT, [2]=NFT, [2,5]=mutable NFT. */
+    p: number[];
+    [key: string]: unknown;
+}
+/** Result of a mint: the token ref plus both transaction ids. */
+interface MintResult {
+    /** Packed 72-hex token ref (the commit outpoint). */
+    ref: string;
+    /** Display ref "txid:vout". */
+    refDisplay: string;
+    commitTxid: string;
+    revealTxid: string;
+}
+/**
+ * Encode a Glyph payload into its reveal scriptSig and commit payload hash.
+ * revealScriptSig = `<gly> <cbor(payload)>`; payloadHash = sha256d(cbor).
+ */
+declare function encodeGlyph(payload: GlyphPayload): {
+    revealScriptSig: string;
+    payloadHash: string;
+};
+/** FT output script: a value-summed ref bound to an owner P2PKH. */
+declare function ftScript(address: string, ref: string, network?: NetworkName): string;
+/** NFT output script: a singleton ref bound to an owner P2PKH. */
+declare function nftScript(address: string, ref: string, network?: NetworkName): string;
+/** Extract the 72-hex packed ref carried by a token script (FT or NFT). */
+declare function parseTokenRef(scriptHex: string): string | null;
+interface BaseMintParams {
+    client: ElectrumClient;
+    /** Owner address (receives the token; pays the fees). */
+    address: string;
+    /** Owner WIF. */
+    wif: string;
+    /** Token-free RXD funding UTXOs for `address`. */
+    fundingUtxos: Utxo[];
+    /** Fee rate, photons/byte. Defaults to the network min-relay rate. */
+    feeRate?: bigint;
+    network?: NetworkName;
+    /** Extra metadata merged into the Glyph payload (name, desc, attrs, ...). */
+    metadata?: Record<string, unknown>;
+}
+interface MintFtParams extends BaseMintParams {
+    ticker: string;
+    /** Token supply in base units. In Glyph FT, amount == output photons. */
+    supply: bigint;
+}
+interface MintNftParams extends BaseMintParams {
+    /** Mark the NFT mutable (p:[2,5]). Default false (immutable singleton). */
+    mutable?: boolean;
+    /** Carrier value (photons) for the NFT output. Default dust. */
+    outputValue?: bigint;
+}
+/** Mint a fungible token (Glyph FT). */
+declare function mintFT(params: MintFtParams): Promise<MintResult>;
+/** Mint a non-fungible token (Glyph NFT singleton). */
+declare function mintNFT(params: MintNftParams): Promise<MintResult>;
+interface TransferTokenParams {
+    client: ElectrumClient;
+    /** Current owner address (signs the token input, pays the fee). */
+    address: string;
+    /** Current owner WIF. */
+    wif: string;
+    /** The token UTXO to move (its `script` must be the on-chain token script). */
+    tokenUtxo: Utxo;
+    /** Recipient address. */
+    toAddress: string;
+    /** Token-free RXD funding UTXOs for `address` to cover the fee. */
+    fundingUtxos: Utxo[];
+    feeRate?: bigint;
+    network?: NetworkName;
+}
+/**
+ * Transfer a Glyph token (FT or NFT) to a new owner. The token output's value
+ * is preserved (for FT this preserves the amount); the covenant preamble is
+ * carried forward unchanged and only the owner P2PKH is re-bound.
+ */
+declare function transferToken(params: TransferTokenParams): Promise<{
+    txid: string;
+    hex: string;
+    ref: string | null;
+}>;
+
+/**
+ * WAVE name resolution.
+ *
+ * WAVE names resolve through the RXinDexer REST API:
+ *   GET {base}/wave/resolve/{name}
+ * The indexer keys on the BARE label (no domain suffix), so "alice.rxd" is
+ * normalised to "alice" before the request. The canonical (first) registration
+ * is always returned; later duplicates are tracked but not used for resolution.
+ */
+
+/** Options for WAVE resolution. */
+interface WaveResolveOptions {
+    /** REST base URL. Default https://radiantcore.org/api */
+    restBase?: string;
+    /** Inject a fetch implementation (tests / non-global-fetch runtimes). */
+    fetchImpl?: typeof fetch;
+    /** AbortSignal to cancel the request. */
+    signal?: AbortSignal;
+}
+/**
+ * Normalise a WAVE name to the label the indexer resolves on: lowercase,
+ * trimmed, with a single trailing suffix (e.g. ".rxd") stripped — mirroring the
+ * REST endpoint's `rfind('.')` behaviour, so subdomains like "mail.alice.rxd"
+ * become "mail.alice". Rejects empty names and leading/trailing dots.
+ */
+declare function waveLabel(name: string): string;
+/**
+ * Resolve a WAVE name to its full record. Returns `registered: false` when the
+ * name is available (unregistered) rather than throwing.
+ */
+declare function waveResolve(name: string, options?: WaveResolveOptions): Promise<WaveResolution>;
+/**
+ * Convenience: resolve a WAVE name straight to its target address, or null if
+ * the name is unregistered or has no target.
+ */
+declare function waveResolveAddress(name: string, options?: WaveResolveOptions): Promise<string | null>;
+
+/**
+ * Single, centralised access point to `@radiant-core/radiantjs`.
+ *
+ * radiantjs is the low-level tx/script/key library (a Radiant fork of
+ * bitcore-lib). We wrap it — never duplicate it. Every other module imports the
+ * classes it needs from here so there is exactly one place that knows about the
+ * underlying library's loose runtime shape.
+ */
+
+/** The raw radiantjs namespace, for advanced callers that need an escape hatch. */
+declare const radiantjs: any;
+
+export { type BuildTxInput, type BuildTxParams, type BuiltTx, DEFAULT_ELECTRUM_ENDPOINT, DEFAULT_REST_BASE, DUST_LIMIT, type DerivedKey, ElectrumClient, type ElectrumClientOptions, ElectrumError, type FundingSelection, GLYPH_PROTOCOL, type GlyphPayload, HDWallet, type HDWalletOptions, InsufficientFundsError, Keys, MIN_RELAY_FEE_RATE, type MintFtParams, type MintNftParams, type MintResult, type NetworkName, PHOTONS_PER_RXD, RADIANT_COIN_TYPE, RXD_DECIMALS, RadiantSdkError, type ScriptHashBalance, type SelectRxdFundingOptions, TokenBurnGuardError, type TransferTokenParams, type TxOutput, type Utxo, type UtxoRef, ValidationError, type WaveResolution, type WaveResolveOptions, addressToScriptHash, assertFundingSafe, buildRxdTransfer, buildTx, encodeGlyph, estimateFee, filterFundingCandidates, ftScript, isFundingSafe, isTokenBearing, mintFT, mintNFT, nftScript, p2pkhScript, packRef, parseTokenRef, photonsToRxd, radiantjs, rxdToPhotons, scriptHash, selectRxdFunding, sumValue, transferToken, unpackRef, waveLabel, waveResolve, waveResolveAddress, zeroRefs };