@x1id/resolve 0.10.0 → 0.12.0

package/dist/voucher.d.ts

@@ -128,3 +128,56 @@ export interface RefundVoucherParams {
 }
 /** Build `refund_voucher` — payer-signed, only valid at/after `expiresAt`. */
 export declare function buildRefundVoucherIx(p: RefundVoucherParams): BuiltInstruction;
+/** `sha256("global:claim_voucher_tokenized")[0..8]`. */
+export declare const CLAIM_VOUCHER_TOKENIZED_DISCRIMINATOR: Uint8Array;
+export interface ClaimVoucherTokenizedParams {
+    readonly programId: AddressLike;
+    /** Submits + signs; fronts the tx fee (reimbursed) + the handle rent. */
+    readonly claimer: AddressLike;
+    readonly config: AddressLike;
+    readonly treasury: AddressLike;
+    readonly voucher: AddressLike;
+    /** The original voucher payer — receives rent back when the voucher closes. */
+    readonly voucherPayer: AddressLike;
+    /** Who the pNFT + ownership go to: the bound recipient, or the claimer for an
+     *  open voucher. The mint's ATA + token record derive against THIS address. */
+    readonly owner: AddressLike;
+    /** The `["handle", name]` PDA. */
+    readonly handle: AddressLike;
+    readonly name: string;
+    /** `["nft_mint", handle]` PDA. */
+    readonly mint: AddressLike;
+    /** `owner`'s associated token account for `mint` (receives the frozen unit). */
+    readonly ownerTokenAccount: AddressLike;
+    /** Metaplex metadata PDA for `mint`. */
+    readonly metadata: AddressLike;
+    /** Metaplex master-edition PDA for `mint`. */
+    readonly masterEdition: AddressLike;
+    /** pNFT TokenRecord PDA for (`mint`, `ownerTokenAccount`). */
+    readonly tokenRecord: AddressLike;
+    /** The collection parent mint (`["collection_mint"]`). */
+    readonly collectionMint: AddressLike;
+    /** The collection parent metadata (writable — sized-collection bump). */
+    readonly collectionMetadata: AddressLike;
+    /** The collection parent master edition. */
+    readonly collectionMasterEdition: AddressLike;
+    /** The collection authority PDA. */
+    readonly collectionAuthority: AddressLike;
+    /** The integrator wallet — REQUIRED iff the voucher carries one; must equal
+     *  the voucher's `integrator`. Omit otherwise. */
+    readonly integrator?: AddressLike;
+}
+/**
+ * Build `claim_voucher_tokenized` (#8335) — the tokenized sibling of
+ * {@link buildClaimVoucherIx} and the DEFAULT path the live gift-claim flow
+ * uses: it registers the handle AND mints its tradeable capability pNFT in one
+ * instruction. The pNFT + ownership go to `owner` (the bound recipient, or the
+ * claimer for an open voucher), so `ownerTokenAccount` / `tokenRecord` derive
+ * against `owner`, not the claimer. Data: `disc ‖ borsh(name)` — the handle type
+ * comes from the voucher, not an argument.
+ *
+ * The register + 3 Metaplex CPIs exceed the 200k default compute budget —
+ * prepend a ComputeBudget `setComputeUnitLimit` instruction in the SAME
+ * transaction (the app uses ~400k) or the claim fails on-chain.
+ */
+export declare function buildClaimVoucherTokenizedIx(p: ClaimVoucherTokenizedParams): BuiltInstruction;

package/dist/voucher.js

@@ -183,3 +183,59 @@ export function buildRefundVoucherIx(p) {
         data,
     };
 }
+// ===================== claim_voucher_tokenized (gift NFTs, #8335) =====================
+/** `sha256("global:claim_voucher_tokenized")[0..8]`. */
+export const CLAIM_VOUCHER_TOKENIZED_DISCRIMINATOR = Uint8Array.from([131, 111, 174, 105, 154, 248, 191, 235]);
+// Fixed Metaplex / SPL program ids + sysvar in the pNFT-mint tail — hardcoded,
+// never derived (matches the app's mintNft.ts).
+const TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+const ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+const TOKEN_METADATA_PROGRAM = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
+const SYSVAR_INSTRUCTIONS = "Sysvar1nstructions1111111111111111111111111";
+/**
+ * Build `claim_voucher_tokenized` (#8335) — the tokenized sibling of
+ * {@link buildClaimVoucherIx} and the DEFAULT path the live gift-claim flow
+ * uses: it registers the handle AND mints its tradeable capability pNFT in one
+ * instruction. The pNFT + ownership go to `owner` (the bound recipient, or the
+ * claimer for an open voucher), so `ownerTokenAccount` / `tokenRecord` derive
+ * against `owner`, not the claimer. Data: `disc ‖ borsh(name)` — the handle type
+ * comes from the voucher, not an argument.
+ *
+ * The register + 3 Metaplex CPIs exceed the 200k default compute budget —
+ * prepend a ComputeBudget `setComputeUnitLimit` instruction in the SAME
+ * transaction (the app uses ~400k) or the claim fails on-chain.
+ */
+export function buildClaimVoucherTokenizedIx(p) {
+    const name = encString(p.name);
+    const data = new Uint8Array(8 + name.length);
+    data.set(CLAIM_VOUCHER_TOKENIZED_DISCRIMINATOR, 0);
+    data.set(name, 8);
+    const keys = [
+        { pubkey: toBase58(p.claimer, "claimer"), isSigner: true, isWritable: true },
+        { pubkey: toBase58(p.config, "config"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.treasury, "treasury"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.voucher, "voucher"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.voucherPayer, "voucherPayer"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.owner, "owner"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.handle, "handle"), isSigner: false, isWritable: true },
+        // Metaplex pNFT tail — order + flags verbatim from mintNft.ts::tokenizedTailKeys.
+        { pubkey: toBase58(p.mint, "mint"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.ownerTokenAccount, "ownerTokenAccount"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.metadata, "metadata"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.masterEdition, "masterEdition"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.tokenRecord, "tokenRecord"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.collectionMint, "collectionMint"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.collectionMetadata, "collectionMetadata"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.collectionMasterEdition, "collectionMasterEdition"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.collectionAuthority, "collectionAuthority"), isSigner: false, isWritable: false },
+        { pubkey: TOKEN_METADATA_PROGRAM, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: SYSTEM_PROGRAM, isSigner: false, isWritable: false },
+        { pubkey: SYSVAR_INSTRUCTIONS, isSigner: false, isWritable: false },
+    ];
+    if (p.integrator !== undefined) {
+        keys.push({ pubkey: toBase58(p.integrator, "integrator"), isSigner: false, isWritable: true });
+    }
+    return { programId: toBase58(p.programId, "programId"), keys, data };
+}

package/dist/wasm.d.ts

@@ -78,5 +78,22 @@ export declare class WasmResolver {
      * Needed on BOTH sides of a `ProgrammableNonFungible` transfer.
      */
     deriveTokenRecordAccount(mint: Uint8Array, token: Uint8Array, programId: Uint8Array): Uint8Array | null;
+    /**
+     * Derive the per-handle `NamespaceOverride` PDA under the registry program id
+     * — seeds `["namespace_override", handle, label]`, matching the on-chain
+     * `CreateNamespaceOverride` account. `handle` is the 32-byte handle PDA
+     * (from {@link deriveHandleAccount}); `label` is the namespace label (e.g.
+     * "xnt"), 1..=16 bytes. Returns the 32-byte override account, or null.
+     *
+     * NOTE: overrides are built but not yet honored by `resolve()` — this derive
+     * is for the write builders (namespaceOverride.ts) and the gated read path.
+     */
+    /**
+     * Derive a `Namespace` directory PDA under the registry program id — seeds
+     * `["namespace", label]`. Needed to pass the namespace account into a
+     * create-override instruction. `label` is 1..=16 bytes. Returns 32 bytes or null.
+     */
+    deriveNamespaceAccount(label: string, programId: Uint8Array): Uint8Array | null;
+    deriveNamespaceOverrideAccount(handle: Uint8Array, label: string, programId: Uint8Array): Uint8Array | null;
 }
 export {};

package/dist/wasm.js

@@ -146,4 +146,42 @@ export class WasmResolver {
         const n = this.#write(joined);
         return this.#x.derive_token_record_account(n) === 1 ? this.#read() : null;
     }
+    /**
+     * Derive the per-handle `NamespaceOverride` PDA under the registry program id
+     * — seeds `["namespace_override", handle, label]`, matching the on-chain
+     * `CreateNamespaceOverride` account. `handle` is the 32-byte handle PDA
+     * (from {@link deriveHandleAccount}); `label` is the namespace label (e.g.
+     * "xnt"), 1..=16 bytes. Returns the 32-byte override account, or null.
+     *
+     * NOTE: overrides are built but not yet honored by `resolve()` — this derive
+     * is for the write builders (namespaceOverride.ts) and the gated read path.
+     */
+    /**
+     * Derive a `Namespace` directory PDA under the registry program id — seeds
+     * `["namespace", label]`. Needed to pass the namespace account into a
+     * create-override instruction. `label` is 1..=16 bytes. Returns 32 bytes or null.
+     */
+    deriveNamespaceAccount(label, programId) {
+        if (programId.length !== 32)
+            return null;
+        const labelBytes = this.#enc.encode(label);
+        if (labelBytes.length < 1 || labelBytes.length > 16)
+            return null;
+        new Uint8Array(this.#x.memory.buffer, this.#x.program_ptr(), 32).set(programId);
+        const n = this.#write(labelBytes);
+        return this.#x.derive_namespace_account(n) === 1 ? this.#read() : null;
+    }
+    deriveNamespaceOverrideAccount(handle, label, programId) {
+        if (handle.length !== 32 || programId.length !== 32)
+            return null;
+        const labelBytes = this.#enc.encode(label);
+        if (labelBytes.length < 1 || labelBytes.length > 16)
+            return null;
+        new Uint8Array(this.#x.memory.buffer, this.#x.program_ptr(), 32).set(programId);
+        const joined = new Uint8Array(32 + labelBytes.length);
+        joined.set(handle, 0);
+        joined.set(labelBytes, 32);
+        const n = this.#write(joined);
+        return this.#x.derive_namespace_override_account(n) === 1 ? this.#read() : null;
+    }
 }

package/package.json

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