@x1id/resolve 0.21.0 → 0.23.0

package/dist/mintNft.js

@@ -0,0 +1,328 @@
+/**
+ * Tokenized registration — the capability-pNFT instructions of the registry
+ * program: `mint_handle_nft` (tokenize an already-registered handle),
+ * `mint_handle_nft_with_uri` (same, caller-pinned metadata URI),
+ * `register_tokenized` (register + mint in ONE instruction — the default
+ * permanent-XNT purchase) and `register_revealed_tokenized` (its
+ * commit-reveal sibling).
+ *
+ * The minted NFT is a Metaplex ProgrammableNonFungible (pNFT) VERIFIED into
+ * the "X1ID Handles" collection, with treasury royalties. Its token account
+ * is FROZEN by Token Metadata; move it with `buildTransferV1Ix`
+ * (pnftTransfer.ts), never a plain SPL transfer.
+ *
+ * One backend call for a tokenized purchase (payer = owner = the user):
+ *
+ * ```ts
+ * import { PublicKey } from "@solana/web3.js";
+ * import {
+ *   deriveTokenizedNftAccounts, buildRegisterTokenizedIx, fetchConfigTreasury,
+ *   REGISTER_TOKENIZED_CU_LIMIT, HandleType,
+ * } from "@x1id/resolve";
+ *
+ * const find = (seeds, pid) => PublicKey.findProgramAddressSync(seeds, new PublicKey(pid))[0].toBase58();
+ * const te = new TextEncoder();
+ * const handle = find([te.encode("handle"), te.encode(canonical)], programId);
+ * const accounts = await deriveTokenizedNftAccounts(find, { programId, owner: user, handle });
+ * const treasury = await fetchConfigTreasury(rpc, accounts.config);
+ * const ix = buildRegisterTokenizedIx({
+ *   ...accounts, programId, payer: user, owner: user, handle, treasury,
+ *   name: canonical, handleType: HandleType.Human,
+ * });
+ * // prepend ComputeBudget SetComputeUnitLimit(REGISTER_TOKENIZED_CU_LIMIT)
+ * ```
+ *
+ * # Account order (source of truth: programs/x1-handles/src/lib.rs)
+ *
+ * - `MintHandleNft<'info>`: payer(s,w) owner(s) config(w) treasury(w)
+ *   handle(w) auction listing mint(w) owner_token_account(w) metadata(w)
+ *   master_edition(w) token_record(w) collection_mint collection_metadata(w)
+ *   collection_master_edition collection_authority token_metadata_program
+ *   token_program associated_token_program system_program
+ *   sysvar_instructions.
+ * - `RegisterTokenized<'info>`: payer(s,w) owner config(w) treasury(w)
+ *   handle(w), then the SAME `mint` … `sysvar_instructions` tail (no
+ *   auction/listing — a just-created handle can have neither), then the
+ *   optional integrator(w) / integrator_allowlist pair.
+ * - `RegisterRevealedTokenized<'info>`: as `RegisterTokenized` plus
+ *   commitment(w) right after handle.
+ *
+ * Note `owner` SIGNS `mint_handle_nft` (it tokenizes its own handle) but does
+ * NOT sign the register variants (gifting parity with `register`).
+ *
+ * # Compute budget
+ *
+ * The pNFT path (CreateV1 + MintV1 + VerifyCollectionV1 in one program
+ * instruction) exceeds the 200k-CU per-instruction default: every
+ * transaction carrying one of these instructions MUST also carry a
+ * ComputeBudget `SetComputeUnitLimit` — {@link MINT_HANDLE_NFT_CU_LIMIT} or
+ * {@link REGISTER_TOKENIZED_CU_LIMIT}. X1 prices the fee by the REQUESTED
+ * limit, so these are sized close to measured mainnet consumption.
+ *
+ * Hand-rolled like the rest of this package: no Anchor client, no
+ * `@solana/web3.js` import, no `@types/node`. Builders are pure (no RPC);
+ * PDAs are derived through an INJECTED `find_program_address`
+ * ({@link PdaFinder}) because this package never hand-rolls the ed25519
+ * on-curve check.
+ */
+import { encodeBase58, decodeBase58_32 } from "./base58.js";
+import { normalizeHandle } from "./parse.js";
+import { MPL_TOKEN_METADATA_PROGRAM } from "./pnftTransfer.js";
+/** `sha256("global:mint_handle_nft")[0..8]`. */
+export const MINT_HANDLE_NFT_DISCRIMINATOR = Uint8Array.from([
+    237, 69, 220, 121, 210, 168, 2, 193,
+]);
+/** `sha256("global:mint_handle_nft_with_uri")[0..8]`. */
+export const MINT_HANDLE_NFT_WITH_URI_DISCRIMINATOR = Uint8Array.from([
+    19, 122, 117, 92, 55, 158, 255, 208,
+]);
+/** `sha256("global:register_tokenized")[0..8]`. */
+export const REGISTER_TOKENIZED_DISCRIMINATOR = Uint8Array.from([
+    226, 155, 236, 28, 221, 160, 186, 73,
+]);
+/** `sha256("global:register_revealed_tokenized")[0..8]`. */
+export const REGISTER_REVEALED_TOKENIZED_DISCRIMINATOR = Uint8Array.from([
+    46, 36, 18, 80, 132, 100, 252, 126,
+]);
+/** Compute-unit limit for any transaction carrying `mint_handle_nft` /
+ *  `mint_handle_nft_with_uri` (measured ~318k CU on mainnet; ~41% headroom). */
+export const MINT_HANDLE_NFT_CU_LIMIT = 450_000;
+/** Compute-unit limit for any transaction carrying `register_tokenized` /
+ *  `register_revealed_tokenized` (measured 299k–347k CU live; ≥17% headroom). */
+export const REGISTER_TOKENIZED_CU_LIMIT = 420_000;
+/** `mpl_token_metadata::MAX_URI_LENGTH` — `mint_handle_nft_with_uri` refuses
+ *  (`UriTooLong`) a longer URI; checked client-side too. */
+export const MAX_NFT_METADATA_URI_LENGTH = 200;
+/** Seed prefix of a handle's NFT mint PDA: `["nft_mint", handle]`. */
+export const NFT_MINT_SEED = "nft_mint";
+/** Seed of the collection parent's mint PDA: `["collection_mint"]`. */
+export const COLLECTION_MINT_SEED = "collection_mint";
+/** Seed of the collection update-authority PDA: `["collection_authority"]`. */
+export const COLLECTION_AUTHORITY_SEED = "collection_authority";
+const SYSTEM_PROGRAM = "11111111111111111111111111111111";
+const SYSVAR_INSTRUCTIONS = "Sysvar1nstructions1111111111111111111111111";
+const SPL_TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+const SPL_ATA_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+const TE = new TextEncoder();
+function toBytes32(v, what) {
+    if (typeof v === "string") {
+        const b = decodeBase58_32(v);
+        if (!b)
+            throw new Error(`${what} is not a valid base58 address`);
+        return b;
+    }
+    if (v.length !== 32)
+        throw new Error(`${what} must be exactly 32 bytes`);
+    return v;
+}
+function toBase58(v, what) {
+    return encodeBase58(toBytes32(v, what));
+}
+function checkHandleType(t) {
+    if (!Number.isInteger(t) || t < 0 || t > 3) {
+        throw new Error("handleType must be 0 (Human), 1 (Merchant), 2 (Org) or 3 (Agent)");
+    }
+}
+/** disc ‖ borsh String ‖ extra */
+function encodeNameIx(disc, name, tail) {
+    const nameBytes = TE.encode(name);
+    if (nameBytes.length < 1 || nameBytes.length > 32) {
+        throw new Error("name must be 1..=32 bytes (UTF-8)");
+    }
+    const data = new Uint8Array(8 + 4 + nameBytes.length + tail.length);
+    data.set(disc, 0);
+    new DataView(data.buffer).setUint32(8, nameBytes.length, true);
+    data.set(nameBytes, 12);
+    data.set(tail, 12 + nameBytes.length);
+    return data;
+}
+function integratorKeys(p) {
+    const has = p.integrator !== undefined || p.integratorAllowlist !== undefined;
+    if (!has)
+        return [];
+    if (p.integrator === undefined || p.integratorAllowlist === undefined) {
+        throw new Error("integrator and integratorAllowlist must both be supplied, or neither");
+    }
+    return [
+        { pubkey: toBase58(p.integrator, "integrator"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.integratorAllowlist, "integratorAllowlist"), isSigner: false, isWritable: false },
+    ];
+}
+/**
+ * Derive every PDA/ATA a tokenized REGISTER (`register_tokenized` /
+ * `register_revealed_tokenized`) needs beyond payer/owner/handle/treasury.
+ * Pure: nothing is fetched. `Config.treasury` is NOT derivable — read it with
+ * `fetchConfigTreasury` (register.ts).
+ */
+export async function deriveTokenizedNftAccounts(find, p) {
+    const programId = toBase58(p.programId, "programId");
+    const owner = toBytes32(p.owner, "owner");
+    const handle = toBytes32(p.handle, "handle");
+    const mpl = toBytes32(MPL_TOKEN_METADATA_PROGRAM, "tokenMetadataProgram");
+    const tokenProgram = toBytes32(SPL_TOKEN_PROGRAM_ID, "tokenProgram");
+    const metadataOf = (m) => find([TE.encode("metadata"), mpl, m], MPL_TOKEN_METADATA_PROGRAM);
+    const editionOf = (m) => find([TE.encode("metadata"), mpl, m, TE.encode("edition")], MPL_TOKEN_METADATA_PROGRAM);
+    const [config, mint, collectionMint, collectionAuthority] = await Promise.all([
+        find([TE.encode("config")], programId),
+        find([TE.encode(NFT_MINT_SEED), handle], programId),
+        find([TE.encode(COLLECTION_MINT_SEED)], programId),
+        find([TE.encode(COLLECTION_AUTHORITY_SEED)], programId),
+    ]);
+    const mintB = toBytes32(mint, "mint");
+    const collB = toBytes32(collectionMint, "collectionMint");
+    const [ownerTokenAccount, metadata, masterEdition, collectionMetadata, collectionMasterEdition] = await Promise.all([
+        find([owner, tokenProgram, mintB], SPL_ATA_PROGRAM_ID),
+        metadataOf(mintB),
+        editionOf(mintB),
+        metadataOf(collB),
+        editionOf(collB),
+    ]);
+    const tokenRecord = await find([TE.encode("metadata"), mpl, mintB, TE.encode("token_record"), toBytes32(ownerTokenAccount, "ownerTokenAccount")], MPL_TOKEN_METADATA_PROGRAM);
+    return {
+        config,
+        mint,
+        ownerTokenAccount,
+        metadata,
+        masterEdition,
+        tokenRecord,
+        collectionMint,
+        collectionMetadata,
+        collectionMasterEdition,
+        collectionAuthority,
+    };
+}
+/**
+ * Derive every PDA/ATA `mint_handle_nft` needs beyond payer/owner/handle/
+ * treasury: {@link deriveTokenizedNftAccounts} plus `["auction", handle]` and
+ * `["listing", handle]`. Pure: nothing is fetched.
+ */
+export async function deriveMintHandleNftAccounts(find, p) {
+    const programId = toBase58(p.programId, "programId");
+    const handle = toBytes32(p.handle, "handle");
+    const [base, auction, listing] = await Promise.all([
+        deriveTokenizedNftAccounts(find, p),
+        find([TE.encode("auction"), handle], programId),
+        find([TE.encode("listing"), handle], programId),
+    ]);
+    return { ...base, auction, listing };
+}
+/**
+ * The 14-account pNFT tail shared by every tokenized instruction, from
+ * `mint` through `sysvar_instructions` (order + signer/writable flags exactly
+ * as `MintHandleNft` / `RegisterTokenized` declare them in lib.rs). Exposed
+ * for instructions that append the same tail to their own preamble.
+ */
+export function buildTokenizedTailKeys(a) {
+    return [
+        { pubkey: toBase58(a.mint, "mint"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(a.ownerTokenAccount, "ownerTokenAccount"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(a.metadata, "metadata"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(a.masterEdition, "masterEdition"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(a.tokenRecord, "tokenRecord"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(a.collectionMint, "collectionMint"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(a.collectionMetadata, "collectionMetadata"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(a.collectionMasterEdition, "collectionMasterEdition"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(a.collectionAuthority, "collectionAuthority"), isSigner: false, isWritable: false },
+        { pubkey: MPL_TOKEN_METADATA_PROGRAM, isSigner: false, isWritable: false },
+        { pubkey: SPL_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: SPL_ATA_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: SYSTEM_PROGRAM, isSigner: false, isWritable: false },
+        { pubkey: SYSVAR_INSTRUCTIONS, isSigner: false, isWritable: false },
+    ];
+}
+function mintHandleNftKeys(p) {
+    return [
+        { pubkey: toBase58(p.payer, "payer"), isSigner: true, isWritable: true },
+        { pubkey: toBase58(p.owner, "owner"), isSigner: true, isWritable: false },
+        { pubkey: toBase58(p.config, "config"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.treasury, "treasury"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.handle, "handle"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.auction, "auction"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.listing, "listing"), isSigner: false, isWritable: false },
+        ...buildTokenizedTailKeys(p),
+    ];
+}
+/**
+ * Build `mint_handle_nft` — tokenize an ALREADY-REGISTERED, untokenized
+ * handle as its capability pNFT. Signers: `payer` AND `owner` (two signature
+ * slots unless they are the same key). Account order: `MintHandleNft<'info>`
+ * (see module docs). Data is the 8-byte discriminator only. Prepend
+ * `SetComputeUnitLimit(MINT_HANDLE_NFT_CU_LIMIT)`.
+ */
+export function buildMintHandleNftIx(p) {
+    return {
+        programId: toBase58(p.programId, "programId"),
+        keys: mintHandleNftKeys(p),
+        data: MINT_HANDLE_NFT_DISCRIMINATOR.slice(),
+    };
+}
+/**
+ * Build `mint_handle_nft_with_uri` — {@link buildMintHandleNftIx} with a
+ * caller-supplied Metaplex `uri` instead of the program's hosted one. Same
+ * accounts and signers; data = discriminator ‖ borsh(String metadataUri).
+ */
+export function buildMintHandleNftWithUriIx(p) {
+    const uri = TE.encode(p.metadataUri);
+    if (uri.length > MAX_NFT_METADATA_URI_LENGTH) {
+        throw new Error(`Metadata URI exceeds ${MAX_NFT_METADATA_URI_LENGTH} bytes.`);
+    }
+    const data = new Uint8Array(8 + 4 + uri.length);
+    data.set(MINT_HANDLE_NFT_WITH_URI_DISCRIMINATOR, 0);
+    new DataView(data.buffer).setUint32(8, uri.length, true);
+    data.set(uri, 12);
+    return { programId: toBase58(p.programId, "programId"), keys: mintHandleNftKeys(p), data };
+}
+/**
+ * Build `register_tokenized` — register a new handle AND mint its pNFT in
+ * one instruction (the default permanent-XNT purchase). Signer: `payer`
+ * only. Account order: `RegisterTokenized<'info>` (see module docs). Data =
+ * discriminator ‖ borsh(name) ‖ handle_type(u8). Price is computed on-chain
+ * (as for `register`). Prepend `SetComputeUnitLimit(REGISTER_TOKENIZED_CU_LIMIT)`.
+ * `name` must be canonical (the PDA seeds on it).
+ */
+export function buildRegisterTokenizedIx(p) {
+    checkHandleType(p.handleType);
+    const canonical = normalizeHandle(p.name);
+    if (canonical !== p.name) {
+        throw new Error(`name must be the canonical handle "${canonical}" (got "${p.name}") — normalizeHandle() it and derive \`handle\` from the same value`);
+    }
+    const data = encodeNameIx(REGISTER_TOKENIZED_DISCRIMINATOR, p.name, Uint8Array.of(p.handleType));
+    const keys = [
+        { pubkey: toBase58(p.payer, "payer"), isSigner: true, isWritable: true },
+        { pubkey: toBase58(p.owner, "owner"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.config, "config"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.treasury, "treasury"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.handle, "handle"), isSigner: false, isWritable: true },
+        ...buildTokenizedTailKeys(p),
+        ...integratorKeys(p),
+    ];
+    return { programId: toBase58(p.programId, "programId"), keys, data };
+}
+/**
+ * Build `register_revealed_tokenized` — the commit-reveal sibling of
+ * {@link buildRegisterTokenizedIx}. Signer: `payer` only. Same accounts plus
+ * `commitment` (w) right after `handle`; data = discriminator ‖ borsh(name)
+ * ‖ handle_type(u8) ‖ secret[32]. Prepend
+ * `SetComputeUnitLimit(REGISTER_TOKENIZED_CU_LIMIT)`.
+ */
+export function buildRegisterRevealedTokenizedIx(p) {
+    checkHandleType(p.handleType);
+    if (!(p.secret instanceof Uint8Array) || p.secret.length !== 32) {
+        throw new Error("secret must be exactly 32 bytes");
+    }
+    const tail = new Uint8Array(33);
+    tail[0] = p.handleType;
+    tail.set(p.secret, 1);
+    const data = encodeNameIx(REGISTER_REVEALED_TOKENIZED_DISCRIMINATOR, p.name, tail);
+    const keys = [
+        { pubkey: toBase58(p.payer, "payer"), isSigner: true, isWritable: true },
+        { pubkey: toBase58(p.owner, "owner"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.config, "config"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.treasury, "treasury"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.handle, "handle"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.commitment, "commitment"), isSigner: false, isWritable: true },
+        ...buildTokenizedTailKeys(p),
+        ...integratorKeys(p),
+    ];
+    return { programId: toBase58(p.programId, "programId"), keys, data };
+}

package/dist/namespacePricing.d.ts

@@ -0,0 +1,207 @@
+/**
+ * TLD creator pricing (docs/specs/tld-creator-pricing.md): the SDK side of a
+ * TLD creator's own price table for names under their TLD.
+ *
+ * - `["ns_pricing", label]` holds a `NamespacePricing` account: a flat lamport
+ *   price per length band (index = `tier_index(len)`: 0 = 1 char … 8 = 9 chars,
+ *   9 = 10+), written ONLY by the namespace creator via `set_namespace_pricing`.
+ * - `register_under_namespace_v2` (v1's accounts + the pricing PDA as the
+ *   first remaining account) charges that band FLAT (no launch ramp) when
+ *   the account exists, else the legacy root price (`Config.tier_lamports` ×
+ *   the time/volume ramp), and refuses to charge more than the buyer's
+ *   `max_price_lamports`.
+ * - The legacy `register_under_namespace` (v1) fails closed
+ *   (`NamespacePricingRequiresV2`, 6117) on any TLD whose creator opted in.
+ *
+ * {@link quoteScopedName} reproduces the program's price selection exactly, so
+ * pass its `lamports` as `maxPriceLamports` to {@link buildRegisterUnderNamespaceV2Ix}.
+ *
+ * Hand-rolled like the rest of this package: no Anchor client, no
+ * `@solana/web3.js` import, no `@types/node`. PDAs are derived through an
+ * INJECTED `find_program_address` (see {@link PdaFinder}) because this package
+ * never hand-rolls the ed25519 on-curve check.
+ */
+import type { AddressLike, BuiltInstruction } from "./delegate.js";
+import type { RpcFn } from "./accounts.js";
+/** Seed prefix of the `["ns_pricing", label]` PDA. */
+export declare const NAMESPACE_PRICING_SEED = "ns_pricing";
+/** `NAMESPACE_TIER_FLOOR_LAMPORTS`: every creator tier must be >= 1 XNT. */
+export declare const NAMESPACE_TIER_FLOOR_LAMPORTS = 1000000000n;
+/** `NAMESPACE_TIER_MAX_LAMPORTS`: every creator tier must be <= 100,000,000 XNT. */
+export declare const NAMESPACE_TIER_MAX_LAMPORTS: bigint;
+/** Number of length bands (same banding as the root `Config.tier_lamports`). */
+export declare const NAMESPACE_TIER_COUNT = 10;
+/** `sha256("global:set_namespace_pricing")[0..8]`. */
+export declare const SET_NAMESPACE_PRICING_DISCRIMINATOR: Uint8Array;
+/** `sha256("global:register_under_namespace_v2")[0..8]`. */
+export declare const REGISTER_UNDER_NAMESPACE_V2_DISCRIMINATOR: Uint8Array;
+/** `sha256("account:NamespacePricing")[0..8]`. */
+export declare const NAMESPACE_PRICING_ACCOUNT_DISCRIMINATOR: Uint8Array;
+/** `Namespace::PRICING_FLAG_EXT_OFFSET` — the one-byte "creator pricing is on"
+ *  marker past the Anchor-allocated `Namespace` (8 + INIT_SPACE = 107). */
+export declare const NAMESPACE_PRICING_MARKER_OFFSET = 107;
+/** Program error codes added by this feature (6000 + variant index). */
+export declare const NAMESPACE_PRICING_ERRORS: {
+    readonly NamespacePricingMismatch: 6116;
+    readonly NamespacePricingRequiresV2: 6117;
+    readonly PriceExceedsMax: 6118;
+    readonly NamespaceTierBelowFloor: 6119;
+    readonly NamespaceTierAboveMax: 6120;
+};
+/** lib.rs `tier_index`: 1 char -> 0 … 10+ -> 9 (0 clamps to 0). */
+export declare function scopedTierIndex(len: number): number;
+/** lib.rs `price_now` (registration price), in bigint like the program's u128. */
+export declare function rootPriceNow(tierLamports: bigint, launchTs: bigint, nowSecs: bigint, totalHandlesSold: bigint): bigint;
+/** Problems with a creator tier table, or null when the program would accept
+ *  it (exactly `validate_namespace_tiers`). */
+export declare function namespaceTiersProblem(tiers: ReadonlyArray<bigint>): string | null;
+/** `find_program_address` — injected so this package never does curve math
+ *  itself. With web3.js: `(seeds, pid) => PublicKey.findProgramAddressSync(seeds, new PublicKey(pid))[0].toBase58()`. */
+export type PdaFinder = (seeds: Uint8Array[], programId: string) => Promise<string> | string;
+/** The seeds of `["ns_pricing", label]`. */
+export declare function namespacePricingSeeds(label: string): Uint8Array[];
+/** Derive the canonical `["ns_pricing", label]` PDA. */
+export declare function deriveNamespacePricingPda(label: string, programId: AddressLike, find: PdaFinder): Promise<string>;
+/** Decoded `NamespacePricing` account. */
+export interface NamespacePricing {
+    readonly version: number;
+    readonly bump: number;
+    /** Lamports per band, index = {@link scopedTierIndex}(len). */
+    readonly tierLamports: readonly bigint[];
+    readonly updatedAt: bigint;
+    readonly label: string;
+}
+/**
+ * Decode a `NamespacePricing` account's raw data (discriminator included):
+ * disc(8) | version(u8) | bump(u8) | tier_lamports([u64;10]) | updated_at(i64)
+ * | label(String). Returns null when the bytes are not a `NamespacePricing`.
+ */
+export declare function decodeNamespacePricing(data: Uint8Array): NamespacePricing | null;
+/** Whether a raw `Namespace` account carries the "creator pricing is on"
+ *  marker (any nonzero byte at offset 107; a shorter account = off). */
+export declare function namespaceHasPricingMarker(namespaceData: Uint8Array): boolean;
+export interface SetNamespacePricingParams {
+    readonly programId: AddressLike;
+    /** The namespace `creator` (signer, pays rent on first set). */
+    readonly creator: AddressLike;
+    /** `["namespace", label]`. */
+    readonly namespace: AddressLike;
+    /** `["ns_pricing", label]` ({@link deriveNamespacePricingPda}). */
+    readonly namespacePricing: AddressLike;
+    readonly label: string;
+    /** 10 lamport prices, index = {@link scopedTierIndex}(len). */
+    readonly tierLamports: ReadonlyArray<bigint>;
+}
+/**
+ * Build `set_namespace_pricing(label, tier_lamports)`. Accounts IN ORDER
+ * (`SetNamespacePricing`): creator(s,w), namespace(w), namespace_pricing(w),
+ * system_program. Validates the table client-side with the program's exact
+ * bounds so a bad table never reaches a wallet prompt.
+ */
+export declare function buildSetNamespacePricingIx(p: SetNamespacePricingParams): BuiltInstruction;
+export interface RegisterUnderNamespaceV2Params {
+    readonly programId: AddressLike;
+    /** `["ns_pricing", label]` — ALWAYS the canonical PDA, whether or not the
+     *  creator has set pricing (the program decides from its contents). */
+    readonly namespacePricing: AddressLike;
+    readonly payer: AddressLike;
+    readonly owner: AddressLike;
+    readonly config: AddressLike;
+    readonly treasury: AddressLike;
+    readonly namespace: AddressLike;
+    readonly creatorPayout: AddressLike;
+    /** `["handle", [label_len], label, name]`. */
+    readonly handle: AddressLike;
+    readonly mint: AddressLike;
+    readonly ownerTokenAccount: AddressLike;
+    readonly metadata: AddressLike;
+    readonly masterEdition: AddressLike;
+    readonly tokenRecord: AddressLike;
+    readonly collectionMint: AddressLike;
+    readonly collectionMetadata: AddressLike;
+    readonly collectionMasterEdition: AddressLike;
+    readonly collectionAuthority: AddressLike;
+    /** Canonical sub-name (`alice` in `alice.pepe`). */
+    readonly name: string;
+    /** 0 Human, 1 Merchant, 2 Org, 3 Agent. */
+    readonly handleType: number;
+    /** Buyer's ceiling: the tx fails (`PriceExceedsMax`) if the on-chain price
+     *  is higher. Pass {@link quoteScopedName}'s `lamports`. */
+    readonly maxPriceLamports: bigint;
+    /** OPTIONAL referral pair — both or neither. */
+    readonly integrator?: AddressLike;
+    readonly integratorAllowlist?: AddressLike;
+    /** OPTIONAL `["ns_minter", label, payer]` (invite-only, non-creator). */
+    readonly minterAuthorization?: AddressLike;
+}
+/**
+ * Build `register_under_namespace_v2(name, handle_type, max_price_lamports)`.
+ * Accounts IN ORDER: the exact v1 `RegisterUnderNamespace` list (payer(s,w),
+ * owner, config(w), treasury(w), namespace, creator_payout(w), handle(w),
+ * mint(w), owner_token_account(w), metadata(w), master_edition(w),
+ * token_record(w), collection_mint, collection_metadata(w),
+ * collection_master_edition, collection_authority, token_metadata_program,
+ * token_program, associated_token_program, system_program,
+ * sysvar_instructions), then the three optional slots ALWAYS present
+ * (integrator, integrator_allowlist, minter_authorization — each the program
+ * id when absent, Anchor's "explicitly None"), then `namespace_pricing` as
+ * `remaining_accounts[0]`. The program fails closed if it is missing or
+ * shifted.
+ */
+export declare function buildRegisterUnderNamespaceV2Ix(p: RegisterUnderNamespaceV2Params): BuiltInstruction;
+/** The program's root pricing inputs, read from `Config`. */
+export interface RootPricingInputs {
+    readonly launchTs: bigint;
+    readonly tierLamports: readonly bigint[];
+    readonly totalHandlesSold: bigint;
+}
+/** Read `launch_ts`, `tier_lamports` and `total_handles_sold` from raw Config bytes. */
+export declare function decodeRootPricingInputs(config: Uint8Array): RootPricingInputs | null;
+/**
+ * The price `register_under_namespace_v2` charges, from already-read state —
+ * `scoped_registration_price` in lib.rs: the creator's band flat when a table
+ * exists, else the root band × the ramp.
+ */
+export declare function scopedRegistrationPrice(pricing: NamespacePricing | null, root: RootPricingInputs, nameLen: number, nowSecs: bigint): bigint;
+export interface ScopedQuote {
+    /** Lamports `register_under_namespace_v2` will charge (pass as `maxPriceLamports`). */
+    readonly lamports: bigint;
+    /** `custom` = the creator's table; `fallback` = root tiers × ramp. */
+    readonly source: "custom" | "fallback";
+    readonly tierIndex: number;
+    /** The canonical `["ns_pricing", label]` PDA (pass to the v2 builder). */
+    readonly pricingAccount: string;
+    /** The creator's full table when `source === "custom"`. */
+    readonly pricing: NamespacePricing | null;
+}
+export interface QuoteScopedNameOptions {
+    readonly rpc: RpcFn;
+    readonly programId: AddressLike;
+    readonly find: PdaFinder;
+    /** Unix seconds; defaults to the local clock (the ramp moves per quarter, so
+     *  seconds of skew never matter for a fresh quote). */
+    readonly nowSecs?: bigint;
+}
+/**
+ * Quote `name.label` exactly like the program prices it (pricing-or-fallback).
+ * Throws when Config is missing, or when the pricing account exists but is not
+ * a valid `NamespacePricing` owned by the program (the program would refuse
+ * too), so a caller never shows a price the chain will not honour.
+ */
+export declare function quoteScopedName(label: string, name: string, opts: QuoteScopedNameOptions): Promise<ScopedQuote>;
+/**
+ * The instruction to SIMULATE (never send) to learn whether the deployed
+ * program has this feature: `set_namespace_pricing` with no accounts. An
+ * upgraded program recognizes the discriminator and fails account validation
+ * (e.g. 3005 `AccountNotEnoughKeys`); a pre-upgrade program fails with
+ * Anchor's `InstructionFallbackNotFound` (101). Interpret the simulation's
+ * `err` with {@link interpretNamespacePricingProbe}.
+ */
+export declare function buildNamespacePricingProbeIx(programId: AddressLike): BuiltInstruction;
+/**
+ * Read a `simulateTransaction` result's `value.err` for the probe tx (whose
+ * probe instruction is at `probeIndex`). `true` = the program knows the
+ * instruction; `false` = it does not, or the result is not the shape we
+ * expect (fail closed: hide the feature rather than show a broken button).
+ */
+export declare function interpretNamespacePricingProbe(err: unknown, probeIndex: number): boolean;