p2party 0.14.2 → 0.14.7

package/lib/blindRendezvous/pairCrypto.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Pair-bootstrap HPKE and established-flight AEAD (Section 4.11).
+ *
+ * This module owns only cryptographic sealing/opening and exact transcript
+ * binding. It deliberately does not own one-use routing-tag consumption,
+ * predecessor/dependency state, identity/admission decisions, persistence, or
+ * SDP dispatch. Those effectful gates consume this module's authenticated
+ * output and must commit their state before exposing it to WebRTC.
+ */
+import type { LibCrypto } from "../cryptography/libcrypto";
+import type { RoomPqMode } from "../roomPolicy";
+import type { OperationPayloadClassV1 } from "./operation";
+import type { PairBootstrapInfoV1, PairFlightSlotV1, PairOuterBindingV1, PairOuterPrebindingV1, PairPlaintextV1 } from "./pairPlaintext";
+import type { PairStepEnvelopeV1 } from "./pairStepEnvelope";
+export declare class PairCryptoError extends Error {
+    readonly name: string;
+    constructor(message: string);
+}
+/**
+ * A bootstrap plaintext authenticated under one HPKE info value but carrying
+ * another identity-flight kind. Recipients may classify this exact
+ * peer-authenticated protocol fault without parsing an error message.
+ */
+export declare class PairBootstrapPlaintextKindError extends PairCryptoError {
+    readonly name = "PairBootstrapPlaintextKindError";
+    constructor();
+}
+export type PairBootstrapOuterFieldsV1 = Omit<PairOuterPrebindingV1, "bootstrapHeaderHash" | "nonce">;
+export interface PairBootstrapSealOptionsV1 {
+    readonly module: LibCrypto;
+    readonly recipientHybridKemPublicKey: Uint8Array;
+    /** RoomRoot for HELLO or the validated HelloRoot for ACCEPT. */
+    readonly psk: Uint8Array;
+    readonly bootstrapInfo: PairBootstrapInfoV1;
+    readonly outerFields: PairBootstrapOuterFieldsV1;
+    readonly roomPqMode: RoomPqMode;
+    /**
+     * Called only after the HPKE header, one-use tag, and exact outer binding
+     * exist, allowing the stable identity signature to cover that binding.
+     */
+    readonly createSignedPlaintext: (binding: PairOuterBindingV1) => PairPlaintextV1 | Promise<PairPlaintextV1>;
+}
+export interface PairBootstrapSealResultV1 {
+    readonly envelope: PairStepEnvelopeV1;
+    readonly binding: PairOuterBindingV1;
+    readonly plaintext: PairPlaintextV1;
+    /**
+     * HelloRoot or AcceptRoot. The caller owns these bytes and must wipe them
+     * after deriving/persisting the next protected state.
+     */
+    readonly bootstrapRoot: Uint8Array;
+}
+/**
+ * Seal one HELLO or ACCEPT. Normal encapsulation always uses the hybrid KEM's
+ * CSPRNG path; deterministic conformance hooks are intentionally unreachable
+ * from this protocol API.
+ */
+export declare const sealPairBootstrapV1: (options: PairBootstrapSealOptionsV1) => Promise<PairBootstrapSealResultV1>;
+export interface PairBootstrapOpenOptionsV1 {
+    readonly module: LibCrypto;
+    readonly recipientHybridKemSecretKey: Uint8Array;
+    readonly psk: Uint8Array;
+    readonly bootstrapInfo: PairBootstrapInfoV1;
+    readonly prebinding: PairOuterPrebindingV1;
+    readonly envelope: PairStepEnvelopeV1;
+    readonly operationPayloadClass: OperationPayloadClassV1;
+    readonly roomPqMode: RoomPqMode;
+    /**
+     * The trusted pair-state layer verifies the stable transcript signature,
+     * identity/commitment binding, exact presences, and state-owned slot before
+     * the bootstrap root is released.
+     */
+    readonly validateAuthenticatedPlaintext: (binding: PairOuterBindingV1, plaintext: PairPlaintextV1) => void | Promise<void>;
+}
+export interface PairBootstrapOpenResultV1 {
+    readonly binding: PairOuterBindingV1;
+    readonly plaintext: PairPlaintextV1;
+    readonly bootstrapRoot: Uint8Array;
+}
+/**
+ * Try one budgeted HELLO/ACCEPT receiver key and expected info candidate.
+ *
+ * A routing-tag or HPKE authentication mismatch is `null` (not this
+ * candidate). Authenticated noncanonical/invalid pair plaintext throws and
+ * must be accounted as a rejected pair attempt by the caller.
+ */
+export declare const openPairBootstrapV1: (options: PairBootstrapOpenOptionsV1) => Promise<PairBootstrapOpenResultV1 | null>;
+export interface SealPairStepOptionsV1 {
+    readonly module: LibCrypto;
+    /** EstablishedPairRoot before promotion, one-use PqSlotSecret afterwards. */
+    readonly baseSecret: Uint8Array;
+    readonly expectedSlot: PairFlightSlotV1;
+    readonly prebinding: PairOuterPrebindingV1;
+    readonly plaintext: PairPlaintextV1;
+    readonly roomPqMode: RoomPqMode;
+}
+export interface SealPairStepResultV1 {
+    readonly envelope: PairStepEnvelopeV1;
+    readonly binding: PairOuterBindingV1;
+    readonly plaintext: PairPlaintextV1;
+}
+/** Seal one non-HPKE pair flight under the exact suite-1 DRY construction. */
+export declare const sealPairStepV1: (options: SealPairStepOptionsV1) => Promise<SealPairStepResultV1>;
+export interface OpenPairStepOptionsV1 {
+    readonly module: LibCrypto;
+    readonly baseSecret: Uint8Array;
+    /** One member of the closed candidate-slot set selected by pair state. */
+    readonly expectedSlot: PairFlightSlotV1;
+    readonly prebinding: PairOuterPrebindingV1;
+    readonly envelope: PairStepEnvelopeV1;
+    readonly operationPayloadClass: OperationPayloadClassV1;
+    readonly roomPqMode: RoomPqMode;
+}
+export interface OpenPairStepResultV1 {
+    readonly binding: PairOuterBindingV1;
+    readonly plaintext: PairPlaintextV1;
+}
+/**
+ * Try one state-selected established-flight slot. A tag/authentication
+ * mismatch is `null`; authenticated slot/body/padding disagreement throws.
+ */
+export declare const openPairStepV1: (options: OpenPairStepOptionsV1) => Promise<OpenPairStepResultV1 | null>;

package/lib/blindRendezvous/pairLedger.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Pure accepted-slot ledger for pair-private operations.
+ *
+ * This boundary starts only after pair opening has authenticated an operation
+ * and checked its state-derived inner slot. Invalid tag/AEAD trials therefore
+ * never consume a slot or routing tag here. Persistence, budgets, pair-machine
+ * state, WebRTC effects, and response publication remain outside this module.
+ *
+ * The coordinate deliberately excludes `kind`: two authenticated kinds at
+ * the same edge/endpoint/direction/sequence coordinate are a fork. Consumed
+ * routing tags and retained fork-stall evidence are projections of entries,
+ * never separately mutable state. The pair machine separately owns overall
+ * edge status, including non-fork failures and causal expiry.
+ */
+import type { PairAuthorChainPrefixEvidenceV1 } from "./coreReduce";
+import type { PairStepKindV1 } from "./pairPlaintext";
+declare const pairAcceptedSlotLedgerBrand: unique symbol;
+/** Process-local immutable ledger handle. Persist only its canonical snapshot. */
+export interface PairAcceptedSlotLedgerV1 {
+    readonly [pairAcceptedSlotLedgerBrand]: true;
+}
+export interface PairAcceptedSlotCoordinateV1 {
+    readonly pairEdgeId: Uint8Array;
+    readonly endpointPresenceOperationIds: readonly [Uint8Array, Uint8Array];
+    readonly direction: 0 | 1;
+    readonly pairSequence: bigint;
+}
+/**
+ * Structural input for the post-authentication boundary.
+ *
+ * Production pair ingress must construct this only from its opaque successful
+ * open result. This ledger owns and validates the shape but does not itself
+ * prove pair AEAD, signatures, bindings, or operation-ID derivation.
+ */
+export interface PairSlotAcceptanceCandidateV1 {
+    readonly coordinate: PairAcceptedSlotCoordinateV1;
+    readonly kind: PairStepKindV1;
+    readonly acceptedOperationId: Uint8Array;
+    readonly exactOperationBytes: Uint8Array;
+    readonly acceptedLogicalWindow: bigint;
+    readonly retainThroughLogicalWindow: bigint;
+    readonly routingTag: Uint8Array;
+    readonly authorChainPrefix: readonly PairAuthorChainPrefixEvidenceV1[];
+    readonly cachedExactResponse: Uint8Array | null;
+}
+export interface PairAcceptedSlotEntryV1 extends PairSlotAcceptanceCandidateV1 {
+    readonly version: 1;
+    /**
+     * A null cached response is durable only for a locally denied
+     * IDENTITY_HELLO or terminal PAIR_CHECKPOINT. The former still reserves its
+     * authenticated slot so a later conflicting HELLO cannot win by arrival.
+     */
+    readonly cachedExactResponse: Uint8Array | null;
+    /**
+     * Bytewise-lowest two distinct authenticated IDs observed at this
+     * coordinate. These are a bounded fork-evidence index; the validated outer
+     * operation store remains the SSOT for the referenced signed bytes.
+     */
+    readonly forkProofOperationIds: readonly [Uint8Array, Uint8Array] | null;
+}
+/** Durable, deeply owned structural representation. */
+export interface PairAcceptedSlotLedgerSnapshotV1 {
+    readonly version: 1;
+    readonly entries: readonly PairAcceptedSlotEntryV1[];
+}
+export type PairAcceptedSlotTransitionV1 = {
+    readonly result: "accepted";
+    readonly ledger: PairAcceptedSlotLedgerV1;
+} | {
+    readonly result: "replay";
+    /** Exact cached bytes are freshly owned by this result. */
+    readonly cachedExactResponse: Uint8Array | null;
+    /** Replay is a no-op and preserves handle identity. */
+    readonly ledger: PairAcceptedSlotLedgerV1;
+} | {
+    readonly result: "fork";
+    readonly forkProofOperationIds: readonly [Uint8Array, Uint8Array];
+    readonly ledger: PairAcceptedSlotLedgerV1;
+} | {
+    readonly result: "edge-stalled";
+    readonly ledger: PairAcceptedSlotLedgerV1;
+};
+/**
+ * Read-only classification at the authenticated pair-slot boundary.
+ *
+ * `unoccupied` is deliberately not called `accepted`: no durable entry or
+ * fork proof exists until `recordAcceptedPairSlotV1` succeeds.
+ */
+export type AuthenticatedPairSlotPreviewV1 = {
+    readonly result: "unoccupied";
+} | {
+    readonly result: "replay";
+    /** Exact cached bytes are freshly owned by this result. */
+    readonly cachedExactResponse: Uint8Array | null;
+} | {
+    readonly result: "fork";
+    readonly forkProofOperationIds: readonly [Uint8Array, Uint8Array];
+} | {
+    readonly result: "edge-stalled";
+};
+export declare class PairLedgerError extends Error {
+    readonly name = "PairLedgerError";
+    constructor(message: string);
+}
+/** Create the unique empty ledger value. */
+export declare const createEmptyPairAcceptedSlotLedgerV1: () => PairAcceptedSlotLedgerV1;
+/** Deep-copy the complete state for the durable transaction adapter. */
+export declare const snapshotPairAcceptedSlotLedgerV1: (ledger: PairAcceptedSlotLedgerV1) => PairAcceptedSlotLedgerSnapshotV1;
+/** Canonical durable bytes for one genuine process-local ledger. */
+export declare const encodePairAcceptedSlotLedgerV1: (ledger: PairAcceptedSlotLedgerV1) => Uint8Array;
+/**
+ * Strict structural reconstruction boundary.
+ *
+ * This restores ledger shape and invariants, not cryptographic provenance.
+ * The durable pair transaction must revalidate exact accepted operation bytes
+ * and pair state before using a restored ledger for protocol effects.
+ */
+export declare const restorePairAcceptedSlotLedgerV1: (snapshotValue: unknown) => PairAcceptedSlotLedgerV1;
+/**
+ * Strict canonical durable-byte reconstruction.
+ *
+ * This restores structural ledger invariants only. The trusted pair
+ * transaction must still revalidate the retained signed operation bytes
+ * before the restored handle can authorize protocol effects.
+ */
+export declare const decodePairAcceptedSlotLedgerV1: (encoded: Uint8Array) => PairAcceptedSlotLedgerV1;
+/**
+ * Classify one fully authenticated candidate without creating any durable
+ * entry, fork proof, consumed-tag projection, or replacement ledger handle.
+ *
+ * A new IDENTITY_HELLO may be previewed with a null cached response so the
+ * caller can run admission and construct that response. The subsequent record
+ * call revalidates the candidate and requires the exact response atomically.
+ */
+export declare const previewAuthenticatedPairSlotV1: (ledger: PairAcceptedSlotLedgerV1, candidateValue: PairSlotAcceptanceCandidateV1) => AuthenticatedPairSlotPreviewV1;
+export declare const recordAcceptedPairSlotV1: (ledger: PairAcceptedSlotLedgerV1, candidateValue: PairSlotAcceptanceCandidateV1) => PairAcceptedSlotTransitionV1;
+/**
+ * Persist a stable-signature-valid HELLO that current local policy denies.
+ *
+ * Denial sends no sensitive response, so an exact replay remains a null
+ * response. Reserving the authenticated slot is nevertheless load-bearing:
+ * a later byte-different HELLO at the same coordinate is a fork rather than
+ * an arrival-order winner. Only the trusted admission transaction may call
+ * this after its sole policy kernel returns deny.
+ */
+export declare const recordDeniedIdentityHelloSlotV1: (ledger: PairAcceptedSlotLedgerV1, candidateValue: PairSlotAcceptanceCandidateV1) => PairAcceptedSlotTransitionV1;
+/** True exactly while retained fork evidence stalls this edge. */
+export declare const pairEdgeIsStalledV1: (ledger: PairAcceptedSlotLedgerV1, pairEdgeId: Uint8Array) => boolean;
+/**
+ * Canonical unique routing-tag projection. There is intentionally no
+ * separately persisted consumed-tag collection.
+ */
+export declare const consumedPairRoutingTagsV1: (ledger: PairAcceptedSlotLedgerV1) => readonly Uint8Array[];
+export {};

package/lib/blindRendezvous/pairOpenBudget.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Pure durable pair-open work-budget reducer.
+ *
+ * The effectful transaction layer derives one charge from a genuine active
+ * PAIR_STEP, calls this reducer, compare-and-swaps the returned row together
+ * with the exact Core/pair-state revisions, and only then mints a one-use
+ * cryptographic trial capability. This module deliberately cannot authorize
+ * crypto work by itself.
+ */
+export interface PairOpenBudgetCoordinateV1 {
+    readonly localRoomId: string;
+    readonly localPresenceOperationId: Uint8Array;
+    readonly budgetLogicalWindow: bigint;
+}
+export interface PairOpenBudgetSnapshotV1 {
+    readonly version: 1;
+    readonly coordinate: PairOpenBudgetCoordinateV1;
+    readonly budgetRevision: bigint;
+    readonly reservedTrialCount: number;
+    readonly reservedEnvelopeBytes: bigint;
+    readonly saturated: boolean;
+}
+/**
+ * Higher layers derive this from an opaque active-operation handle. In
+ * particular, `completeEnvelopeBytes` is the exact validated fixed payload
+ * length and is never a transport- or caller-reported estimate.
+ */
+export interface PairOpenBudgetChargeV1 {
+    readonly localRoomId: string;
+    readonly localPresenceOperationId: Uint8Array;
+    readonly capturedReferenceWindow: bigint;
+    readonly completeEnvelopeBytes: number;
+}
+export interface PairOpenBudgetLimitsV1 {
+    readonly maxPairOpenTrialsPerPresenceWindow: number;
+    readonly maxPairOpenBytesPerPresenceWindow: number;
+}
+export type PairOpenBudgetTransitionV1 = {
+    readonly result: "prepared";
+    /** Must be durably committed before any cryptographic work begins. */
+    readonly next: PairOpenBudgetSnapshotV1;
+} | {
+    readonly result: "saturated";
+    /**
+     * Non-null on the first saturation (or a new-window reset) and must be
+     * committed. Null means the persisted row was already sticky-saturated.
+     */
+    readonly next: PairOpenBudgetSnapshotV1 | null;
+};
+export declare class PairOpenBudgetError extends Error {
+    readonly name = "PairOpenBudgetError";
+    constructor(message: string);
+}
+/**
+ * Apply one actual expensive-trial charge.
+ *
+ * Equal/older captured windows reuse the durable counters. Only a strictly
+ * newer captured Core reference window resets them, and reset plus charge is
+ * represented by one replacement row. Repeating crypto work repeats charge.
+ */
+export declare const reducePairOpenBudgetV1: (previousValue: PairOpenBudgetSnapshotV1 | null, chargeValue: PairOpenBudgetChargeV1, limitsValue: PairOpenBudgetLimitsV1) => PairOpenBudgetTransitionV1;
+/** Strictly own and validate one row read from durable storage. */
+export declare const validatePairOpenBudgetSnapshotV1: (value: unknown) => PairOpenBudgetSnapshotV1;
+/** Canonical durable bytes after complete structural and reachability checks. */
+export declare const encodePairOpenBudgetSnapshotV1: (value: unknown) => Uint8Array;
+/** Strictly restore and own one canonical durable budget row. */
+export declare const decodePairOpenBudgetSnapshotV1: (bytes: Uint8Array) => PairOpenBudgetSnapshotV1;

package/lib/blindRendezvous/pairOpenReservation.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Effectful pair-open budget reservation boundary.
+ *
+ * The pure reducer in pairOpenBudget.ts describes the next durable row. This
+ * module is the only bridge from that structural transition to permission for
+ * one expensive identity-HELLO open: it derives every coordinate and fence
+ * from opaque provenance, commits the exact row with one storage CAS, and only
+ * then mints an object-identity capability.
+ *
+ * The storage adapter treats canonical rows as opaque bytes. An IndexedDB
+ * implementation performs compare + optional replacement in one readwrite
+ * transaction over the Core, receiver-key, and budget stores and resolves
+ * "committed" only after `transaction.oncomplete`. No cryptography or other
+ * promise is awaited while that transaction is live.
+ */
+import type { ActivePairOperationCandidateV1 } from "./coreReduce";
+import type { ExpectedIdentityHelloTrialV1 } from "./identityHelloTrial";
+import type { PairOpenBudgetLimitsV1 } from "./pairOpenBudget";
+/** Storage subject shared by the Core, receiver-key, and budget lookups. */
+export interface PairOpenBudgetSubjectV1 {
+    readonly localRoomId: string;
+    readonly localPresenceOperationId: Uint8Array;
+}
+/**
+ * Exact durable budget-row state. `absent` is distinct from malformed, empty,
+ * or deleted-and-recreated bytes.
+ */
+export type ExactPairOpenBudgetRowV1 = {
+    readonly kind: "absent";
+} | {
+    readonly kind: "present";
+    readonly exactBytes: Uint8Array;
+};
+export interface PairOpenReservationCasRequestV1 {
+    readonly subject: PairOpenBudgetSubjectV1;
+    /** Exact canonical Core bytes, not only `operationsDigest` or a revision. */
+    readonly expectedExactCoreStateBytes: Uint8Array;
+    /**
+     * Exact canonical HELLO-time Core bytes identifying the complete retained
+     * historical evidence view. This may intentionally differ from the current
+     * Core fence for a delayed HELLO.
+     *
+     * The durable row selected by this fence owns the exact presence operations
+     * and author prefixes for every observed presence in that Core view. An
+     * adapter must conflict if the row or any of that complete evidence is no
+     * longer retained.
+     */
+    readonly expectedExactEvidenceCoreStateBytes: Uint8Array;
+    /**
+     * Exact revision at the subject's receiver-key row. Revisions must never be
+     * reused after replacement or retirement, so deletion cannot create ABA.
+     */
+    readonly expectedReceiverKeyRecordRevision: bigint;
+    /** Exact prior bytes (or exact absence), never revision-only equality. */
+    readonly expectedBudgetRow: ExactPairOpenBudgetRowV1;
+    readonly budgetMutation: {
+        /** A sticky saturated row is still fenced, but needs no rewrite. */
+        readonly kind: "keep";
+    } | {
+        /** Canonical prepared or newly saturated replacement bytes. */
+        readonly kind: "replace";
+        readonly exactNextBytes: Uint8Array;
+    };
+}
+export type PairOpenReservationCasResultV1 = {
+    readonly status: "committed";
+    /**
+     * Exact row visible at commit. For `keep`, this is the prior row; for
+     * `replace`, this is the replacement. The service verifies this echo.
+     */
+    readonly exactBudgetRowBytes: Uint8Array;
+} | {
+    readonly status: "conflict";
+    /**
+     * Adapters compare in this order: current Core, historical evidence
+     * view, receiver key, then budget row. The first mismatch determines
+     * this closed result.
+     */
+    readonly fence: "core" | "historical-evidence" | "receiver-key" | "budget";
+};
+/**
+ * Minimal byte-store port. Implementations own all input before retaining it
+ * and return fresh bytes; this module additionally snapshots every boundary.
+ */
+export interface PairOpenReservationStorePortV1 {
+    /**
+     * Read the one current budget row for this room/presence subject. This read
+     * need not share a transaction with the later CAS: the exact returned bytes
+     * become the CAS fence.
+     */
+    readExactBudgetRow(subject: PairOpenBudgetSubjectV1): Promise<ExactPairOpenBudgetRowV1>;
+    /**
+     * In one atomic transaction, compare exact current Core bytes, the complete
+     * exact historical-evidence view, receiver-key record revision, and exact
+     * budget row/absence, then apply the requested mutation.
+     *
+     * If physical budget keys include `budgetLogicalWindow`, a replacement that
+     * advances the window deletes the old key and writes the new key in this
+     * same transaction.
+     */
+    compareAndSwap(request: PairOpenReservationCasRequestV1): Promise<PairOpenReservationCasResultV1>;
+}
+declare const reservedIdentityHelloOpenBrand: unique symbol;
+/**
+ * One process-local permission for one already charged HELLO open.
+ *
+ * It intentionally exposes no structural fields. Spread, structured clone,
+ * persistence, or a type assertion cannot reproduce its WeakMap provenance.
+ */
+export interface ReservedIdentityHelloOpenV1 {
+    readonly [reservedIdentityHelloOpenBrand]: true;
+}
+export type ReserveIdentityHelloOpenResultV1 = {
+    readonly kind: "reserved";
+    readonly capability: ReservedIdentityHelloOpenV1;
+} | {
+    readonly kind: "saturated";
+    readonly condition: "pair-control-DoS/stalled";
+} | {
+    readonly kind: "retry";
+    readonly reason: "budget-conflict";
+} | {
+    readonly kind: "stale";
+    readonly reason: "core-changed" | "historical-evidence-changed" | "receiver-key-changed";
+};
+export interface PairOpenReservationServiceV1 {
+    /**
+     * Perform one read/reduce/CAS attempt. Budget contention is returned to the
+     * deterministic pair scheduler; this method never spins or reorders trials.
+     */
+    reserveIdentityHelloOpen(candidate: ActivePairOperationCandidateV1, trial: ExpectedIdentityHelloTrialV1): Promise<ReserveIdentityHelloOpenResultV1>;
+}
+export declare class PairOpenReservationError extends Error {
+    readonly name = "PairOpenReservationError";
+    constructor(message: string);
+}
+/**
+ * Create the trusted effectful boundary around one concrete storage adapter.
+ *
+ * The adapter and validated local resource policy are captured once; callers
+ * cannot supply a transition, charge, coordinate, fence, or commit result per
+ * trial.
+ */
+export declare const createPairOpenReservationServiceV1: (port: PairOpenReservationStorePortV1, limits: PairOpenBudgetLimitsV1) => PairOpenReservationServiceV1;
+/**
+ * Consume one exact reservation before any trial-secret transfer or KEM work.
+ *
+ * Deletion is synchronous and precedes return, so reentrancy and a second
+ * attempt cannot reuse the capability. The returned value is the opaque
+ * candidate privately stored at reservation time; the gated trial-secret
+ * transfer compares it to the candidate sealed inside the trial. No
+ * structural transition or secret-bearing snapshot is returned.
+ *
+ * @internal
+ */
+export declare const consumeReservedIdentityHelloOpenV1: (capability: ReservedIdentityHelloOpenV1, trial: ExpectedIdentityHelloTrialV1) => ActivePairOperationCandidateV1;
+export {};