@origintrail-official/dkg-chain 10.0.15 → 10.0.17

package/dist/browser-wallet-rpc-policy.d.ts

@@ -0,0 +1,5 @@
+import type { BrowserWalletRpcMethod } from './chain-adapter.js';
+export type BrowserWalletReadStrategy = 'tipTransparent' | 'tipNullableTransparent' | 'stickyNullable' | 'sticky';
+/** Select failover semantics for the bounded read methods used by browser wallets. */
+export declare function classifyBrowserWalletRead(method: BrowserWalletRpcMethod, params: readonly unknown[]): BrowserWalletReadStrategy;
+//# sourceMappingURL=browser-wallet-rpc-policy.d.ts.map

package/dist/browser-wallet-rpc-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-wallet-rpc-policy.d.ts","sourceRoot":"","sources":["../src/browser-wallet-rpc-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAIjE,MAAM,MAAM,yBAAyB,GACjC,gBAAgB,GAChB,wBAAwB,GACxB,gBAAgB,GAChB,QAAQ,CAAC;AAOb,sFAAsF;AACtF,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,sBAAsB,EAC9B,MAAM,EAAE,SAAS,OAAO,EAAE,GACzB,yBAAyB,CAmB3B"}

package/dist/browser-wallet-rpc-policy.js

@@ -0,0 +1,26 @@
+const TIP_BLOCK_TAGS = new Set(['latest', 'pending', 'safe', 'finalized']);
+function assertNeverBrowserWalletMethod(method) {
+    const description = typeof method === 'string' ? method : '<non-string>';
+    throw new Error(`Unsupported browser-wallet RPC method: ${description}`);
+}
+/** Select failover semantics for the bounded read methods used by browser wallets. */
+export function classifyBrowserWalletRead(method, params) {
+    const isLatestFamilyTag = (tag) => typeof tag === 'string' && TIP_BLOCK_TAGS.has(tag);
+    switch (method) {
+        case 'eth_blockNumber':
+            return 'tipTransparent';
+        case 'eth_call':
+            return params[1] === undefined || isLatestFamilyTag(params[1])
+                ? 'tipTransparent'
+                : 'sticky';
+        case 'eth_getBlockByNumber':
+            return isLatestFamilyTag(params[0]) ? 'tipNullableTransparent' : 'stickyNullable';
+        case 'eth_getTransactionReceipt':
+        case 'eth_getTransactionByHash':
+            return 'stickyNullable';
+        case 'eth_chainId':
+            return 'sticky';
+    }
+    return assertNeverBrowserWalletMethod(method);
+}
+//# sourceMappingURL=browser-wallet-rpc-policy.js.map

package/dist/browser-wallet-rpc-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-wallet-rpc-policy.js","sourceRoot":"","sources":["../src/browser-wallet-rpc-policy.ts"],"names":[],"mappings":"AAEA,MAAM,cAAc,GAAG,IAAI,GAAG,CAAS,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;AAQnF,SAAS,8BAA8B,CAAC,MAAa;IACnD,MAAM,WAAW,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,cAAc,CAAC;IACzE,MAAM,IAAI,KAAK,CAAC,0CAA0C,WAAW,EAAE,CAAC,CAAC;AAC3E,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,yBAAyB,CACvC,MAA8B,EAC9B,MAA0B;IAE1B,MAAM,iBAAiB,GAAG,CAAC,GAAY,EAAW,EAAE,CAClD,OAAO,GAAG,KAAK,QAAQ,IAAI,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACrD,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,iBAAiB;YACpB,OAAO,gBAAgB,CAAC;QAC1B,KAAK,UAAU;YACb,OAAO,MAAM,CAAC,CAAC,CAAC,KAAK,SAAS,IAAI,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;gBAC5D,CAAC,CAAC,gBAAgB;gBAClB,CAAC,CAAC,QAAQ,CAAC;QACf,KAAK,sBAAsB;YACzB,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,wBAAwB,CAAC,CAAC,CAAC,gBAAgB,CAAC;QACpF,KAAK,2BAA2B,CAAC;QACjC,KAAK,0BAA0B;YAC7B,OAAO,gBAAgB,CAAC;QAC1B,KAAK,aAAa;YAChB,OAAO,QAAQ,CAAC;IACpB,CAAC;IACD,OAAO,8BAA8B,CAAC,MAAM,CAAC,CAAC;AAChD,CAAC"}

package/dist/chain-adapter.d.ts

@@ -1,5 +1,12 @@
+import type { RandomSamplingAvailability } from './random-sampling-availability.js';
+import type { RandomSamplingReadContextReader } from './random-sampling-read-context.js';
 import type { ethers } from 'ethers';
+import type { RpcRequestClass } from './rpc-request-transport.js';
 import type { RpcUsageWindow } from './rpc-usage.js';
+import type { ContextGraphAuthorityIndexSnapshots } from './context-graph-authority-index-snapshot.js';
+import type { ContextGraphAuthorityProjectionServedEvidence } from './context-graph-authority-index-projection.js';
+import type { ContextGraphAuthorityIndexId } from './context-graph-authority-index-id.js';
+export type { ContextGraphAuthorityIndexId } from './context-graph-authority-index-id.js';
 /**
  * The Publishing-Conviction-Account read methods the funded-wallet selector
  * needs from the conviction mixin. Declared as a shared interface so a rename or
@@ -16,12 +23,22 @@ export interface ConvictionReader {
         fresh?: boolean;
     }): Promise<ShardingTableNode[]>;
     getPublishingConvictionContracts?(): Promise<PcaContracts>;
+    /** @deprecated Use requestBrowserWalletRpc for new browser-read features. */
     requestPublishingConvictionRpc?(method: PcaRpcMethod, params?: unknown[]): Promise<unknown>;
 }
 /** Inputs for one adapter-owned, cost-aware publisher planning decision. */
 export interface PublisherPublishPlanRequest {
     contextGraphId: bigint;
+    /**
+     * @deprecated Prefer billableByteSize in new code. Kept required so callers
+     * and adapters compiled against the previous planning shape remain valid.
+     */
     effectiveByteSize: bigint;
+    /**
+     * Exact byte quantity used for token quoting and fundability checks.
+     * Publisher calls supply both names while the deprecated alias is supported.
+     */
+    billableByteSize?: bigint;
     /** Caller override. When omitted, a covering PCA may select its own lock. */
     explicitPublishEpochs?: number;
     /** Direct-spend lifetime used when no covering PCA-specific plan applies. */
@@ -29,6 +46,8 @@ export interface PublisherPublishPlanRequest {
     /** Exact signer pin for an explicit publisher address/private key. */
     publisherAddress?: string;
 }
+/** Normalize the current and deprecated planning names to one exact quantity. */
+export declare function publisherPublishPlanByteSize(request: PublisherPublishPlanRequest): bigint;
 /** Final signer-dependent values that must be fixed before publish side effects. */
 export interface PublisherPublishPlan {
     publisherAddress: string;
@@ -59,7 +78,18 @@ export interface PcaContracts {
     rpcUrls: string[];
     walletRpcUrls?: string[];
 }
-export type PcaRpcMethod = 'eth_chainId' | 'eth_call' | 'eth_getTransactionReceipt' | 'eth_getTransactionByHash' | 'eth_blockNumber' | 'eth_getBlockByNumber';
+/** Browser-safe read methods shared by the independently scoped wallet features. */
+export type BrowserWalletRpcMethod = 'eth_chainId' | 'eth_call' | 'eth_getTransactionReceipt' | 'eth_getTransactionByHash' | 'eth_blockNumber' | 'eth_getBlockByNumber';
+export type PcaRpcMethod = BrowserWalletRpcMethod;
+/** All-or-none node-identity contract surface for browser-signed key rotation. */
+export interface IdentityWalletContracts {
+    profile: string;
+    identity: string;
+    storage: string;
+    chainId: string;
+    rpcUrls: string[];
+    walletRpcUrls?: string[];
+}
 export interface IdentityProof {
     publicKey: Uint8Array;
     signature: Uint8Array;
@@ -261,10 +291,17 @@ export type CanonicalFinalizationReceiptResolution = {
  * absence.
  */
 export type PublishTransactionResolution = 
-/** Mined, successful, and carries a publish this adapter parsed. */
+/**
+ * Mined, successful, and carries a publish this adapter parsed. An adapter
+ * that established the verdict from a canonical receipt may also carry that
+ * exact receipt so same-operation consumers do not have to re-prove it.
+ * Absence preserves compatibility with adapters that cannot project the
+ * stricter receipt shape; callers must then perform their existing read.
+ */
 {
     status: 'confirmed';
     publish: OnChainPublishResult;
+    canonicalReceipt?: CanonicalFinalizationReceipt;
 }
 /** Mined with a failure receipt: proven ineffective, and permanently so. */
  | {
@@ -396,6 +433,16 @@ export interface ChainEvent {
     blockNumber: number;
     data: Record<string, unknown>;
 }
+/**
+ * A process-local, non-serializable lease over one conservative background
+ * event-scan boundary. It has no chain-head, finality or authorization
+ * meaning. Consumers must re-check `holds()` after every awaited dispatch and
+ * immediately before advancing or persisting their cursor.
+ */
+export interface EventScanHorizonLease {
+    readonly throughBlockNumber: number;
+    holds(): Promise<boolean>;
+}
 /**
  * Why an off-chain ACK signer pre-flight rejected a recovered signer.
  * Mirrors the two on-chain gates in
@@ -454,6 +501,99 @@ export interface ContextGraphOnChain {
     /** Only set if metadata was revealed on-chain. */
     description?: string;
 }
+/** Deterministic finalized authority generation used by RFC-64 policy composition. */
+/**
+ * Live (latest-block) authority for one context graph, from ONE
+ * `ContextGraphStorage.getContextGraph(uint256)` read: liveness, access policy
+ * and participant roster at a single block. Three separate reads at `latest`
+ * can straddle a deactivation or a membership change; one storage read cannot.
+ */
+export interface ContextGraphLiveAuthority {
+    readonly active: boolean;
+    readonly accessPolicy: number;
+    readonly participantAgents: readonly string[];
+}
+/**
+ * Rejection from `getContextGraphLiveAuthority` when the single read failed in
+ * a way the package does not classify as retryable - a tuple that does not
+ * decode, a revert that proves nothing about this id. Callers fall back to the
+ * three point reads, which do not share the tuple. Distinct from a nonexistent
+ * id (which resolves `null`) and from a failure classified transient, local
+ * governor saturation included (which rejects with the transport's own error
+ * and is NOT a cue to issue more reads). `cause` is the original error.
+ */
+export declare class ContextGraphLiveAuthorityUnsupportedError extends Error {
+    readonly code: "CONTEXT_GRAPH_LIVE_AUTHORITY_UNSUPPORTED";
+    constructor(detail: string, options?: {
+        cause?: unknown;
+    });
+}
+export interface ContextGraphAuthoritySnapshot {
+    readonly chainId: string;
+    readonly governanceContract: string;
+    readonly contextGraphId: string;
+    readonly owner: string;
+    readonly active: boolean;
+    readonly accessPolicy: number;
+    readonly publishPolicy: number;
+    readonly publishAuthority: string | null;
+    readonly publishAuthorityAccountId: string;
+    readonly participantAgents: readonly string[];
+    readonly nameHash: string;
+    readonly ownershipEra: string;
+    readonly policyVersion: string;
+    readonly rosterVersion: string;
+    readonly sourceBlockNumber: string;
+    readonly sourceBlockHash: string;
+}
+/**
+ * The two write-once fields committed by one finalized
+ * `ContextGraphCreated` event. This value is deliberately all-or-nothing:
+ * callers must never combine one field from the event index with the other
+ * from a later unpinned point read.
+ */
+export interface ContextGraphFinalizedCreation {
+    readonly nameHash: string;
+    readonly accessPolicy: 0 | 1;
+}
+/**
+ * Logical finalized-authority capability. Callers provide the complete target
+ * set for one operation; the chain implementation owns validation, projection,
+ * and the single finalized anchor.
+ */
+export interface ContextGraphAuthorityIndexRevisionReader {
+    /**
+     * Resolve one RFC-64 authority binding at the index's finalized anchor.
+     * This intentionally differs from the public current-state name resolver.
+     */
+    resolveFinalizedContextGraphIdByNameHash?(nameHash: string, options?: ContextGraphAuthorityReadOptions): Promise<bigint | null>;
+    /**
+     * Resolve many unique name commitments from one finalized index projection.
+     * Missing and zero-hash commitments are omitted; ambiguity fails closed.
+     */
+    resolveFinalizedContextGraphIdsByNameHashes?(nameHashes: readonly string[], options?: ContextGraphAuthorityReadOptions): Promise<ReadonlyMap<string, bigint>>;
+    /**
+     * Resolve a name commitment and its complete authority state atomically at
+     * one finalized anchor. RFC-64 consumers should prefer this over composing
+     * the single-name ID resolver with a later snapshot read.
+     */
+    resolveFinalizedContextGraphAuthoritySnapshotByNameHash?(nameHash: string, options?: ContextGraphAuthorityReadOptions): Promise<ContextGraphAuthoritySnapshot | null>;
+    /**
+     * Resolve many name commitments and their complete authority state from one
+     * finalized index projection. Missing and zero-hash commitments are omitted;
+     * ambiguity fails the whole projection closed.
+     */
+    resolveFinalizedContextGraphAuthoritySnapshotsByNameHashes?(nameHashes: readonly string[], options?: ContextGraphAuthorityReadOptions): Promise<ReadonlyMap<string, ContextGraphAuthoritySnapshot>>;
+    readContextGraphAuthorityIndexRevisions(contextGraphIds: readonly ContextGraphAuthorityIndexId[], options?: ContextGraphAuthorityReadOptions): Promise<ReadonlyMap<ContextGraphAuthorityIndexId, string>>;
+    /**
+     * Read complete authority snapshots for many graphs at one finalized anchor.
+     * Responsibility selection and immediate authority acceptance share this
+     * projection. Optional so older/custom adapters retain their point-read path.
+     */
+    readContextGraphAuthorityIndexSnapshots?(contextGraphIds: readonly ContextGraphAuthorityIndexId[], options?: ContextGraphAuthorityReadOptions): Promise<ReadonlyMap<ContextGraphAuthorityIndexId, ContextGraphAuthoritySnapshot>>;
+    /** Await the physical shared-index scans underlying detached/cancelled waiters. */
+    whenIdle(): Promise<void>;
+}
 export declare class ContextGraphChainScanPartialError extends Error {
     readonly partialResults: ContextGraphOnChain[];
     readonly scannedToBlock: number;
@@ -494,7 +634,7 @@ export type ContextGraphLegacyIncrementalScanOptions = {
 };
 export type ContextGraphChainScanOptions = ContextGraphChainListOptions | ContextGraphLegacyIncrementalScanOptions;
 /** Cursor-backed daemon ContextGraphNameRegistry scan modes. */
-export type ContextGraphRegistryScanOptions = {
+export type ContextGraphRegistryScanOptions = ({
     mode: 'incremental';
     pageBudget?: number;
 } | {
@@ -502,9 +642,38 @@ export type ContextGraphRegistryScanOptions = {
 } | {
     mode: 'seedFromCursor';
     pageBudget?: number;
-};
+} | {
+    /**
+     * Establish the daemon's live cursor at the current reorg-protected tail.
+     * Historical discovery is deliberately left to the independent repair
+     * lane so a missing/corrupt live watermark cannot delay new registrations.
+     */
+    mode: 'seedLiveTail';
+    pageBudget?: number;
+} | {
+    /**
+     * Low-priority historical integrity pass. Repair scans use a cursor and
+     * captured target that are independent from the live discovery cursor,
+     * never enter its reorg window, and resume within a logical page budget.
+     * Provider retry/failover attempts are governed independently by RPC
+     * request-class policy and may exceed the number of logical pages.
+     */
+    mode: 'repair';
+    pageBudget: number;
+    minimumIntervalMs?: number;
+}) & ChainReadOptions;
 export interface ContextGraphRegistryScanPage {
     contextGraphs: ContextGraphOnChain[];
+    /** Bounded operational progress; contains no graph identifiers. */
+    scanProgress?: Readonly<{
+        mode: ContextGraphRegistryScanOptions['mode'] | 'listAll';
+        page: number;
+        pageBudget?: number;
+        fromBlock: number;
+        toBlock: number;
+        targetBlock: number;
+        completesGeneration: boolean;
+    }>;
     ack(): Promise<void>;
 }
 export declare function buildEvmDeploymentId(input: {
@@ -516,9 +685,15 @@ export interface ContextGraphRegistryScanCursorKey {
     deploymentId: string;
     registryAddress: string;
 }
+export interface ContextGraphRegistryRepairAuditStore {
+    load(key: ContextGraphRegistryScanCursorKey): Promise<unknown>;
+    save(key: ContextGraphRegistryScanCursorKey, checkpoint: unknown): Promise<void>;
+}
 export interface ContextGraphRegistryScanCursorStore {
     load(key: ContextGraphRegistryScanCursorKey): Promise<number | undefined>;
     save(key: ContextGraphRegistryScanCursorKey, nextBlock: number): Promise<void>;
+    /** Optional grouped capability for opaque, atomically replaced repair state. */
+    repairAudit?: ContextGraphRegistryRepairAuditStore;
 }
 /**
  * Per SPEC_CG_MEMORY_MODEL: every CG is hosted by the network's sharding
@@ -1030,6 +1205,61 @@ export interface PreBroadcastSignal {
 export interface ChainReadOptions {
     signal?: AbortSignal;
 }
+/**
+ * One coherent finalized Knowledge Asset version and the immutable physical
+ * evidence that produced it. The binding fields are optional only for legacy
+ * and third-party adapters; optimizations must refuse reuse when any is absent.
+ */
+export interface KnowledgeAssetVersionSnapshot {
+    knowledgeAssetId?: bigint;
+    latestRoot: string;
+    rootCount: bigint;
+    latestAuthor: string;
+    latestPublisher: string;
+    blockNumber: number;
+    blockHash?: string;
+    knowledgeAssetStorageAddress?: string;
+    knowledgeAssetStorageGeneration?: number;
+}
+/** Options honored only by the shared live-authority read. */
+export interface ContextGraphLiveAuthorityReadOptions extends ChainReadOptions {
+    /**
+     * Explicit transport priority for this read. Only
+     * `getContextGraphLiveAuthority` consults it today, to partition its shared
+     * flights so a foreground gate read never waits behind a throttled
+     * background one. Omitted means the caller's ambient class, which is what an
+     * unshared read would have used anyway.
+     */
+    requestClass?: RpcRequestClass;
+}
+/** Options honored only by finalized Context Graph authority projections. */
+export interface ContextGraphAuthorityReadOptions extends ChainReadOptions {
+    /**
+     * Finalized Context Graph authority reads only: told how the read was
+     * answered. FOUR ways, and a consumer that assumes three will read the
+     * fourth as something it is not:
+     *
+     *  - `scan` exercised the RPC pool now.
+     *  - `cache` came from a projection still inside `chain.indexTickMs`.
+     *  - `log` was FOLDED out of the node-local chain event log's stored rows and
+     *    touched no endpoint at all. It is neither inside `chain.indexTickMs`
+     *    (its bound is `min(max(3T, 15s), 5m)` against the background tick's last
+     *    head read, not T) nor the consequence of any failure — a healthy node
+     *    answers this way in the steady state. That combination is what makes it
+     *    worth naming here: the pre-log rule "a non-scan answer is either fresh
+     *    inside T or a failure" is no longer true of this interface.
+     *  - `stale-cache` was answered DESPITE a failed refresh.
+     *
+     * ONLY `scan` and `cache` are evidence that the pool is alive. A health
+     * governor — the RFC-64 authority circuit breaker is the one that exists —
+     * needs the distinction and must default to the no-proof side, so a member
+     * added later cannot be mistaken for health by omission.
+     * {@link ContextGraphAuthorityProjectionServedEvidence} carries the full
+     * statement of each member. Every other reader ignores this and no other read
+     * reports it.
+     */
+    onContextGraphAuthorityProjectionServed?: (evidence: ContextGraphAuthorityProjectionServedEvidence) => void;
+}
 /**
  * Scalar KA state returned by
  * `DKGKnowledgeAssets.getKnowledgeAssetUpdateContext(uint256)`.
@@ -1080,6 +1310,13 @@ export interface ChainAdapter {
      * `chainId` (single in-memory deployment per process).
      */
     deploymentId: string;
+    /**
+     * Optional explicit capability for daemon-local authority-index revisions.
+     * Presence means a local index is bound; every read either returns revisions
+     * or rejects, while absence selects the caller's unsupported path.
+     */
+    readonly contextGraphAuthorityIndexRevisionReader?: ContextGraphAuthorityIndexRevisionReader;
+    readonly contextGraphAuthorityIndexSnapshots?: ContextGraphAuthorityIndexSnapshots;
     /**
      * OPTIONAL RPC-usage capability: drain the raw JSON-RPC request counts
      * accumulated since the previous drain (a DELTA window — summing drains over
@@ -1199,6 +1436,12 @@ export interface ChainAdapter {
      */
     verifyPublisherOwnsRange?(publisherAddress: string, startKAId: bigint, endKAId: bigint): Promise<boolean>;
     getBlockNumber?(): Promise<number>;
+    /**
+     * Conservative, possibly lagging one-log horizon for background event
+     * polling. This is not a canonical head, finality fact, or authorization
+     * input; absence makes the poller use `getBlockNumber()` exactly as before.
+     */
+    acquireEventScanHorizonLease?(eventTypes: readonly string[]): Promise<EventScanHorizonLease | undefined>;
     listenForEvents(filter: EventFilter): AsyncIterable<ChainEvent>;
     createContextGraph(params: CreateContextGraphParams): Promise<TxResult>;
     submitToContextGraph(kaId: string, contextGraphId: string): Promise<TxResult>;
@@ -1214,6 +1457,21 @@ export interface ChainAdapter {
     scanContextGraphRegistryPages?(options: ContextGraphRegistryScanOptions): AsyncIterable<ContextGraphRegistryScanPage>;
     /** True when the adapter has a registry scan watermark for its currently bound ContextGraphNameRegistry. */
     hasContextGraphRegistryScanWatermark?(): Promise<boolean>;
+    /**
+     * Resolve one graph's current policy and roster at a stable finalized
+     * anchor. Optional for NoChain and legacy adapters; default RFC-64 callers
+     * must bind the explicit ContextGraphAuthorityReader capability instead of
+     * probing this member in individual workflows.
+     */
+    getContextGraphAuthoritySnapshot?(contextGraphId: bigint, options?: ContextGraphAuthorityReadOptions): Promise<ContextGraphAuthoritySnapshot>;
+    /**
+     * Read the immutable creation pair from one complete, current finalized
+     * authority projection. Returns `undefined` when the event index cannot
+     * prove a positive non-zero name commitment; callers then keep their
+     * existing live reads. Implementations must not cache misses or either
+     * field independently.
+     */
+    getContextGraphFinalizedCreation?(contextGraphId: bigint, options?: ContextGraphAuthorityReadOptions): Promise<ContextGraphFinalizedCreation | undefined>;
     /**
      * Live owner lookup for a PCA NFT — wraps `DKGPublishingConvictionNFT.ownerOf(accountId)`.
      * Used by the daemon's curated-CG registration preflight to populate the
@@ -1256,18 +1514,25 @@ export interface ChainAdapter {
     listDesignatableNodes?(opts?: {
         fresh?: boolean;
     }): Promise<ShardingTableNode[]>;
+    /**
+     * Independent browser bootstrap for node-identity key management. `null`
+     * means the deployment does not expose the complete Profile / Identity /
+     * IdentityStorage capability.
+     */
+    getIdentityWalletContracts?(): Promise<IdentityWalletContracts | null>;
+    /** Feature-neutral, read-only JSON-RPC bridge for browser-wallet routes. */
+    requestBrowserWalletRpc?(method: BrowserWalletRpcMethod, params?: unknown[]): Promise<unknown>;
+    /**
+     * @deprecated Use {@link requestBrowserWalletRpc}. Retained as a compatibility
+     * bridge for adapters and embedders compiled against the PCA-specific API.
+     */
+    requestPublishingConvictionRpc?(method: PcaRpcMethod, params?: unknown[]): Promise<unknown>;
     /**
      * Browser-bootstrap contract addresses + chain params for the HW signing
      * layer. The browser needs the PCA NFT address, TRAC token address, chain id,
      * and safe RPC URLs; Hub/logic/ShardingTable stay daemon-side.
     */
     getPublishingConvictionContracts?(): Promise<PcaContracts>;
-    /**
-     * Daemon-internal read-only JSON-RPC bridge used by `/api/pca/rpc`. The HTTP
-     * route owns the allowlist; adapters forward allowed reads without exposing
-     * endpoint URLs.
-     */
-    requestPublishingConvictionRpc?(method: PcaRpcMethod, params?: unknown[]): Promise<unknown>;
     /**
      * Returns the V10 NFT-backed PCA's `lockDurationEpochs` for the given
      * `accountId` — i.e. the snapshotted publishing-conviction-epochs the
@@ -1622,6 +1887,10 @@ export interface ChainAdapter {
      * check rather than only testing method presence.
      */
     isRandomSamplingReady?(): boolean;
+    /** Refresh RandomSampling bindings and read membership through one typed capability. */
+    resolveRandomSamplingAvailability?(identityId: bigint): Promise<RandomSamplingAvailability>;
+    /** Cohesive binding/epoch capability used for solved-period reuse. */
+    getRandomSamplingReadContextReader?(): RandomSamplingReadContextReader | undefined;
     /**
      * Returns the deployed address of `KnowledgeAssetsV10` on this chain.
      * Required — the publisher uses it to build the H5-prefixed publish
@@ -1637,6 +1906,20 @@ export interface ChainAdapter {
      * publisher to build the H5-prefixed publish digests.
      */
     getEvmChainId(): Promise<bigint>;
+    /**
+     * The RESOLVED `chain.finalityConfirmations` this adapter is using — the
+     * node's single definition of finality (see evm-finality-anchor.ts).
+     *
+     * Exposed because callers that hold an adapter must not re-derive the depth
+     * from a raw config they may not have. `DKGAgent` accepts a PRE-BUILT
+     * `chainAdapter`, in which case `chainConfig` is ignored entirely, so an
+     * RFC-64 precommit reading `chainConfig?.finalityConfirmations` would anchor
+     * at the default while the adapter's own authority reads honoured the
+     * operator — two anchors in one process, with no error anywhere. Optional so
+     * out-of-tree and mock adapters need not implement it; absent means "no
+     * opinion", and the caller falls back to its configured value.
+     */
+    getFinalityConfirmations?(): number;
     createKnowledgeAsset?(params: CreateKCParams): Promise<TxResult>;
     updateKnowledgeAsset?(params: UpdateKCParams): Promise<TxResult>;
     /**
@@ -1714,13 +1997,13 @@ export interface ChainAdapter {
      * The pinned height uses `chain.finalityConfirmations`: confirmation 1 is the current head,
      * and larger values pin `head - confirmations + 1`.
      */
-    readKnowledgeAssetVersionSnapshot?(kaId: bigint, options?: ChainReadOptions): Promise<{
-        latestRoot: string;
-        rootCount: bigint;
-        latestAuthor: string;
-        latestPublisher: string;
-        blockNumber: number;
-    } | null>;
+    readKnowledgeAssetVersionSnapshot?(kaId: bigint, options?: ChainReadOptions): Promise<KnowledgeAssetVersionSnapshot | null>;
+    /**
+     * Cheap lease validation for a previously-read coherent snapshot. A true
+     * result proves that the same finalized block hash and exact physical KAS
+     * binding generation are still current. Missing evidence is always false.
+     */
+    knowledgeAssetVersionSnapshotIsCurrent?(kaId: bigint, snapshot: KnowledgeAssetVersionSnapshot, options?: ChainReadOptions): Promise<boolean>;
     /**
      * Constant-cost scalar update context for a KA. Consumers that need version
      * plus sizing data should prefer this over separate root-count and leaf-count
@@ -1875,6 +2158,19 @@ export interface ChainAdapter {
      * their own fail-closed or ACK-backed fallback behavior.
      */
     isContextGraphActiveOnChain?(contextGraphId: bigint, options?: ChainReadOptions): Promise<boolean>;
+    /**
+     * One-read live authority: `active`, `accessPolicy` and `participantAgents`
+     * from `ContextGraphStorage.getContextGraph(uint256)` at `latest`.
+     *
+     * Resolves `null` ONLY when the chain proved the id nonexistent
+     * (`ERC721NonexistentToken`); callers must treat that exactly as a liveness
+     * probe returning `false` — terminal, never retried. Rejects with
+     * `ContextGraphLiveAuthorityUnsupportedError` on a deterministic failure of
+     * the single read (callers fall back to the three point reads) and with the
+     * transport's own error on a transient one. Optional, like the point reads
+     * it composes.
+     */
+    getContextGraphLiveAuthority?(contextGraphId: bigint, options?: ContextGraphLiveAuthorityReadOptions): Promise<ContextGraphLiveAuthority | null>;
     /**
      * On-chain publish policy for `contextGraphId`. Read from
      * `ContextGraphStorage.getPublishPolicy(uint256)`. Returns the
@@ -1951,6 +2247,16 @@ export interface ChainAdapter {
      * exceeds it.
      */
     resolveContextGraphIdByNameHash?(nameHash: string, options?: ChainReadOptions): Promise<bigint | null>;
+    /**
+     * Request-scoped bulk equivalent of the exact current name-hash lookup.
+     * Returns every unique lowercase bytes32 key supplied by the caller,
+     * including null for proven misses. A partial or ambiguous batch MUST reject.
+     * Absence from a returned map is never proof of non-registration.
+     * Implementations page historical creation inventory by block range and
+     * share fences across the complete input batch. They must not reuse a
+     * persistent negative snapshot for an independent call.
+     */
+    resolveContextGraphIdsByNameHashes?(nameHashes: readonly string[], options?: ChainReadOptions): Promise<ReadonlyMap<string, bigint | null>>;
 }
 /** @deprecated Use VerifyParams instead. */
 export type AddBatchToContextGraphParams = VerifyParams;