@coordination-network/network-member-client 0.0.1

package/types/index.d.ts

@@ -0,0 +1,550 @@
+import { Hex32, SerializedZkCredential, CredentialSigner, ApprovalResolver, ZkCredentialIssueParams } from '@coordination-network/credential';
+export { ApprovalResolver, CredentialSigner } from '@coordination-network/credential';
+import { IssuerMembershipWitness, ContractLeafReader, IssuerPublicKey } from '@coordination-network/issuer-set';
+export { ContractLeafReader, IssuerMembershipWitness } from '@coordination-network/issuer-set';
+import { buildAnnouncement, Hex, Address } from '@coordination-network/identity';
+import { RegistryLocation, NetworkMemberProof, IdentityUpdate, RevocationUpdate } from '@coordination-network/network-member-proof';
+import { Group } from '@semaphore-protocol/group';
+import { ChainDomain, RegistrationRequest } from '@coordination-network/user-client';
+export { ChainDomain, RegistrationRequest } from '@coordination-network/user-client';
+import { Address as Address$1, PublicClient, WalletClient, Transport, Chain, Account, Hex as Hex$1, SignedAuthorization, TransactionReceipt } from 'viem';
+import { Identity } from '@semaphore-protocol/identity';
+import { entryPoint08Abi } from 'viem/account-abstraction';
+
+type NetworkMemberClientErrorCode = "ISSUER_KEY_NOT_PUBLISHED" | "MEMBER_NOT_APPROVED" | "RECIPIENT_NOT_REGISTERED" | "INVALID_META_STEALTH_ADDRESS" | "INVALID_REGISTRATION_REQUEST" | "REGISTRY_UNAVAILABLE" | "GROUP_MIRROR_UNAVAILABLE" | "MEMBER_NOT_IN_GROUP" | "REGISTRATION_REJECTED" | "REVOCATION_REJECTED";
+declare class NetworkMemberClientError extends Error {
+    readonly code: NetworkMemberClientErrorCode;
+    readonly cause?: unknown;
+    constructor(code: NetworkMemberClientErrorCode, message: string, cause?: unknown);
+}
+/** A named revert from IdentityRegistry or Semaphore, walked out of a viem contract-call error. */
+declare class RegistryRevertError extends NetworkMemberClientError {
+    readonly errorName: string;
+    constructor(errorName: string, cause?: unknown);
+}
+/**
+ * A revert from CredentialRevocationRegistry, or from the revocation service or Semaphore behind
+ * it. `reason` is the decoded error name, or the raw revert data when nothing in the registry's
+ * ABI matches it: a caller retries `InvalidLowLeaf` against a re-synced mirror and gives up on
+ * `LeafAlreadyExists`, so it has to be able to tell them apart.
+ */
+declare class RevocationRevertError extends NetworkMemberClientError {
+    readonly reason: string;
+    constructor(reason: string, cause?: unknown);
+}
+
+/** issueVC's result: the signed claim-tree credential plus a fresh Merkle path into the approved-issuer set. */
+interface IssuedCredential {
+    credential: SerializedZkCredential;
+    issuerSetRoot: bigint;
+    issuerMembershipWitness: IssuerMembershipWitness;
+}
+/**
+ * Reads `IdentityRegistry.identity(networkId)`. Empty bytes on chain (unregistered) resolves to
+ * null. The method name matches the UserClient's registry-reader port so one adapter serves both.
+ */
+interface IdentityReader {
+    /** The IdentityRegistry deployment this reader targets, when the reader knows one. submitRegistration checks it against `domain`. */
+    readonly registryAddress?: Address;
+    getIdentity(networkId: Hex32): Promise<Hex | null>;
+}
+/** `buildAnnouncement`'s return shape, derived rather than restated so it can't drift. */
+type Announcement = ReturnType<typeof buildAnnouncement>;
+/** Submits a built ERC-5564 announcement on chain. */
+interface AnnouncementSubmitter {
+    announce(announcement: Announcement): Promise<Hex>;
+}
+/**
+ * deliverToStealth's result. txHash is the hash of the submitted announce transaction, not proof
+ * of inclusion: confirm it before treating the delivery as done.
+ */
+interface DeliveredToStealth {
+    stealthAddress: Address;
+    announcement: Announcement;
+    txHash: Hex;
+}
+/** The approved-member group, rebuilt fresh on every call so a proof always proves against a live root. */
+interface GroupMirror {
+    currentGroup(): Promise<Group>;
+}
+/** Produces the membership proof authorising one IdentityRegistry write. */
+interface RegistrationProver {
+    /** The IdentityRegistry deployment this proof is bound to. submitRegistration checks it against `domain`. */
+    readonly registry: RegistryLocation;
+    prove(update: IdentityUpdate): Promise<NetworkMemberProof>;
+}
+/** Produces the membership proof authorising one CredentialRevocationRegistry write. */
+interface RevocationProver {
+    /** The CredentialRevocationRegistry deployment this proof is bound to. */
+    readonly registry: RegistryLocation;
+    prove(update: RevocationUpdate): Promise<NetworkMemberProof>;
+}
+/**
+ * Facts about a sponsored registerIdentity call: what the disposable sender and the paymaster's
+ * deposit looked like before and after, so a caller can show what the paymaster actually paid.
+ */
+interface Sponsorship {
+    sender: Address;
+    senderBalanceBefore: bigint;
+    senderBalanceAfter: bigint;
+    userOpHash: Hex;
+    bundleTxHash: Hex;
+    actualGasCost: bigint;
+    paymaster: Address;
+    paymasterDepositBefore: bigint;
+    paymasterDepositAfter: bigint;
+}
+/**
+ * registerIdentity's result. txHash is the hash of the write (or, when sponsored, the bundle)
+ * transaction, not proof of inclusion: confirm it before treating the registration as done.
+ */
+interface RegistrationWrite {
+    txHash: Hex;
+    sponsorship?: Sponsorship;
+}
+/** Submits a network-member-authorised write to `IdentityRegistry`. */
+interface RegistrationWriter {
+    /** The IdentityRegistry deployment this writer targets. submitRegistration checks it against `domain`. */
+    readonly registry: RegistryLocation;
+    /** An `AlreadyRegistered` revert must surface as `RegistryRevertError`: submitRegistration's
+     *  lost-race handling keys on that one specifically. Any other revert may surface as any error. */
+    registerIdentity(networkId: Hex32, metaStealthAddress: Hex, proof: NetworkMemberProof): Promise<RegistrationWrite>;
+}
+/**
+ * revoke's result. txHash is the hash of the write (or, when sponsored, the bundle) transaction,
+ * not proof of inclusion: confirm it before treating the revocation as done.
+ */
+interface RevocationWrite {
+    txHash: Hex;
+    sponsorship?: Sponsorship;
+}
+/** Submits a network-member-authorised write to `CredentialRevocationRegistry`. */
+interface RevocationRegistryWriter {
+    /** The CredentialRevocationRegistry deployment this writer targets. */
+    readonly registry: RegistryLocation;
+    /** A revert must surface as `RevocationRevertError`: a caller has to tell a stale
+     *  `lowLeafIndex`, which it retries, from an already-revoked commitment, which it does not. */
+    revoke(commitment: bigint, lowLeafIndex: bigint, proof: NetworkMemberProof): Promise<RevocationWrite>;
+}
+/**
+ * submitRegistration's result. txHash on `submitted` is the hash of the write transaction, not
+ * proof of inclusion: confirm it before treating the registration as done.
+ */
+type SubmitRegistrationResult = {
+    status: "submitted";
+    networkId: Hex32;
+    metaStealthAddress: Hex;
+    txHash: Hex;
+    sponsorship?: Sponsorship;
+} | {
+    status: "alreadyRegistered";
+    networkId: Hex32;
+    metaStealthAddress: Hex;
+    matchesRequest: boolean;
+};
+
+interface FetchIssuerMembershipWitnessParams {
+    issuerSetReader: ContractLeafReader;
+    issuerPublicKey: IssuerPublicKey;
+}
+interface IssuerMembershipWitnessResult {
+    root: bigint;
+    witness: IssuerMembershipWitness;
+}
+/** Rebuilds the approved-issuer set from its current on-chain leaves and proves membership against the fresh root. */
+declare function fetchIssuerMembershipWitness({ issuerSetReader, issuerPublicKey }: FetchIssuerMembershipWitnessParams): Promise<IssuerMembershipWitnessResult>;
+
+interface IssueVCPorts {
+    signer: CredentialSigner;
+    approval: ApprovalResolver;
+    issuerSetReader: ContractLeafReader;
+}
+/**
+ * Issues a UserApproval credential plus the issuer's fresh Merkle path into the
+ * approved-issuer set. The witness is fetched before any signing, so an issuer
+ * whose key was never published fails at issuance without spending a signature.
+ */
+declare function issueVC(params: ZkCredentialIssueParams, { signer, approval, issuerSetReader }: IssueVCPorts): Promise<IssuedCredential>;
+
+interface DeliverToStealthParams {
+    memberNetworkId: Hex32;
+    recipientNetworkId: Hex32;
+}
+interface DeliverToStealthPorts {
+    approval: ApprovalResolver;
+    identityReader: IdentityReader;
+    submitter: AnnouncementSubmitter;
+}
+/**
+ * Delivers value to a network member's recipient: resolves their registered identity and announces
+ * a fresh stealth address for it. `ERC5564Announcer.announce` is permissionless, so the member's
+ * approval is checked here, first, before any other port runs.
+ */
+declare function deliverToStealth({ memberNetworkId, recipientNetworkId }: DeliverToStealthParams, { approval, identityReader, submitter }: DeliverToStealthPorts): Promise<DeliveredToStealth>;
+
+interface SubmitRegistrationPorts {
+    domain: ChainDomain;
+    identityReader: IdentityReader;
+    prover: RegistrationProver;
+    writer: RegistrationWriter;
+}
+/**
+ * Submits a user's signed registration consent to `IdentityRegistry`, as an approved network
+ * member. The ports' own registry binding is checked first, then consent, both before any port
+ * runs, so a misconfigured member app or a forged/mistargeted request never reaches the registry.
+ */
+declare function submitRegistration(request: RegistrationRequest, { domain, identityReader, prover, writer }: SubmitRegistrationPorts): Promise<SubmitRegistrationResult>;
+
+/**
+ * Chain-backed IdentityReader over `IdentityRegistry`'s public `identity` mapping. Each read puts
+ * the recipient's networkId in `eth_call` calldata, visible to whoever serves the RPC.
+ */
+declare class IdentityRegistryClient implements IdentityReader {
+    readonly registryAddress: Address$1;
+    private readonly client;
+    constructor(registryAddress: Address$1, client: Pick<PublicClient, "readContract">);
+    getIdentity(networkId: Hex$1): Promise<Hex$1 | null>;
+}
+/**
+ * Chain-backed ContractLeafReader over ApprovedIssuerSet's paging getters. Reads are pinned to
+ * the block observed at `getLeafCount`, so a multi-page rebuild can't mix chain states into a
+ * root that never existed; serve one rebuild at a time per instance.
+ */
+declare class ApprovedIssuerSetClient implements ContractLeafReader {
+    private readonly setAddress;
+    private readonly client;
+    private blockNumber?;
+    constructor(setAddress: Address$1, client: Pick<PublicClient, "readContract" | "getBlockNumber">);
+    getLeafCount(): Promise<bigint>;
+    getLeaves(start: number, end: number): Promise<bigint[]>;
+}
+/** Chain-backed AnnouncementSubmitter over `ERC5564Announcer.announce`. */
+declare class ERC5564AnnouncerClient implements AnnouncementSubmitter {
+    private readonly announcerAddress;
+    private readonly walletClient;
+    constructor(announcerAddress: Address$1, walletClient: Pick<WalletClient<Transport, Chain, Account>, "writeContract">);
+    announce(announcement: Announcement): Promise<Hex$1>;
+}
+/**
+ * Chain-backed GroupMirror over Semaphore's own group events. Rebuilds the approved-member group
+ * by replaying every MemberAdded/MembersAdded/MemberUpdated/MemberRemoved event for `groupId` in
+ * emission order, pinned to one `getBlockNumber` so the replay and the root check below can't
+ * straddle two chain states. A removal zeroes its leaf rather than deleting it, since Semaphore
+ * never reuses an index, so the replay must carry the zero forward into the rebuilt tree.
+ *
+ * The rebuilt root is then checked against `getMerkleTreeRoot` at that same block: a mismatch
+ * means the replay is wrong, not that membership is false, and this is what makes that loud
+ * instead of silently producing a proof nothing will accept.
+ */
+declare class SemaphoreGroupClient implements GroupMirror {
+    private readonly semaphoreAddress;
+    private readonly groupId;
+    private readonly client;
+    private readonly fromBlock;
+    constructor(semaphoreAddress: Address$1, groupId: bigint, client: Pick<PublicClient, "getBlockNumber" | "getLogs" | "readContract">, { fromBlock }?: {
+        fromBlock?: bigint;
+    });
+    currentGroup(): Promise<Group>;
+    /** Replays the four membership events into a dense, index-ordered leaf array. `undefined`
+     *  marks an index no admission log ever set, so a hole can't silently pass as leaf `0n`. */
+    private replayLeaves;
+}
+interface SemaphoreRegistrationProverParams {
+    /** The network member's own Semaphore identity. Its commitment must be a leaf of the mirrored group. */
+    identity: Identity;
+    groupMirror: GroupMirror;
+    registry: RegistryLocation;
+}
+/**
+ * Chain-backed RegistrationProver: mirrors the approved-member group fresh for every call, then
+ * generates the Semaphore proof authorising one IdentityRegistry write.
+ */
+declare class SemaphoreRegistrationProver implements RegistrationProver {
+    private readonly identity;
+    private readonly groupMirror;
+    readonly registry: RegistryLocation;
+    constructor({ identity, groupMirror, registry }: SemaphoreRegistrationProverParams);
+    prove(update: IdentityUpdate): Promise<NetworkMemberProof>;
+}
+interface SemaphoreRevocationProverParams {
+    /** The network member's own Semaphore identity. Its commitment must be a leaf of the mirrored group. */
+    identity: Identity;
+    groupMirror: GroupMirror;
+    registry: RegistryLocation;
+}
+/**
+ * Chain-backed RevocationProver: mirrors the approved-member group fresh for every call, then
+ * generates the Semaphore proof authorising one write to the network's credential revocation
+ * registry. The same group as registration's, reached through the same mirror: the registry
+ * inherits `NetworkMemberGate`, so `SEMAPHORE()` and `NETWORK_MEMBER_GROUP_ID()` are public on it
+ * too and the mirror only needs a different address.
+ */
+declare class SemaphoreRevocationProver implements RevocationProver {
+    private readonly identity;
+    private readonly groupMirror;
+    readonly registry: RegistryLocation;
+    constructor({ identity, groupMirror, registry }: SemaphoreRevocationProverParams);
+    prove(update: RevocationUpdate): Promise<NetworkMemberProof>;
+}
+/**
+ * Chain-backed RegistrationWriter over `IdentityRegistry.registerIdentity`. No receipt wait:
+ * `AlreadyRegistered` surfaces at viem's gas estimate, and a returned txHash means submitted,
+ * matching `RegistrationSubmitter`'s contract in `@coordination-network/user-client`.
+ */
+declare class IdentityRegistryWriter implements RegistrationWriter {
+    readonly registry: RegistryLocation;
+    private readonly walletClient;
+    constructor(registry: RegistryLocation, walletClient: Pick<WalletClient<Transport, Chain, Account>, "writeContract">);
+    registerIdentity(networkId: Hex32, metaStealthAddress: Hex$1, proof: NetworkMemberProof): Promise<RegistrationWrite>;
+}
+
+/**
+ * A fully assembled ERC-4337 v0.8 user operation for a 7702-delegated, paymaster-sponsored call.
+ * Every gas and paymaster field is required, never left to a bundler default: `factory` is always
+ * the 7702 marker and `authorization` is always present, since this track has no other kind of op.
+ */
+interface SponsoredUserOperation {
+    sender: Address$1;
+    nonce: bigint;
+    factory: "0x7702";
+    callData: Hex$1;
+    callGasLimit: bigint;
+    verificationGasLimit: bigint;
+    preVerificationGas: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    paymaster: Address$1;
+    paymasterVerificationGasLimit: bigint;
+    paymasterPostOpGasLimit: bigint;
+    paymasterData: Hex$1;
+    authorization: SignedAuthorization;
+    signature: Hex$1;
+}
+/** One submitted user operation's outcome, parsed from the EntryPoint's own events so both submitters report the same shape. */
+interface UserOperationReceipt {
+    transactionHash: Hex$1;
+    success: boolean;
+    actualGasCost: bigint;
+    actualGasUsed: bigint;
+    /** Raw `UserOperationRevertReason` data, present only when `success` is false. */
+    revertReason?: Hex$1;
+}
+/** Submits a signed user operation and waits for its outcome. `waitForReceipt` takes the hash `send` returns. */
+interface UserOperationSubmitter {
+    send(userOperation: SponsoredUserOperation): Promise<Hex$1>;
+    waitForReceipt(userOpHash: Hex$1): Promise<UserOperationReceipt>;
+}
+/** Decodes `UserOperationEvent`/`UserOperationRevertReason` for one userOpHash out of a mined transaction's logs. */
+declare function parseUserOperationReceipt(transactionReceipt: TransactionReceipt, entryPointAbi: typeof entryPoint08Abi, userOpHash: Hex$1): UserOperationReceipt;
+/** Submits to a bundler's JSON-RPC (`eth_sendUserOperation`/`eth_getUserOperationReceipt`), for the member server. */
+declare class BundlerRpcSubmitter implements UserOperationSubmitter {
+    private readonly entryPoint;
+    private readonly client;
+    constructor(url: string, entryPoint: Address$1);
+    send(userOperation: SponsoredUserOperation): Promise<Hex$1>;
+    waitForReceipt(userOpHash: Hex$1): Promise<UserOperationReceipt>;
+}
+type EntryPointChainClient = Pick<WalletClient<Transport, Chain, Account>, "account" | "chain" | "sendTransaction"> & Pick<PublicClient, "waitForTransactionReceipt">;
+/**
+ * Submits straight to the EntryPoint's `handleOps`, for the stack bundler and the integration
+ * test: no mempool, one operation per call, the beneficiary is the submitting account itself.
+ */
+declare class EntryPointSubmitter implements UserOperationSubmitter {
+    private readonly client;
+    private readonly entryPoint;
+    private readonly transactionHashes;
+    constructor(client: EntryPointChainClient, entryPoint: Address$1);
+    send(userOperation: SponsoredUserOperation): Promise<Hex$1>;
+    waitForReceipt(userOpHash: Hex$1): Promise<UserOperationReceipt>;
+}
+
+interface SponsoredMemberKeys {
+    /** The member's own long-term meta-stealth address; each call derives a fresh, disposable sender from it. */
+    metaStealthAddress: Hex$1;
+    spendingPrivateKey: Hex$1;
+    viewingPrivateKey: Hex$1;
+}
+interface SponsoredRelayParams {
+    chainId: number;
+    entryPoint: Address$1;
+    paymaster: Address$1;
+    accountImplementation: Address$1;
+    memberKeys: SponsoredMemberKeys;
+    /** The member's own Semaphore identity; must be a leaf of `paymasterGroup`. */
+    paymasterIdentity: Identity;
+    /** The paymaster's own mirrored Semaphore group (its admitted members, not the network's). */
+    paymasterGroup: GroupMirror;
+    submitter: UserOperationSubmitter;
+    publicClient: Pick<PublicClient, "getBalance" | "getTransactionCount" | "readContract">;
+}
+/** One relayed call's outcome: whatever the EntryPoint reported, plus what the sponsorship cost. */
+interface RelayedCall {
+    receipt: UserOperationReceipt;
+    sponsorship: Sponsorship;
+}
+/** The call to relay. `value` defaults to zero, which is every call this track makes today. */
+interface RelayCall {
+    target: Address$1;
+    value?: bigint;
+    data: Hex$1;
+}
+/**
+ * Relays one call through a fresh, disposable stealth sender delegated to Simple7702Account and
+ * sponsored by SemaphorePaymaster, so the member pays nothing and no sender links two of the
+ * member's relayed calls to each other.
+ *
+ * A reverted operation comes back as a receipt, not an error: which reverts are worth retrying and
+ * which are final depends on the contract being called, so the caller owns that reading.
+ */
+declare class SponsoredRelay {
+    private readonly chainId;
+    private readonly entryPoint;
+    private readonly paymaster;
+    private readonly accountImplementation;
+    private readonly memberKeys;
+    private readonly paymasterIdentity;
+    private readonly paymasterGroup;
+    private readonly submitter;
+    private readonly publicClient;
+    constructor(params: SponsoredRelayParams);
+    relay({ target, value, data }: RelayCall): Promise<RelayedCall>;
+    /**
+     * A fresh, disposable stealth address derived from the member's own meta-address: used once
+     * to sign and pay (nothing, since it's sponsored) for this call, then dropped. No announcement
+     * is made, so it can't link two of the member's relayed calls to each other.
+     */
+    private deriveSender;
+    private readPaymasterDeposit;
+    /** The paymaster's own proof: the member's Semaphore identity against its mirrored group, message and scope both the disposable sender (`SemaphorePaymaster`'s own binding). */
+    private buildPaymasterProof;
+}
+
+interface SponsoredIdentityRegistryWriterParams extends SponsoredRelayParams {
+    registry: RegistryLocation;
+}
+/**
+ * Sponsored RegistrationWriter: relays a `registerIdentity` call through {@link SponsoredRelay},
+ * so the member pays nothing and no sender links two of the member's relayed registrations to
+ * each other.
+ */
+declare class SponsoredIdentityRegistryWriter implements RegistrationWriter {
+    readonly registry: RegistryLocation;
+    private readonly relay;
+    constructor({ registry, ...relayParams }: SponsoredIdentityRegistryWriterParams);
+    registerIdentity(networkId: Hex32, metaStealthAddress: Hex$1, proof: NetworkMemberProof): Promise<RegistrationWrite>;
+}
+
+/**
+ * The `CredentialRevocationRegistry` fragments a writer needs. The errors matter as much as the
+ * function: `InvalidLowLeaf` is the one a caller recomputes an index and retries on, and
+ * `LeafAlreadyExists` the one it stops on, so both writers must decode the same names.
+ */
+declare const CREDENTIAL_REVOCATION_REGISTRY_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "revoke";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "revocationCommitment";
+        readonly type: "uint256";
+    }, {
+        readonly name: "lowLeafIndex";
+        readonly type: "uint256";
+    }, {
+        readonly name: "proof";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "merkleTreeDepth";
+            readonly type: "uint256";
+        }, {
+            readonly name: "merkleTreeRoot";
+            readonly type: "uint256";
+        }, {
+            readonly name: "nullifier";
+            readonly type: "uint256";
+        }, {
+            readonly name: "scope";
+            readonly type: "uint256";
+        }, {
+            readonly name: "points";
+            readonly type: "uint256[8]";
+        }];
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidLowLeaf";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "LeafAlreadyExists";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "LeafCannotBeZero";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "LeafGreaterThanSnarkScalarField";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "RegistryDoesNotExist";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "CallerIsNotTheRegistryAdmin";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "Semaphore__GroupHasNoMembers";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "Semaphore__MerkleTreeDepthIsNotSupported";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "Semaphore__MerkleTreeRootIsExpired";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "Semaphore__MerkleTreeRootIsNotPartOfTheGroup";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "Semaphore__YouAreUsingTheSameNullifierTwice";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "Semaphore__InvalidProof";
+    readonly inputs: readonly [];
+}];
+/**
+ * Sponsored RevocationRegistryWriter: relays a `revoke` call through {@link SponsoredRelay}, so
+ * the write costs the member nothing and its sender names no member. That matters more here than for
+ * registration: one tree holds the whole network's revocations, and an EOA paying for the write
+ * would say which member revoked which credential.
+ */
+declare class SponsoredRevocationWriter implements RevocationRegistryWriter {
+    readonly registry: RegistryLocation;
+    private readonly relay;
+    constructor(registry: RegistryLocation, relay: SponsoredRelay);
+    revoke(commitment: bigint, lowLeafIndex: bigint, proof: NetworkMemberProof): Promise<RevocationWrite>;
+}
+/**
+ * Chain-backed RevocationRegistryWriter over `CredentialRevocationRegistry.revoke`, for a member
+ * server running without an account-abstraction stack. The submitting EOA is on chain, so it says
+ * which member revoked; the sponsored writer above is what keeps that unattributable.
+ *
+ * No receipt wait: a reverting write surfaces at viem's gas estimate, and a returned txHash means
+ * submitted, matching `IdentityRegistryWriter`.
+ */
+declare class DirectRevocationWriter implements RevocationRegistryWriter {
+    readonly registry: RegistryLocation;
+    private readonly walletClient;
+    constructor(registry: RegistryLocation, walletClient: Pick<WalletClient<Transport, Chain, Account>, "writeContract">);
+    revoke(commitment: bigint, lowLeafIndex: bigint, proof: NetworkMemberProof): Promise<RevocationWrite>;
+}
+
+export { ApprovedIssuerSetClient, BundlerRpcSubmitter, CREDENTIAL_REVOCATION_REGISTRY_ABI, DirectRevocationWriter, ERC5564AnnouncerClient, EntryPointSubmitter, IdentityRegistryClient, IdentityRegistryWriter, NetworkMemberClientError, RegistryRevertError, RevocationRevertError, SemaphoreGroupClient, SemaphoreRegistrationProver, SemaphoreRevocationProver, SponsoredIdentityRegistryWriter, SponsoredRelay, SponsoredRevocationWriter, deliverToStealth, fetchIssuerMembershipWitness, issueVC, parseUserOperationReceipt, submitRegistration };
+export type { Announcement, AnnouncementSubmitter, DeliverToStealthParams, DeliverToStealthPorts, DeliveredToStealth, FetchIssuerMembershipWitnessParams, GroupMirror, IdentityReader, IssueVCPorts, IssuedCredential, IssuerMembershipWitnessResult, NetworkMemberClientErrorCode, RegistrationProver, RegistrationWrite, RegistrationWriter, RelayCall, RelayedCall, RevocationProver, RevocationRegistryWriter, RevocationWrite, SemaphoreRegistrationProverParams, SemaphoreRevocationProverParams, SponsoredIdentityRegistryWriterParams, SponsoredMemberKeys, SponsoredRelayParams, SponsoredUserOperation, Sponsorship, SubmitRegistrationPorts, SubmitRegistrationResult, UserOperationReceipt, UserOperationSubmitter };