@x1id/resolve 0.23.0 → 0.44.0

package/dist/recoveryNft.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Recovery for TOKENIZED names (program upgrade 6, OpenProject #8471; spec
+ * docs/specs/recovery-tokenized.md). The untokenized family stays in
+ * `recovery.ts` and still refuses a tokenized handle.
+ *
+ * The holder ARMS recovery by approving the registry PDA `["nft_recovery",
+ * handle]` as the pNFT's Metaplex **Transfer delegate** (the token stays in
+ * the holder's wallet). The recovery key — any signer, e.g. an axio_multisig
+ * vault; it never pays — initiates; after the same timelock as untokenized
+ * recovery (`max(Config.recovery_timelock_secs, 24h)`, 7 days by default)
+ * `complete_nft_recovery` moves the pNFT to the target with the registry PDA
+ * signing, and bumps the holder epoch. Any move of the pNFT (native sale,
+ * off-platform transfer) clears the Metaplex delegate and kills the arm;
+ * anyone may then disarm it (rent back to whoever paid it).
+ *
+ * `list_handle` REFUSES a tokenized name whose arm is live
+ * (`NftRecoveryArmed`, 6214): the holder disarms first. Its tokenized branch
+ * takes the `["nft_recovery", handle]` PDA as a REQUIRED trailing account
+ * after `sysvar_instructions` ({@link deriveNftRecoveryPda}); omitting it or
+ * passing another address is `NftRecoveryAccountMismatch` (6210). A dead arm
+ * (see {@link isNftRecoveryArmLive}) does not block a listing.
+ *
+ *   arm_nft_recovery(recovery)    holder    refused while listed/auctioned/locked
+ *   initiate_nft_recovery(target) recovery  needs a live arm; refused while locked
+ *   cancel_nft_recovery           holder    allowed while locked
+ *   complete_nft_recovery         recovery + payer, after the timelock
+ *   disarm_nft_recovery           holder (live; revokes the delegate) / anyone (dead)
+ */
+import type { AddressLike, BuiltInstruction } from "./delegate.js";
+import type { PdaFinder } from "./namespacePricing.js";
+export declare const NFT_RECOVERY_SEED = "nft_recovery";
+export declare const ARM_NFT_RECOVERY_DISCRIMINATOR: Uint8Array;
+export declare const INITIATE_NFT_RECOVERY_DISCRIMINATOR: Uint8Array;
+export declare const CANCEL_NFT_RECOVERY_DISCRIMINATOR: Uint8Array;
+export declare const COMPLETE_NFT_RECOVERY_DISCRIMINATOR: Uint8Array;
+export declare const DISARM_NFT_RECOVERY_DISCRIMINATOR: Uint8Array;
+/** `sha256("account:NftRecovery")[0..8]`. */
+export declare const NFT_RECOVERY_ACCOUNT_DISCRIMINATOR: Uint8Array;
+/** `8 + NftRecovery::INIT_SPACE`. */
+export declare const NFT_RECOVERY_ACCOUNT_LEN = 258;
+/** Program error codes (NftRecoveryError, offset 6205). */
+export declare const NFT_RECOVERY_ERRORS: Readonly<Record<number, string>>;
+/** Every PDA the tokenized recovery family touches, for one handle + holder. */
+export interface NftRecoveryAccounts {
+    readonly nftRecovery: string;
+    readonly config: string;
+    readonly listing: string;
+    readonly auction: string;
+    readonly metadata: string;
+    readonly masterEdition: string;
+    readonly holderTokenAccount: string;
+    readonly tokenRecord: string;
+}
+/** `["nft_recovery", handle]` alone: the trailing account `list_handle`'s
+ *  tokenized branch requires (after `sysvar_instructions`). */
+export declare function deriveNftRecoveryPda(find: PdaFinder, programId: AddressLike, handle: AddressLike): Promise<string>;
+/** Derive the PDAs for `handle`, its pNFT `mint` and the (armed) `holder`. */
+export declare function deriveNftRecoveryAccounts(find: PdaFinder, programId: AddressLike, handle: AddressLike, mint: AddressLike, holder: AddressLike): Promise<NftRecoveryAccounts>;
+/** The target's ATA + token record for `complete_nft_recovery`. */
+export declare function deriveNftRecoveryTargetAccounts(find: PdaFinder, mint: AddressLike, target: AddressLike): Promise<{
+    readonly targetTokenAccount: string;
+    readonly targetTokenRecord: string;
+}>;
+export interface ArmNftRecoveryParams {
+    readonly programId: AddressLike;
+    /** The current pNFT holder (signer; pays the PDA rent). */
+    readonly holder: AddressLike;
+    readonly handle: AddressLike;
+    readonly mint: AddressLike;
+    /** The recovery key (guardian / multisig vault). */
+    readonly recovery: AddressLike;
+    readonly accounts: NftRecoveryAccounts;
+}
+/** `arm_nft_recovery(recovery)`. ~95k CU. */
+export declare function buildArmNftRecoveryIx(p: ArmNftRecoveryParams): BuiltInstruction;
+export interface InitiateNftRecoveryParams {
+    readonly programId: AddressLike;
+    /** The recovery key. Signer (a multisig vault PDA may sign via CPI). */
+    readonly recovery: AddressLike;
+    readonly handle: AddressLike;
+    /** Derived for the ARMED holder. */
+    readonly accounts: NftRecoveryAccounts;
+    /** Who receives the pNFT (must differ from the armed holder). */
+    readonly target: AddressLike;
+}
+/** `initiate_nft_recovery(target)`: starts (or restarts) the timelock. */
+export declare function buildInitiateNftRecoveryIx(p: InitiateNftRecoveryParams): BuiltInstruction;
+export interface CancelNftRecoveryParams {
+    readonly programId: AddressLike;
+    /** The CURRENT holder. Signer. Allowed while the name is locked. */
+    readonly holder: AddressLike;
+    readonly handle: AddressLike;
+    readonly nftRecovery: AddressLike;
+    /** The holder's canonical pNFT ATA (authority proof). */
+    readonly holderTokenAccount: AddressLike;
+}
+/** `cancel_nft_recovery()`: clears the pending recovery; the arm stays. */
+export declare function buildCancelNftRecoveryIx(p: CancelNftRecoveryParams): BuiltInstruction;
+export interface DisarmNftRecoveryParams {
+    readonly programId: AddressLike;
+    /** The armed holder while the arm is live (the delegate is revoked); anyone
+     *  once it is dead. Signer. */
+    readonly signer: AddressLike;
+    readonly handle: AddressLike;
+    readonly mint: AddressLike;
+    /** `NftRecovery.rent_payer` (receives the rent). */
+    readonly rentPayer: AddressLike;
+    /** Derived for the ARMED holder. */
+    readonly accounts: NftRecoveryAccounts;
+}
+/** `disarm_nft_recovery()`: closes the arm. */
+export declare function buildDisarmNftRecoveryIx(p: DisarmNftRecoveryParams): BuiltInstruction;
+export interface CompleteNftRecoveryParams {
+    readonly programId: AddressLike;
+    /** The recovery key. Signer. Never pays. */
+    readonly recovery: AddressLike;
+    /** Funds the target's ATA + token record (anyone; never X1ID). Signer. */
+    readonly payer: AddressLike;
+    readonly handle: AddressLike;
+    readonly mint: AddressLike;
+    /** `NftRecovery.holder`. */
+    readonly holder: AddressLike;
+    /** `NftRecovery.target`. */
+    readonly target: AddressLike;
+    /** `NftRecovery.rent_payer`. */
+    readonly rentPayer: AddressLike;
+    /** Derived for the ARMED holder. */
+    readonly accounts: NftRecoveryAccounts;
+    readonly targetAccounts: {
+        readonly targetTokenAccount: AddressLike;
+        readonly targetTokenRecord: AddressLike;
+    };
+}
+/** `complete_nft_recovery()`: ~180k CU when the target's ATA is created. */
+export declare function buildCompleteNftRecoveryIx(p: CompleteNftRecoveryParams): BuiltInstruction;
+/** A decoded `NftRecovery` account. */
+export interface NftRecoveryAccount {
+    readonly version: number;
+    readonly bump: number;
+    readonly handle: string;
+    readonly mint: string;
+    readonly holder: string;
+    readonly holderTokenAccount: string;
+    readonly recovery: string;
+    /** `max(registered_at, holder_epoch)` at arm; a different current value = dead arm. */
+    readonly holderEpoch: bigint;
+    readonly armedAt: bigint;
+    /** 0n = nothing pending. */
+    readonly initiatedAt: bigint;
+    /** Null when nothing is pending. */
+    readonly target: string | null;
+    readonly rentPayer: string;
+}
+/**
+ * Decode `NftRecovery`: disc | version | bump | handle@10 | mint@42 |
+ * holder@74 | holder_token_account@106 | recovery@138 | holder_epoch@170 |
+ * armed_at@178 | initiated_at@186 | target@194 | rent_payer@226. Null when
+ * not one.
+ */
+export declare function decodeNftRecovery(data: Uint8Array): NftRecoveryAccount | null;
+/** When a pending tokenized recovery can complete (the program's clamp). */
+export declare function nftRecoveryCompletesAt(r: NftRecoveryAccount, configTimelockSecs: bigint | null): bigint | null;
+/**
+ * Whether the Metaplex `TokenRecord` data still names `nftRecovery` as the
+ * Transfer delegate (the on-chain liveness rule's Metaplex half). Layout:
+ * key | bump | state | Option<u64> rule_set_revision | Option<Pubkey>
+ * delegate | Option<u8> role.
+ */
+export declare function tokenRecordHasRecoveryDelegate(tokenRecordData: Uint8Array, nftRecovery: AddressLike): boolean;
+/**
+ * Client mirror of the program's liveness rule for the parts a UI can see
+ * without the handle's epoch: the arm exists, the current `holder` is the
+ * armed holder, and the holder's `TokenRecord` still names the PDA as its
+ * Transfer delegate. `true` means `list_handle` will refuse
+ * (`NftRecoveryArmed`) until the holder disarms. Pass `nftRecoveryData = null`
+ * when the account does not exist.
+ */
+export declare function isNftRecoveryArmLive(p: {
+    readonly nftRecovery: AddressLike;
+    readonly nftRecoveryData: Uint8Array | null;
+    readonly holder: AddressLike;
+    readonly tokenRecordData: Uint8Array | null;
+}): boolean;

package/dist/recoveryNft.js

@@ -0,0 +1,291 @@
+/**
+ * Recovery for TOKENIZED names (program upgrade 6, OpenProject #8471; spec
+ * docs/specs/recovery-tokenized.md). The untokenized family stays in
+ * `recovery.ts` and still refuses a tokenized handle.
+ *
+ * The holder ARMS recovery by approving the registry PDA `["nft_recovery",
+ * handle]` as the pNFT's Metaplex **Transfer delegate** (the token stays in
+ * the holder's wallet). The recovery key — any signer, e.g. an axio_multisig
+ * vault; it never pays — initiates; after the same timelock as untokenized
+ * recovery (`max(Config.recovery_timelock_secs, 24h)`, 7 days by default)
+ * `complete_nft_recovery` moves the pNFT to the target with the registry PDA
+ * signing, and bumps the holder epoch. Any move of the pNFT (native sale,
+ * off-platform transfer) clears the Metaplex delegate and kills the arm;
+ * anyone may then disarm it (rent back to whoever paid it).
+ *
+ * `list_handle` REFUSES a tokenized name whose arm is live
+ * (`NftRecoveryArmed`, 6214): the holder disarms first. Its tokenized branch
+ * takes the `["nft_recovery", handle]` PDA as a REQUIRED trailing account
+ * after `sysvar_instructions` ({@link deriveNftRecoveryPda}); omitting it or
+ * passing another address is `NftRecoveryAccountMismatch` (6210). A dead arm
+ * (see {@link isNftRecoveryArmLive}) does not block a listing.
+ *
+ *   arm_nft_recovery(recovery)    holder    refused while listed/auctioned/locked
+ *   initiate_nft_recovery(target) recovery  needs a live arm; refused while locked
+ *   cancel_nft_recovery           holder    allowed while locked
+ *   complete_nft_recovery         recovery + payer, after the timelock
+ *   disarm_nft_recovery           holder (live; revokes the delegate) / anyone (dead)
+ */
+import { encodeBase58, decodeBase58_32 } from "./base58.js";
+import { bytesEqual } from "./accounts.js";
+import { recoveryCompletesAt } from "./recovery.js";
+export const NFT_RECOVERY_SEED = "nft_recovery";
+export const ARM_NFT_RECOVERY_DISCRIMINATOR = Uint8Array.from([155, 147, 102, 165, 32, 203, 158, 250]);
+export const INITIATE_NFT_RECOVERY_DISCRIMINATOR = Uint8Array.from([159, 54, 209, 96, 179, 210, 209, 150]);
+export const CANCEL_NFT_RECOVERY_DISCRIMINATOR = Uint8Array.from([162, 102, 34, 153, 10, 203, 112, 212]);
+export const COMPLETE_NFT_RECOVERY_DISCRIMINATOR = Uint8Array.from([114, 50, 101, 177, 37, 203, 222, 56]);
+export const DISARM_NFT_RECOVERY_DISCRIMINATOR = Uint8Array.from([120, 4, 249, 9, 63, 241, 141, 150]);
+/** `sha256("account:NftRecovery")[0..8]`. */
+export const NFT_RECOVERY_ACCOUNT_DISCRIMINATOR = Uint8Array.from([209, 254, 105, 152, 211, 178, 138, 91]);
+/** `8 + NftRecovery::INIT_SPACE`. */
+export const NFT_RECOVERY_ACCOUNT_LEN = 258;
+/** Program error codes (NftRecoveryError, offset 6205). */
+export const NFT_RECOVERY_ERRORS = {
+    6205: "NftRecoveryNotTokenized",
+    6206: "NftRecoveryStale",
+    6207: "NftRecoveryNotRecoveryKey",
+    6208: "NftRecoveryNotPending",
+    6209: "NftRecoveryTimelockActive",
+    6210: "NftRecoveryAccountMismatch",
+    6211: "NftRecoveryMarketActive",
+    6212: "NftRecoveryNotHolder",
+    6213: "NftRecoveryBadTarget",
+    6214: "NftRecoveryArmed",
+};
+const TOKEN_PROGRAM = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+const ATA_PROGRAM = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+const METADATA_PROGRAM = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
+const SYSVAR_INSTRUCTIONS = "Sysvar1nstructions1111111111111111111111111";
+const SYSTEM_PROGRAM = "11111111111111111111111111111111";
+const TE = new TextEncoder();
+function raw(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 b58(v, what) {
+    return encodeBase58(raw(v, what));
+}
+function nk(v, what, isSigner, isWritable) {
+    return { pubkey: b58(v, what), isSigner, isWritable };
+}
+function join(a, b) {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a, 0);
+    out.set(b, a.length);
+    return out;
+}
+async function pnftAta(find, owner, mint) {
+    return find([raw(owner, "owner"), raw(TOKEN_PROGRAM, "tokenProgram"), raw(mint, "mint")], ATA_PROGRAM);
+}
+async function pnftTokenRecord(find, mint, token) {
+    return find([TE.encode("metadata"), raw(METADATA_PROGRAM, "metadataProgram"), raw(mint, "mint"), TE.encode("token_record"), raw(token, "token")], METADATA_PROGRAM);
+}
+/** `["nft_recovery", handle]` alone: the trailing account `list_handle`'s
+ *  tokenized branch requires (after `sysvar_instructions`). */
+export async function deriveNftRecoveryPda(find, programId, handle) {
+    return find([TE.encode(NFT_RECOVERY_SEED), raw(handle, "handle")], b58(programId, "programId"));
+}
+/** Derive the PDAs for `handle`, its pNFT `mint` and the (armed) `holder`. */
+export async function deriveNftRecoveryAccounts(find, programId, handle, mint, holder) {
+    const program = b58(programId, "programId");
+    const h = raw(handle, "handle");
+    const m = raw(mint, "mint");
+    const meta = raw(METADATA_PROGRAM, "metadataProgram");
+    const holderTokenAccount = await pnftAta(find, holder, mint);
+    const [nftRecovery, config, listing, auction, metadata, masterEdition, tokenRecord] = await Promise.all([
+        find([TE.encode(NFT_RECOVERY_SEED), h], program),
+        find([TE.encode("config")], program),
+        find([TE.encode("listing"), h], program),
+        find([TE.encode("auction"), h], program),
+        find([TE.encode("metadata"), meta, m], METADATA_PROGRAM),
+        find([TE.encode("metadata"), meta, m, TE.encode("edition")], METADATA_PROGRAM),
+        pnftTokenRecord(find, mint, holderTokenAccount),
+    ]);
+    return { nftRecovery, config, listing, auction, metadata, masterEdition, holderTokenAccount, tokenRecord };
+}
+/** The target's ATA + token record for `complete_nft_recovery`. */
+export async function deriveNftRecoveryTargetAccounts(find, mint, target) {
+    const targetTokenAccount = await pnftAta(find, target, mint);
+    return { targetTokenAccount, targetTokenRecord: await pnftTokenRecord(find, mint, targetTokenAccount) };
+}
+/** `arm_nft_recovery(recovery)`. ~95k CU. */
+export function buildArmNftRecoveryIx(p) {
+    const a = p.accounts;
+    return {
+        programId: b58(p.programId, "programId"),
+        keys: [
+            nk(p.holder, "holder", true, true),
+            nk(p.handle, "handle", false, false),
+            nk(a.nftRecovery, "nftRecovery", false, true),
+            nk(p.mint, "mint", false, false),
+            nk(a.holderTokenAccount, "holderTokenAccount", false, true),
+            nk(a.metadata, "metadata", false, true),
+            nk(a.masterEdition, "masterEdition", false, false),
+            nk(a.tokenRecord, "tokenRecord", false, true),
+            nk(a.listing, "listing", false, false),
+            nk(a.auction, "auction", false, false),
+            nk(METADATA_PROGRAM, "tokenMetadataProgram", false, false),
+            nk(TOKEN_PROGRAM, "tokenProgram", false, false),
+            nk(SYSTEM_PROGRAM, "systemProgram", false, false),
+            nk(SYSVAR_INSTRUCTIONS, "sysvarInstructions", false, false),
+        ],
+        data: join(ARM_NFT_RECOVERY_DISCRIMINATOR, raw(p.recovery, "recovery")),
+    };
+}
+/** `initiate_nft_recovery(target)`: starts (or restarts) the timelock. */
+export function buildInitiateNftRecoveryIx(p) {
+    const a = p.accounts;
+    return {
+        programId: b58(p.programId, "programId"),
+        keys: [
+            nk(p.recovery, "recovery", true, false),
+            nk(p.handle, "handle", false, false),
+            nk(a.nftRecovery, "nftRecovery", false, true),
+            nk(a.holderTokenAccount, "holderTokenAccount", false, false),
+            nk(a.tokenRecord, "tokenRecord", false, false),
+            nk(a.auction, "auction", false, false),
+        ],
+        data: join(INITIATE_NFT_RECOVERY_DISCRIMINATOR, raw(p.target, "target")),
+    };
+}
+/** `cancel_nft_recovery()`: clears the pending recovery; the arm stays. */
+export function buildCancelNftRecoveryIx(p) {
+    return {
+        programId: b58(p.programId, "programId"),
+        keys: [
+            nk(p.holder, "holder", true, false),
+            nk(p.handle, "handle", false, false),
+            nk(p.nftRecovery, "nftRecovery", false, true),
+            nk(p.holderTokenAccount, "holderTokenAccount", false, false),
+        ],
+        data: CANCEL_NFT_RECOVERY_DISCRIMINATOR.slice(),
+    };
+}
+/** `disarm_nft_recovery()`: closes the arm. */
+export function buildDisarmNftRecoveryIx(p) {
+    const a = p.accounts;
+    return {
+        programId: b58(p.programId, "programId"),
+        keys: [
+            nk(p.signer, "signer", true, true),
+            nk(p.handle, "handle", false, false),
+            nk(a.nftRecovery, "nftRecovery", false, true),
+            nk(p.rentPayer, "rentPayer", false, true),
+            nk(p.mint, "mint", false, false),
+            nk(a.holderTokenAccount, "holderTokenAccount", false, true),
+            nk(a.metadata, "metadata", false, true),
+            nk(a.masterEdition, "masterEdition", false, false),
+            nk(a.tokenRecord, "tokenRecord", false, true),
+            nk(METADATA_PROGRAM, "tokenMetadataProgram", false, false),
+            nk(TOKEN_PROGRAM, "tokenProgram", false, false),
+            nk(SYSTEM_PROGRAM, "systemProgram", false, false),
+            nk(SYSVAR_INSTRUCTIONS, "sysvarInstructions", false, false),
+        ],
+        data: DISARM_NFT_RECOVERY_DISCRIMINATOR.slice(),
+    };
+}
+/** `complete_nft_recovery()`: ~180k CU when the target's ATA is created. */
+export function buildCompleteNftRecoveryIx(p) {
+    const a = p.accounts;
+    return {
+        programId: b58(p.programId, "programId"),
+        keys: [
+            nk(p.recovery, "recovery", true, false),
+            nk(p.payer, "payer", true, true),
+            nk(p.handle, "handle", false, true),
+            nk(a.config, "config", false, false),
+            nk(a.nftRecovery, "nftRecovery", false, true),
+            nk(p.rentPayer, "rentPayer", false, true),
+            nk(a.listing, "listing", false, false),
+            nk(a.auction, "auction", false, false),
+            nk(p.mint, "mint", false, false),
+            nk(p.holder, "holder", false, false),
+            nk(a.holderTokenAccount, "holderTokenAccount", false, true),
+            nk(p.target, "target", false, false),
+            nk(p.targetAccounts.targetTokenAccount, "targetTokenAccount", false, true),
+            nk(a.metadata, "metadata", false, true),
+            nk(a.masterEdition, "masterEdition", false, false),
+            nk(a.tokenRecord, "tokenRecord", false, true),
+            nk(p.targetAccounts.targetTokenRecord, "targetTokenRecord", false, true),
+            nk(METADATA_PROGRAM, "tokenMetadataProgram", false, false),
+            nk(TOKEN_PROGRAM, "tokenProgram", false, false),
+            nk(ATA_PROGRAM, "associatedTokenProgram", false, false),
+            nk(SYSTEM_PROGRAM, "systemProgram", false, false),
+            nk(SYSVAR_INSTRUCTIONS, "sysvarInstructions", false, false),
+        ],
+        data: COMPLETE_NFT_RECOVERY_DISCRIMINATOR.slice(),
+    };
+}
+/**
+ * Decode `NftRecovery`: disc | version | bump | handle@10 | mint@42 |
+ * holder@74 | holder_token_account@106 | recovery@138 | holder_epoch@170 |
+ * armed_at@178 | initiated_at@186 | target@194 | rent_payer@226. Null when
+ * not one.
+ */
+export function decodeNftRecovery(data) {
+    if (data.length < NFT_RECOVERY_ACCOUNT_LEN || !bytesEqual(data.subarray(0, 8), NFT_RECOVERY_ACCOUNT_DISCRIMINATOR))
+        return null;
+    const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const pk = (o) => encodeBase58(data.subarray(o, o + 32));
+    const initiatedAt = dv.getBigInt64(186, true);
+    return {
+        version: data[8],
+        bump: data[9],
+        handle: pk(10),
+        mint: pk(42),
+        holder: pk(74),
+        holderTokenAccount: pk(106),
+        recovery: pk(138),
+        holderEpoch: dv.getBigInt64(170, true),
+        armedAt: dv.getBigInt64(178, true),
+        initiatedAt,
+        target: initiatedAt === 0n ? null : pk(194),
+        rentPayer: pk(226),
+    };
+}
+/** When a pending tokenized recovery can complete (the program's clamp). */
+export function nftRecoveryCompletesAt(r, configTimelockSecs) {
+    return recoveryCompletesAt(r.initiatedAt, configTimelockSecs);
+}
+/**
+ * Whether the Metaplex `TokenRecord` data still names `nftRecovery` as the
+ * Transfer delegate (the on-chain liveness rule's Metaplex half). Layout:
+ * key | bump | state | Option<u64> rule_set_revision | Option<Pubkey>
+ * delegate | Option<u8> role.
+ */
+export function tokenRecordHasRecoveryDelegate(tokenRecordData, nftRecovery) {
+    const d = tokenRecordData;
+    if (d.length < 4)
+        return false;
+    let o = 3;
+    o += d[o] === 1 ? 9 : 1;
+    if (d[o] !== 1 || d.length < o + 35)
+        return false;
+    if (!bytesEqual(d.subarray(o + 1, o + 33), raw(nftRecovery, "nftRecovery")))
+        return false;
+    o += 33;
+    return d[o] === 1 && d[o + 1] === 1;
+}
+/**
+ * Client mirror of the program's liveness rule for the parts a UI can see
+ * without the handle's epoch: the arm exists, the current `holder` is the
+ * armed holder, and the holder's `TokenRecord` still names the PDA as its
+ * Transfer delegate. `true` means `list_handle` will refuse
+ * (`NftRecoveryArmed`) until the holder disarms. Pass `nftRecoveryData = null`
+ * when the account does not exist.
+ */
+export function isNftRecoveryArmLive(p) {
+    if (!p.nftRecoveryData || !p.tokenRecordData)
+        return false;
+    const rec = decodeNftRecovery(p.nftRecoveryData);
+    if (!rec || rec.holder !== b58(p.holder, "holder"))
+        return false;
+    return tokenRecordHasRecoveryDelegate(p.tokenRecordData, p.nftRecovery);
+}