@x1id/resolve 0.2.0 → 0.3.0

package/dist/attestation.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Domain/social verification attestations (`Attestation` accounts, #7379) —
+ * read WITH the universal staleness rule from docs/record-trust.md
+ * structurally enforced, plus instruction builders for `set_attestor` /
+ * `create_attestation` / `close_attestation`.
+ *
+ * Hand-rolled like the rest of this package — no Anchor client, no
+ * `@solana/web3.js` import (it stays an optional peer). Builders return the
+ * transport-neutral {@link BuiltInstruction} `delegate.ts` defines; PDAs are
+ * NOT derived here (see delegate.ts's module docs for why — derive
+ * `["attestation", handlePda, kindByte]` / `["attestor_config"]` with your
+ * runtime's canonical `findProgramAddress`).
+ *
+ * # What an attestation proves — and, honestly, what it does not
+ *
+ * An `Attestation` proves exactly one statement: **"the key configured in
+ * `AttestorConfig` — the x1id review process — attested this evidence at
+ * time `attestedAt`."** It is NOT a trustless proof of domain or social
+ * control: the verification (DNS lookup, social-post check, human review)
+ * happens OFF-chain, and the chain records only that the attestor key signed
+ * off on it. That key is admin-rotatable, so the trust anchor is "whoever
+ * the registry admin currently designates" — rotatable-key trust, not
+ * trustlessness. Consumers needing stronger guarantees must not render an
+ * attestation as more than it is.
+ *
+ * # Verified = ONE live attestation of EITHER kind
+ *
+ * Per the #7145 decision (a single strong signal is enough — requiring two
+ * would reject Nike proving control of nike.com), a handle is "verified"
+ * when at least one NON-STALE attestation of either kind exists; `kind`
+ * records which signal proved it. {@link isHandleVerified} implements
+ * exactly this.
+ *
+ * # Why every function here demands `registeredAt` — epoch-bound, no TTL
+ *
+ * Attestations do not expire on a timer (owner decision 2026-09-03); they
+ * are invalidated by OWNERSHIP EPOCH. A `Handle`'s address is
+ * `["handle", name]` — a pure function of the name — so release +
+ * re-register lands the new registration at the SAME pubkey, and the
+ * previous owner's attestation is physically attached to the new owner's
+ * name with no action by anyone. The mandatory read-side rule
+ * (docs/record-trust.md, the universal rule):
+ *
+ *     attestation.attested_at >= handle.registered_at
+ *
+ * An attestation that fails it belongs to a previous, unrelated owner and
+ * must never be rendered as verifying the current one. Like `records.ts`,
+ * there is deliberately no way to decode or fetch an attestation through
+ * this module without the handle's `registered_at` in hand. (The one
+ * documented blind spot is shared with `Handle.owner`/`Primary`/
+ * `RecordDelegate`: a bearer-NFT marketplace trade bumps no epoch, so the
+ * attestation keeps reading live until the attestor re-reviews or revokes.)
+ */
+import type { AddressLike, BuiltInstruction } from "./delegate.js";
+import type { RpcFn } from "./accounts.js";
+/** Seed prefix of an attestation PDA: `["attestation", handlePda, kindByte]`. */
+export declare const ATTESTATION_SEED = "attestation";
+/** Seed of the attestor-config singleton PDA: `["attestor_config"]`. */
+export declare const ATTESTOR_CONFIG_SEED = "attestor_config";
+/** `Attestation.kind` — domain control proven (DNS TXT challenge). */
+export declare const ATTESTATION_KIND_DNS = 0;
+/** `Attestation.kind` — social-account control proven. */
+export declare const ATTESTATION_KIND_SOCIAL = 1;
+/** Anchor account discriminator: `sha256("account:Attestation")[0..8]`.
+ *  Pinned (this SDK is zero-dependency and cannot assume WebCrypto SHA-256
+ *  everywhere it runs); asserted against a re-derivation in the test suite
+ *  so a typo can never silently pass. */
+export declare const ATTESTATION_DISCRIMINATOR: Uint8Array;
+/** Anchor account discriminator: `sha256("account:AttestorConfig")[0..8]`. */
+export declare const ATTESTOR_CONFIG_DISCRIMINATOR: Uint8Array;
+/** Anchor instruction discriminator: `sha256("global:set_attestor")[0..8]`. */
+export declare const SET_ATTESTOR_DISCRIMINATOR: Uint8Array;
+/** Anchor instruction discriminator: `sha256("global:create_attestation")[0..8]`. */
+export declare const CREATE_ATTESTATION_DISCRIMINATOR: Uint8Array;
+/** Anchor instruction discriminator: `sha256("global:close_attestation")[0..8]`. */
+export declare const CLOSE_ATTESTATION_DISCRIMINATOR: Uint8Array;
+/** `Attestation` account size — every field is fixed-width, so unlike a
+ *  `Handle` the account is exactly this long:
+ *  disc(8) + handle(32) + kind(1) + evidence_hash(32) + attested_at(8)
+ *  + attestor(32) + bump(1). */
+export declare const ATTESTATION_LEN = 114;
+/** `AttestorConfig` account size: disc(8) + attestor(32) + bump(1). */
+export declare const ATTESTOR_CONFIG_LEN = 41;
+/** Which verification signal an attestation `kind` byte names, or null for a
+ *  kind this SDK does not know (future program versions may add kinds). */
+export declare function attestationKindName(kind: number): "dns" | "social" | null;
+/** A decoded verification attestation, staleness already judged. */
+export interface HandleAttestation {
+    /** The Attestation account's address, base58. */
+    readonly account: string;
+    /** The Handle account this attestation is for, base58. */
+    readonly handle: string;
+    /** Raw kind byte (0 = dns, 1 = social). */
+    readonly kind: number;
+    /** Human name for `kind`, or null for an unknown kind. */
+    readonly kindName: "dns" | "social" | null;
+    /** `sha256` commitment to the off-chain verdict-inputs bundle. */
+    readonly evidenceHash: Uint8Array;
+    /** Unix seconds the attestation was (last) stamped. */
+    readonly attestedAt: bigint;
+    /** The attestor key that signed the stamp, base58 — a historical fact,
+     *  not re-checked against the current `AttestorConfig`. */
+    readonly attestor: string;
+    /**
+     * The rule docs/record-trust.md mandates: this attestation only vouches
+     * for the current owner if `attested_at >= handle.registered_at`. A stale
+     * attestation belongs to a previous, unrelated owner of the same name and
+     * must never be rendered as verifying the current one.
+     */
+    readonly stale: boolean;
+}
+/**
+ * Decode one Attestation account.
+ *
+ * `registeredAt` is the owning Handle's `registered_at`, decoded by the
+ * caller from the Handle account — it decides `stale`. There is
+ * intentionally no overload without it (see the module docs).
+ *
+ * Returns null for anything that is not an Attestation: wrong length or
+ * wrong discriminator.
+ */
+export declare function decodeAttestation(raw: Uint8Array, account: string, registeredAt: bigint): HandleAttestation | null;
+/** The attestations that vouch for the CURRENT owner — `stale` ones
+ *  excluded. This is the list to judge verification from. */
+export declare function liveAttestations(attestations: readonly HandleAttestation[]): HandleAttestation[];
+/**
+ * The #7145 verified rule: a handle is verified when at least ONE non-stale
+ * attestation of EITHER kind exists (a single strong signal is enough; the
+ * surviving `kindName`s say which signals proved it).
+ */
+export declare function isHandleVerified(attestations: readonly HandleAttestation[]): boolean;
+/**
+ * Fetch every Attestation account of a handle — one `getProgramAccounts`
+ * call, filtered by the RPC on size (114), the Attestation discriminator at
+ * offset 0 and the handle pubkey at offset 8, then every byte re-checked
+ * locally (the node's filters are an optimisation, never the guarantee) —
+ * the exact shape of `fetchRecords`. Scoping the scan to the registry
+ * program id also IS the ownership check.
+ *
+ * `registeredAt` is `Handle.registered_at` as decoded from the Handle
+ * account the caller already has — the staleness rule needs it, and there
+ * is no variant of this function without it. Every attestation is returned,
+ * stale ones flagged, so an owner surface can show what a previous
+ * registration left behind; anything that renders a verified badge takes
+ * {@link isHandleVerified} / {@link liveAttestations}.
+ */
+export declare function fetchAttestations(rpc: RpcFn, programId: string, handleAccount: string, registeredAt: bigint): Promise<HandleAttestation[]>;
+export interface SetAttestorParams {
+    /** The registry program id. */
+    readonly programId: AddressLike;
+    /** The registry admin (`Config.admin`). Signer; also pays the one-time
+     *  `AttestorConfig` init. */
+    readonly admin: AddressLike;
+    /** The `["config"]` PDA. */
+    readonly config: AddressLike;
+    /** The `["attestor_config"]` PDA — derive per the module docs. */
+    readonly attestorConfig: AddressLike;
+    /** The key being granted attestation-signing authority. */
+    readonly attestor: AddressLike;
+}
+/**
+ * Build `set_attestor` — admin-only: initialize or rotate the attestor key.
+ * Rotation does not void existing attestations (they record their signer as
+ * a historical fact); revoking a bad key's output is `close_attestation`.
+ */
+export declare function buildSetAttestorIx(p: SetAttestorParams): BuiltInstruction;
+export interface CreateAttestationParams {
+    /** The registry program id. */
+    readonly programId: AddressLike;
+    /** The configured attestor. Signer; pays the attestation's rent on first
+     *  stamp. */
+    readonly attestor: AddressLike;
+    /** The `["attestor_config"]` PDA. */
+    readonly attestorConfig: AddressLike;
+    /** The `["handle", name]` PDA being attested (must be registered). */
+    readonly handle: AddressLike;
+    /** The `["attestation", handle, kindByte]` PDA — derive per the module
+     *  docs, with the SAME kind byte passed below. */
+    readonly attestation: AddressLike;
+    /** {@link ATTESTATION_KIND_DNS} or {@link ATTESTATION_KIND_SOCIAL}. */
+    readonly kind: number;
+    /** `sha256` of the off-chain verdict-inputs bundle (32 bytes) — a
+     *  commitment, never the raw evidence. */
+    readonly evidenceHash: Uint8Array;
+}
+/**
+ * Build `create_attestation` — attestor-only: stamp (or re-stamp,
+ * re-deriving `attested_at` from the Clock and replacing the evidence hash)
+ * the (handle, kind) attestation.
+ */
+export declare function buildCreateAttestationIx(p: CreateAttestationParams): BuiltInstruction;
+export interface CloseAttestationParams {
+    /** The registry program id. */
+    readonly programId: AddressLike;
+    /** The current attestor OR the admin. Signer. */
+    readonly signer: AddressLike;
+    /** The `["config"]` PDA. */
+    readonly config: AddressLike;
+    /** The `["attestor_config"]` PDA. */
+    readonly attestorConfig: AddressLike;
+    /** The attestation account being closed. No Handle account is needed —
+     *  the program re-derives the seeds from the attestation's own stored
+     *  fields, so a stale attestation stranded by a released handle stays
+     *  revocable. */
+    readonly attestation: AddressLike;
+    /** Receives the closed account's rent — any account the caller chooses. */
+    readonly recipient: AddressLike;
+}
+/**
+ * Build `close_attestation` — revoke: close the account, rent to
+ * `recipient`. Attestor- or admin-signed (the admin path is the cleanup for
+ * a rotated-away key's output).
+ */
+export declare function buildCloseAttestationIx(p: CloseAttestationParams): BuiltInstruction;

package/dist/attestation.js

@@ -0,0 +1,278 @@
+/**
+ * Domain/social verification attestations (`Attestation` accounts, #7379) —
+ * read WITH the universal staleness rule from docs/record-trust.md
+ * structurally enforced, plus instruction builders for `set_attestor` /
+ * `create_attestation` / `close_attestation`.
+ *
+ * Hand-rolled like the rest of this package — no Anchor client, no
+ * `@solana/web3.js` import (it stays an optional peer). Builders return the
+ * transport-neutral {@link BuiltInstruction} `delegate.ts` defines; PDAs are
+ * NOT derived here (see delegate.ts's module docs for why — derive
+ * `["attestation", handlePda, kindByte]` / `["attestor_config"]` with your
+ * runtime's canonical `findProgramAddress`).
+ *
+ * # What an attestation proves — and, honestly, what it does not
+ *
+ * An `Attestation` proves exactly one statement: **"the key configured in
+ * `AttestorConfig` — the x1id review process — attested this evidence at
+ * time `attestedAt`."** It is NOT a trustless proof of domain or social
+ * control: the verification (DNS lookup, social-post check, human review)
+ * happens OFF-chain, and the chain records only that the attestor key signed
+ * off on it. That key is admin-rotatable, so the trust anchor is "whoever
+ * the registry admin currently designates" — rotatable-key trust, not
+ * trustlessness. Consumers needing stronger guarantees must not render an
+ * attestation as more than it is.
+ *
+ * # Verified = ONE live attestation of EITHER kind
+ *
+ * Per the #7145 decision (a single strong signal is enough — requiring two
+ * would reject Nike proving control of nike.com), a handle is "verified"
+ * when at least one NON-STALE attestation of either kind exists; `kind`
+ * records which signal proved it. {@link isHandleVerified} implements
+ * exactly this.
+ *
+ * # Why every function here demands `registeredAt` — epoch-bound, no TTL
+ *
+ * Attestations do not expire on a timer (owner decision 2026-09-03); they
+ * are invalidated by OWNERSHIP EPOCH. A `Handle`'s address is
+ * `["handle", name]` — a pure function of the name — so release +
+ * re-register lands the new registration at the SAME pubkey, and the
+ * previous owner's attestation is physically attached to the new owner's
+ * name with no action by anyone. The mandatory read-side rule
+ * (docs/record-trust.md, the universal rule):
+ *
+ *     attestation.attested_at >= handle.registered_at
+ *
+ * An attestation that fails it belongs to a previous, unrelated owner and
+ * must never be rendered as verifying the current one. Like `records.ts`,
+ * there is deliberately no way to decode or fetch an attestation through
+ * this module without the handle's `registered_at` in hand. (The one
+ * documented blind spot is shared with `Handle.owner`/`Primary`/
+ * `RecordDelegate`: a bearer-NFT marketplace trade bumps no epoch, so the
+ * attestation keeps reading live until the attestor re-reviews or revokes.)
+ */
+import { encodeBase58 } from "./base58.js";
+import { decodeBase58_32 } from "./base58.js";
+/** Seed prefix of an attestation PDA: `["attestation", handlePda, kindByte]`. */
+export const ATTESTATION_SEED = "attestation";
+/** Seed of the attestor-config singleton PDA: `["attestor_config"]`. */
+export const ATTESTOR_CONFIG_SEED = "attestor_config";
+/** `Attestation.kind` — domain control proven (DNS TXT challenge). */
+export const ATTESTATION_KIND_DNS = 0;
+/** `Attestation.kind` — social-account control proven. */
+export const ATTESTATION_KIND_SOCIAL = 1;
+/** Anchor account discriminator: `sha256("account:Attestation")[0..8]`.
+ *  Pinned (this SDK is zero-dependency and cannot assume WebCrypto SHA-256
+ *  everywhere it runs); asserted against a re-derivation in the test suite
+ *  so a typo can never silently pass. */
+export const ATTESTATION_DISCRIMINATOR = Uint8Array.from([
+    152, 125, 183, 86, 36, 146, 121, 73,
+]);
+/** Anchor account discriminator: `sha256("account:AttestorConfig")[0..8]`. */
+export const ATTESTOR_CONFIG_DISCRIMINATOR = Uint8Array.from([
+    72, 128, 1, 99, 238, 231, 80, 72,
+]);
+/** Anchor instruction discriminator: `sha256("global:set_attestor")[0..8]`. */
+export const SET_ATTESTOR_DISCRIMINATOR = Uint8Array.from([
+    95, 11, 236, 157, 234, 146, 163, 237,
+]);
+/** Anchor instruction discriminator: `sha256("global:create_attestation")[0..8]`. */
+export const CREATE_ATTESTATION_DISCRIMINATOR = Uint8Array.from([
+    49, 24, 67, 80, 12, 249, 96, 239,
+]);
+/** Anchor instruction discriminator: `sha256("global:close_attestation")[0..8]`. */
+export const CLOSE_ATTESTATION_DISCRIMINATOR = Uint8Array.from([
+    249, 84, 133, 23, 48, 175, 252, 221,
+]);
+/** `Attestation` account size — every field is fixed-width, so unlike a
+ *  `Handle` the account is exactly this long:
+ *  disc(8) + handle(32) + kind(1) + evidence_hash(32) + attested_at(8)
+ *  + attestor(32) + bump(1). */
+export const ATTESTATION_LEN = 114;
+/** `AttestorConfig` account size: disc(8) + attestor(32) + bump(1). */
+export const ATTESTOR_CONFIG_LEN = 41;
+/** Byte offset of `handle` within an Attestation account. */
+const ATTESTATION_HANDLE_OFFSET = 8;
+const SYSTEM_PROGRAM = "11111111111111111111111111111111";
+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) {
+    // Round-trip through bytes so a non-canonical base58 spelling and a byte
+    // input both come out identically.
+    return encodeBase58(toBytes32(v, what));
+}
+/** Which verification signal an attestation `kind` byte names, or null for a
+ *  kind this SDK does not know (future program versions may add kinds). */
+export function attestationKindName(kind) {
+    if (kind === ATTESTATION_KIND_DNS)
+        return "dns";
+    if (kind === ATTESTATION_KIND_SOCIAL)
+        return "social";
+    return null;
+}
+/**
+ * Decode one Attestation account.
+ *
+ * `registeredAt` is the owning Handle's `registered_at`, decoded by the
+ * caller from the Handle account — it decides `stale`. There is
+ * intentionally no overload without it (see the module docs).
+ *
+ * Returns null for anything that is not an Attestation: wrong length or
+ * wrong discriminator.
+ */
+export function decodeAttestation(raw, account, registeredAt) {
+    if (raw.length !== ATTESTATION_LEN)
+        return null;
+    for (let i = 0; i < 8; i++) {
+        if (raw[i] !== ATTESTATION_DISCRIMINATOR[i])
+            return null;
+    }
+    const dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+    let o = 8;
+    const handle = encodeBase58(raw.slice(o, o + 32));
+    o += 32;
+    const kind = raw[o];
+    o += 1;
+    const evidenceHash = raw.slice(o, o + 32);
+    o += 32;
+    const attestedAt = dv.getBigInt64(o, true);
+    o += 8;
+    const attestor = encodeBase58(raw.slice(o, o + 32));
+    return {
+        account,
+        handle,
+        kind,
+        kindName: attestationKindName(kind),
+        evidenceHash,
+        attestedAt,
+        attestor,
+        stale: attestedAt < registeredAt,
+    };
+}
+/** The attestations that vouch for the CURRENT owner — `stale` ones
+ *  excluded. This is the list to judge verification from. */
+export function liveAttestations(attestations) {
+    return attestations.filter((a) => !a.stale);
+}
+/**
+ * The #7145 verified rule: a handle is verified when at least ONE non-stale
+ * attestation of EITHER kind exists (a single strong signal is enough; the
+ * surviving `kindName`s say which signals proved it).
+ */
+export function isHandleVerified(attestations) {
+    return attestations.some((a) => !a.stale);
+}
+/**
+ * Fetch every Attestation account of a handle — one `getProgramAccounts`
+ * call, filtered by the RPC on size (114), the Attestation discriminator at
+ * offset 0 and the handle pubkey at offset 8, then every byte re-checked
+ * locally (the node's filters are an optimisation, never the guarantee) —
+ * the exact shape of `fetchRecords`. Scoping the scan to the registry
+ * program id also IS the ownership check.
+ *
+ * `registeredAt` is `Handle.registered_at` as decoded from the Handle
+ * account the caller already has — the staleness rule needs it, and there
+ * is no variant of this function without it. Every attestation is returned,
+ * stale ones flagged, so an owner surface can show what a previous
+ * registration left behind; anything that renders a verified badge takes
+ * {@link isHandleVerified} / {@link liveAttestations}.
+ */
+export async function fetchAttestations(rpc, programId, handleAccount, registeredAt) {
+    const res = (await rpc("getProgramAccounts", [
+        programId,
+        {
+            encoding: "base64",
+            commitment: "confirmed",
+            filters: [
+                { dataSize: ATTESTATION_LEN },
+                { memcmp: { offset: 0, bytes: encodeBase58(ATTESTATION_DISCRIMINATOR) } },
+                { memcmp: { offset: ATTESTATION_HANDLE_OFFSET, bytes: handleAccount } },
+            ],
+        },
+    ]));
+    const out = [];
+    for (const a of res ?? []) {
+        const bin = atob(a.account.data[0]);
+        const raw = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; i++)
+            raw[i] = bin.charCodeAt(i);
+        const decoded = decodeAttestation(raw, a.pubkey, registeredAt);
+        // Defence in depth: the memcmp filter should guarantee the handle
+        // match, but a wrong offset would silently attribute someone else's
+        // attestation to this handle. A malformed account is skipped, not fatal.
+        if (decoded && decoded.handle === handleAccount)
+            out.push(decoded);
+    }
+    out.sort((x, y) => x.kind - y.kind);
+    return out;
+}
+/**
+ * Build `set_attestor` — admin-only: initialize or rotate the attestor key.
+ * Rotation does not void existing attestations (they record their signer as
+ * a historical fact); revoking a bad key's output is `close_attestation`.
+ */
+export function buildSetAttestorIx(p) {
+    const data = new Uint8Array(8 + 32);
+    data.set(SET_ATTESTOR_DISCRIMINATOR, 0);
+    data.set(toBytes32(p.attestor, "attestor"), 8);
+    const keys = [
+        { pubkey: toBase58(p.admin, "admin"), isSigner: true, isWritable: true },
+        { pubkey: toBase58(p.config, "config"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.attestorConfig, "attestorConfig"), isSigner: false, isWritable: true },
+        { pubkey: SYSTEM_PROGRAM, isSigner: false, isWritable: false },
+    ];
+    return { programId: toBase58(p.programId, "programId"), keys, data };
+}
+/**
+ * Build `create_attestation` — attestor-only: stamp (or re-stamp,
+ * re-deriving `attested_at` from the Clock and replacing the evidence hash)
+ * the (handle, kind) attestation.
+ */
+export function buildCreateAttestationIx(p) {
+    if (!Number.isInteger(p.kind) || p.kind < 0 || p.kind > 1) {
+        throw new Error("kind must be 0 (dns) or 1 (social)");
+    }
+    if (p.evidenceHash.length !== 32) {
+        throw new Error("evidenceHash must be exactly 32 bytes (a sha256 digest)");
+    }
+    const data = new Uint8Array(8 + 1 + 32);
+    data.set(CREATE_ATTESTATION_DISCRIMINATOR, 0);
+    data[8] = p.kind;
+    data.set(p.evidenceHash, 9);
+    const keys = [
+        { pubkey: toBase58(p.attestor, "attestor"), isSigner: true, isWritable: true },
+        { pubkey: toBase58(p.attestorConfig, "attestorConfig"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.handle, "handle"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.attestation, "attestation"), isSigner: false, isWritable: true },
+        { pubkey: SYSTEM_PROGRAM, isSigner: false, isWritable: false },
+    ];
+    return { programId: toBase58(p.programId, "programId"), keys, data };
+}
+/**
+ * Build `close_attestation` — revoke: close the account, rent to
+ * `recipient`. Attestor- or admin-signed (the admin path is the cleanup for
+ * a rotated-away key's output).
+ */
+export function buildCloseAttestationIx(p) {
+    const keys = [
+        { pubkey: toBase58(p.signer, "signer"), isSigner: true, isWritable: false },
+        { pubkey: toBase58(p.config, "config"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.attestorConfig, "attestorConfig"), isSigner: false, isWritable: false },
+        { pubkey: toBase58(p.attestation, "attestation"), isSigner: false, isWritable: true },
+        { pubkey: toBase58(p.recipient, "recipient"), isSigner: false, isWritable: true },
+    ];
+    return {
+        programId: toBase58(p.programId, "programId"),
+        keys,
+        data: CLOSE_ATTESTATION_DISCRIMINATOR.slice(),
+    };
+}