@x1id/resolve 0.22.0 → 0.23.0

package/dist/index.d.ts

@@ -52,6 +52,7 @@ export * from "./recordWrite.js";
 export * from "./clearRecords.js";
 export * from "./commitReveal.js";
 export * from "./pnftTransfer.js";
+export * from "./mintNft.js";
 export * from "./payment.js";
 export * from "./signin.js";
 export * from "./connect.js";

package/dist/index.js

@@ -59,6 +59,7 @@ export * from "./recordWrite.js";
 export * from "./clearRecords.js";
 export * from "./commitReveal.js";
 export * from "./pnftTransfer.js";
+export * from "./mintNft.js";
 export * from "./payment.js";
 export * from "./signin.js";
 export * from "./connect.js";

package/dist/mintNft.d.ts

@@ -0,0 +1,247 @@
+/**
+ * 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 type { AddressLike, BuiltInstruction, InstructionKey } from "./delegate.js";
+import type { PdaFinder } from "./namespacePricing.js";
+import type { HandleTypeValue } from "./voucher.js";
+/** `sha256("global:mint_handle_nft")[0..8]`. */
+export declare const MINT_HANDLE_NFT_DISCRIMINATOR: Uint8Array;
+/** `sha256("global:mint_handle_nft_with_uri")[0..8]`. */
+export declare const MINT_HANDLE_NFT_WITH_URI_DISCRIMINATOR: Uint8Array;
+/** `sha256("global:register_tokenized")[0..8]`. */
+export declare const REGISTER_TOKENIZED_DISCRIMINATOR: Uint8Array;
+/** `sha256("global:register_revealed_tokenized")[0..8]`. */
+export declare const REGISTER_REVEALED_TOKENIZED_DISCRIMINATOR: Uint8Array;
+/** Compute-unit limit for any transaction carrying `mint_handle_nft` /
+ *  `mint_handle_nft_with_uri` (measured ~318k CU on mainnet; ~41% headroom). */
+export declare const MINT_HANDLE_NFT_CU_LIMIT = 450000;
+/** Compute-unit limit for any transaction carrying `register_tokenized` /
+ *  `register_revealed_tokenized` (measured 299k–347k CU live; ≥17% headroom). */
+export declare const REGISTER_TOKENIZED_CU_LIMIT = 420000;
+/** `mpl_token_metadata::MAX_URI_LENGTH` — `mint_handle_nft_with_uri` refuses
+ *  (`UriTooLong`) a longer URI; checked client-side too. */
+export declare const MAX_NFT_METADATA_URI_LENGTH = 200;
+/** Seed prefix of a handle's NFT mint PDA: `["nft_mint", handle]`. */
+export declare const NFT_MINT_SEED = "nft_mint";
+/** Seed of the collection parent's mint PDA: `["collection_mint"]`. */
+export declare const COLLECTION_MINT_SEED = "collection_mint";
+/** Seed of the collection update-authority PDA: `["collection_authority"]`. */
+export declare const COLLECTION_AUTHORITY_SEED = "collection_authority";
+/** The pNFT account block every tokenized instruction carries from `mint`
+ *  onward, plus the `["config"]` PDA. Everything here is a PDA/ATA derived
+ *  from `(programId, owner, handle)` — see {@link deriveTokenizedNftAccounts}. */
+export interface TokenizedNftAccounts {
+    /** The `["config"]` PDA. */
+    readonly config: string;
+    /** The handle's NFT mint — `["nft_mint", handle]` under the registry program. */
+    readonly mint: string;
+    /** `owner`'s ATA for `mint` (classic SPL Token) — receives the single unit, frozen. */
+    readonly ownerTokenAccount: string;
+    /** Metaplex metadata PDA for `mint`. */
+    readonly metadata: string;
+    /** Metaplex master-edition PDA for `mint`. */
+    readonly masterEdition: string;
+    /** pNFT `TokenRecord` PDA for (`mint`, `ownerTokenAccount`). */
+    readonly tokenRecord: string;
+    /** Collection parent's mint — `["collection_mint"]` under the registry program. */
+    readonly collectionMint: string;
+    /** Collection parent's metadata (writable — sized-collection count bump). */
+    readonly collectionMetadata: string;
+    /** Collection parent's master edition. */
+    readonly collectionMasterEdition: string;
+    /** `["collection_authority"]` program-signer PDA. */
+    readonly collectionAuthority: string;
+}
+/** {@link TokenizedNftAccounts} plus the two read-only market PDAs
+ *  `mint_handle_nft` checks (no live auction/listing may exist). */
+export interface MintHandleNftAccounts extends TokenizedNftAccounts {
+    /** `["auction", handle]` under the registry program (normally absent). */
+    readonly auction: string;
+    /** `["listing", handle]` under the registry program (normally absent). */
+    readonly listing: string;
+}
+export interface TokenizedNftAccountsInput {
+    /** The registry program id. */
+    readonly programId: AddressLike;
+    /** The wallet that will hold the NFT (its ATA + token record are derived). */
+    readonly owner: AddressLike;
+    /** The `["handle", name]` PDA being tokenized. */
+    readonly handle: AddressLike;
+}
+/**
+ * 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 declare function deriveTokenizedNftAccounts(find: PdaFinder, p: TokenizedNftAccountsInput): Promise<TokenizedNftAccounts>;
+/**
+ * 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 declare function deriveMintHandleNftAccounts(find: PdaFinder, p: TokenizedNftAccountsInput): Promise<MintHandleNftAccounts>;
+/** The `mint` … `collectionAuthority` addresses — any object carrying them
+ *  (e.g. a {@link TokenizedNftAccounts}, or a per-TLD collection variant). */
+export interface TokenizedTailAccounts {
+    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;
+}
+/**
+ * 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 declare function buildTokenizedTailKeys(a: TokenizedTailAccounts): InstructionKey[];
+export interface MintHandleNftParams extends TokenizedTailAccounts {
+    /** The registry program id. */
+    readonly programId: AddressLike;
+    /** Pays the mint fee + all new-account rent. Signer. */
+    readonly payer: AddressLike;
+    /** The handle's current owner — SIGNS (normally the same wallet as payer). */
+    readonly owner: AddressLike;
+    /** The `["config"]` PDA. */
+    readonly config: AddressLike;
+    /** `Config.treasury` — `fetchConfigTreasury` (register.ts). */
+    readonly treasury: AddressLike;
+    /** The existing, untokenized `["handle", name]` PDA. */
+    readonly handle: AddressLike;
+    /** `["auction", handle]` — read-only. */
+    readonly auction: AddressLike;
+    /** `["listing", handle]` — read-only. */
+    readonly listing: AddressLike;
+}
+/**
+ * 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 declare function buildMintHandleNftIx(p: MintHandleNftParams): BuiltInstruction;
+export interface MintHandleNftWithUriParams extends MintHandleNftParams {
+    /** A metadata URI the caller has ALREADY pinned (Arweave/IPFS), ≤ 200 bytes. */
+    readonly metadataUri: string;
+}
+/**
+ * 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 declare function buildMintHandleNftWithUriIx(p: MintHandleNftWithUriParams): BuiltInstruction;
+export interface RegisterTokenizedParams extends TokenizedTailAccounts {
+    /** The registry program id. */
+    readonly programId: AddressLike;
+    /** Pays the price and all rent. Signer. */
+    readonly payer: AddressLike;
+    /** Receives the handle + NFT. Need NOT sign (gifting parity with `register`). */
+    readonly owner: AddressLike;
+    /** The `["config"]` PDA. */
+    readonly config: AddressLike;
+    /** `Config.treasury` — `fetchConfigTreasury` (register.ts). */
+    readonly treasury: AddressLike;
+    /** The `["handle", name]` PDA being claimed — must not already exist. */
+    readonly handle: AddressLike;
+    /** Canonical form (`normalizeHandle` output), 1..=32 bytes. */
+    readonly name: string;
+    readonly handleType: HandleTypeValue;
+    /** OPTIONAL revenue-share pair (#7397) — supply BOTH or NEITHER. */
+    readonly integrator?: AddressLike;
+    /** The `["integrator", integrator]` allowlist PDA. */
+    readonly integratorAllowlist?: AddressLike;
+}
+/**
+ * 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 declare function buildRegisterTokenizedIx(p: RegisterTokenizedParams): BuiltInstruction;
+export interface RegisterRevealedTokenizedParams extends RegisterTokenizedParams {
+    /** The `["commitment", commitmentHash]` PDA the matching `commit` created. */
+    readonly commitment: AddressLike;
+    /** The exact 32-byte secret the commitment hashed. */
+    readonly secret: Uint8Array;
+}
+/**
+ * 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 declare function buildRegisterRevealedTokenizedIx(p: RegisterRevealedTokenizedParams): BuiltInstruction;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@x1id/resolve",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Resolve @handles and X1NS names on X1. Never silently picks between namespaces.",
   "type": "module",
   "main": "./dist/index.js",