@radiant-core/sdk 0.1.0 → 0.2.0

package/dist/index.d.cts

@@ -223,6 +223,40 @@ declare function unpackRef(ref: string): {
     txid: string;
     vout: number;
 };
+/** Owner address hash from a bare P2PKH script, if that's all it is. */
+declare function parseP2pkhScript(scriptHex: string): {
+    addressHash?: string;
+};
+/**
+ * Parse an NFT output script into its singleton ref + owner hash.
+ *
+ * Matches the plain singleton:
+ *   OP_PUSHINPUTREFSINGLETON <ref> OP_DROP <P2PKH>
+ *   d8 <ref:72> 75 76a914 <h160:40> 88ac
+ *
+ * ...and the AUTH form that a mutable NFT (a WAVE name) is forced into after a
+ * target update — the mutable covenant makes the token output re-commit the
+ * mutable ref plus its scriptSig hash:
+ *   ( OP_REQUIREINPUTREF <ref> <scriptSigHash> OP_2DROP )+ OP_STATESEPARATOR
+ *   OP_PUSHINPUTREFSINGLETON <ref> OP_DROP <P2PKH>
+ *
+ * The singleton ref and owner are always the TRAILING `d8…/p2pkh`, so the
+ * optional preamble is skipped without changing what's captured. Returns {} for
+ * anything that isn't an NFT script.
+ */
+declare function parseNftScript(scriptHex: string): {
+    ref?: string;
+    addressHash?: string;
+};
+/** Parse an FT output script into its ref + owner hash. Returns {} if not an FT. */
+declare function parseFtScript(scriptHex: string): {
+    ref?: string;
+    addressHash?: string;
+};
+/** What kind of token a script is, if any. */
+type TokenScriptKind = "nft" | "ft" | null;
+/** Classify a token output script by SHAPE (not by a loose ref scan). */
+declare function tokenScriptKind(scriptHex: string): TokenScriptKind;
 
 /**
  * ElectrumX WebSocket client.
@@ -631,15 +665,67 @@ interface TransferTokenParams {
     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.
+ * Transfer a Glyph token (FT or NFT, including a WAVE name) to a new owner.
+ *
+ * Moves the UTXO whole: the token output's value is preserved, which for an FT
+ * preserves the amount. To send PART of an FT balance (which needs multi-UTXO
+ * accumulation and a change output), that is a different operation and this is
+ * not it.
  */
 declare function transferToken(params: TransferTokenParams): Promise<{
     txid: string;
     hex: string;
     ref: string | null;
 }>;
+interface TransferFungibleParams {
+    client: ElectrumClient;
+    /** Current owner address (signs the token inputs, pays the fee, gets change). */
+    address: string;
+    /** Current owner WIF. */
+    wif: string;
+    /**
+     * FT UTXOs to draw from. They must ALL be the same token — see the ref check
+     * in {@link transferFungible}. Pass the owner's whole balance for that ref;
+     * only as many as needed are spent.
+     */
+    tokenUtxos: Utxo[];
+    /** Recipient address. */
+    toAddress: string;
+    /**
+     * Amount to send, in the token's base units. For a Glyph FT the amount IS the
+     * output's photon value — the covenant sums photons per code-script.
+     */
+    amount: bigint;
+    /** Token-free RXD funding UTXOs for `address` to cover the fee. */
+    fundingUtxos: Utxo[];
+    feeRate?: bigint;
+    network?: NetworkName;
+}
+/**
+ * Send PART of a fungible balance, accumulating across UTXOs and returning the
+ * remainder as FT change.
+ *
+ * This is what {@link transferToken} cannot do: that moves one UTXO whole, so
+ * "send 50 of my 500" is inexpressible on it.
+ *
+ * The token outputs conserve the accumulated sum EXACTLY. That is not tidiness —
+ * the FT covenant enforces `sum(inputs) >= sum(outputs)` for its code-script
+ * (`OP_CODESCRIPTHASHVALUESUM_UTXOS ... OP_GREATERTHANOREQUAL OP_VERIFY`), so it
+ * permits burning and only forbids minting. Emit less than you spent and the
+ * difference is destroyed, silently and permanently. Hence the change output
+ * whenever the accumulation overshoots.
+ *
+ * The RXD arithmetic falls out of that conservation: token value in equals token
+ * value out, so the only surplus is the RXD funding, and `buildTx`'s change is
+ * exactly `funding - fee`.
+ */
+declare function transferFungible(params: TransferFungibleParams): Promise<{
+    txid: string;
+    hex: string;
+    ref: string;
+    sent: bigint;
+    change: bigint;
+}>;
 
 /**
  * WAVE name resolution.
@@ -678,6 +764,92 @@ declare function waveResolve(name: string, options?: WaveResolveOptions): Promis
  */
 declare function waveResolveAddress(name: string, options?: WaveResolveOptions): Promise<string | null>;
 
+/**
+ * Token discovery — global, newest-first asset lists.
+ *
+ * Backed by the RXinDexer v4 discovery indexes (Glyph DB schema 4,
+ * deployed 2026-07-18):
+ *   GET {base}/glyphs/recent                      — newest across ALL types
+ *   GET {base}/glyphs/by-type/{typeId}?order=…    — one type, ref or recent order
+ *
+ * Pages are cursor-paginated: pass the previous response's `nextCursor` back
+ * to fetch the next page. Cursors are opaque, URL-safe strings, and are
+ * order-specific — never reuse a cursor across a change of `order` or type.
+ *
+ * The killer pattern this enables is an incremental watermark sync: do one
+ * full walk, remember the newest `deploy_height` you saw, then on later runs
+ * page newest-first and STOP as soon as `deploy_height` drops below your
+ * watermark — you only ever pay for tokens minted since the last run.
+ */
+/** GlyphTokenType ids as served by the indexer (`type` field). */
+declare const GLYPH_TOKEN_TYPE: {
+    readonly UNKNOWN: 0;
+    readonly FT: 1;
+    readonly NFT: 2;
+    readonly DAT: 3;
+    readonly DMINT: 4;
+    readonly WAVE: 5;
+    readonly CONTAINER: 6;
+    readonly AUTHORITY: 7;
+};
+type GlyphTokenTypeId = (typeof GLYPH_TOKEN_TYPE)[keyof typeof GLYPH_TOKEN_TYPE];
+/**
+ * One token row from a discovery list. Only the stable, always-present core is
+ * typed; the indexer returns many more fields (supply, dMint, icon, attrs, …)
+ * which remain reachable through the index signature.
+ */
+interface GlyphTokenSummary {
+    /** Display ref: big-endian txid + "_" + vout (canonical output form). */
+    ref: string;
+    /** 72-hex internal ref (raw index key bytes) — feed this to get_by_ref-style APIs. */
+    ref_hex: string;
+    /** Primary token type id (see GLYPH_TOKEN_TYPE). */
+    type: number;
+    type_name: string;
+    /** Glyph protocol ids the token carries (1=FT, 2=NFT, 8=ENCRYPTED, 11=WAVE, …). */
+    protocols: number[];
+    name: string | null;
+    ticker: string | null;
+    deploy_height: number;
+    deploy_txid: string;
+    is_spent: boolean;
+    [extra: string]: unknown;
+}
+/** One page of a discovery list. */
+interface TokenPage {
+    tokens: GlyphTokenSummary[];
+    /** Pass back as `cursor` to fetch the next page; null = no more pages. */
+    nextCursor: string | null;
+}
+/** Options shared by the discovery queries. */
+interface DiscoveryOptions {
+    /** Max rows per page (indexer caps at 500). Default 100. */
+    limit?: number;
+    /** Opaque cursor from the previous page's `nextCursor`. */
+    cursor?: string;
+    /** 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;
+}
+/**
+ * Newest-deployed tokens across every type (or one type via `typeId`),
+ * newest-first.
+ */
+declare function getRecentTokens(options?: DiscoveryOptions & {
+    typeId?: GlyphTokenTypeId | number;
+}): Promise<TokenPage>;
+/**
+ * Tokens of one type. `order: "recent"` = newest-deployed first;
+ * `order: "ref"` (default, matches the pre-v4 API) = stable ref-hash order.
+ * Cursors are order-specific.
+ */
+declare function getTokensByType(typeId: GlyphTokenTypeId | number, options?: DiscoveryOptions & {
+    order?: "ref" | "recent";
+}): Promise<TokenPage>;
+
 /**
  * Single, centralised access point to `@radiant-core/radiantjs`.
  *
@@ -690,4 +862,4 @@ declare function waveResolveAddress(name: string, options?: WaveResolveOptions):
 /** 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 };
+export { type BuildTxInput, type BuildTxParams, type BuiltTx, DEFAULT_ELECTRUM_ENDPOINT, DEFAULT_REST_BASE, DUST_LIMIT, type DerivedKey, type DiscoveryOptions, ElectrumClient, type ElectrumClientOptions, ElectrumError, type FundingSelection, GLYPH_PROTOCOL, GLYPH_TOKEN_TYPE, type GlyphPayload, type GlyphTokenSummary, type GlyphTokenTypeId, 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 TokenPage, type TokenScriptKind, type TransferFungibleParams, type TransferTokenParams, type TxOutput, type Utxo, type UtxoRef, ValidationError, type WaveResolution, type WaveResolveOptions, addressToScriptHash, assertFundingSafe, buildRxdTransfer, buildTx, encodeGlyph, estimateFee, filterFundingCandidates, ftScript, getRecentTokens, getTokensByType, isFundingSafe, isTokenBearing, mintFT, mintNFT, nftScript, p2pkhScript, packRef, parseFtScript, parseNftScript, parseP2pkhScript, parseTokenRef, photonsToRxd, radiantjs, rxdToPhotons, scriptHash, selectRxdFunding, sumValue, tokenScriptKind, transferFungible, transferToken, unpackRef, waveLabel, waveResolve, waveResolveAddress, zeroRefs };

package/dist/index.d.ts

@@ -223,6 +223,40 @@ declare function unpackRef(ref: string): {
     txid: string;
     vout: number;
 };
+/** Owner address hash from a bare P2PKH script, if that's all it is. */
+declare function parseP2pkhScript(scriptHex: string): {
+    addressHash?: string;
+};
+/**
+ * Parse an NFT output script into its singleton ref + owner hash.
+ *
+ * Matches the plain singleton:
+ *   OP_PUSHINPUTREFSINGLETON <ref> OP_DROP <P2PKH>
+ *   d8 <ref:72> 75 76a914 <h160:40> 88ac
+ *
+ * ...and the AUTH form that a mutable NFT (a WAVE name) is forced into after a
+ * target update — the mutable covenant makes the token output re-commit the
+ * mutable ref plus its scriptSig hash:
+ *   ( OP_REQUIREINPUTREF <ref> <scriptSigHash> OP_2DROP )+ OP_STATESEPARATOR
+ *   OP_PUSHINPUTREFSINGLETON <ref> OP_DROP <P2PKH>
+ *
+ * The singleton ref and owner are always the TRAILING `d8…/p2pkh`, so the
+ * optional preamble is skipped without changing what's captured. Returns {} for
+ * anything that isn't an NFT script.
+ */
+declare function parseNftScript(scriptHex: string): {
+    ref?: string;
+    addressHash?: string;
+};
+/** Parse an FT output script into its ref + owner hash. Returns {} if not an FT. */
+declare function parseFtScript(scriptHex: string): {
+    ref?: string;
+    addressHash?: string;
+};
+/** What kind of token a script is, if any. */
+type TokenScriptKind = "nft" | "ft" | null;
+/** Classify a token output script by SHAPE (not by a loose ref scan). */
+declare function tokenScriptKind(scriptHex: string): TokenScriptKind;
 
 /**
  * ElectrumX WebSocket client.
@@ -631,15 +665,67 @@ interface TransferTokenParams {
     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.
+ * Transfer a Glyph token (FT or NFT, including a WAVE name) to a new owner.
+ *
+ * Moves the UTXO whole: the token output's value is preserved, which for an FT
+ * preserves the amount. To send PART of an FT balance (which needs multi-UTXO
+ * accumulation and a change output), that is a different operation and this is
+ * not it.
  */
 declare function transferToken(params: TransferTokenParams): Promise<{
     txid: string;
     hex: string;
     ref: string | null;
 }>;
+interface TransferFungibleParams {
+    client: ElectrumClient;
+    /** Current owner address (signs the token inputs, pays the fee, gets change). */
+    address: string;
+    /** Current owner WIF. */
+    wif: string;
+    /**
+     * FT UTXOs to draw from. They must ALL be the same token — see the ref check
+     * in {@link transferFungible}. Pass the owner's whole balance for that ref;
+     * only as many as needed are spent.
+     */
+    tokenUtxos: Utxo[];
+    /** Recipient address. */
+    toAddress: string;
+    /**
+     * Amount to send, in the token's base units. For a Glyph FT the amount IS the
+     * output's photon value — the covenant sums photons per code-script.
+     */
+    amount: bigint;
+    /** Token-free RXD funding UTXOs for `address` to cover the fee. */
+    fundingUtxos: Utxo[];
+    feeRate?: bigint;
+    network?: NetworkName;
+}
+/**
+ * Send PART of a fungible balance, accumulating across UTXOs and returning the
+ * remainder as FT change.
+ *
+ * This is what {@link transferToken} cannot do: that moves one UTXO whole, so
+ * "send 50 of my 500" is inexpressible on it.
+ *
+ * The token outputs conserve the accumulated sum EXACTLY. That is not tidiness —
+ * the FT covenant enforces `sum(inputs) >= sum(outputs)` for its code-script
+ * (`OP_CODESCRIPTHASHVALUESUM_UTXOS ... OP_GREATERTHANOREQUAL OP_VERIFY`), so it
+ * permits burning and only forbids minting. Emit less than you spent and the
+ * difference is destroyed, silently and permanently. Hence the change output
+ * whenever the accumulation overshoots.
+ *
+ * The RXD arithmetic falls out of that conservation: token value in equals token
+ * value out, so the only surplus is the RXD funding, and `buildTx`'s change is
+ * exactly `funding - fee`.
+ */
+declare function transferFungible(params: TransferFungibleParams): Promise<{
+    txid: string;
+    hex: string;
+    ref: string;
+    sent: bigint;
+    change: bigint;
+}>;
 
 /**
  * WAVE name resolution.
@@ -678,6 +764,92 @@ declare function waveResolve(name: string, options?: WaveResolveOptions): Promis
  */
 declare function waveResolveAddress(name: string, options?: WaveResolveOptions): Promise<string | null>;
 
+/**
+ * Token discovery — global, newest-first asset lists.
+ *
+ * Backed by the RXinDexer v4 discovery indexes (Glyph DB schema 4,
+ * deployed 2026-07-18):
+ *   GET {base}/glyphs/recent                      — newest across ALL types
+ *   GET {base}/glyphs/by-type/{typeId}?order=…    — one type, ref or recent order
+ *
+ * Pages are cursor-paginated: pass the previous response's `nextCursor` back
+ * to fetch the next page. Cursors are opaque, URL-safe strings, and are
+ * order-specific — never reuse a cursor across a change of `order` or type.
+ *
+ * The killer pattern this enables is an incremental watermark sync: do one
+ * full walk, remember the newest `deploy_height` you saw, then on later runs
+ * page newest-first and STOP as soon as `deploy_height` drops below your
+ * watermark — you only ever pay for tokens minted since the last run.
+ */
+/** GlyphTokenType ids as served by the indexer (`type` field). */
+declare const GLYPH_TOKEN_TYPE: {
+    readonly UNKNOWN: 0;
+    readonly FT: 1;
+    readonly NFT: 2;
+    readonly DAT: 3;
+    readonly DMINT: 4;
+    readonly WAVE: 5;
+    readonly CONTAINER: 6;
+    readonly AUTHORITY: 7;
+};
+type GlyphTokenTypeId = (typeof GLYPH_TOKEN_TYPE)[keyof typeof GLYPH_TOKEN_TYPE];
+/**
+ * One token row from a discovery list. Only the stable, always-present core is
+ * typed; the indexer returns many more fields (supply, dMint, icon, attrs, …)
+ * which remain reachable through the index signature.
+ */
+interface GlyphTokenSummary {
+    /** Display ref: big-endian txid + "_" + vout (canonical output form). */
+    ref: string;
+    /** 72-hex internal ref (raw index key bytes) — feed this to get_by_ref-style APIs. */
+    ref_hex: string;
+    /** Primary token type id (see GLYPH_TOKEN_TYPE). */
+    type: number;
+    type_name: string;
+    /** Glyph protocol ids the token carries (1=FT, 2=NFT, 8=ENCRYPTED, 11=WAVE, …). */
+    protocols: number[];
+    name: string | null;
+    ticker: string | null;
+    deploy_height: number;
+    deploy_txid: string;
+    is_spent: boolean;
+    [extra: string]: unknown;
+}
+/** One page of a discovery list. */
+interface TokenPage {
+    tokens: GlyphTokenSummary[];
+    /** Pass back as `cursor` to fetch the next page; null = no more pages. */
+    nextCursor: string | null;
+}
+/** Options shared by the discovery queries. */
+interface DiscoveryOptions {
+    /** Max rows per page (indexer caps at 500). Default 100. */
+    limit?: number;
+    /** Opaque cursor from the previous page's `nextCursor`. */
+    cursor?: string;
+    /** 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;
+}
+/**
+ * Newest-deployed tokens across every type (or one type via `typeId`),
+ * newest-first.
+ */
+declare function getRecentTokens(options?: DiscoveryOptions & {
+    typeId?: GlyphTokenTypeId | number;
+}): Promise<TokenPage>;
+/**
+ * Tokens of one type. `order: "recent"` = newest-deployed first;
+ * `order: "ref"` (default, matches the pre-v4 API) = stable ref-hash order.
+ * Cursors are order-specific.
+ */
+declare function getTokensByType(typeId: GlyphTokenTypeId | number, options?: DiscoveryOptions & {
+    order?: "ref" | "recent";
+}): Promise<TokenPage>;
+
 /**
  * Single, centralised access point to `@radiant-core/radiantjs`.
  *
@@ -690,4 +862,4 @@ declare function waveResolveAddress(name: string, options?: WaveResolveOptions):
 /** 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 };
+export { type BuildTxInput, type BuildTxParams, type BuiltTx, DEFAULT_ELECTRUM_ENDPOINT, DEFAULT_REST_BASE, DUST_LIMIT, type DerivedKey, type DiscoveryOptions, ElectrumClient, type ElectrumClientOptions, ElectrumError, type FundingSelection, GLYPH_PROTOCOL, GLYPH_TOKEN_TYPE, type GlyphPayload, type GlyphTokenSummary, type GlyphTokenTypeId, 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 TokenPage, type TokenScriptKind, type TransferFungibleParams, type TransferTokenParams, type TxOutput, type Utxo, type UtxoRef, ValidationError, type WaveResolution, type WaveResolveOptions, addressToScriptHash, assertFundingSafe, buildRxdTransfer, buildTx, encodeGlyph, estimateFee, filterFundingCandidates, ftScript, getRecentTokens, getTokensByType, isFundingSafe, isTokenBearing, mintFT, mintNFT, nftScript, p2pkhScript, packRef, parseFtScript, parseNftScript, parseP2pkhScript, parseTokenRef, photonsToRxd, radiantjs, rxdToPhotons, scriptHash, selectRxdFunding, sumValue, tokenScriptKind, transferFungible, transferToken, unpackRef, waveLabel, waveResolve, waveResolveAddress, zeroRefs };

package/dist/index.js

@@ -43,6 +43,11 @@ var MIN_RELAY_FEE_RATE = {
   testnet: 1000n,
   regtest: 1000n
 };
+var MAX_REASONABLE_FEE_RATE = {
+  mainnet: MIN_RELAY_FEE_RATE.mainnet * 2n,
+  testnet: MIN_RELAY_FEE_RATE.testnet * 2n,
+  regtest: MIN_RELAY_FEE_RATE.regtest * 2n
+};
 var DUST_LIMIT = 1000n;
 var TOKEN_OUTPUT_VALUE = 1n;
 var DEFAULT_ELECTRUM_ENDPOINT = {
@@ -241,6 +246,25 @@ function unpackRef(ref) {
   const vout = buf.readUInt32LE(32);
   return { txid, vout };
 }
+function parseP2pkhScript(scriptHex) {
+  const [, addressHash] = scriptHex.toLowerCase().match(/^76a914([0-9a-f]{40})88ac$/) || [];
+  return { addressHash };
+}
+function parseNftScript(scriptHex) {
+  const pattern = /^(?:d1[0-9a-f]{72}20[0-9a-f]{64}6d)*(?:bd)?d8([0-9a-f]{72})7576a914([0-9a-f]{40})88ac$/;
+  const [, ref, addressHash] = scriptHex.toLowerCase().match(pattern) || [];
+  return { ref, addressHash };
+}
+function parseFtScript(scriptHex) {
+  const pattern = /^76a914([0-9a-f]{40})88acbdd0([0-9a-f]{72})dec0e9aa76e378e4a269e69d$/;
+  const [, addressHash, ref] = scriptHex.toLowerCase().match(pattern) || [];
+  return { ref, addressHash };
+}
+function tokenScriptKind(scriptHex) {
+  if (parseNftScript(scriptHex).ref) return "nft";
+  if (parseFtScript(scriptHex).ref) return "ft";
+  return null;
+}
 
 // src/client.ts
 var WS_OPEN = 1;
@@ -646,6 +670,17 @@ function sumValue(utxos) {
 }
 
 // src/tx.ts
+function assertSaneFee(tx, network) {
+  const sizeBytes = BigInt(tx.toString().length / 2);
+  const reference = MAX_REASONABLE_FEE_RATE[network];
+  const ceiling = sizeBytes * reference * 12n / 10n;
+  const actual = BigInt(tx.getFee?.() ?? 0);
+  if (actual > ceiling) {
+    throw new ValidationError(
+      `buildTx: fee ${actual} photons is above the sanity ceiling ${ceiling} for a ${sizeBytes}-byte tx (${network} reference ${reference} photons/byte). Refusing to build \u2014 this is almost always a units mistake or an over-funded change-less tx, and the excess would be paid to miners irrecoverably.`
+    );
+  }
+}
 function bn(value) {
   return new crypto.BN(value.toString());
 }
@@ -720,6 +755,7 @@ function buildTx(params) {
   }
   tx.sign(privKeys[0]);
   if (typeof tx.seal === "function") tx.seal();
+  assertSaneFee(tx, network);
   const hex = tx.toString();
   const resolvedOutputs = tx.outputs.map((o) => ({
     script: o.script.toHex(),
@@ -803,16 +839,14 @@ function parseTokenRef(scriptHex) {
   }
   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`);
+function tokenTransferScript(scriptHex, toAddress, network) {
+  const nft = parseNftScript(scriptHex);
+  if (nft.ref) return nftScript(toAddress, nft.ref, network);
+  const ft = parseFtScript(scriptHex);
+  if (ft.ref) return ftScript(toAddress, ft.ref, network);
+  throw new ValidationError(
+    "transferToken: tokenUtxo.script is not a recognised NFT or FT output script"
+  );
 }
 async function commitReveal(base, payload, refType, buildRevealOutputScript, tokenOutputValue) {
   const network = base.network ?? "mainnet";
@@ -926,8 +960,8 @@ async function transferToken(params) {
       "transferToken: tokenUtxo.script is required to rebuild the token output"
     );
   }
-  const newScript = rebindOwner(tokenUtxo.script, params.toAddress);
-  const ref = parseTokenRef(tokenUtxo.script);
+  const newScript = tokenTransferScript(tokenUtxo.script, params.toAddress, network);
+  const ref = parseNftScript(tokenUtxo.script).ref ?? parseFtScript(tokenUtxo.script).ref ?? null;
   const selection = selectRxdFunding(params.fundingUtxos, 0n, feeRate, {
     baseOutputCount: 1,
     // the token output
@@ -961,6 +995,76 @@ async function transferToken(params) {
   await params.client.broadcastTx(built.hex);
   return { txid: built.txid, hex: built.hex, ref };
 }
+async function transferFungible(params) {
+  const network = params.network ?? "mainnet";
+  const feeRate = params.feeRate ?? MIN_RELAY_FEE_RATE[network];
+  const { amount, tokenUtxos } = params;
+  if (amount <= 0n) {
+    throw new ValidationError("transferFungible: amount must be positive");
+  }
+  if (!tokenUtxos.length) {
+    throw new ValidationError("transferFungible: no token UTXOs given");
+  }
+  let ref;
+  for (const u of tokenUtxos) {
+    const parsed = u.script ? parseFtScript(u.script) : {};
+    if (!parsed.ref) {
+      throw new ValidationError(
+        `transferFungible: ${u.txid}:${u.vout} is not an FT output (its script must be the on-chain ftScript)`
+      );
+    }
+    if (ref && parsed.ref !== ref) {
+      throw new ValidationError(
+        "transferFungible: token UTXOs are for different tokens \u2014 refusing to mix refs, it would burn one of them"
+      );
+    }
+    ref = parsed.ref;
+  }
+  const sorted = [...tokenUtxos].sort((a, b) => a.value < b.value ? 1 : a.value > b.value ? -1 : 0);
+  const spend = [];
+  let sum = 0n;
+  for (const u of sorted) {
+    spend.push(u);
+    sum += u.value;
+    if (sum >= amount) break;
+  }
+  if (sum < amount) {
+    throw new ValidationError(
+      `transferFungible: insufficient token balance \u2014 have ${sum}, need ${amount}`
+    );
+  }
+  const change = sum - amount;
+  const outputs = [{ script: ftScript(params.toAddress, ref, network), value: amount }];
+  if (change > 0n) {
+    outputs.push({ script: ftScript(params.address, ref, network), value: change });
+  }
+  const selection = selectRxdFunding(params.fundingUtxos, 0n, feeRate, {
+    baseOutputCount: outputs.length,
+    extraInputBytes: BigInt(148 * spend.length),
+    // the token inputs we add below
+    withChange: true
+  });
+  const inputs = [
+    ...spend.map((u) => ({ txid: u.txid, vout: u.vout, value: u.value, script: u.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,
+    addChange: true,
+    feeRate,
+    network
+  });
+  await params.client.broadcastTx(built.hex);
+  return { txid: built.txid, hex: built.hex, ref, sent: amount, change };
+}
 
 // src/wave.ts
 function waveLabel(name) {
@@ -1010,6 +1114,61 @@ async function waveResolveAddress(name, options = {}) {
   return r.registered ? r.address ?? null : null;
 }
 
-export { DEFAULT_ELECTRUM_ENDPOINT, DEFAULT_REST_BASE, DUST_LIMIT, ElectrumClient, ElectrumError, GLYPH_PROTOCOL, HDWallet, InsufficientFundsError, Keys, MIN_RELAY_FEE_RATE, PHOTONS_PER_RXD, RADIANT_COIN_TYPE, RXD_DECIMALS, RadiantSdkError, TokenBurnGuardError, ValidationError, 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 };
+// src/discovery.ts
+var GLYPH_TOKEN_TYPE = {
+  UNKNOWN: 0,
+  FT: 1,
+  NFT: 2,
+  DAT: 3,
+  DMINT: 4,
+  WAVE: 5,
+  CONTAINER: 6,
+  AUTHORITY: 7
+};
+async function fetchTokenPage(path, params, options, fnName) {
+  const base = (options.restBase ?? DEFAULT_REST_BASE).replace(/\/+$/, "");
+  const doFetch = options.fetchImpl ?? globalThis.fetch;
+  if (typeof doFetch !== "function") {
+    throw new ValidationError(
+      `${fnName}: no fetch implementation available; pass options.fetchImpl`
+    );
+  }
+  const query = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0) query.set(k, String(v));
+  }
+  const qs = query.toString();
+  const url = `${base}${path}${qs ? `?${qs}` : ""}`;
+  const res = await doFetch(url, { signal: options.signal });
+  if (!res.ok) {
+    throw new ValidationError(`${fnName}: HTTP ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  return {
+    tokens: Array.isArray(data?.tokens) ? data.tokens : [],
+    nextCursor: data?.next_cursor ?? null
+  };
+}
+async function getRecentTokens(options = {}) {
+  return fetchTokenPage(
+    "/glyphs/recent",
+    { limit: options.limit, cursor: options.cursor, type_id: options.typeId },
+    options,
+    "getRecentTokens"
+  );
+}
+async function getTokensByType(typeId, options = {}) {
+  if (!Number.isInteger(typeId) || typeId < 0 || typeId > 7) {
+    throw new ValidationError(`getTokensByType: invalid typeId ${typeId}`);
+  }
+  return fetchTokenPage(
+    `/glyphs/by-type/${typeId}`,
+    { limit: options.limit, cursor: options.cursor, order: options.order },
+    options,
+    "getTokensByType"
+  );
+}
+
+export { DEFAULT_ELECTRUM_ENDPOINT, DEFAULT_REST_BASE, DUST_LIMIT, ElectrumClient, ElectrumError, GLYPH_PROTOCOL, GLYPH_TOKEN_TYPE, HDWallet, InsufficientFundsError, Keys, MIN_RELAY_FEE_RATE, PHOTONS_PER_RXD, RADIANT_COIN_TYPE, RXD_DECIMALS, RadiantSdkError, TokenBurnGuardError, ValidationError, addressToScriptHash, assertFundingSafe, buildRxdTransfer, buildTx, encodeGlyph, estimateFee, filterFundingCandidates, ftScript, getRecentTokens, getTokensByType, isFundingSafe, isTokenBearing, mintFT, mintNFT, nftScript, p2pkhScript, packRef, parseFtScript, parseNftScript, parseP2pkhScript, parseTokenRef, photonsToRxd, radiantjs, rxdToPhotons, scriptHash, selectRxdFunding, sumValue, tokenScriptKind, transferFungible, transferToken, unpackRef, waveLabel, waveResolve, waveResolveAddress, zeroRefs };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map