@verify-network/protocol 0.0.0-stage → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,708 @@
+import { HASH_TO_CURVE_MAX_ITERATIONS, Proof, PublicKey, SENTINEL_PROOF, decodeProof, deriveRandomness, encodeProof, hashToCurveIterations, isFulfillable, isSentinel, proofCommitment, prove, publicKeyPoint, verify } from "./ecvrf.js";
+import { t as RouterDomain } from "./domain-CXJsoNRU.js";
+import { MAX_CALLBACK_DATA_BYTES, Request as Request$1, SERVICE_VRF, STALE_DELAY, isLate, remainingDelay, requestId, staleAt } from "./request.js";
+import { EventLog, decodeRandomnessFulfilled, decodeRandomnessRequested, randomnessFulfilledEvent, randomnessRequestedEvent } from "./event.js";
+import { CALLDATA_GAS_PER_BYTE, DEFAULT_FEE_FLOOR, GasFees, INTRINSIC_GAS, PremiumShare, WHOLE_PREMIUM, ceiling, chargedGas, computeFees, fee, fulfillmentItemGas, lockedGasPrice, premiumShare, settlement, settlementAtShare } from "./fee.js";
+import { fulfillmentDigest, fulfillmentTypedData } from "./fulfillment.js";
+import { Address as Address$1, Hex, LocalAccount, PublicClient } from "viem";
+import { Duration, Effect, Option, Result, Schema, Scope } from "effect";
+import { Socket } from "effect/socket";
+//#region src/attestation.d.ts
+/** A PCR as the Nitro verifier's ABI splits its 48 bytes: 32, then 16 (`Bytes48` in `INitroEnclaveVerifier.sol`). */
+type Bytes48 = {
+  readonly first: Hex;
+  readonly second: Hex;
+};
+/** Splits a 48-byte PCR the way the Nitro verifier takes it. */
+export declare const bytes48: (pcr: Hex) => Bytes48;
+/**
+ * Mirrors `NitroAttestationVerifier._hasExpectedNonce`, the Nitro verifier's check: the nonce an
+ * enclave must put in its attestation for this operator to register this key on this router
+ * before the deadline (seconds since the epoch), so an attestation registers nowhere else.
+ */
+export declare const registrationNonce: ({ chainId, router, operator, publicKey, deadline }: RouterDomain & {
+  readonly operator: Address$1;
+  readonly publicKey: PublicKey;
+  readonly deadline: bigint;
+}) => Hex;
+/**
+ * The attestation `registerNode` takes when the Nitro verifier is configured: the SP1 journal
+ * and proof of the enclave's attestation document, and the deadline its nonce was bound to, as
+ * `NitroAttestationVerifier.EnclaveRegistrationProof`.
+ */
+export declare const encodeAttestation: ({ journal, proof, deadline }: {
+  readonly journal: Hex;
+  readonly proof: Hex;
+  readonly deadline: bigint;
+}) => Hex;
+//#endregion
+//#region src/directApi.d.ts
+/**
+ * `POST /direct`: the authorization as the signer signed it (`DirectRequest`, whose numbers are
+ * decimal strings in JSON, as `GET /` spells the public key) and the signer's signature over it.
+ */
+export declare const DirectRequestBody: Schema.Struct<{
+  readonly consumer: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly node: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly nonce: Schema.BigInt;
+  readonly deadline: Schema.BigInt;
+  readonly callbackGasLimit: Schema.Number;
+  readonly maxGasPrice: Schema.BigInt;
+  readonly callbackData: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly signature: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+}>;
+export type DirectRequestBody = typeof DirectRequestBody.Type;
+/**
+ * What `POST /direct` returns once the node's source has seen the fulfillment land: the id, the
+ * randomness the consumer received, the evidence a challenge takes, and the transaction.
+ */
+export declare const DirectResponse: Schema.Struct<{
+  readonly requestId: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly randomness: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly proof: Schema.Tuple<readonly [Schema.BigInt, Schema.BigInt, Schema.BigInt, Schema.BigInt]>;
+  readonly enclaveSignature: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly hash: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+}>;
+export type DirectResponse = typeof DirectResponse.Type;
+/**
+ * `GET /` as a signer reads it: the node the endpoint serves and its public key. The enclave's
+ * status carries more (the chain, the runtime's counters); a client needs these two to know the
+ * endpoint is the node's the router named, and which key its proofs verify under.
+ */
+export declare const NodeIdentity: Schema.Struct<{
+  readonly node: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly publicKey: Schema.Tuple<readonly [Schema.BigInt, Schema.BigInt]>;
+}>;
+export type NodeIdentity = typeof NodeIdentity.Type;
+declare const DirectRequestRefused_base: Schema.Class<DirectRequestRefused, Schema.TaggedStruct<"DirectRequestRefused", {
+  readonly reason: Schema.Literals<readonly ["too-long", "wrong-node", "deadline", "max-gas-price", "callback-gas-limit", "bad-signature", "unfulfillable", "insufficient-balance"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A 400: why `POST /direct` refused an authorization, cheapest check first (ADR 0026, 0028):
+ * the callback data is over the router's cap; the named node is another; the deadline has
+ * passed or is past the horizon; the maximum gas price is under what the sender would bid now;
+ * the callback gas limit is over the router's maximum; the signer's signature recovers nobody;
+ * the id has no curve point under the enclave key, so the signer picks another nonce; or the
+ * signer's balance does not cover the ceiling.
+ */
+export declare class DirectRequestRefused extends DirectRequestRefused_base {}
+declare const NonceTaken_base: Schema.Class<NonceTaken, Schema.TaggedStruct<"NonceTaken", {
+  readonly signer: Schema.String;
+  readonly nonce: Schema.BigInt;
+}>, import("effect/Cause").YieldableError>;
+/** A 409: this node already took up, or saw land, an authorization under `signer` and `nonce`. */
+export declare class NonceTaken extends NonceTaken_base {}
+declare const TooManyRequests_base: Schema.Class<TooManyRequests, Schema.TaggedStruct<"TooManyRequests", {
+  readonly reason: Schema.Literals<readonly ["in-flight", "signer", "ip", "edge"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A 429: the node is past a bound (as many direct requests in flight as it takes at once, as
+ * many under this signer, or a block on the caller's address for the incorrect authorizations it
+ * sent), or the edge in front of it refused the flood with no body of the node's. Nothing was
+ * checked or proven; the signer may try another node, or this one again later.
+ */
+export declare class TooManyRequests extends TooManyRequests_base {}
+declare const NotServing_base: Schema.Class<NotServing, Schema.TaggedStruct<"NotServing", {
+  readonly reason: Schema.Literals<readonly ["not-set-up", "not-active", "disconnected", "chain-unreachable"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A 503: the node serves no direct request right now: it is not set up; it is not in the active
+ * set (exiting, ejected, forgotten, or stopped); its request source reports no connection, so it
+ * could not see the fulfillment land; or the chain could not be read.
+ */
+export declare class NotServing extends NotServing_base {}
+declare const DeadlinePassed_base: Schema.Class<DeadlinePassed, Schema.TaggedStruct<"DeadlinePassed", {
+  readonly deadline: Schema.BigInt;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A 504: the authorization's deadline passed before the source saw the fulfillment land: it can
+ * no longer land, so the signer may make an on-chain request instead (ADR 0026).
+ */
+export declare class DeadlinePassed extends DeadlinePassed_base {}
+/** Every refusal `POST /direct` answers with, as its body spells it. */
+export declare const DirectRefusal: Schema.Union<readonly [typeof DirectRequestRefused, typeof NonceTaken, typeof TooManyRequests, typeof NotServing, typeof DeadlinePassed]>;
+export type DirectRefusal = typeof DirectRefusal.Type;
+//#endregion
+//#region src/directRequest.d.ts
+/**
+ * An authorization: what a signer signs to make a direct request (ADR 0026, 0027, 0028). The
+ * signer is not a field; the router recovers it from the signature. `node` is the one node that
+ * may fulfill it, `deadline` the last second the router takes it, `nonce` unordered and used at
+ * most once per signer, `maxGasPrice` the most the charge is priced at.
+ */
+export declare const DirectRequest: Schema.Struct<{
+  readonly consumer: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly node: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly nonce: Schema.BigInt;
+  readonly deadline: Schema.BigInt;
+  readonly callbackGasLimit: Schema.Number;
+  readonly maxGasPrice: Schema.BigInt;
+  readonly callbackData: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+}>;
+export type DirectRequest = typeof DirectRequest.Type;
+/**
+ * The typed data a signer signs, as viem's `signTypedData` takes it: the fulfillment's domain
+ * (`VerifyNetworkVRF` version 2, the chain, the router) over the `DirectRequest` struct.
+ */
+export declare const directRequestTypedData: ({ chainId, router, authorization }: RouterDomain & {
+  readonly authorization: DirectRequest;
+}) => {
+  readonly domain: {
+    readonly name: "VerifyNetworkVRF";
+    readonly version: "2";
+    readonly chainId: number | bigint;
+    readonly verifyingContract: `0x${string}`;
+  };
+  readonly types: {
+    readonly DirectRequest: readonly [{
+      readonly name: "consumer";
+      readonly type: "address";
+    }, {
+      readonly name: "node";
+      readonly type: "address";
+    }, {
+      readonly name: "nonce";
+      readonly type: "uint256";
+    }, {
+      readonly name: "deadline";
+      readonly type: "uint64";
+    }, {
+      readonly name: "callbackGasLimit";
+      readonly type: "uint32";
+    }, {
+      readonly name: "maxGasPrice";
+      readonly type: "uint256";
+    }, {
+      readonly name: "callbackData";
+      readonly type: "bytes";
+    }];
+  };
+  readonly primaryType: "DirectRequest";
+  readonly message: {
+    readonly consumer: `0x${string}`;
+    readonly node: `0x${string}`;
+    readonly nonce: bigint;
+    readonly deadline: bigint;
+    readonly callbackGasLimit: number;
+    readonly maxGasPrice: bigint;
+    readonly callbackData: `0x${string}`;
+  };
+};
+/**
+ * The authorization's EIP-712 digest, which is the direct request's id and the VRF input; the
+ * router computes the same (ticket 02) and the contracts parity test holds it to this. The domain binds the chain and the router;
+ * the type hash keeps it apart from every on-chain request id.
+ */
+export declare const directRequestId: (authorization: Parameters<typeof directRequestTypedData>[0]) => Hex;
+/**
+ * Signs an authorization with a viem account that signs locally (a private key or a session
+ * key): the strict low-`s` signature the router recovers the signer from over `directRequestId`.
+ */
+export declare const signDirectRequest: ({ account, ...input }: Parameters<typeof directRequestTypedData>[0] & {
+  readonly account: Pick<LocalAccount, "signTypedData">;
+}) => Promise<Hex>;
+/**
+ * `IDirectVrfReceiver.onDirectRandomness`: what a consumer implements to receive a direct
+ * request's randomness. A different selector from the on-chain callback, so a consumer that never
+ * opted in cannot mistake one for a request it made; `signer` is who paid and who the consumer
+ * decides about.
+ */
+export declare const onDirectRandomness: {
+  readonly name: "onDirectRandomness";
+  readonly type: 'function';
+  readonly stateMutability: "nonpayable";
+  readonly inputs: readonly [{
+    readonly type: "bytes32";
+    readonly name: "requestId";
+  }, {
+    readonly type: "address";
+    readonly name: "signer";
+  }, {
+    readonly type: "bytes32";
+    readonly name: "randomness";
+  }, {
+    readonly type: "bytes";
+    readonly name: "callbackData";
+  }];
+  readonly outputs: readonly [];
+};
+/**
+ * `VrfFacet.DirectRequestFulfilled`: emitted beside `RandomnessFulfilled` on a direct fulfillment,
+ * with the id, the signer and the node indexed. Spelled out here because the protocol package does
+ * not depend on the contracts package; the contracts package holds it to the real log once the
+ * router emits it (ticket 02 of the direct request).
+ */
+export declare const directRequestFulfilledEvent: {
+  readonly name: "DirectRequestFulfilled";
+  readonly type: 'event';
+  readonly inputs: readonly [{
+    readonly type: "bytes32";
+    readonly name: "requestId";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "signer";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "node";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "consumer";
+  }];
+};
+/**
+ * `NodesFacet.NodeEndpointSet`: an operator published or changed the endpoint a node serves
+ * direct requests at. Empty means the node serves none. Held to the real log as the event above,
+ * once the router has the setter (ticket 03).
+ */
+export declare const nodeEndpointSetEvent: {
+  readonly name: "NodeEndpointSet";
+  readonly type: 'event';
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "node";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "operator";
+    readonly indexed: true;
+  }, {
+    readonly type: "string";
+    readonly name: "endpoint";
+  }];
+};
+//#endregion
+//#region src/quote.d.ts
+/** `ConfigFacet.pricing()`: the fee parameters the admin set, which every question is priced under. */
+type Pricing = {
+  readonly premiumPercent: number;
+  readonly fulfillmentOverheadGas: number;
+  readonly fulfillmentSettlementGas: number;
+  readonly defaultCallbackGasLimit: number;
+  readonly maxCallbackGasLimit: number;
+};
+declare const RouterUnreadable_base: Schema.Class<RouterUnreadable, Schema.TaggedStruct<"RouterUnreadable", {
+  readonly operation: Schema.String;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/** The router could not be read; `operation` names the viem call. */
+export declare class RouterUnreadable extends RouterUnreadable_base {}
+/** The request being priced: its callback data's length, and its callback gas limit when not the router's default. */
+type Priced = {
+  readonly callbackDataLength: number;
+  /** The router's default when omitted. */
+  readonly callbackGasLimit?: number;
+};
+type QuoteOptions = {
+  readonly publicClient: PublicClient;
+  readonly router: Address$1;
+};
+export type Quote = {
+  readonly pricing: Pricing;
+  /**
+   * The fees the node's sender would bid now: twice the latest base fee plus the tip, never
+   * under the floor. What an on-chain request sends with, so the router locks at most this, and
+   * what an authorization's maximum gas price must clear, since the node refuses one under its
+   * bid (ADR 0028). Read from the chain, at most every `BASE_FEE_MAX_AGE`.
+   */
+  readonly bid: Effect.Effect<GasFees, RouterUnreadable>;
+  /**
+   * The reservation an on-chain request locks when sent at `gasPrice`: the gas it reserves at
+   * that price, never below the latest base fee (ADR 0019), plus the premium. A ceiling on what
+   * the request can cost, not its price; the settlement refunds the rest.
+   */
+  readonly reservation: (input: Priced & {
+    readonly gasPrice: bigint;
+  }) => Effect.Effect<bigint, RouterUnreadable>;
+  /**
+   * The ceiling a direct request's authorization carries at `maxGasPrice`: the reservation
+   * formula at that price, which has no base-fee floor since the signer names it (ADR 0028).
+   * What the signer's balance must hold for the request to land.
+   */
+  readonly ceiling: (input: Priced & {
+    readonly maxGasPrice: bigint;
+  }) => bigint;
+  /**
+   * The charge a settlement takes of the reservation: `gasUsed` at `lockedGasPrice` plus the
+   * premium, capped by `reservation` (ADR 0019); the premium decays in a straight line from
+   * `assignedAt` (ADR 0029) to nothing once the request is late (ADR 0025), the same timing the
+   * router judges by.
+   */
+  readonly charge: (input: {
+    readonly gasUsed: bigint | number;
+    readonly lockedGasPrice: bigint;
+    readonly reservation: bigint;
+    readonly assignedAt: bigint | number;
+    readonly settledAt: bigint | number;
+  }) => bigint;
+};
+export declare const Quote: {
+  make: (args_0: QuoteOptions) => Effect.Effect<Quote, RouterUnreadable, never>;
+};
+//#endregion
+//#region src/directClient.d.ts
+/** How long an authorization is good for when the caller names no deadline. */
+export declare const DEFAULT_DEADLINE_SECONDS = 5;
+/**
+ * Headroom over the bid the node's sender would make now: the maximum gas price an
+ * authorization names by default. The charge is at the fulfillment's own gas price under it
+ * (ADR 0028), so the headroom bounds the ceiling debited and refunded, not what is paid.
+ */
+export declare const MAX_GAS_PRICE_HEADROOM = 2n;
+/** A node in the active set whose endpoint passed validation. */
+type DiscoveredNode = {
+  readonly node: Address$1;
+  readonly url: URL;
+};
+/** A node that answered `GET /` as itself, and how long the answer took. */
+type MeasuredNode = DiscoveredNode & {
+  readonly publicKey: PublicKey;
+  readonly latencyMs: number;
+};
+/**
+ * What the client posts and measures with: the global `fetch` by default, spelled as the one
+ * call it makes so a test can hand a server's handler in and a runtime's own type of `fetch`
+ * (Bun's, say) is not required of it.
+ */
+type Fetch = (input: string, init?: RequestInit) => Promise<Response>;
+declare const NoNodeServing_base: Schema.Class<NoNodeServing, Schema.TaggedStruct<"NoNodeServing", {
+  readonly active: Schema.Int;
+  readonly published: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * No node to post to: of `active` nodes, `published` had an endpoint the client trusts the shape
+ * of, and none of those answered `GET /` as itself in time.
+ */
+export declare class NoNodeServing extends NoNodeServing_base {}
+declare const SigningFailed_base: Schema.Class<SigningFailed, Schema.TaggedStruct<"SigningFailed", {
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/** The account did not sign the authorization: a wallet refused, or the key could not. */
+export declare class SigningFailed extends SigningFailed_base {}
+declare const UnexpectedResponse_base: Schema.Class<UnexpectedResponse, Schema.TaggedStruct<"UnexpectedResponse", {
+  readonly status: Schema.Int;
+  readonly body: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The node answered something `POST /direct` does not: neither a landing nor a refusal it
+ * spells, under a status that says the authorization was not taken up (a 4xx of the edge's, a
+ * landing whose body cannot be read). Not a signal to fall back on: nothing here says whether
+ * the fulfillment landed.
+ */
+export declare class UnexpectedResponse extends UnexpectedResponse_base {}
+/** What `request` fails with: the node's typed refusals, and what went wrong before or around them. */
+type RequestError = DirectRequestRefused | NonceTaken | TooManyRequests | NotServing | RouterUnreadable | SigningFailed | UnexpectedResponse;
+/** The fulfillment landed: what the node returned once its source saw it, and the authorization behind it. */
+type Landed = {
+  readonly _tag: "Landed";
+  readonly node: Address$1;
+  readonly requestId: Hex;
+  readonly authorization: DirectRequest;
+  readonly randomness: Hex;
+  readonly proof: Proof;
+  readonly enclaveSignature: Hex;
+  readonly hash: Hex;
+  /** From the post leaving to the response read, in milliseconds. */
+  readonly elapsedMs: number;
+};
+/**
+ * The deadline has passed and no fulfillment was seen to land: the node said so (504); or it
+ * could not be reached, did not answer in time, or answered a 5xx it does not spell (the edge in
+ * front of it, say), in which case the authorization may have reached it all the same; or it
+ * answered a landing for some other request's id, which says nothing about this one's (ADR
+ * 0027). Resolved only once the deadline is behind on the chain's clock, the one the router
+ * judges it by, so the fallback to an on-chain request cannot race a landing (ADR 0026).
+ */
+type NotLanded = {
+  readonly _tag: "NotLanded";
+  readonly node: Address$1;
+  readonly requestId: Hex;
+  readonly authorization: DirectRequest;
+  readonly reason: "deadline-passed" | "unreachable" | "mismatched-answer";
+  readonly elapsedMs: number;
+};
+type DirectRequestInput = {
+  readonly consumer: Address$1;
+  readonly callbackData: Hex;
+  /** The router's default when omitted. */
+  readonly callbackGasLimit?: number;
+  /** A random one whose id has a curve point when omitted. */
+  readonly nonce?: bigint;
+  /** The client's `deadlineSeconds` ahead of the chain's clock when omitted. */
+  readonly deadline?: bigint;
+  /** `MAX_GAS_PRICE_HEADROOM` over the node's bid, read from the chain, when omitted. */
+  readonly maxGasPrice?: bigint;
+  /**
+   * Who signs this one, when not the client's account: a backend serving many session keys
+   * keeps one client, and one warm connection, for all of them.
+   */
+  readonly account?: Pick<LocalAccount, "address" | "signTypedData">;
+};
+type DirectClientOptions = RouterDomain & {
+  readonly publicClient: PublicClient;
+  /** Who signs: a local key, a session key, or a wallet's account. */
+  readonly account: Pick<LocalAccount, "address" | "signTypedData">;
+  /**
+   * Post here instead of discovering a node on the router. The caller's own choice, so it is not
+   * validated: a local node in a test, or an endpoint the caller trusts by other means. The node
+   * is whatever `GET /` there reports.
+   */
+  readonly endpoint?: string;
+  /** The `fetch` to use; the global one otherwise. A test hands the enclave's handler in. */
+  readonly fetch?: Fetch;
+  /**
+   * How far ahead of the chain's clock a request's deadline is dated when the caller names none:
+   * `DEFAULT_DEADLINE_SECONDS` otherwise.
+   */
+  readonly deadlineSeconds?: number;
+};
+export type DirectClient = {
+  /** The node every request goes to: the fastest measured, kept for the client's lifetime. */
+  readonly node: MeasuredNode;
+  /** What a request costs: the pricing, and the ceiling an authorization carries (ADR 0028). */
+  readonly quote: Quote;
+  /**
+   * The maximum gas price a request names by default: the quote's bid, the one the node's
+   * sender makes and refuses an authorization under, with `MAX_GAS_PRICE_HEADROOM` over it.
+   */
+  readonly maxGasPrice: Effect.Effect<bigint, RouterUnreadable>;
+  /** `GET /` to the node, so the next request finds the connection open. Never fails. */
+  readonly warm: Effect.Effect<void>;
+  readonly request: (input: DirectRequestInput) => Effect.Effect<Landed | NotLanded, RequestError>;
+};
+/**
+ * An endpoint as the client will use it, or nothing when it is not one the client connects to:
+ * `https` only, a hostname rather than an IP literal, no credentials, no query. A trailing path
+ * is kept, with a slash after it, so the routes resolve under it. A backend that fetched an
+ * unvalidated URL from the chain would be an SSRF vector (ADR 0027).
+ */
+export declare const validateEndpoint: (endpoint: string) => URL | undefined;
+/**
+ * The active set with the endpoints the client will connect to: the router's `activeNodes`,
+ * then the endpoints in one multicall, and every endpoint that is not `https` to a hostname
+ * dropped (ADR 0027). `active` is the whole set, for telling "no node publishes an endpoint"
+ * from "no node at all".
+ */
+export declare const discoverNodes: (args_0: {
+  readonly publicClient: PublicClient;
+  readonly router: Address$1;
+}) => Effect.Effect<{
+  active: number;
+  nodes: DiscoveredNode[];
+}, RouterUnreadable, never>;
+export declare const DirectClient: {
+  connect: (options: DirectClientOptions) => Effect.Effect<DirectClient, NoNodeServing | RouterUnreadable, never>;
+};
+//#endregion
+//#region src/routerWatch.d.ts
+/** A JSON-RPC request as a text frame. */
+export declare const requestFrame: (id: number, method: string, params: ReadonlyArray<unknown>) => string;
+/** The filter of a `pendingLogs` subscription: the emitter, and the selectors of its first topic. */
+type PendingLogsFilter = {
+  readonly address: Address$1;
+  readonly topics?: ReadonlyArray<Hex | ReadonlyArray<Hex>>;
+};
+/** The `eth_subscribe` of `pendingLogs` under `filter`, as a text frame. */
+export declare const pendingLogsSubscribe: (id: number, filter: PendingLogsFilter) => string;
+/** The reply to a request of ours: the `eth_subscribe`, or anything else sent under an id. */
+export declare const SubscriptionReply: Schema.Struct<{
+  readonly id: Schema.Finite;
+  readonly result: Schema.optionalKey<Schema.String>;
+  readonly error: Schema.optionalKey<Schema.Struct<{
+    readonly code: Schema.Finite;
+    readonly message: Schema.String;
+  }>>;
+}>;
+export type SubscriptionReply = typeof SubscriptionReply.Type;
+/** A notification on a subscription; `result` is whatever the subscription carries. */
+export declare const SubscriptionNotification: Schema.Struct<{
+  readonly method: Schema.Literal<"eth_subscription">;
+  readonly params: Schema.Struct<{
+    readonly subscription: Schema.String;
+    readonly result: Schema.Unknown;
+  }>;
+}>;
+export type SubscriptionNotification = typeof SubscriptionNotification.Type;
+/** What comes down the socket: one or the other. */
+export declare const SubscriptionFrame: Schema.Union<readonly [Schema.Struct<{
+  readonly id: Schema.Finite;
+  readonly result: Schema.optionalKey<Schema.String>;
+  readonly error: Schema.optionalKey<Schema.Struct<{
+    readonly code: Schema.Finite;
+    readonly message: Schema.String;
+  }>>;
+}>, Schema.Struct<{
+  readonly method: Schema.Literal<"eth_subscription">;
+  readonly params: Schema.Struct<{
+    readonly subscription: Schema.String;
+    readonly result: Schema.Unknown;
+  }>;
+}>]>;
+export type SubscriptionFrame = typeof SubscriptionFrame.Type;
+export declare const decodeSubscriptionFrame: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Result.Result<{
+  readonly id: number;
+  readonly result?: string;
+  readonly error?: {
+    readonly code: number;
+    readonly message: string;
+  };
+} | {
+  readonly method: "eth_subscription";
+  readonly params: {
+    readonly subscription: string;
+    readonly result: unknown;
+  };
+}, Schema.SchemaError>;
+/** A log as a `pendingLogs` notification carries it, as far as anything here reads it. */
+export declare const PendingLog: Schema.Struct<{
+  readonly address: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly topics: Schema.$Array<Schema.TemplateLiteral<readonly ["0x", Schema.String]>>;
+  readonly data: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly blockNumber: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  /** Named by the endpoints that carry it; what a sender matches its own request by. */
+  readonly transactionHash: Schema.optionalKey<Schema.TemplateLiteral<readonly ["0x", Schema.String]>>;
+  readonly removed: Schema.optionalKey<Schema.Boolean>;
+}>;
+export type PendingLog = typeof PendingLog.Type;
+export declare const decodePendingLog: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Result.Result<{
+  readonly address: `0x${string}`;
+  readonly topics: readonly `0x${string}`[];
+  readonly data: `0x${string}`;
+  readonly blockNumber: `0x${string}`;
+  readonly transactionHash?: `0x${string}`;
+  readonly removed?: boolean;
+}, Schema.SchemaError>;
+/** What every observation carries, whichever event it is. */
+type Observed = {
+  readonly requestId: Hex;
+  readonly blockNumber: bigint;
+  /** The transaction the log came from, when the endpoint named one. */
+  readonly transactionHash: Hex | undefined;
+  /** `performance.now()` when the frame carrying it reached this process. */
+  readonly at: number;
+};
+/** A request the router opened, as its `RandomnessRequested` log carried it. */
+type SeenRequest = Observed & {
+  readonly event: "RandomnessRequested";
+  readonly request: Request$1;
+};
+/**
+ * A fulfillment the router accepted, as its `RandomnessFulfilled` log carried it: `requestId` is
+ * the id it closed, with the randomness delivered and the evidence a verifier takes.
+ */
+type SeenFulfillment = Observed & {
+  readonly event: "RandomnessFulfilled";
+  readonly randomness: Hex;
+  readonly proof: Proof;
+  readonly enclaveSignature: Hex;
+};
+type Seen = SeenRequest | SeenFulfillment;
+/**
+ * The observation a pending log carries, if it is one of the router's two the watch is for;
+ * `at` is when its frame arrived. A log of another emitter, another event, or one the endpoint
+ * withdrew is nothing.
+ */
+export declare const seenIn: (router: Address$1, result: unknown, at: number) => Seen | undefined;
+declare const SubscriptionRefused_base: Schema.Class<SubscriptionRefused, Schema.TaggedStruct<"SubscriptionRefused", {
+  readonly url: Schema.String;
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The endpoint refused the router's log subscription, or never confirmed it. */
+export declare class SubscriptionRefused extends SubscriptionRefused_base {
+  get message(): string;
+}
+declare const WatchEnded_base: Schema.Class<WatchEnded, Schema.TaggedStruct<"WatchEnded", {
+  readonly url: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The socket carrying the router's logs ended while something was still waiting on it. */
+export declare class WatchEnded extends WatchEnded_base {
+  get message(): string;
+}
+/** The router's logs from the confirmed subscription on. */
+type RouterWatch = {
+  /**
+   * The next observation not yet taken, in the order the frames arrived; fails once the socket
+   * has ended, so nothing waits on a connection that is gone. Each observation is taken once:
+   * two waits on the same watch split the observations between them, so waits that must each see
+   * everything take their own `branch`.
+   */
+  readonly next: Effect.Effect<Seen, WatchEnded>;
+  /**
+   * A watch of its own, seeing every observation from the moment it is taken, so any number of
+   * concurrent waits each see every log. Taken before whatever it must see is fired; scoped.
+   */
+  readonly branch: Effect.Effect<RouterWatch, never, Scope.Scope>;
+};
+type WatchOptions = {
+  /** The provider's WebSocket endpoint. */
+  readonly url: string;
+  readonly router: Address$1;
+  /** How long the endpoint has to confirm the subscription before the watch gives up on it. */
+  readonly subscribeTimeout?: Duration.Input;
+  /** How long the socket has to open. */
+  readonly openTimeout?: Duration.Input;
+};
+/**
+ * Opens the socket, subscribes to the router's request and fulfillment logs, and returns once
+ * the endpoint has confirmed the subscription, so nothing is fired at the chain before the watch
+ * meant to see it is in place. The WebSocket comes from the `Socket.WebSocketConstructor` in
+ * context (`Socket.layerWebSocketConstructorGlobal` where there is a global one). Scoped: the
+ * socket closes with the scope.
+ */
+export declare const watchRouter: (options: WatchOptions) => Effect.Effect<RouterWatch, Socket.SocketError | SubscriptionRefused | WatchEnded, Scope.Scope | Socket.WebSocketConstructor>;
+/**
+ * The next observation `match` accepts, or `None` if `timeout` passes first. Observations before
+ * it are dropped: they belong to other consumers on the same router.
+ */
+export declare const nextSeen: <A extends Seen>(watch: RouterWatch, match: (seen: Seen) => A | undefined, timeout: Duration.Input) => Effect.Effect<Option.Option<A>, WatchEnded, never>;
+/** A WebSocket class, as a browser or Node has one: what the watch is handed where no Effect runs. */
+type WebSocketConstructor = new (url: string, protocols?: string | Array<string>) => globalThis.WebSocket;
+/**
+ * The watch as callbacks, for code without Effect, through the package's `run`: opens and
+ * subscribes with `webSocket`, succeeds once the subscription is confirmed with the function
+ * that closes it, and from then on hands `onSeen` every observation until the socket ends, which
+ * `onEnded` learns of. Fails as `watchRouter` does.
+ *
+ *     const close = await run(observeRouter({ url, router, webSocket: WebSocket, onSeen }), signal);
+ */
+export declare const observeRouter: (options: WatchOptions & {
+  readonly webSocket: WebSocketConstructor;
+  readonly onSeen: (seen: Seen) => void;
+  readonly onEnded?: (ended: WatchEnded) => void;
+}) => Effect.Effect<() => undefined, Socket.SocketError | SubscriptionRefused | WatchEnded, never>;
+//#endregion
+//#region src/run.d.ts
+/**
+ * The package's one binding for code that runs no Effect: any protocol effect, as a promise.
+ * It resolves with what the effect succeeds with and rejects with the very error it fails with
+ * (the typed classes, so `instanceof` works on them). `signal` aborting interrupts the effect
+ * and rejects with the signal's reason. Effect stays beneath the package: a caller needs none.
+ *
+ *     const client = await run(DirectClient.connect(options));
+ *     const result = await run(client.request(input), signal);
+ */
+export declare const run: <A, E>(effect: Effect.Effect<A, E>, signal?: AbortSignal) => Promise<A>;
+//#endregion
+//#region src/schemas.d.ts
+/** A `0x`-prefixed hex string of any length, as viem spells quantities, data, and keys. */
+export declare const HexString: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+/** Whole bytes in hex: exactly `size` of them, or any number when no size is given. */
+export declare const hexBytes: (size?: number) => Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+export declare const Address: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+export declare const Bytes32: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+/** The schema of a `Request` (request.ts), which `request.test.ts` holds to the same type. */
+export declare const Request: Schema.Struct<{
+  readonly consumer: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly sequence: Schema.BigInt;
+  readonly fulfiller: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly assignedAt: Schema.Number;
+  readonly fee: Schema.BigInt;
+  readonly gasPrice: Schema.BigInt;
+  readonly callbackGasLimit: Schema.Number;
+  readonly callbackData: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+}>;
+export type Request = typeof Request.Type;
+//#endregion
+export { type Bytes48, CALLDATA_GAS_PER_BYTE, DEFAULT_FEE_FLOOR, type DirectClientOptions, type DirectRequestInput, type DiscoveredNode, type EventLog, type Fetch, type GasFees, HASH_TO_CURVE_MAX_ITERATIONS, INTRINSIC_GAS, type Landed, MAX_CALLBACK_DATA_BYTES, type MeasuredNode, type NotLanded, type PendingLogsFilter, type PremiumShare, type Priced, type Pricing, type Proof, type PublicKey, type QuoteOptions, type RequestError, type RouterDomain, type RouterWatch, SENTINEL_PROOF, SERVICE_VRF, STALE_DELAY, type Seen, type SeenFulfillment, type SeenRequest, WHOLE_PREMIUM, type WatchOptions, type WebSocketConstructor, ceiling, chargedGas, computeFees, decodeProof, decodeRandomnessFulfilled, decodeRandomnessRequested, deriveRandomness, encodeProof, fee, fulfillmentDigest, fulfillmentItemGas, fulfillmentTypedData, hashToCurveIterations, isFulfillable, isLate, isSentinel, lockedGasPrice, premiumShare, proofCommitment, prove, publicKeyPoint, randomnessFulfilledEvent, randomnessRequestedEvent, remainingDelay, requestId, settlement, settlementAtShare, staleAt, verify };