@radiant-core/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1064 @@
+'use strict';
+
+var rjs = require('@radiant-core/radiantjs');
+var cborX = require('cbor-x');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var rjs__default = /*#__PURE__*/_interopDefault(rjs);
+
+// src/errors.ts
+var RadiantSdkError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var InsufficientFundsError = class extends RadiantSdkError {
+  constructor(requiredPhotons, availablePhotons) {
+    super(
+      `Insufficient funds: need ${requiredPhotons} photons (incl. fee) but only ${availablePhotons} available in token-free UTXOs`
+    );
+    this.requiredPhotons = requiredPhotons;
+    this.availablePhotons = availablePhotons;
+  }
+};
+var TokenBurnGuardError = class extends RadiantSdkError {
+  constructor(txid, vout) {
+    super(
+      `Refusing token-bearing UTXO ${txid}:${vout} as RXD funding (would burn the token)`
+    );
+    this.txid = txid;
+    this.vout = vout;
+  }
+};
+var ElectrumError = class extends RadiantSdkError {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+};
+var ValidationError = class extends RadiantSdkError {
+};
+
+// src/constants.ts
+var PHOTONS_PER_RXD = 100000000n;
+var RADIANT_COIN_TYPE = 512;
+var MIN_RELAY_FEE_RATE = {
+  mainnet: 10000n,
+  testnet: 1000n,
+  regtest: 1000n
+};
+var DUST_LIMIT = 1000n;
+var TOKEN_OUTPUT_VALUE = 1n;
+var DEFAULT_ELECTRUM_ENDPOINT = {
+  mainnet: "wss://electrumx.radiantcore.org:443",
+  // Adjust to your own infra; no canonical public testnet/regtest endpoint.
+  testnet: "wss://electrumx.radiantcore.org:443",
+  regtest: "ws://localhost:50011"
+};
+var DEFAULT_REST_BASE = "https://radiantcore.org/api";
+var GLYPH_MAGIC_BYTES = Uint8Array.from([103, 108, 121]);
+var GLYPH_PROTOCOL = {
+  FT: 1,
+  NFT: 2,
+  MUTABLE: 5,
+  CONTAINER: 7,
+  ENCRYPTED: 8,
+  WAVE: 11
+};
+var INPUT_REF_OP_MIN = 208;
+var INPUT_REF_OP_MAX = 216;
+var RECONNECT_BASE_MS = 1e3;
+var RECONNECT_MAX_MS = 3e4;
+var DEFAULT_REQUEST_TIMEOUT_MS = 15e3;
+
+// src/units.ts
+var RXD_DECIMALS = 8;
+function rxdToPhotons(rxd) {
+  const str = typeof rxd === "number" ? formatNumber(rxd) : rxd.trim();
+  if (!/^-?\d*(\.\d*)?$/.test(str) || str === "" || str === "." || str === "-") {
+    throw new ValidationError(`Invalid RXD amount: ${JSON.stringify(rxd)}`);
+  }
+  const negative = str.startsWith("-");
+  const [whole, frac = ""] = (negative ? str.slice(1) : str).split(".");
+  if (frac.length > RXD_DECIMALS) {
+    throw new ValidationError(
+      `RXD amount has more than ${RXD_DECIMALS} decimal places: ${str}`
+    );
+  }
+  const padded = frac.padEnd(RXD_DECIMALS, "0");
+  const photons = BigInt(whole || "0") * PHOTONS_PER_RXD + BigInt(padded || "0");
+  return negative ? -photons : photons;
+}
+function photonsToRxd(photons) {
+  const negative = photons < 0n;
+  const abs = negative ? -photons : photons;
+  const whole = abs / PHOTONS_PER_RXD;
+  const frac = abs % PHOTONS_PER_RXD;
+  const fracStr = frac.toString().padStart(RXD_DECIMALS, "0").replace(/0+$/, "");
+  const body = fracStr.length ? `${whole}.${fracStr}` : `${whole}.0`;
+  return negative ? `-${body}` : body;
+}
+function formatNumber(n) {
+  if (!Number.isFinite(n)) {
+    throw new ValidationError(`Invalid RXD amount: ${n}`);
+  }
+  return n.toFixed(RXD_DECIMALS);
+}
+var Address = rjs__default.default.Address;
+var HDPrivateKey = rjs__default.default.HDPrivateKey;
+rjs__default.default.HDPublicKey;
+var PrivateKey = rjs__default.default.PrivateKey;
+rjs__default.default.PublicKey;
+var Script = rjs__default.default.Script;
+var Opcode = rjs__default.default.Opcode;
+var Transaction = rjs__default.default.Transaction;
+var Mnemonic = rjs__default.default.Mnemonic;
+var Networks = rjs__default.default.Networks;
+var crypto = rjs__default.default.crypto;
+var radiantjs = rjs__default.default;
+function toRjsNetwork(network) {
+  switch (network) {
+    case "mainnet":
+      return Networks.livenet;
+    case "testnet":
+      return Networks.testnet;
+    case "regtest":
+      Networks.enableRegtest?.();
+      return Networks.regtest;
+  }
+}
+function sha256(data) {
+  return crypto.Hash.sha256(data);
+}
+function sha256d(data) {
+  return crypto.Hash.sha256sha256(data);
+}
+var SIGHASH_FORKID_ALL = crypto.Signature.SIGHASH_ALL | crypto.Signature.SIGHASH_FORKID;
+
+// src/script.ts
+var CHECKSIG_OPS = /* @__PURE__ */ new Set([
+  172,
+  // OP_CHECKSIG
+  173,
+  // OP_CHECKSIGVERIFY
+  174,
+  // OP_CHECKMULTISIG
+  175
+  // OP_CHECKMULTISIGVERIFY
+]);
+function scriptHash(scriptHex) {
+  if (!scriptHex) {
+    throw new ValidationError("scriptHash: cannot hash an empty script");
+  }
+  return Buffer.from(sha256(Buffer.from(scriptHex, "hex"))).reverse().toString("hex");
+}
+function p2pkhScript(address, _network) {
+  try {
+    return Script.buildPublicKeyHashOut(address).toHex();
+  } catch (err) {
+    throw new ValidationError(
+      `p2pkhScript: invalid address ${JSON.stringify(address)}: ${String(err)}`
+    );
+  }
+}
+function addressToScriptHash(address, network) {
+  return scriptHash(p2pkhScript(address));
+}
+function isTokenBearing(scriptHex) {
+  if (!scriptHex) return false;
+  let bytes;
+  try {
+    bytes = Buffer.from(scriptHex, "hex");
+  } catch {
+    return false;
+  }
+  const n = bytes.length;
+  let pos = 0;
+  while (pos < n) {
+    const op = bytes[pos];
+    if (op >= INPUT_REF_OP_MIN && op <= INPUT_REF_OP_MAX) return true;
+    let next;
+    if (op >= 1 && op <= 75) {
+      next = pos + 1 + op;
+    } else if (op === 76) {
+      if (pos + 1 >= n) return false;
+      next = pos + 2 + bytes[pos + 1];
+    } else if (op === 77) {
+      if (pos + 2 >= n) return false;
+      next = pos + 3 + (bytes[pos + 1] | bytes[pos + 2] << 8);
+    } else if (op === 78) {
+      if (pos + 4 >= n) return false;
+      next = pos + 5 + ((bytes[pos + 1] | bytes[pos + 2] << 8 | bytes[pos + 3] << 16 | bytes[pos + 4] << 24) >>> 0);
+    } else {
+      next = pos + 1;
+    }
+    if (next <= pos || next > n) return false;
+    pos = next;
+  }
+  return false;
+}
+function zeroRefs(scriptHex) {
+  const script = Buffer.from(scriptHex, "hex");
+  const out = Buffer.from(script);
+  let requiresSig = false;
+  let n = 0;
+  while (n < script.length) {
+    const op = script[n];
+    n += 1;
+    if (CHECKSIG_OPS.has(op)) {
+      requiresSig = true;
+    } else if (op >= INPUT_REF_OP_MIN && op <= INPUT_REF_OP_MAX) {
+      out.fill(0, n, n + 36);
+      n += 36;
+    } else if (op <= 78 && op >= 1) {
+      let dlen = op;
+      if (op === 76) {
+        dlen = script[n];
+        n += 1;
+      } else if (op === 77) {
+        dlen = script.readUInt16LE(n);
+        n += 2;
+      } else if (op === 78) {
+        dlen = script.readUInt32LE(n);
+        n += 4;
+      }
+      n += dlen;
+    }
+  }
+  return (requiresSig ? out : script).toString("hex");
+}
+function packRef(txid, vout) {
+  if (!/^[0-9a-fA-F]{64}$/.test(txid)) {
+    throw new ValidationError(`packRef: invalid txid ${JSON.stringify(txid)}`);
+  }
+  const txidLE = Buffer.from(txid, "hex").reverse();
+  const voutLE = Buffer.alloc(4);
+  voutLE.writeUInt32LE(vout >>> 0, 0);
+  return Buffer.concat([txidLE, voutLE]).toString("hex");
+}
+function unpackRef(ref) {
+  if (!/^[0-9a-fA-F]{72}$/.test(ref)) {
+    throw new ValidationError(`unpackRef: invalid ref ${JSON.stringify(ref)}`);
+  }
+  const buf = Buffer.from(ref, "hex");
+  const txid = Buffer.from(buf.subarray(0, 32)).reverse().toString("hex");
+  const vout = buf.readUInt32LE(32);
+  return { txid, vout };
+}
+
+// src/client.ts
+var WS_OPEN = 1;
+var ElectrumClient = class {
+  constructor(options = {}) {
+    this.nextId = 1;
+    this.pending = /* @__PURE__ */ new Map();
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.reconnectAttempts = 0;
+    this.closedByUser = false;
+    const network = options.network ?? "mainnet";
+    this.endpoint = options.endpoint ?? DEFAULT_ELECTRUM_ENDPOINT[network];
+    this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    this.autoReconnect = options.reconnect ?? true;
+    this.injectedCtor = options.webSocketCtor;
+  }
+  /** True if the socket is open and ready. */
+  get connected() {
+    return this.ws?.readyState === WS_OPEN;
+  }
+  /** Open the connection (idempotent). Resolves once the socket is ready. */
+  async connect() {
+    if (this.connected) return;
+    if (this.connectPromise) return this.connectPromise;
+    this.closedByUser = false;
+    this.connectPromise = this.openSocket();
+    try {
+      await this.connectPromise;
+    } finally {
+      this.connectPromise = void 0;
+    }
+  }
+  async resolveCtor() {
+    if (this.ctor) return this.ctor;
+    if (this.injectedCtor) return this.ctor = this.injectedCtor;
+    const g = globalThis;
+    if (typeof g.WebSocket !== "undefined") {
+      return this.ctor = g.WebSocket;
+    }
+    try {
+      const mod = await import('ws');
+      return this.ctor = mod.default ?? mod;
+    } catch {
+      throw new ElectrumError(
+        "No WebSocket implementation available. On Node <22, install the optional `ws` dependency."
+      );
+    }
+  }
+  async openSocket() {
+    const Ctor = await this.resolveCtor();
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const ws = new Ctor(this.endpoint);
+      this.ws = ws;
+      ws.addEventListener("open", () => {
+        this.reconnectAttempts = 0;
+        settled = true;
+        resolve();
+      });
+      ws.addEventListener(
+        "message",
+        (ev) => this.onMessage(ev.data)
+      );
+      ws.addEventListener("error", (ev) => {
+        if (!settled) {
+          settled = true;
+          reject(new ElectrumError(`WebSocket error connecting to ${this.endpoint}`));
+        }
+      });
+      ws.addEventListener("close", () => this.onClose());
+    });
+  }
+  onMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(typeof data === "string" ? data : String(data));
+    } catch {
+      return;
+    }
+    const handle = (m) => {
+      if (m && typeof m.id === "number") {
+        const p = this.pending.get(m.id);
+        if (!p) return;
+        this.pending.delete(m.id);
+        clearTimeout(p.timer);
+        if (m.error) {
+          const e = m.error;
+          p.reject(new ElectrumError(e?.message ?? String(e), e?.code));
+        } else {
+          p.resolve(m.result);
+        }
+      } else if (m && typeof m.method === "string") {
+        const handler = this.subscriptions.get(m.method);
+        if (handler) handler(Array.isArray(m.params) ? m.params : []);
+      }
+    };
+    if (Array.isArray(msg)) msg.forEach(handle);
+    else handle(msg);
+  }
+  onClose() {
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(new ElectrumError("Connection closed"));
+    }
+    this.pending.clear();
+    this.ws = void 0;
+    if (this.closedByUser || !this.autoReconnect) return;
+    const delay = this.nextReconnectDelay();
+    setTimeout(() => {
+      this.connect().catch(() => {
+      });
+    }, delay);
+  }
+  /** Exponential backoff with full jitter, capped at RECONNECT_MAX_MS. */
+  nextReconnectDelay() {
+    const capped = Math.min(
+      RECONNECT_MAX_MS,
+      RECONNECT_BASE_MS * 2 ** this.reconnectAttempts
+    );
+    this.reconnectAttempts++;
+    return capped / 2 + Math.random() * (capped / 2);
+  }
+  /** Send a JSON-RPC request and await its result. */
+  async request(method, ...params) {
+    if (!this.connected) await this.connect();
+    const id = this.nextId++;
+    const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new ElectrumError(`Request timed out: ${method}`));
+      }, this.requestTimeoutMs);
+      this.pending.set(id, {
+        resolve,
+        reject,
+        timer
+      });
+      try {
+        this.ws.send(payload);
+      } catch (err) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(new ElectrumError(`Failed to send ${method}: ${String(err)}`));
+      }
+    });
+  }
+  // ---- Server info ----------------------------------------------------------
+  /** Negotiate protocol version. */
+  async serverVersion(client = "@radiant-core/sdk", protocol = ["1.4", "1.4.3"]) {
+    return this.request("server.version", client, protocol);
+  }
+  // ---- Scripthash queries ---------------------------------------------------
+  toScriptHash(addressOrScriptHash) {
+    return /^[0-9a-fA-F]{64}$/.test(addressOrScriptHash) ? addressOrScriptHash.toLowerCase() : addressToScriptHash(addressOrScriptHash);
+  }
+  /** Confirmed + unconfirmed balance (photons) for an address or scripthash. */
+  async getBalance(addressOrScriptHash) {
+    const sh = this.toScriptHash(addressOrScriptHash);
+    const r = await this.request(
+      "blockchain.scripthash.get_balance",
+      sh
+    );
+    return {
+      confirmed: BigInt(r.confirmed ?? 0),
+      unconfirmed: BigInt(r.unconfirmed ?? 0)
+    };
+  }
+  /**
+   * 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.
+   */
+  async listUnspent(addressOrScriptHash) {
+    const isAddress = !/^[0-9a-fA-F]{64}$/.test(addressOrScriptHash);
+    const sh = this.toScriptHash(addressOrScriptHash);
+    const rows = await this.request(
+      "blockchain.scripthash.listunspent",
+      sh
+    );
+    const script = isAddress ? p2pkhScript(addressOrScriptHash) : "";
+    return rows.map((r) => ({
+      txid: r.tx_hash,
+      vout: r.tx_pos,
+      value: BigInt(r.value),
+      height: r.height,
+      script,
+      refs: r.refs
+    }));
+  }
+  /** Raw transaction history for an address or scripthash. */
+  async getHistory(addressOrScriptHash) {
+    const sh = this.toScriptHash(addressOrScriptHash);
+    return this.request("blockchain.scripthash.get_history", sh);
+  }
+  /** Fetch a raw transaction (hex, or verbose object when verbose=true). */
+  async getTransaction(txid, verbose = false) {
+    return this.request("blockchain.transaction.get", txid, verbose);
+  }
+  /**
+   * Subscribe to an address/scripthash; `onUpdate` fires with the new status
+   * hash whenever the set of outputs changes. Returns the current status.
+   */
+  async subscribe(addressOrScriptHash, onUpdate) {
+    const sh = this.toScriptHash(addressOrScriptHash);
+    this.subscriptions.set("blockchain.scripthash.subscribe", (params) => {
+      if (params[0] === sh) onUpdate(params[1] ?? null);
+    });
+    return this.request("blockchain.scripthash.subscribe", sh);
+  }
+  /** Stop receiving updates for a scripthash/address. */
+  async unsubscribe(addressOrScriptHash) {
+    const sh = this.toScriptHash(addressOrScriptHash);
+    this.subscriptions.delete("blockchain.scripthash.subscribe");
+    return this.request("blockchain.scripthash.unsubscribe", sh);
+  }
+  // ---- Broadcast ------------------------------------------------------------
+  /**
+   * 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).
+   */
+  async broadcastTx(rawHex) {
+    try {
+      return await this.request(
+        "blockchain.transaction.broadcast",
+        rawHex
+      );
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.toLowerCase().includes("transactionalreadyinblockchain")) {
+        return "";
+      }
+      throw err;
+    }
+  }
+  // ---- Lifecycle ------------------------------------------------------------
+  /** Close the connection and stop reconnecting. */
+  close() {
+    this.closedByUser = true;
+    this.subscriptions.clear();
+    try {
+      this.ws?.close();
+    } catch {
+    }
+    this.ws = void 0;
+  }
+};
+
+// src/wallet.ts
+var HDWallet = class _HDWallet {
+  constructor(accountNode, network, account, coinType) {
+    this.root = accountNode;
+    this.network = network;
+    this.account = account;
+    this.coinType = coinType;
+  }
+  /** Create a wallet from a BIP39 mnemonic phrase. */
+  static fromMnemonic(phrase, options = {}) {
+    if (!Mnemonic.isValid(phrase)) {
+      throw new ValidationError("fromMnemonic: invalid BIP39 mnemonic");
+    }
+    const mnemonic = new Mnemonic(phrase);
+    const network = options.network ?? "mainnet";
+    const rjsNet = toRjsNetwork(network);
+    const seed = mnemonic.toSeed(options.passphrase ?? "");
+    const master = HDPrivateKey.fromSeed(seed, rjsNet);
+    return _HDWallet.fromMaster(master, network, options);
+  }
+  /** Create a wallet from a raw seed (Buffer or hex string). */
+  static fromSeed(seed, options = {}) {
+    const network = options.network ?? "mainnet";
+    const buf = typeof seed === "string" ? Buffer.from(seed, "hex") : seed;
+    const master = HDPrivateKey.fromSeed(buf, toRjsNetwork(network));
+    return _HDWallet.fromMaster(master, network, options);
+  }
+  /** Create a wallet from an extended private key (xprv). */
+  static fromXprv(xprv, options = {}) {
+    const network = options.network ?? "mainnet";
+    const master = new HDPrivateKey(xprv);
+    return _HDWallet.fromMaster(master, network, options);
+  }
+  /** Generate a fresh random mnemonic phrase (BIP39, 12 words). */
+  static generateMnemonic() {
+    return Mnemonic.fromRandom().toString();
+  }
+  static fromMaster(master, network, options) {
+    const account = options.account ?? 0;
+    const coinType = options.coinType ?? RADIANT_COIN_TYPE;
+    const accountNode = master.deriveChild(
+      `m/44'/${coinType}'/${account}'`
+    );
+    return new _HDWallet(accountNode, network, account, coinType);
+  }
+  /** Full derivation path for a given change/index under this account. */
+  pathFor(index, change = 0) {
+    return `m/44'/${this.coinType}'/${this.account}'/${change}/${index}`;
+  }
+  /** radiantjs PrivateKey at the given index (default external chain). */
+  privateKey(index, change = 0) {
+    const node = this.root.deriveChild(change).deriveChild(index);
+    return node.privateKey;
+  }
+  /** Derive a full key bundle (WIF, pubkey, address, scripthash) at an index. */
+  deriveKey(index, change = 0) {
+    const priv = this.privateKey(index, change);
+    const address = priv.toAddress(toRjsNetwork(this.network)).toString();
+    return {
+      index,
+      change,
+      path: this.pathFor(index, change),
+      wif: priv.toWIF(),
+      publicKey: priv.toPublicKey().toString(),
+      address,
+      scriptHash: addressToScriptHash(address)
+    };
+  }
+  /** Address at an index (external chain by default). */
+  address(index = 0, change = 0) {
+    return this.deriveKey(index, change).address;
+  }
+  /** WIF private key at an index. */
+  wif(index = 0, change = 0) {
+    return this.privateKey(index, change).toWIF();
+  }
+  /** Derive a batch of key bundles [start, start+count). */
+  deriveRange(start, count, change = 0) {
+    const out = [];
+    for (let i = 0; i < count; i++) out.push(this.deriveKey(start + i, change));
+    return out;
+  }
+};
+var Keys = {
+  /** Address (Base58Check) for a WIF private key. */
+  addressFromWif(wif, network = "mainnet") {
+    return PrivateKey.fromWIF(wif).toAddress(toRjsNetwork(network)).toString();
+  },
+  /** Compressed public key hex for a WIF private key. */
+  publicKeyFromWif(wif) {
+    return PrivateKey.fromWIF(wif).toPublicKey().toString();
+  },
+  /** ElectrumX scripthash for a WIF private key's P2PKH address. */
+  scriptHashFromWif(wif, network = "mainnet") {
+    return addressToScriptHash(this.addressFromWif(wif, network));
+  }
+};
+
+// src/utxo.ts
+var TX_OVERHEAD_BYTES = 10n;
+var P2PKH_INPUT_BYTES = 148n;
+var P2PKH_OUTPUT_BYTES = 34n;
+var SELECTION_HEADROOM_BYTES = 160n;
+function isFundingSafe(utxo) {
+  if (utxo.refs && utxo.refs.length > 0) return false;
+  if (isTokenBearing(utxo.script)) return false;
+  return true;
+}
+function filterFundingCandidates(utxos) {
+  return utxos.filter(isFundingSafe);
+}
+function assertFundingSafe(utxos) {
+  for (const u of utxos) {
+    if (!isFundingSafe(u)) throw new TokenBurnGuardError(u.txid, u.vout);
+  }
+}
+function estimateFee(inputCount, outputCount, feeRate, extraInputBytes = 0n) {
+  const bytes = TX_OVERHEAD_BYTES + P2PKH_INPUT_BYTES * BigInt(inputCount) + P2PKH_OUTPUT_BYTES * BigInt(outputCount) + extraInputBytes;
+  return bytes * feeRate;
+}
+function selectRxdFunding(utxos, target, feeRate, options = {}) {
+  const baseOutputCount = options.baseOutputCount ?? 1;
+  const extraInputBytes = options.extraInputBytes ?? 0n;
+  const withChange = options.withChange ?? true;
+  const candidates = filterFundingCandidates(utxos).sort(
+    (a, b) => a.value < b.value ? 1 : a.value > b.value ? -1 : 0
+  );
+  const reserveBytes = extraInputBytes + SELECTION_HEADROOM_BYTES;
+  const selected = [];
+  let total = 0n;
+  for (const u of candidates) {
+    selected.push(u);
+    total += u.value;
+    const outputs = baseOutputCount + (withChange ? 1 : 0);
+    const fee = estimateFee(selected.length, outputs, feeRate, reserveBytes);
+    if (total >= target + fee) {
+      return { inputs: selected, fee, total, change: total - target - fee };
+    }
+  }
+  const available = candidates.reduce((s, u) => s + u.value, 0n);
+  const finalFee = estimateFee(
+    Math.max(selected.length, 1),
+    baseOutputCount + (withChange ? 1 : 0),
+    feeRate,
+    reserveBytes
+  );
+  throw new InsufficientFundsError(target + finalFee, available);
+}
+function sumValue(utxos) {
+  return utxos.reduce((s, u) => s + u.value, 0n);
+}
+
+// src/tx.ts
+function bn(value) {
+  return new crypto.BN(value.toString());
+}
+function applyFeeRate(tx, feeRate) {
+  const rate = Number(feeRate);
+  if (typeof tx.feePerByte === "function") {
+    tx.feePerByte(rate);
+  } else if (typeof tx.feePerKb === "function") {
+    tx.feePerKb(rate * 1e3);
+  }
+}
+function buildTx(params) {
+  const {
+    address,
+    inputs,
+    outputs,
+    feeRate,
+    addChange = true,
+    network = "mainnet"
+  } = params;
+  const wifs = Array.isArray(params.wif) ? params.wif : [params.wif];
+  const privKeys = wifs.map((w) => PrivateKey.fromWIF(w));
+  const ownerP2pkh = p2pkhScript(address);
+  const tx = new Transaction();
+  applyFeeRate(tx, feeRate);
+  inputs.forEach((input, index) => {
+    const prevScript = input.script ?? ownerP2pkh;
+    tx.addInput(
+      new Transaction.Input({
+        prevTxId: input.txid,
+        outputIndex: input.vout,
+        script: new Script(),
+        output: new Transaction.Output({
+          script: Script.fromHex(prevScript),
+          satoshis: bn(input.value)
+        })
+      })
+    );
+    tx.setInputScript(index, (_tx, output) => {
+      const privKey = privKeys[index] ?? privKeys[0];
+      const sigType = SIGHASH_FORKID_ALL;
+      const sig = Transaction.Sighash.sign(
+        tx,
+        privKey,
+        sigType,
+        index,
+        output.script,
+        bn(input.value)
+      );
+      const spend = Script.empty().add(Buffer.concat([sig.toBuffer(), Buffer.from([sigType])])).add(privKey.toPublicKey().toBuffer());
+      if (params.setInputScript) {
+        const overridden = params.setInputScript(index, spend);
+        if (overridden) {
+          return typeof overridden === "string" ? overridden : overridden.toString();
+        }
+      }
+      return spend.toString();
+    });
+  });
+  outputs.forEach(({ script, value }) => {
+    tx.addOutput(
+      new Transaction.Output({ script: Script.fromHex(script), satoshis: bn(value) })
+    );
+  });
+  if (addChange) {
+    tx.change(address);
+    const probe = tx.toString();
+    const sizeBytes = BigInt(probe.length / 2);
+    const fee = (sizeBytes + 20n) * feeRate;
+    tx.fee(Number(fee));
+    tx.change(address);
+  }
+  tx.sign(privKeys[0]);
+  if (typeof tx.seal === "function") tx.seal();
+  const hex = tx.toString();
+  const resolvedOutputs = tx.outputs.map((o) => ({
+    script: o.script.toHex(),
+    value: BigInt(o.satoshis?.toString?.() ?? o.satoshis)
+  }));
+  return { tx, hex, txid: tx.id, outputs: resolvedOutputs };
+}
+function buildRxdTransfer(params) {
+  const { address, wif, to, amount, utxos, feeRate, network = "mainnet" } = params;
+  if (amount <= 0n) throw new ValidationError("buildRxdTransfer: amount must be > 0");
+  const selection = selectRxdFunding(utxos, amount, feeRate, {
+    baseOutputCount: 1,
+    // the recipient output
+    withChange: true
+  });
+  const inputs = selection.inputs.map((u) => ({
+    txid: u.txid,
+    vout: u.vout,
+    value: u.value,
+    script: u.script || void 0
+  }));
+  return buildTx({
+    address,
+    wif,
+    inputs,
+    outputs: [{ script: p2pkhScript(to), value: amount }],
+    addChange: true,
+    feeRate,
+    network
+  });
+}
+var MAGIC = Buffer.from(GLYPH_MAGIC_BYTES);
+function encodeGlyph(payload) {
+  const encoded = Buffer.from(cborX.encode(payload));
+  const revealScriptSig = new Script().add(MAGIC).add(encoded).toHex();
+  const payloadHash = Buffer.from(sha256d(encoded)).toString("hex");
+  return { revealScriptSig, payloadHash };
+}
+function commitScript(address, payloadHash, refType, network) {
+  const addr = Address.fromString(address);
+  const refOp = refType === 1 ? "OP_1" : "OP_2";
+  const script = new Script();
+  script.add(Opcode.OP_HASH256).add(Buffer.from(payloadHash, "hex")).add(Opcode.OP_EQUALVERIFY).add(MAGIC).add(Opcode.OP_EQUALVERIFY).add(
+    Script.fromASM(
+      `OP_INPUTINDEX OP_OUTPOINTTXHASH OP_INPUTINDEX OP_OUTPOINTINDEX OP_4 OP_NUM2BIN OP_CAT OP_REFTYPE_OUTPUT ${refOp} OP_NUMEQUALVERIFY`
+    )
+  ).add(Script.buildPublicKeyHashOut(addr));
+  return script.toHex();
+}
+function ftScript(address, ref, network = "mainnet") {
+  const addr = Address.fromString(address);
+  const script = Script.buildPublicKeyHashOut(addr).add(
+    Script.fromASM(
+      `OP_STATESEPARATOR OP_PUSHINPUTREF ${ref} OP_REFOUTPUTCOUNT_OUTPUTS OP_INPUTINDEX OP_CODESCRIPTBYTECODE_UTXO OP_HASH256 OP_DUP OP_CODESCRIPTHASHVALUESUM_UTXOS OP_OVER OP_CODESCRIPTHASHVALUESUM_OUTPUTS OP_GREATERTHANOREQUAL OP_VERIFY OP_CODESCRIPTHASHOUTPUTCOUNT_OUTPUTS OP_NUMEQUALVERIFY`
+    )
+  );
+  return script.toHex();
+}
+function nftScript(address, ref, network = "mainnet") {
+  const addr = Address.fromString(address);
+  const script = Script.fromASM(`OP_PUSHINPUTREFSINGLETON ${ref} OP_DROP`).add(
+    Script.buildPublicKeyHashOut(addr)
+  );
+  return script.toHex();
+}
+function parseTokenRef(scriptHex) {
+  const bytes = Buffer.from(scriptHex, "hex");
+  let pos = 0;
+  while (pos < bytes.length) {
+    const op = bytes[pos];
+    if (op >= INPUT_REF_OP_MIN && op <= INPUT_REF_OP_MAX) {
+      if (pos + 1 + 36 > bytes.length) return null;
+      return bytes.subarray(pos + 1, pos + 1 + 36).toString("hex");
+    }
+    if (op >= 1 && op <= 75) pos += 1 + op;
+    else if (op === 76) pos += 2 + (bytes[pos + 1] ?? 0);
+    else if (op === 77) pos += 3 + ((bytes[pos + 1] ?? 0) | (bytes[pos + 2] ?? 0) << 8);
+    else if (op === 78)
+      pos += 5 + (((bytes[pos + 1] ?? 0) | (bytes[pos + 2] ?? 0) << 8 | (bytes[pos + 3] ?? 0) << 16 | (bytes[pos + 4] ?? 0) << 24) >>> 0);
+    else pos += 1;
+  }
+  return null;
+}
+function rebindOwner(scriptHex, toAddress, network) {
+  const newPkh = Address.fromString(toAddress).hashBuffer.toString("hex");
+  const re = /76a914[0-9a-f]{40}88ac/i;
+  const matches = scriptHex.match(new RegExp(re, "gi"));
+  if (!matches || matches.length !== 1) {
+    throw new ValidationError(
+      "rebindOwner: expected exactly one owner P2PKH in the token script"
+    );
+  }
+  return scriptHex.replace(re, `76a914${newPkh}88ac`);
+}
+async function commitReveal(base, payload, refType, buildRevealOutputScript, tokenOutputValue) {
+  const network = base.network ?? "mainnet";
+  const feeRate = base.feeRate ?? MIN_RELAY_FEE_RATE[network];
+  const { revealScriptSig, payloadHash } = encodeGlyph(payload);
+  const commit = commitScript(base.address, payloadHash, refType);
+  const envelopeBytes = BigInt(revealScriptSig.length / 2);
+  const revealReserve = tokenOutputValue + estimateRevealFee(feeRate, envelopeBytes);
+  const commitTarget = TOKEN_OUTPUT_VALUE + revealReserve;
+  const selection = selectRxdFunding(base.fundingUtxos, commitTarget, feeRate, {
+    baseOutputCount: 1,
+    // the commit carrier output
+    withChange: true
+  });
+  const commitInputs = selection.inputs.map((u) => ({
+    txid: u.txid,
+    vout: u.vout,
+    value: u.value,
+    script: u.script || void 0
+  }));
+  const commitTx = buildTx({
+    address: base.address,
+    wif: base.wif,
+    inputs: commitInputs,
+    outputs: [{ script: commit, value: TOKEN_OUTPUT_VALUE }],
+    addChange: true,
+    feeRate,
+    network
+  });
+  const changeIndex = commitTx.outputs.length - 1;
+  const change = commitTx.outputs[changeIndex];
+  if (change.value <= 0n) {
+    throw new ValidationError(
+      "commitReveal: commit produced no change to fund the reveal"
+    );
+  }
+  await base.client.broadcastTx(commitTx.hex);
+  const ref = packRef(commitTx.txid, 0);
+  const tokenScript = buildRevealOutputScript(ref);
+  const revealTx = buildTx({
+    address: base.address,
+    wif: base.wif,
+    inputs: [
+      // input 0: the commit carrier — its scriptSig carries the envelope.
+      { txid: commitTx.txid, vout: 0, value: TOKEN_OUTPUT_VALUE, script: commit },
+      // input 1: the commit change, funds the token output + fee.
+      {
+        txid: commitTx.txid,
+        vout: changeIndex,
+        value: change.value,
+        script: change.script
+      }
+    ],
+    outputs: [{ script: tokenScript, value: tokenOutputValue }],
+    addChange: true,
+    feeRate,
+    network,
+    setInputScript: (index, defaultScript) => {
+      if (index === 0) {
+        return defaultScript.toHex() + revealScriptSig;
+      }
+      return void 0;
+    }
+  });
+  await base.client.broadcastTx(revealTx.hex);
+  return {
+    ref,
+    refDisplay: `${commitTx.txid}:0`,
+    commitTxid: commitTx.txid,
+    revealTxid: revealTx.txid
+  };
+}
+function estimateRevealFee(feeRate, envelopeBytes = 0n) {
+  return (10n + 2n * 148n + 2n * 200n + envelopeBytes) * feeRate;
+}
+async function mintFT(params) {
+  if (!params.ticker) throw new ValidationError("mintFT: ticker is required");
+  if (params.supply <= 0n) throw new ValidationError("mintFT: supply must be > 0");
+  const payload = {
+    v: 2,
+    p: [GLYPH_PROTOCOL.FT],
+    ticker: params.ticker,
+    ...params.metadata
+  };
+  return commitReveal(
+    params,
+    payload,
+    1,
+    (ref) => ftScript(params.address, ref, params.network ?? "mainnet"),
+    params.supply
+  );
+}
+async function mintNFT(params) {
+  const p = params.mutable ? [GLYPH_PROTOCOL.NFT, GLYPH_PROTOCOL.MUTABLE] : [GLYPH_PROTOCOL.NFT];
+  const payload = { v: 2, p, ...params.metadata };
+  const value = params.outputValue ?? DUST_LIMIT;
+  return commitReveal(
+    params,
+    payload,
+    2,
+    (ref) => nftScript(params.address, ref, params.network ?? "mainnet"),
+    value
+  );
+}
+async function transferToken(params) {
+  const network = params.network ?? "mainnet";
+  const feeRate = params.feeRate ?? MIN_RELAY_FEE_RATE[network];
+  const { tokenUtxo } = params;
+  if (!tokenUtxo.script) {
+    throw new ValidationError(
+      "transferToken: tokenUtxo.script is required to rebuild the token output"
+    );
+  }
+  const newScript = rebindOwner(tokenUtxo.script, params.toAddress);
+  const ref = parseTokenRef(tokenUtxo.script);
+  const selection = selectRxdFunding(params.fundingUtxos, 0n, feeRate, {
+    baseOutputCount: 1,
+    // the token output
+    extraInputBytes: 148n,
+    // the token input we add below
+    withChange: true
+  });
+  const inputs = [
+    {
+      txid: tokenUtxo.txid,
+      vout: tokenUtxo.vout,
+      value: tokenUtxo.value,
+      script: tokenUtxo.script
+    },
+    ...selection.inputs.map((u) => ({
+      txid: u.txid,
+      vout: u.vout,
+      value: u.value,
+      script: u.script || void 0
+    }))
+  ];
+  const built = buildTx({
+    address: params.address,
+    wif: params.wif,
+    inputs,
+    outputs: [{ script: newScript, value: tokenUtxo.value }],
+    addChange: true,
+    feeRate,
+    network
+  });
+  await params.client.broadcastTx(built.hex);
+  return { txid: built.txid, hex: built.hex, ref };
+}
+
+// src/wave.ts
+function waveLabel(name) {
+  const trimmed = name.trim().toLowerCase();
+  if (!trimmed || trimmed.startsWith(".") || trimmed.endsWith(".")) {
+    throw new ValidationError(`waveLabel: invalid WAVE name ${JSON.stringify(name)}`);
+  }
+  const lastDot = trimmed.lastIndexOf(".");
+  const label = lastDot > 0 ? trimmed.slice(0, lastDot) : trimmed;
+  if (!label || label.length > 253) {
+    throw new ValidationError(`waveLabel: invalid WAVE name ${JSON.stringify(name)}`);
+  }
+  return label;
+}
+async function waveResolve(name, options = {}) {
+  const label = waveLabel(name);
+  const base = (options.restBase ?? DEFAULT_REST_BASE).replace(/\/+$/, "");
+  const doFetch = options.fetchImpl ?? globalThis.fetch;
+  if (typeof doFetch !== "function") {
+    throw new ValidationError(
+      "waveResolve: no fetch implementation available; pass options.fetchImpl"
+    );
+  }
+  const url = `${base}/wave/resolve/${encodeURIComponent(label)}`;
+  const res = await doFetch(url, { signal: options.signal });
+  if (!res.ok) {
+    throw new ValidationError(
+      `waveResolve: ${label} -> HTTP ${res.status} ${res.statusText}`
+    );
+  }
+  const data = await res.json();
+  const registered = data?.available !== true && data?.resolved !== false;
+  const zone = data?.zone ?? {};
+  return {
+    name: data?.name ?? label,
+    registered,
+    address: data?.target ?? zone?.address ?? void 0,
+    ref: data?.ref ?? void 0,
+    owner: data?.owner ?? void 0,
+    expires: zone?.expires ?? void 0,
+    records: zone?.records ?? void 0,
+    raw: data
+  };
+}
+async function waveResolveAddress(name, options = {}) {
+  const r = await waveResolve(name, options);
+  return r.registered ? r.address ?? null : null;
+}
+
+exports.DEFAULT_ELECTRUM_ENDPOINT = DEFAULT_ELECTRUM_ENDPOINT;
+exports.DEFAULT_REST_BASE = DEFAULT_REST_BASE;
+exports.DUST_LIMIT = DUST_LIMIT;
+exports.ElectrumClient = ElectrumClient;
+exports.ElectrumError = ElectrumError;
+exports.GLYPH_PROTOCOL = GLYPH_PROTOCOL;
+exports.HDWallet = HDWallet;
+exports.InsufficientFundsError = InsufficientFundsError;
+exports.Keys = Keys;
+exports.MIN_RELAY_FEE_RATE = MIN_RELAY_FEE_RATE;
+exports.PHOTONS_PER_RXD = PHOTONS_PER_RXD;
+exports.RADIANT_COIN_TYPE = RADIANT_COIN_TYPE;
+exports.RXD_DECIMALS = RXD_DECIMALS;
+exports.RadiantSdkError = RadiantSdkError;
+exports.TokenBurnGuardError = TokenBurnGuardError;
+exports.ValidationError = ValidationError;
+exports.addressToScriptHash = addressToScriptHash;
+exports.assertFundingSafe = assertFundingSafe;
+exports.buildRxdTransfer = buildRxdTransfer;
+exports.buildTx = buildTx;
+exports.encodeGlyph = encodeGlyph;
+exports.estimateFee = estimateFee;
+exports.filterFundingCandidates = filterFundingCandidates;
+exports.ftScript = ftScript;
+exports.isFundingSafe = isFundingSafe;
+exports.isTokenBearing = isTokenBearing;
+exports.mintFT = mintFT;
+exports.mintNFT = mintNFT;
+exports.nftScript = nftScript;
+exports.p2pkhScript = p2pkhScript;
+exports.packRef = packRef;
+exports.parseTokenRef = parseTokenRef;
+exports.photonsToRxd = photonsToRxd;
+exports.radiantjs = radiantjs;
+exports.rxdToPhotons = rxdToPhotons;
+exports.scriptHash = scriptHash;
+exports.selectRxdFunding = selectRxdFunding;
+exports.sumValue = sumValue;
+exports.transferToken = transferToken;
+exports.unpackRef = unpackRef;
+exports.waveLabel = waveLabel;
+exports.waveResolve = waveResolve;
+exports.waveResolveAddress = waveResolveAddress;
+exports.zeroRefs = zeroRefs;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map