@opendatalabs/personal-server-ts-core 1.34.2 → 1.35.0

package/dist/replication/copy-promotion.js

@@ -0,0 +1,126 @@
+import { encodeAbiParameters, keccak256 } from "viem";
+/**
+ * keccak256(abi.encode(string "pdpp.replica.copy.v1", bytes32[] commitments)),
+ * commitments in slot order. A manifest-carried batch has one slot: its
+ * manifest. Always recomputed locally from the verified (dataHash,
+ * metadataHash) pairs, never taken from a sender.
+ */
+export function replicaCopyKey(fragmentCommitments) {
+    return keccak256(encodeAbiParameters([{ type: "string" }, { type: "bytes32[]" }], [
+        "pdpp.replica.copy.v1",
+        fragmentCommitments.map((c) => c.toLowerCase()),
+    ])).toLowerCase();
+}
+const same = (a, b) => a.toLowerCase() === b.toLowerCase();
+/**
+ * The one copy-promotion rule (contract v2 §2 with amendments B, G and I).
+ * First matching rule wins:
+ * 1. terminal disposition or any contradiction → terminal;
+ * 2. promoted p: p missing or disproved → terminal, else reconcile_promoted;
+ * 3. more than one proven copy → terminal (needs a hash collision);
+ * 4. exactly one proven copy → promote;
+ * 5. every copy disproved and finality known → refetch, then owner at budget;
+ * 6. otherwise → wait for finality.
+ * Never arrival order, size, counter, deadline or hint. The predecessor check
+ * is the caller's precondition, not part of this decision.
+ */
+/** Completed non-matching re-downloads before the owner decides (contract F4). */
+export const REPLICA_REFETCH_BUDGET = 5;
+export function decideCopyPromotion(input) {
+    const byKey = new Map();
+    for (const copy of input.copies)
+        if (copy.validity === "valid")
+            byKey.set(copy.copyKey.toLowerCase(), {
+                ...copy,
+                copyKey: copy.copyKey.toLowerCase(),
+            });
+    const valid = [...byKey.values()].sort((a, b) => a.copyKey < b.copyKey ? -1 : a.copyKey > b.copyKey ? 1 : 0);
+    const keys = valid.map((copy) => copy.copyKey);
+    const except = (key) => keys.filter((k) => k !== key);
+    const terminal = () => ({
+        kind: "terminal",
+        reason: "finalized_conflict",
+        quarantine: keys,
+    });
+    const facts = (copy) => copy.fragmentCommitments.map((commitment, index) => [commitment, input.evidence.get(index) ?? { kind: "unknown" }]);
+    const proven = (copy) => facts(copy).every(([commitment, evidence]) => evidence.kind === "committed" &&
+        evidence.eligible &&
+        same(evidence.commitment, commitment));
+    const disproved = (copy) => facts(copy).some(([commitment, evidence]) => evidence.kind === "committed" && !same(evidence.commitment, commitment));
+    const evidence = [...input.evidence.values()];
+    if (input.disposition.state === "terminal" ||
+        evidence.some((e) => e.kind === "contradiction"))
+        return terminal();
+    if (input.disposition.state === "promoted") {
+        const promoted = byKey.get(input.disposition.copyKey.toLowerCase());
+        if (!promoted || disproved(promoted))
+            return terminal();
+        return {
+            kind: "reconcile_promoted",
+            copyKey: promoted.copyKey,
+            quarantine: except(promoted.copyKey),
+        };
+    }
+    const provenCopies = valid.filter(proven);
+    if (provenCopies.length > 1)
+        return terminal();
+    if (provenCopies.length === 1) {
+        const key = provenCopies[0].copyKey;
+        return { kind: "promote", copyKey: key, quarantine: except(key) };
+    }
+    if (valid.every(disproved) && evidence.some((e) => e.kind === "committed"))
+        return input.refetch.attempts < input.refetch.budget
+            ? { kind: "refetch", quarantine: keys }
+            : { kind: "owner", reason: "copy_conflict_unresolved", quarantine: keys };
+    return {
+        kind: "wait",
+        on: "finality",
+        quarantine: valid.length >= 2 ? keys : [],
+    };
+}
+/**
+ * The evidence of one slot from its verified fact history (amendment D).
+ * Versions append, so a currentVersion above the slot is normal. A slot's
+ * commitment is write-once, so contradiction is absorbing: two commitments
+ * for the slot, an absent fact later than a committed one, facts about two
+ * slots, one block number with two hashes, or facts from two authorities.
+ * Otherwise the fact with the highest block number decides, and among facts
+ * at that block the last observed. `facts` must be in observation order.
+ */
+export function indexEvidenceFromFacts(facts) {
+    if (!facts.length)
+        return { kind: "unknown" };
+    const authority = (f) => `${f.chainId} ${f.registry.toLowerCase()} ${f.owner.toLowerCase()}`;
+    if (new Set(facts.map(authority)).size > 1)
+        return { kind: "contradiction" };
+    if (new Set(facts.map((f) => f.version)).size > 1)
+        return { kind: "contradiction" };
+    const slot = BigInt(facts[0].version);
+    const committed = (f) => BigInt(f.currentVersion) >= slot;
+    const committedFacts = facts.filter(committed);
+    if (new Set(committedFacts.map((f) => f.commitment.toLowerCase())).size > 1)
+        return { kind: "contradiction" };
+    const hashes = new Map();
+    for (const f of facts) {
+        const seen = hashes.get(f.blockNumber);
+        if (seen !== undefined && seen !== f.blockHash.toLowerCase())
+            return { kind: "contradiction" };
+        hashes.set(f.blockNumber, f.blockHash.toLowerCase());
+    }
+    const firstCommitted = committedFacts.reduce((low, f) => low === undefined || f.blockNumber < low ? f.blockNumber : low, undefined);
+    if (firstCommitted !== undefined &&
+        facts.some((f) => !committed(f) && f.blockNumber > firstCommitted))
+        return { kind: "contradiction" };
+    // Facts arrive in observation order. At one block, a later observation
+    // supersedes: eligibility follows the live head, which can change while
+    // the finalized block does not.
+    const latest = facts.reduce((a, b) => b.blockNumber >= a.blockNumber ? b : a);
+    return committed(latest)
+        ? {
+            kind: "committed",
+            commitment: latest.commitment.toLowerCase(),
+            eligible: latest.eligible,
+        }
+        : { kind: "absent" };
+}
+//# sourceMappingURL=copy-promotion.js.map

package/dist/replication/copy-promotion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy-promotion.js","sourceRoot":"","sources":["../../src/replication/copy-promotion.ts"],"names":[],"mappings":"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"}

package/dist/replication/door.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The one-way door for replication on one device's database.
+ *
+ * Replication can be turned on once. Turning it off is permanent: a later
+ * enabled open is refused, because writes made while it was off were never
+ * captured and a peer would never see them. No data is deleted.
+ *
+ * - `never`: replication has never been enabled on this database.
+ * - `on`: enabled, and every replicated write since the first enable was
+ *   captured.
+ * - `off`: replication was enabled once and this open has it off. The door
+ *   is now closed.
+ * - `refused`: an enabled open found the door closed. The host shows
+ *   `refusal`; the store runs as if the flag were off.
+ */
+export type ReplicationDoorStatus = {
+    state: "never" | "on" | "off";
+} | {
+    state: "refused";
+    refusal: ReplicationRefusal;
+};
+/**
+ * Why an enabled open was refused. `reenable_refused`: replication was
+ * turned off after it was on, a write bypassed capture, or the database was
+ * enabled by a build that kept no record of its off periods.
+ */
+export type ReplicationRefusal = "reenable_refused";
+/** Thrown by a store asked to replicate behind a closed door. */
+export declare class ReplicationRefusedError extends Error {
+    readonly reason: ReplicationRefusal;
+    constructor(reason: ReplicationRefusal);
+}
+//# sourceMappingURL=door.d.ts.map

package/dist/replication/door.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"door.d.ts","sourceRoot":"","sources":["../../src/replication/door.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,qBAAqB,GAC7B;IAAE,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,KAAK,CAAA;CAAE,GACjC;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,kBAAkB,CAAA;CAAE,CAAC;AAEtD;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,kBAAkB,CAAC;AAEpD,iEAAiE;AACjE,qBAAa,uBAAwB,SAAQ,KAAK;aACpB,MAAM,EAAE,kBAAkB;gBAA1B,MAAM,EAAE,kBAAkB;CAIvD"}

package/dist/replication/door.js

@@ -0,0 +1,10 @@
+/** Thrown by a store asked to replicate behind a closed door. */
+export class ReplicationRefusedError extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+        this.name = "ReplicationRefusedError";
+    }
+}
+//# sourceMappingURL=door.js.map

package/dist/replication/door.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"door.js","sourceRoot":"","sources":["../../src/replication/door.ts"],"names":[],"mappings":"AA0BA,iEAAiE;AACjE,MAAM,OAAO,uBAAwB,SAAQ,KAAK;IACpB;IAA5B,YAA4B,MAA0B;QACpD,KAAK,CAAC,MAAM,CAAC,CAAC;QADY,WAAM,GAAN,MAAM,CAAoB;QAEpD,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;IACxC,CAAC;CACF"}

package/dist/replication/dpv2.d.ts

@@ -0,0 +1,141 @@
+import type { ReplicaFinalityHints } from "./finality.js";
+export { createReplicaFinalityHints } from "./finality.js";
+import { type GatewayClient } from "@opendatalabs/vana-sdk/browser";
+import { type Hex } from "viem";
+import type { BoundedStorageAdapter } from "../storage/adapters/interface.js";
+import type { DataPointFeedPort } from "../ports/index.js";
+import type { ServerSigner } from "../signing/signer.js";
+import { type PreparedFragment, type PreparedManifest } from "./transport.js";
+/** Every peer read has a finite default, including existence probes. */
+export declare const REPLICA_RECEIVE_TIMEOUT_MS = 30000;
+export interface ReplicaCommitment {
+    owner: string;
+    scope: string;
+    version: string;
+    dataHash: string;
+    metadataHash: string;
+    deleted: boolean;
+}
+/**
+ * DataRegistryV2 stores the hash-pair commitment, never its preimages.
+ * `version` is the requested slot; `commitment` is that slot's commitment,
+ * zero while `currentVersion` is below it.
+ */
+export interface ReplicaFinalizedChainEvidence {
+    owner: string;
+    scope: string;
+    version: string;
+    currentVersion: string;
+    status: "None" | "Active" | "Inactive" | "Unavailable";
+    commitment: Hex;
+    chainId: number;
+    registry: Hex;
+    blockNumber: bigint;
+    blockHash: Hex;
+    blockTimestamp: bigint;
+}
+export interface ReplicaRegistrationEvidence {
+    /** The Gateway's current head of the scope: its latest version only. */
+    head: ReplicaCommitment | null;
+    /** null means unavailable, never authoritative absence. */
+    chain: ReplicaFinalizedChainEvidence | null;
+    pending: boolean;
+}
+/** One registered slot: a writer scope at one version. */
+export interface ReplicaSlot {
+    owner: string;
+    scope: string;
+    version: number;
+    dataHash?: string;
+    metadataHash?: string;
+}
+export declare function replicaChainCommitment(dataHash: Hex, metadataHash: Hex): Hex;
+/**
+ * The carrier will not read an object: it is larger than the caller's bound,
+ * it is a compressed OpenPGP message, whose plaintext size the ciphertext
+ * does not bound, or its packets are outside the profile every writer emits,
+ * which bounds the password KDF. Writers never make any of these.
+ */
+export declare class ReplicaObjectRefused extends Error {
+    readonly cause_: "oversize" | "compressed" | "profile";
+    constructor(cause_: "oversize" | "compressed" | "profile");
+}
+/** One bounded read: stop reading and throw ReplicaObjectRefused past `maxBytes`. */
+export interface ReplicaRead {
+    maxBytes: number;
+    signal?: AbortSignal;
+}
+export interface ReplicaTransportPort {
+    /** The owner whose keys and signer this port uses. A worker refuses any other binding. */
+    owner?: string;
+    finality?: ReplicaFinalityHints;
+    encrypt(scope: string, plaintext: Uint8Array): Promise<Uint8Array>;
+    /** Exact size for this uncompressed codec, independent of content and randomness.
+     * Without this capability, aggregate attribution stays Retry rather than
+     * guessing which operations are permanently unsupported. */
+    encryptedByteLength?: (plaintextBytes: number) => number;
+    /**
+     * Refuses a message outside the writers' OpenPGP profile before its KDF
+     * runs, and a compressed message, so the plaintext is never larger than
+     * `encrypted`.
+     */
+    decrypt(scope: string, encrypted: Uint8Array): Promise<Uint8Array>;
+    /** Finalized evidence of one slot, plus the Gateway head of its scope. */
+    evidence(scope: string, version: number): Promise<ReplicaRegistrationEvidence>;
+    /** Store an unregistered fragment at its content address. */
+    putFragment(fragment: Pick<PreparedFragment, "scope" | "digest" | "encrypted">, signal?: AbortSignal): Promise<void>;
+    getFragment(scope: string, digest: string, read: ReplicaRead): Promise<Uint8Array>;
+    /** False only when storage definitively has no object at the address. */
+    hasFragment(scope: string, digest: string, signal?: AbortSignal): Promise<boolean>;
+    put(manifest: PreparedManifest, signal?: AbortSignal): Promise<void>;
+    /** The batch's single AddData registration, at version `manifest.version`. */
+    register(manifest: PreparedManifest): Promise<void>;
+    get(scope: string, version: number, read: ReplicaRead): Promise<Uint8Array>;
+    /** Owner feed page: every scope with the Gateway's latest version of it. */
+    list(cursor: string | null): Promise<{
+        points: {
+            scope: string;
+            version: string;
+        }[];
+        cursor: string | null;
+    }>;
+}
+/** SDK binary literal + AES-256 SKESKv4 / SEIPDv1, without compression or AEAD. */
+export declare function replicaOpenPgpCiphertextByteLength(plaintextBytes: number): number;
+/** Uses existing DPv2 crypto, storage keying, AddData signing and owner feed. No file-head rebase. */
+export declare function createDpv2ReplicaTransport(deps: {
+    finality?: ReplicaFinalityHints;
+    owner: `0x${string}`;
+    masterKey: Uint8Array;
+    /** Every read is bounded, so an adapter without bounded reads is refused. */
+    storage: BoundedStorageAdapter;
+    gateway: Pick<GatewayClient, "registerDataPoint">;
+    feed: DataPointFeedPort;
+    signer: Pick<ServerSigner, "signAddData">;
+    /** Host verifies a slot against a pinned finalized DataRegistryV2 commitment.
+     * SDK head-only lookup cannot implement this port. No production fallback is allowed. */
+    evidence: (scope: string, version: number) => Promise<ReplicaRegistrationEvidence>;
+}): ReplicaTransportPort;
+/**
+ * The registration state of one slot. Versions append, so a later version
+ * is normal. A finalized slot commitment never changes, so only a finalized
+ * commitment that differs from the known expected hash pair quarantines.
+ * A Gateway head can roll back and status can reactivate: both stay pending.
+ */
+export declare function replicaRegistrationState(evidence: ReplicaRegistrationEvidence, slot: ReplicaSlot): "absent" | "pending" | "confirmed" | "conflict";
+/**
+ * A finalized registration of exactly the expected commitment whose status
+ * is not Active (for example temporarily Unavailable). Status can
+ * reactivate, so this is a Wait on the chain, never a conflict or an error.
+ * A receiver that has not fetched the slot yet has no expected commitment:
+ * any finalized commitment then counts, because nothing is fetched or
+ * trusted until the status is Active again.
+ */
+export declare function replicaRegistrationInactive(evidence: ReplicaRegistrationEvidence, slot: ReplicaSlot): boolean;
+/**
+ * Expected optimistic registration of this slot, distinct from disagreements
+ * and errors: the Gateway head is at or above the slot and finality has not
+ * reached it. Only a head at exactly the slot can be checked against hashes.
+ */
+export declare function replicaAwaitingFinality(evidence: ReplicaRegistrationEvidence, slot: ReplicaSlot): boolean;
+//# sourceMappingURL=dpv2.d.ts.map

package/dist/replication/dpv2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dpv2.d.ts","sourceRoot":"","sources":["../../src/replication/dpv2.ts"],"names":[],"mappings":"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"}

package/dist/replication/dpv2.js

@@ -0,0 +1,320 @@
+export { createReplicaFinalityHints } from "./finality.js";
+import { deriveScopeKey, encryptWithPassword, } from "@opendatalabs/vana-sdk/browser";
+import { CompressedDataPacket, decrypt, enums, readMessage, SymEncryptedIntegrityProtectedDataPacket, SymEncryptedSessionKeyPacket, } from "openpgp";
+import { bytesToHex, encodeAbiParameters, keccak256, stringToHex, } from "viem";
+import { isDefinitiveNotFound } from "../storage/adapters/sdk.js";
+import { abortable } from "./coordinator.js";
+import { AdditionsBudget, AdditionsBudgetExceeded, } from "../additions/budget.js";
+import { replicaFragmentKey, replicaManifestKey, } from "./transport.js";
+const tombstoneDataHash = keccak256(stringToHex("vana.data-point.tombstone.v1"));
+/** Every peer read has a finite default, including existence probes. */
+export const REPLICA_RECEIVE_TIMEOUT_MS = 30_000;
+const tombstoneMetadataHash = keccak256(stringToHex("vana.data-point.tombstone.metadata.v1"));
+export function replicaChainCommitment(dataHash, metadataHash) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }], [dataHash, metadataHash]));
+}
+/**
+ * The carrier will not read an object: it is larger than the caller's bound,
+ * it is a compressed OpenPGP message, whose plaintext size the ciphertext
+ * does not bound, or its packets are outside the profile every writer emits,
+ * which bounds the password KDF. Writers never make any of these.
+ */
+export class ReplicaObjectRefused extends Error {
+    cause_;
+    constructor(cause_) {
+        super(`replica object refused: ${cause_}`);
+        this.cause_ = cause_;
+        this.name = "ReplicaObjectRefused";
+    }
+}
+/** SDK binary literal + AES-256 SKESKv4 / SEIPDv1, without compression or AEAD. */
+export function replicaOpenPgpCiphertextByteLength(plaintextBytes) {
+    if (!Number.isSafeInteger(plaintextBytes) ||
+        plaintextBytes < 0 ||
+        plaintextBytes > 0xffffffff - 128)
+        throw new RangeError("invalid replica plaintext length");
+    // New-format packet: tag, one/two/five length octets, then body.
+    const packet = (body) => 1 + (body < 192 ? 1 : body < 8384 ? 2 : 5) + body;
+    // 48-byte encrypted session-key packet; binary literal has a six-byte
+    // header; SEIPDv1 has version(1), CFB prefix(18), MDC header/hash(22).
+    return 48 + packet(41 + packet(6 + plaintextBytes));
+}
+/** Uses existing DPv2 crypto, storage keying, AddData signing and owner feed. No file-head rebase. */
+export function createDpv2ReplicaTransport(deps) {
+    if (typeof deps.storage.downloadBounded !== "function")
+        throw new TypeError("replication needs a storage adapter with bounded reads");
+    const password = (scope) => bytesToHex(deriveScopeKey(deps.masterKey, scope)).slice(2);
+    const fragmentUrl = (scope, digest) => deps.storage.urlForKey(replicaFragmentKey(scope, digest));
+    async function download(url, read) {
+        const timeout = AbortSignal.timeout(REPLICA_RECEIVE_TIMEOUT_MS);
+        const signal = read.signal
+            ? AbortSignal.any([read.signal, timeout])
+            : timeout;
+        let bytes;
+        // The bounded reader charges the chunks and their contiguous copy.
+        try {
+            bytes = await abortable(signal, () => deps.storage.downloadBounded(url, new AdditionsBudget(2 * read.maxBytes, undefined, signal)));
+        }
+        catch (error) {
+            signal.throwIfAborted();
+            if (error instanceof AdditionsBudgetExceeded)
+                throw new ReplicaObjectRefused("oversize");
+            throw error;
+        }
+        if (bytes.length > read.maxBytes)
+            throw new ReplicaObjectRefused("oversize");
+        return bytes;
+    }
+    return {
+        owner: deps.owner,
+        finality: deps.finality,
+        encrypt: (scope, bytes) => encryptWithPassword(bytes, password(scope)),
+        encryptedByteLength: replicaOpenPgpCiphertextByteLength,
+        decrypt: (scope, bytes) => decryptUncompressed(bytes, password(scope)),
+        evidence: deps.evidence,
+        async putFragment(fragment, signal) {
+            await deps.storage.upload(replicaFragmentKey(fragment.scope, fragment.digest), fragment.encrypted, signal);
+        },
+        getFragment: (scope, digest, read) => download(fragmentUrl(scope, digest), read),
+        async hasFragment(scope, digest, signal) {
+            try {
+                // A zero-byte bounded probe proves presence as soon as bytes arrive.
+                // StorageAdapter.exists may hide a full SDK download; never call it.
+                await download(fragmentUrl(scope, digest), { maxBytes: 0, signal });
+                return true;
+            }
+            catch (error) {
+                if (error instanceof ReplicaObjectRefused)
+                    return true;
+                if (isDefinitiveNotFound(error))
+                    return false;
+                throw error;
+            }
+        },
+        async put(manifest, signal) {
+            await deps.storage.upload(replicaManifestKey(manifest.scope, manifest.version), manifest.encrypted, signal);
+        },
+        async register(manifest) {
+            const msg = {
+                ownerAddress: deps.owner,
+                scope: manifest.scope,
+                dataHash: manifest.dataHash,
+                metadataHash: manifest.metadataHash,
+                expectedVersion: BigInt(manifest.version),
+            };
+            await deps.gateway.registerDataPoint({
+                ...msg,
+                expectedVersion: String(manifest.version),
+                signature: await deps.signer.signAddData(msg),
+            });
+        },
+        get: (scope, version, read) => download(deps.storage.urlForKey(replicaManifestKey(scope, version)), read),
+        async list(cursor) {
+            const page = await deps.feed.listDataPointsByOwner(deps.owner, cursor, {
+                includeDeleted: true,
+            });
+            // The Gateway version only says where to look. Each slot is verified
+            // against finalized evidence before anything is fetched or trusted.
+            return {
+                points: page.dataPoints.map((p) => ({
+                    scope: p.scope,
+                    version: p.expectedVersion,
+                })),
+                cursor: page.cursor,
+            };
+        },
+    };
+}
+/**
+ * The iterated S2K count byte of OpenPGP.js's default, which the SDK's
+ * `encryptWithPassword` uses: 16 MiB hashed per password attempt.
+ */
+const REPLICA_S2K_MAX_COUNT_BYTE = 224;
+/**
+ * Refuse packets outside the profile the SDK's `encryptWithPassword` emits on
+ * OpenPGP.js defaults, before decrypt runs the password KDF: exactly one v4
+ * password packet whose S2K is iterated and salted SHA-256 at no more than
+ * the default count, then one v1 integrity-protected data packet. So the KDF
+ * runs once, takes no memory parameter (Argon2 is refused) and hashes at most
+ * 16 MiB. Reading the packets runs no KDF.
+ */
+function checkReplicaProfile(packets) {
+    const [session, data, ...rest] = packets;
+    const s2k = session?.s2k;
+    if (rest.length !== 0 ||
+        !(session instanceof SymEncryptedSessionKeyPacket) ||
+        session.version !== 4 ||
+        s2k?.type !== "iterated" ||
+        s2k.algorithm !== enums.hash.sha256 ||
+        typeof s2k.c !== "number" ||
+        s2k.c > REPLICA_S2K_MAX_COUNT_BYTE ||
+        !(data instanceof SymEncryptedIntegrityProtectedDataPacket) ||
+        data.version !== 1)
+        throw new ReplicaObjectRefused("profile");
+}
+/**
+ * The SDK's password decryption inside the writers' profile, refusing
+ * compression before it inflates anything. OpenPGP 6.3 constructs the allowed
+ * class for tag 8 before it reads the packet, and wraps what `read` throws,
+ * so the refusal is a flag.
+ */
+async function decryptUncompressed(encrypted, password) {
+    let compressed = false;
+    class RefusedCompressedPacket extends CompressedDataPacket {
+        async read() {
+            compressed = true;
+            throw new Error("compressed OpenPGP packet");
+        }
+    }
+    const config = {
+        additionalAllowedPackets: [RefusedCompressedPacket],
+        maxDecompressedMessageSize: 0,
+        ignoreUnsupportedPackets: false,
+        ignoreMalformedPackets: false,
+    };
+    try {
+        const message = await readMessage({ binaryMessage: encrypted, config });
+        checkReplicaProfile(message.packets);
+        const { data } = await decrypt({
+            message,
+            passwords: [password],
+            format: "binary",
+            config,
+        });
+        if (!(data instanceof Uint8Array))
+            throw new Error("unexpected OpenPGP stream");
+        return data;
+    }
+    catch (error) {
+        if (compressed)
+            throw new ReplicaObjectRefused("compressed");
+        throw error;
+    }
+}
+const isTombstone = (head) => head.dataHash.toLowerCase() === tombstoneDataHash &&
+    head.metadataHash.toLowerCase() === tombstoneMetadataHash;
+const uintPattern = /^(0|[1-9][0-9]*)$/;
+const hashPattern = /^0x[0-9a-fA-F]{64}$/;
+const expectedCommitment = (slot) => slot.dataHash !== undefined && slot.metadataHash !== undefined
+    ? replicaChainCommitment(slot.dataHash, slot.metadataHash).toLowerCase()
+    : undefined;
+/** The chain object is for exactly this owner, scope and slot. */
+function chainFor(evidence, slot) {
+    const { chain } = evidence;
+    return chain &&
+        Number.isSafeInteger(slot.version) &&
+        slot.version >= 1 &&
+        chain.owner.toLowerCase() === slot.owner.toLowerCase() &&
+        chain.scope === slot.scope &&
+        chain.version === String(slot.version) &&
+        uintPattern.test(chain.currentVersion)
+        ? chain
+        : undefined;
+}
+/** The Gateway head is live and agrees with the slot where it can. */
+function headAgrees(head, slot, commitment) {
+    if (!head ||
+        head.owner.toLowerCase() !== slot.owner.toLowerCase() ||
+        head.scope !== slot.scope ||
+        !uintPattern.test(head.version) ||
+        head.deleted ||
+        isTombstone(head) ||
+        !hashPattern.test(head.dataHash) ||
+        !hashPattern.test(head.metadataHash))
+        return false;
+    const version = BigInt(head.version);
+    if (version < BigInt(slot.version))
+        return false;
+    // Only the latest version has a head. A later head says nothing about
+    // this slot's preimages; the finalized chain commitment binds them.
+    if (version > BigInt(slot.version))
+        return true;
+    return ((slot.dataHash === undefined ||
+        head.dataHash.toLowerCase() === slot.dataHash.toLowerCase()) &&
+        (slot.metadataHash === undefined ||
+            head.metadataHash.toLowerCase() === slot.metadataHash.toLowerCase()) &&
+        replicaChainCommitment(head.dataHash, head.metadataHash).toLowerCase() === commitment);
+}
+/**
+ * The registration state of one slot. Versions append, so a later version
+ * is normal. A finalized slot commitment never changes, so only a finalized
+ * commitment that differs from the known expected hash pair quarantines.
+ * A Gateway head can roll back and status can reactivate: both stay pending.
+ */
+export function replicaRegistrationState(evidence, slot) {
+    const chain = chainFor(evidence, slot);
+    if (!chain)
+        return "pending";
+    const current = BigInt(chain.currentVersion);
+    const version = BigInt(slot.version);
+    const expected = expectedCommitment(slot);
+    const committed = chain.commitment.toLowerCase();
+    if (current >= version && expected !== undefined && expected !== committed)
+        return "conflict";
+    if (evidence.pending)
+        return "pending";
+    if (current < version) {
+        // No finalized commitment at this slot. Absent only if the Gateway has
+        // no head at or above it either (an optimistic registration).
+        const { head } = evidence;
+        const headBelow = !head ||
+            (uintPattern.test(head.version) && BigInt(head.version) < version);
+        return headBelow &&
+            /^0x0{64}$/i.test(chain.commitment) &&
+            (current > 0n || chain.status === "None")
+            ? "absent"
+            : "pending";
+    }
+    if (chain.status !== "Active")
+        return "pending";
+    return headAgrees(evidence.head, slot, committed) ? "confirmed" : "pending";
+}
+/**
+ * A finalized registration of exactly the expected commitment whose status
+ * is not Active (for example temporarily Unavailable). Status can
+ * reactivate, so this is a Wait on the chain, never a conflict or an error.
+ * A receiver that has not fetched the slot yet has no expected commitment:
+ * any finalized commitment then counts, because nothing is fetched or
+ * trusted until the status is Active again.
+ */
+export function replicaRegistrationInactive(evidence, slot) {
+    const chain = chainFor(evidence, slot);
+    const expected = expectedCommitment(slot);
+    return (replicaRegistrationState(evidence, slot) === "pending" &&
+        !evidence.pending &&
+        chain !== undefined &&
+        BigInt(chain.currentVersion) >= BigInt(slot.version) &&
+        chain.status !== "Active" &&
+        (expected === undefined
+            ? !/^0x0{64}$/i.test(chain.commitment)
+            : expected === chain.commitment.toLowerCase()));
+}
+/**
+ * Expected optimistic registration of this slot, distinct from disagreements
+ * and errors: the Gateway head is at or above the slot and finality has not
+ * reached it. Only a head at exactly the slot can be checked against hashes.
+ */
+export function replicaAwaitingFinality(evidence, slot) {
+    const chain = chainFor(evidence, slot);
+    const { head } = evidence;
+    return (replicaRegistrationState(evidence, slot) === "pending" &&
+        chain !== undefined &&
+        BigInt(chain.currentVersion) < BigInt(slot.version) &&
+        (BigInt(chain.currentVersion) > 0n || chain.status === "None") &&
+        /^0x0{64}$/i.test(chain.commitment) &&
+        head !== null &&
+        head.owner.toLowerCase() === slot.owner.toLowerCase() &&
+        head.scope === slot.scope &&
+        uintPattern.test(head.version) &&
+        BigInt(head.version) >= BigInt(slot.version) &&
+        !head.deleted &&
+        !isTombstone(head) &&
+        hashPattern.test(head.dataHash) &&
+        hashPattern.test(head.metadataHash) &&
+        (head.version !== String(slot.version) ||
+            ((slot.dataHash === undefined ||
+                head.dataHash.toLowerCase() === slot.dataHash.toLowerCase()) &&
+                (slot.metadataHash === undefined ||
+                    head.metadataHash.toLowerCase() === slot.metadataHash.toLowerCase()))));
+}
+//# sourceMappingURL=dpv2.js.map