@x1id/resolve 0.3.0 → 0.7.0

package/dist/index.js

@@ -38,6 +38,21 @@ export * from "./textRecords.js";
 export * from "./lock.js";
 export * from "./integrator.js";
 export * from "./voucher.js";
+export * from "./agent.js";
+export * from "./register.js";
+// Was previously imported here for internal use only, never re-exported —
+// promoted to public API 2026-09-22 because a second real package (mcp/)
+// now needs `parseHandleAccount`/`RpcFn` directly rather than duplicating
+// this decoder (the Handle account's `Option<Pubkey>` fields are
+// variable-width Borsh — a hand-rolled offset guess here would be exactly
+// the kind of drift docs/record-trust.md's "one implementation" rule
+// exists to prevent).
+export * from "./accounts.js";
+export * from "./x402.js";
+export * from "./recordWrite.js";
+export * from "./clearRecords.js";
+export * from "./commitReveal.js";
+export * from "./pnftTransfer.js";
 import { ResolveError, CHAIN_COIN_TYPE } from "./types.js";
 import { parseName } from "./parse.js";
 import { encodeBase58, decodeBase58_32 } from "./base58.js";
@@ -136,7 +151,7 @@ export function createResolver(config) {
         // behind by a previous registration of the same name is never resolved,
         // and a stale `verified: true` is never surfaced.
         if (chain !== "X1" && chain !== "SOL") {
-            const live = liveRecords(await fetchRecords(rpc, programBase58, pda, handle.registeredAt));
+            const live = liveRecords(await fetchRecords(rpc, programBase58, pda, handle.registeredAt, handle.recordsClearedAt));
             const record = live.find((r) => r.coinType === CHAIN_COIN_TYPE[chain]);
             if (!record) {
                 throw new ResolveError("no-record-for-chain", `@${canonical} has no ${chain} record`, input);
@@ -166,7 +181,7 @@ export function createResolver(config) {
             throw new ResolveError("unrecognized", `per-chain records exist only for @handles, not .${parsed.namespace} domains`, input);
         }
         const { pda, handle } = await fetchHandle(parsed.canonical, input);
-        return fetchRecords(rpc, programBase58, pda, handle.registeredAt);
+        return fetchRecords(rpc, programBase58, pda, handle.registeredAt, handle.recordsClearedAt);
     }
     async function resolve(input, opts) {
         const chain = opts?.chain ?? "X1";

package/dist/pnftTransfer.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Move a handle's capability NFT — `TransferV1` for Metaplex
+ * ProgrammableNonFungibles (pNFTs), the standard `mint_handle_nft` mints.
+ *
+ * One import to move a handle NFT:
+ *
+ * ```ts
+ * import { WasmResolver, buildTransferV1Ix, deriveTransferV1Accounts } from "@x1id/resolve";
+ *
+ * const accounts = deriveTransferV1Accounts(wasm, {
+ *   mint,                 // Handle.nft_mint (parseHandleAccount(...).nftMint)
+ *   holder,               // current holder — signs
+ *   recipient,            // destination wallet
+ * });
+ * const ix = buildTransferV1Ix({ ...accounts, amount: 1n });
+ * // adapt `ix` to your runtime (see delegate.ts's module docs for the
+ * // two-line web3.js adapter) and send with the holder's signature.
+ * ```
+ *
+ * # Why a plain SPL transfer no longer works
+ *
+ * A pNFT's token accounts are permanently FROZEN by the Token Metadata
+ * program (that is how it enforces programmability): `spl_token::transfer`
+ * fails with `AccountFrozen`. The ONLY way to move one is the Token Metadata
+ * program's own `TransferV1`, which thaw-moves-refreezes under the hood and
+ * maintains one `TokenRecord` PDA per token account on both sides.
+ * READ paths are unaffected — a frozen account still reports `amount 1`, so
+ * holder resolution (`nftHolder`, `reverse()`) is identical for both
+ * standards.
+ *
+ * Handles tokenized BEFORE the pNFT cutover hold plain `NonFungible`s
+ * (unfrozen) — those still move by plain SPL transfer. Branch on the mint's
+ * metadata `token_standard` (or on the source ATA's frozen state); this
+ * module only builds the pNFT path.
+ *
+ * # Wire format (verified against mpl-token-metadata 5.1.1, the crate the
+ * # workspace Cargo.lock pins — `src/generated/instructions/transfer_v1.rs`)
+ *
+ * Data: `[49, 0]` (instruction discriminator `Transfer` = 49, then
+ * `TransferArgs::V1` = 0) ‖ `amount: u64 LE` ‖ `authorization_data:
+ * Option` (`0` — this SDK never builds `AuthorizationData`; handle rule
+ * sets carry `rule_set: None`, so none is ever needed). 11 bytes total.
+ *
+ * Accounts, in exactly this order (17): token(w) token_owner
+ * destination_token(w) destination_owner mint metadata(w) edition
+ * token_record(w) destination_token_record(w) authority(s) payer(s,w)
+ * system_program sysvar_instructions spl_token_program spl_ata_program
+ * authorization_rules_program authorization_rules. An absent OPTIONAL slot
+ * is filled with the Token Metadata program id itself, read-only — Metaplex's
+ * "explicitly None" convention (kinobi-generated builders do the same).
+ *
+ * The destination ATA and its `TokenRecord` need not exist: `TransferV1`
+ * creates both (rent from `payer`) — that is why the ATA program is in the
+ * account list. No separate create-ATA instruction is needed.
+ *
+ * PDAs are derived through the WASM module (this package's one rule: never
+ * hand-roll `find_program_address`'s on-curve check in TypeScript — see
+ * wasm.ts). The Token Metadata program id is a parameter everywhere because
+ * X1 runs its own deployment ({@link MPL_TOKEN_METADATA_PROGRAM}).
+ */
+import type { AddressLike, BuiltInstruction } from "./delegate.js";
+import type { WasmResolver } from "./wasm.js";
+/** X1's Token Metadata deployment — the id `mint_handle_nft` CPIs into
+ *  (lib.rs `TOKEN_METADATA_PROGRAM_ID`, `…x1s` suffix). NOT the canonical
+ *  Solana-mainnet id; on another chain, pass that deployment's id instead. */
+export declare const MPL_TOKEN_METADATA_PROGRAM = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
+/** `MetadataInstruction::Transfer`'s Borsh enum discriminator. */
+export declare const TRANSFER_IX_DISCRIMINATOR = 49;
+/** `TransferArgs::V1`'s Borsh enum discriminator. */
+export declare const TRANSFER_ARGS_V1 = 0;
+/** Metadata `token_standard` value for a pNFT
+ *  (`TokenStandard::ProgrammableNonFungible`, mpl 5.1.1 enum order). */
+export declare const TOKEN_STANDARD_PROGRAMMABLE_NON_FUNGIBLE = 4;
+/**
+ * Derive the `TokenRecord` PDA for `(mint, token)` — `token` is the token
+ * ACCOUNT (the ATA), not its owner. Byte-for-byte
+ * `mpl_token_metadata::accounts::TokenRecord::find_pda`; seeds
+ * `["metadata", program, mint, "token_record", token]` under `programId`.
+ */
+export declare function deriveTokenRecordPda(wasm: WasmResolver, mint: AddressLike, token: AddressLike, programId?: AddressLike): string;
+/** Every address {@link buildTransferV1Ix} needs, derived from just
+ *  `(mint, holder, recipient)`. */
+export interface TransferV1Accounts {
+    /** The holder's ATA — the account the NFT leaves. */
+    readonly token: string;
+    /** The holder. */
+    readonly tokenOwner: string;
+    /** The recipient's ATA — created by `TransferV1` itself if absent. */
+    readonly destinationToken: string;
+    readonly destinationOwner: string;
+    readonly mint: string;
+    readonly metadata: string;
+    readonly edition: string;
+    readonly tokenRecord: string;
+    readonly destinationTokenRecord: string;
+    /** The holder — pNFT self-transfers sign as owner. */
+    readonly authority: string;
+    /** Rent for the destination ATA + token record. Defaults to the holder. */
+    readonly payer: string;
+    readonly tokenMetadataProgramId: string;
+}
+/**
+ * Derive the full `TransferV1` account set for moving a handle NFT from
+ * `holder` to `recipient`. Pure derivation — nothing is fetched; whether the
+ * mint really is a pNFT is the caller's check (read the metadata
+ * `token_standard`, or the source ATA's frozen state).
+ */
+export declare function deriveTransferV1Accounts(wasm: WasmResolver, p: {
+    readonly mint: AddressLike;
+    readonly holder: AddressLike;
+    readonly recipient: AddressLike;
+    /** Pays destination-side rent. Defaults to `holder`. */
+    readonly payer?: AddressLike;
+    readonly tokenMetadataProgramId?: AddressLike;
+}): TransferV1Accounts;
+export interface TransferV1Params {
+    /** Source token account (the holder's ATA). */
+    readonly token: AddressLike;
+    readonly tokenOwner: AddressLike;
+    /** Destination token account — need not exist yet (see module docs). */
+    readonly destinationToken: AddressLike;
+    readonly destinationOwner: AddressLike;
+    readonly mint: AddressLike;
+    readonly metadata: AddressLike;
+    /** Master Edition PDA. Required for a pNFT. */
+    readonly edition: AddressLike;
+    /** `TokenRecord` PDA of the SOURCE token account. Required for a pNFT. */
+    readonly tokenRecord: AddressLike;
+    /** `TokenRecord` PDA of the DESTINATION token account. Required for a
+     *  pNFT — `TransferV1` creates the account if it does not exist. */
+    readonly destinationTokenRecord: AddressLike;
+    /** The transfer authority (holder or delegate). Signer. */
+    readonly authority: AddressLike;
+    /** Pays destination-side rent. Signer. */
+    readonly payer: AddressLike;
+    /** Defaults to 1 — handle NFTs are fixed-supply-1. */
+    readonly amount?: bigint;
+    /** OPTIONAL auth-rules pair — supply BOTH or NEITHER. Handle NFTs are
+     *  minted with `rule_set: None`, so normally neither: the slots are then
+     *  filled with the "explicitly None" placeholder (the program id). Plumbed
+     *  for completeness should a rule set ever exist. */
+    readonly authorizationRulesProgram?: AddressLike;
+    readonly authorizationRules?: AddressLike;
+    readonly tokenMetadataProgramId?: AddressLike;
+}
+/**
+ * Build `TransferV1`. See the module docs for the verified account order and
+ * data serialization. `authorization_data` is always serialized `None` —
+ * with `rule_set: None` there is nothing to authorize against.
+ */
+export declare function buildTransferV1Ix(p: TransferV1Params): BuiltInstruction;

package/dist/pnftTransfer.js

@@ -0,0 +1,183 @@
+/**
+ * Move a handle's capability NFT — `TransferV1` for Metaplex
+ * ProgrammableNonFungibles (pNFTs), the standard `mint_handle_nft` mints.
+ *
+ * One import to move a handle NFT:
+ *
+ * ```ts
+ * import { WasmResolver, buildTransferV1Ix, deriveTransferV1Accounts } from "@x1id/resolve";
+ *
+ * const accounts = deriveTransferV1Accounts(wasm, {
+ *   mint,                 // Handle.nft_mint (parseHandleAccount(...).nftMint)
+ *   holder,               // current holder — signs
+ *   recipient,            // destination wallet
+ * });
+ * const ix = buildTransferV1Ix({ ...accounts, amount: 1n });
+ * // adapt `ix` to your runtime (see delegate.ts's module docs for the
+ * // two-line web3.js adapter) and send with the holder's signature.
+ * ```
+ *
+ * # Why a plain SPL transfer no longer works
+ *
+ * A pNFT's token accounts are permanently FROZEN by the Token Metadata
+ * program (that is how it enforces programmability): `spl_token::transfer`
+ * fails with `AccountFrozen`. The ONLY way to move one is the Token Metadata
+ * program's own `TransferV1`, which thaw-moves-refreezes under the hood and
+ * maintains one `TokenRecord` PDA per token account on both sides.
+ * READ paths are unaffected — a frozen account still reports `amount 1`, so
+ * holder resolution (`nftHolder`, `reverse()`) is identical for both
+ * standards.
+ *
+ * Handles tokenized BEFORE the pNFT cutover hold plain `NonFungible`s
+ * (unfrozen) — those still move by plain SPL transfer. Branch on the mint's
+ * metadata `token_standard` (or on the source ATA's frozen state); this
+ * module only builds the pNFT path.
+ *
+ * # Wire format (verified against mpl-token-metadata 5.1.1, the crate the
+ * # workspace Cargo.lock pins — `src/generated/instructions/transfer_v1.rs`)
+ *
+ * Data: `[49, 0]` (instruction discriminator `Transfer` = 49, then
+ * `TransferArgs::V1` = 0) ‖ `amount: u64 LE` ‖ `authorization_data:
+ * Option` (`0` — this SDK never builds `AuthorizationData`; handle rule
+ * sets carry `rule_set: None`, so none is ever needed). 11 bytes total.
+ *
+ * Accounts, in exactly this order (17): token(w) token_owner
+ * destination_token(w) destination_owner mint metadata(w) edition
+ * token_record(w) destination_token_record(w) authority(s) payer(s,w)
+ * system_program sysvar_instructions spl_token_program spl_ata_program
+ * authorization_rules_program authorization_rules. An absent OPTIONAL slot
+ * is filled with the Token Metadata program id itself, read-only — Metaplex's
+ * "explicitly None" convention (kinobi-generated builders do the same).
+ *
+ * The destination ATA and its `TokenRecord` need not exist: `TransferV1`
+ * creates both (rent from `payer`) — that is why the ATA program is in the
+ * account list. No separate create-ATA instruction is needed.
+ *
+ * PDAs are derived through the WASM module (this package's one rule: never
+ * hand-roll `find_program_address`'s on-curve check in TypeScript — see
+ * wasm.ts). The Token Metadata program id is a parameter everywhere because
+ * X1 runs its own deployment ({@link MPL_TOKEN_METADATA_PROGRAM}).
+ */
+import { encodeBase58, decodeBase58_32 } from "./base58.js";
+/** X1's Token Metadata deployment — the id `mint_handle_nft` CPIs into
+ *  (lib.rs `TOKEN_METADATA_PROGRAM_ID`, `…x1s` suffix). NOT the canonical
+ *  Solana-mainnet id; on another chain, pass that deployment's id instead. */
+export const MPL_TOKEN_METADATA_PROGRAM = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
+/** `MetadataInstruction::Transfer`'s Borsh enum discriminator. */
+export const TRANSFER_IX_DISCRIMINATOR = 49;
+/** `TransferArgs::V1`'s Borsh enum discriminator. */
+export const TRANSFER_ARGS_V1 = 0;
+/** Metadata `token_standard` value for a pNFT
+ *  (`TokenStandard::ProgrammableNonFungible`, mpl 5.1.1 enum order). */
+export const TOKEN_STANDARD_PROGRAMMABLE_NON_FUNGIBLE = 4;
+const SYSTEM_PROGRAM = "11111111111111111111111111111111";
+const SYSVAR_INSTRUCTIONS = "Sysvar1nstructions1111111111111111111111111";
+const SPL_TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+const SPL_ATA_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+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));
+}
+/**
+ * Derive the `TokenRecord` PDA for `(mint, token)` — `token` is the token
+ * ACCOUNT (the ATA), not its owner. Byte-for-byte
+ * `mpl_token_metadata::accounts::TokenRecord::find_pda`; seeds
+ * `["metadata", program, mint, "token_record", token]` under `programId`.
+ */
+export function deriveTokenRecordPda(wasm, mint, token, programId = MPL_TOKEN_METADATA_PROGRAM) {
+    const out = wasm.deriveTokenRecordAccount(toBytes32(mint, "mint"), toBytes32(token, "token"), toBytes32(programId, "programId"));
+    if (!out)
+        throw new Error("token record derivation failed");
+    return encodeBase58(out);
+}
+/**
+ * Derive the full `TransferV1` account set for moving a handle NFT from
+ * `holder` to `recipient`. Pure derivation — nothing is fetched; whether the
+ * mint really is a pNFT is the caller's check (read the metadata
+ * `token_standard`, or the source ATA's frozen state).
+ */
+export function deriveTransferV1Accounts(wasm, p) {
+    const mint = toBytes32(p.mint, "mint");
+    const holder = toBytes32(p.holder, "holder");
+    const recipient = toBytes32(p.recipient, "recipient");
+    const program = toBytes32(p.tokenMetadataProgramId ?? MPL_TOKEN_METADATA_PROGRAM, "tokenMetadataProgramId");
+    const sourceAta = wasm.deriveAssociatedTokenAccount(holder, mint);
+    const destAta = wasm.deriveAssociatedTokenAccount(recipient, mint);
+    const metadata = wasm.deriveMetadataAccount(mint, program);
+    const edition = wasm.deriveMasterEditionAccount(mint, program);
+    const sourceRecord = sourceAta && wasm.deriveTokenRecordAccount(mint, sourceAta, program);
+    const destRecord = destAta && wasm.deriveTokenRecordAccount(mint, destAta, program);
+    if (!sourceAta || !destAta || !metadata || !edition || !sourceRecord || !destRecord) {
+        throw new Error("TransferV1 account derivation failed");
+    }
+    return {
+        token: encodeBase58(sourceAta),
+        tokenOwner: encodeBase58(holder),
+        destinationToken: encodeBase58(destAta),
+        destinationOwner: encodeBase58(recipient),
+        mint: encodeBase58(mint),
+        metadata: encodeBase58(metadata),
+        edition: encodeBase58(edition),
+        tokenRecord: encodeBase58(sourceRecord),
+        destinationTokenRecord: encodeBase58(destRecord),
+        authority: encodeBase58(holder),
+        payer: encodeBase58(p.payer !== undefined ? toBytes32(p.payer, "payer") : holder),
+        tokenMetadataProgramId: encodeBase58(program),
+    };
+}
+/**
+ * Build `TransferV1`. See the module docs for the verified account order and
+ * data serialization. `authorization_data` is always serialized `None` —
+ * with `rule_set: None` there is nothing to authorize against.
+ */
+export function buildTransferV1Ix(p) {
+    const amount = p.amount ?? 1n;
+    if (amount < 0n || amount > 0xffffffffffffffffn) {
+        throw new Error("amount must fit in a u64");
+    }
+    const hasRules = p.authorizationRulesProgram !== undefined || p.authorizationRules !== undefined;
+    if (hasRules && (p.authorizationRulesProgram === undefined || p.authorizationRules === undefined)) {
+        throw new Error("authorizationRulesProgram and authorizationRules must both be supplied, or neither");
+    }
+    const programId = toBase58(p.tokenMetadataProgramId ?? MPL_TOKEN_METADATA_PROGRAM, "tokenMetadataProgramId");
+    // [49, 0] ‖ amount u64 LE ‖ Option<AuthorizationData> = None (0).
+    const data = new Uint8Array(11);
+    data[0] = TRANSFER_IX_DISCRIMINATOR;
+    data[1] = TRANSFER_ARGS_V1;
+    new DataView(data.buffer).setBigUint64(2, amount, true);
+    data[10] = 0;
+    const keys = [
+        { pubkey: toBase58(p.token, "token"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.tokenOwner, "tokenOwner"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.destinationToken, "destinationToken"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.destinationOwner, "destinationOwner"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.mint, "mint"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.metadata, "metadata"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.edition, "edition"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.tokenRecord, "tokenRecord"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.destinationTokenRecord, "destinationTokenRecord"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.authority, "authority"), isSigner: true, isWritable: false },
+        { pubkey: toBase58(p.payer, "payer"), isSigner: true, isWritable: true },
+        { pubkey: SYSTEM_PROGRAM, isSigner: false, isWritable: false },
+        { pubkey: SYSVAR_INSTRUCTIONS, isSigner: false, isWritable: false },
+        { pubkey: SPL_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: SPL_ATA_PROGRAM_ID, isSigner: false, isWritable: false },
+        hasRules
+            ? { pubkey: toBase58(p.authorizationRulesProgram, "authorizationRulesProgram"), isSigner: false, isWritable: false }
+            : { pubkey: programId, isSigner: false, isWritable: false },
+        hasRules
+            ? { pubkey: toBase58(p.authorizationRules, "authorizationRules"), isSigner: false, isWritable: false }
+            : { pubkey: programId, isSigner: false, isWritable: false },
+    ];
+    return { programId, keys, data };
+}

package/dist/recordWrite.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Write builders for the address `Record` family: `create_record` and the
+ * three `verify_record_*` proof-of-control instructions (ETH/secp256k1,
+ * SVM/ed25519, BTC/BIP-137). `records.ts` was read-only until now — every
+ * other record family (text records, attestations, vouchers, subnames...)
+ * already had write builders; this was the one gap (WP #8142).
+ *
+ * Hand-rolled like the rest of this package — no Anchor client, no
+ * `@solana/web3.js` import. PDAs are NOT derived here (see delegate.ts's
+ * module docs for why) — derive `["record", handlePda, coinTypeLE(4)]`
+ * with your runtime's canonical `findProgramAddress`.
+ *
+ * # What this SDK does and does not do for you
+ *
+ * This does NOT sign anything, derive an address from a signature, or
+ * verify a signature client-side — that's the on-chain program's job
+ * (`verify_record_eth`/`svm`/`btc` recover the signer's address from the
+ * signature itself and compare it to the record's claimed value; a client
+ * proving nothing false cannot fabricate a match). What this module DOES do:
+ *
+ * 1. {@link buildRecordChallenge} — build the exact bytes a wallet must
+ *    sign, byte-identical to `handle-normalize`'s Rust `challenge()`
+ *    (verified: `crates/handle-normalize/src/challenge.rs`). Unlike the
+ *    off-chain control-proof flow (`control.ts`), this challenge's nonce
+ *    does NOT need to be server-issued — the on-chain transaction landing
+ *    IS the single-use event, so any ASCII-alphanumeric nonce (1..=64
+ *    chars) the caller picks is fine.
+ * 2. {@link splitEthSignature} / {@link splitBtcSignature} — repackage what
+ *    a wallet's `personal_sign` (ETH) or `signmessage` (BTC) actually
+ *    returns into the exact args each verify instruction expects.
+ * 3. The four instruction builders themselves.
+ *
+ * # ETH: EIP-191 `personal_sign`, not EIP-712
+ *
+ * `verify_record_eth` (lib.rs) hashes the challenge with EIP-191's
+ * `"\x19Ethereum Signed Message:\n" + len + message` framing — the exact
+ * framing every wallet's `personal_sign` / `eth_sign` RPC method produces.
+ * There is no EIP-712 typed-data variant on-chain to build a client for.
+ *
+ * # BTC: mainnet-only, compressed P2PKH or bech32/P2WPKH only
+ *
+ * `verify_record_btc` derives the address FROM the recovered pubkey (never
+ * trusts a client-supplied address) and only accepts the header-byte ranges
+ * for compressed P2PKH (31-34) and bech32/P2WPKH (39-42) — see `btc.rs`'s
+ * module doc for exactly why uncompressed P2PKH and P2SH-segwit are refused
+ * rather than guessed. {@link splitBtcSignature} passes the header byte
+ * through unchanged; it is the wallet's job to produce one of the two
+ * supported ranges (most current wallets do).
+ */
+import type { AddressLike, BuiltInstruction } from "./delegate.js";
+export declare const CREATE_RECORD_DISCRIMINATOR: Uint8Array;
+export declare const VERIFY_RECORD_ETH_DISCRIMINATOR: Uint8Array;
+export declare const VERIFY_RECORD_SVM_DISCRIMINATOR: Uint8Array;
+export declare const VERIFY_RECORD_BTC_DISCRIMINATOR: Uint8Array;
+/** The delegate-aware trailing account every verify builder shares — same
+ *  rule as `textRecords.ts`'s identically-named private helper (not shared
+ *  across files by import: each write-builder module owns its own copy,
+ *  matching this SDK's existing convention). */
+interface RecordEditAuthorityParams {
+    readonly recordDelegate?: AddressLike;
+    readonly holderTokenAccount?: AddressLike;
+}
+/**
+ * `x1-handles:v1:<handle>:<coinType>:<registeredAt>:<nonce>` — byte-identical
+ * to `handle_normalize::challenge` (Rust). `handle` must already be
+ * canonical (pass it through {@link import("./parse.js").normalizeHandle}
+ * first if it might have a leading `@` or mixed case).
+ */
+export declare function buildRecordChallenge(handle: string, coinType: number, registeredAt: bigint, nonce: string): string;
+/** Split a 65-byte ETH `personal_sign` output (`r(32) || s(32) || v(1)`)
+ *  into `verify_record_eth`'s `{signature: [u8;64], recoveryId: u8}`,
+ *  normalizing `v`'s two common conventions (27/28, matching most wallets'
+ *  raw RPC output, or already 0/1). */
+export declare function splitEthSignature(sig65: Uint8Array): {
+    signature: Uint8Array;
+    recoveryId: number;
+};
+/** Split a 65-byte BTC BIP-137 `signmessage` output (`header(1) || r(32) ||
+ *  s(32)`) into `verify_record_btc`'s `{header, signature: [u8;64]}`. The
+ *  header byte is passed through unchanged — see the module docs for which
+ *  ranges `verify_record_btc` accepts. */
+export declare function splitBtcSignature(sig65: Uint8Array): {
+    header: number;
+    signature: Uint8Array;
+};
+export interface CreateRecordParams {
+    readonly programId: AddressLike;
+    readonly payer: AddressLike;
+    readonly owner: AddressLike;
+    readonly handle: AddressLike;
+    /** The `["record", handle, coinTypeLE(4)]` PDA. */
+    readonly record: AddressLike;
+    readonly coinType: number;
+    /** Raw address bytes (1..=64), NOT verified yet — `verified` starts
+     *  false until a matching `verify_record_*` call succeeds. */
+    readonly value: Uint8Array;
+}
+export declare function buildCreateRecordIx(p: CreateRecordParams): BuiltInstruction;
+export interface VerifyRecordEthParams extends RecordEditAuthorityParams {
+    readonly programId: AddressLike;
+    readonly owner: AddressLike;
+    readonly handle: AddressLike;
+    readonly record: AddressLike;
+    readonly nonce: string;
+    /** The 64-byte `r || s` half — use {@link splitEthSignature} on a
+     *  wallet's raw 65-byte `personal_sign` output. */
+    readonly signature: Uint8Array;
+    readonly recoveryId: number;
+}
+export declare function buildVerifyRecordEthIx(p: VerifyRecordEthParams): BuiltInstruction;
+export interface VerifyRecordSvmParams extends RecordEditAuthorityParams {
+    readonly programId: AddressLike;
+    readonly owner: AddressLike;
+    /** The address being claimed — MUST co-sign this transaction; its
+     *  signature IS the proof, no challenge/nonce needed (X1 and Solana
+     *  share ed25519). */
+    readonly claimed: AddressLike;
+    readonly handle: AddressLike;
+    readonly record: AddressLike;
+}
+export declare function buildVerifyRecordSvmIx(p: VerifyRecordSvmParams): BuiltInstruction;
+export interface VerifyRecordBtcParams extends RecordEditAuthorityParams {
+    readonly programId: AddressLike;
+    readonly owner: AddressLike;
+    readonly handle: AddressLike;
+    readonly record: AddressLike;
+    readonly nonce: string;
+    /** BIP-137 header byte — use {@link splitBtcSignature} on a wallet's raw
+     *  65-byte `signmessage` output. Only 31-34 (compressed P2PKH) and 39-42
+     *  (bech32/P2WPKH) are accepted on-chain; see the module docs. */
+    readonly header: number;
+    /** The 64-byte `r || s` half. */
+    readonly signature: Uint8Array;
+}
+export declare function buildVerifyRecordBtcIx(p: VerifyRecordBtcParams): BuiltInstruction;
+export {};