@x1id/resolve 0.21.0 → 0.23.0

package/README.md

@@ -605,8 +605,10 @@ const requirements = buildX402Requirements({
   buyer: buyerAddress, // x1id v1 is self-sponsored: buyer pays their own fee, no facilitator
   network: X1_MAINNET_NETWORK, // defaults to mainnet; a server on another cluster
                                // should pass x402NetworkForGenesis(await getGenesisHash)
-  memo: "invoice-42",
+  reference: invoiceReference, // a unique base58 reference per invoice (the payment carries it)
 });
+// Buyer side for api.x1id.io: sign x402RedeemMessage(reference) with the paying
+// wallet and send it as payload.payerSig next to payload.signature.
 ```
 
 This package only builds the requirements object — it does not build, sign,

package/dist/adminConfig.d.ts

@@ -44,6 +44,18 @@ export declare const SET_LEASE_GRACE_PERIOD_DISCRIMINATOR: Uint8Array;
 export declare const SET_RECOVERY_TIMELOCK_DISCRIMINATOR: Uint8Array;
 export declare const SET_MIN_COMMITMENT_AGE_DISCRIMINATOR: Uint8Array;
 export declare const SET_MAX_COMMITMENT_AGE_DISCRIMINATOR: Uint8Array;
+/** `sha256("global:set_namespace_creation_fee")[0..8]` — sets
+ *  `Config.namespace_creation_fee_lamports` (u64, the permissionless
+ *  `create_namespace` TLD creation fee paid to treasury). */
+export declare const SET_NAMESPACE_CREATION_FEE_DISCRIMINATOR: Uint8Array;
+/** Byte offset of `Config.namespace_creation_fee_lamports` (u64 LE) in the
+ *  Config account data, including the 8-byte Anchor discriminator — mirrors
+ *  `Config::NAMESPACE_CREATION_FEE_LAMPORTS_OFFSET` (state.rs). */
+export declare const NAMESPACE_CREATION_FEE_LAMPORTS_OFFSET = 436;
+/** Decode `Config.namespace_creation_fee_lamports` from raw Config account
+ *  data. Returns null for a Config too short to carry the field (pre-v6
+ *  layout) — never a guessed default. */
+export declare function decodeNamespaceCreationFeeLamports(configData: Uint8Array): bigint | null;
 /** Map an admin config action name → its discriminator (for a relay executor
  *  that dispatches on the action string). set_admin/set_attestor intentionally
  *  absent — those are owner-gated, never dispatched here. */
@@ -54,10 +66,12 @@ export interface AdminScalarParams {
     readonly config: AddressLike;
     /** The discriminator for the specific setter (from ADMIN_SCALAR_DISCRIMINATORS). */
     readonly discriminator: Uint8Array;
-    /** The integer arg (u64/i64 encoding is identical for a non-negative value). */
-    readonly value: number | bigint;
+    /** The integer arg (u64/i64 encoding is identical for a non-negative value).
+     *  A string must be plain decimal digits (lamports amounts beyond JS's safe
+     *  integer range arrive from the admin queue as decimal strings). */
+    readonly value: number | bigint | string;
 }
 /** Build any one-integer-arg AdminOnly setter (lease rate divisor, lease grace,
- *  recovery timelock, min/max commitment age). disc(8) + value as little-endian
+ *  recovery timelock, min/max commitment age, namespace creation fee). disc(8) + value as little-endian
  *  u64(8). The value must be a non-negative integer that fits u64. */
 export declare function buildAdminScalarSetterIx(p: AdminScalarParams): BuiltInstruction;

package/dist/adminConfig.js

@@ -84,6 +84,22 @@ export const SET_LEASE_GRACE_PERIOD_DISCRIMINATOR = Uint8Array.from([212, 2, 110
 export const SET_RECOVERY_TIMELOCK_DISCRIMINATOR = Uint8Array.from([178, 183, 148, 243, 155, 166, 79, 6]);
 export const SET_MIN_COMMITMENT_AGE_DISCRIMINATOR = Uint8Array.from([181, 20, 114, 43, 51, 23, 47, 248]);
 export const SET_MAX_COMMITMENT_AGE_DISCRIMINATOR = Uint8Array.from([163, 106, 196, 206, 146, 156, 79, 249]);
+/** `sha256("global:set_namespace_creation_fee")[0..8]` — sets
+ *  `Config.namespace_creation_fee_lamports` (u64, the permissionless
+ *  `create_namespace` TLD creation fee paid to treasury). */
+export const SET_NAMESPACE_CREATION_FEE_DISCRIMINATOR = Uint8Array.from([158, 152, 239, 141, 143, 5, 75, 198]);
+/** Byte offset of `Config.namespace_creation_fee_lamports` (u64 LE) in the
+ *  Config account data, including the 8-byte Anchor discriminator — mirrors
+ *  `Config::NAMESPACE_CREATION_FEE_LAMPORTS_OFFSET` (state.rs). */
+export const NAMESPACE_CREATION_FEE_LAMPORTS_OFFSET = 436;
+/** Decode `Config.namespace_creation_fee_lamports` from raw Config account
+ *  data. Returns null for a Config too short to carry the field (pre-v6
+ *  layout) — never a guessed default. */
+export function decodeNamespaceCreationFeeLamports(configData) {
+    if (configData.length < NAMESPACE_CREATION_FEE_LAMPORTS_OFFSET + 8)
+        return null;
+    return new DataView(configData.buffer, configData.byteOffset, configData.byteLength).getBigUint64(NAMESPACE_CREATION_FEE_LAMPORTS_OFFSET, true);
+}
 /** Map an admin config action name → its discriminator (for a relay executor
  *  that dispatches on the action string). set_admin/set_attestor intentionally
  *  absent — those are owner-gated, never dispatched here. */
@@ -93,11 +109,18 @@ export const ADMIN_SCALAR_DISCRIMINATORS = {
     set_recovery_timelock: SET_RECOVERY_TIMELOCK_DISCRIMINATOR,
     set_min_commitment_age: SET_MIN_COMMITMENT_AGE_DISCRIMINATOR,
     set_max_commitment_age: SET_MAX_COMMITMENT_AGE_DISCRIMINATOR,
+    set_namespace_creation_fee: SET_NAMESPACE_CREATION_FEE_DISCRIMINATOR,
 };
 /** Build any one-integer-arg AdminOnly setter (lease rate divisor, lease grace,
- *  recovery timelock, min/max commitment age). disc(8) + value as little-endian
+ *  recovery timelock, min/max commitment age, namespace creation fee). disc(8) + value as little-endian
  *  u64(8). The value must be a non-negative integer that fits u64. */
 export function buildAdminScalarSetterIx(p) {
+    if (typeof p.value === "string" && !/^\d{1,20}$/.test(p.value)) {
+        throw new Error(`value ${JSON.stringify(p.value)} is not a non-negative decimal integer`);
+    }
+    if (typeof p.value === "number" && !Number.isSafeInteger(p.value)) {
+        throw new Error(`value ${p.value} is not a safe integer`);
+    }
     const raw = typeof p.value === "bigint" ? p.value : BigInt(p.value);
     if (raw < 0n || raw > 0xffffffffffffffffn) {
         throw new Error(`value ${p.value} is out of u64 range`);

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";
@@ -126,4 +127,5 @@ export interface Resolver {
 export declare function createResolver(config: ResolverConfig): Resolver;
 export * from "./adminMarket.js";
 export * from "./namespaceOverride.js";
+export * from "./namespacePricing.js";
 export * from "./universal.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";
@@ -816,6 +817,7 @@ export function createResolver(config) {
 }
 export * from "./adminMarket.js";
 export * from "./namespaceOverride.js";
+export * from "./namespacePricing.js";
 // The X1ID Universal Resolver (#8475): cross-namespace resolution (.sol via SNS,
 // .eth via ENS) alongside the native path. Additive — the native resolver above
 // is untouched; `createUniversalResolver` composes it with external adapters.

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;