@reclaimprotocol/attestor-core
Version:
<div> <div> <img src="https://raw.githubusercontent.com/reclaimprotocol/.github/main/assets/banners/Attestor-Core.png" /> </div> </div>
656 lines (655 loc) • 26.3 kB
TypeScript
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
export declare const protobufPackage = "reclaim_attestor";
export declare const TranscriptMessageSenderType: {
readonly TRANSCRIPT_MESSAGE_SENDER_TYPE_UNKNOWN: 0;
readonly TRANSCRIPT_MESSAGE_SENDER_TYPE_CLIENT: 1;
readonly TRANSCRIPT_MESSAGE_SENDER_TYPE_SERVER: 2;
readonly UNRECOGNIZED: -1;
};
export type TranscriptMessageSenderType = typeof TranscriptMessageSenderType[keyof typeof TranscriptMessageSenderType];
export declare namespace TranscriptMessageSenderType {
type TRANSCRIPT_MESSAGE_SENDER_TYPE_UNKNOWN = typeof TranscriptMessageSenderType.TRANSCRIPT_MESSAGE_SENDER_TYPE_UNKNOWN;
type TRANSCRIPT_MESSAGE_SENDER_TYPE_CLIENT = typeof TranscriptMessageSenderType.TRANSCRIPT_MESSAGE_SENDER_TYPE_CLIENT;
type TRANSCRIPT_MESSAGE_SENDER_TYPE_SERVER = typeof TranscriptMessageSenderType.TRANSCRIPT_MESSAGE_SENDER_TYPE_SERVER;
type UNRECOGNIZED = typeof TranscriptMessageSenderType.UNRECOGNIZED;
}
export declare function transcriptMessageSenderTypeFromJSON(object: any): TranscriptMessageSenderType;
export declare function transcriptMessageSenderTypeToJSON(object: TranscriptMessageSenderType): string;
export declare const ServiceSignatureType: {
readonly SERVICE_SIGNATURE_TYPE_UNKNOWN: 0;
/**
* SERVICE_SIGNATURE_TYPE_ETH - ETH keys & signature
* keys: secp256k1
* signature: ethereum flavor of ECDSA (https://goethereumbook.org/signature-generate/)
*/
readonly SERVICE_SIGNATURE_TYPE_ETH: 1;
readonly UNRECOGNIZED: -1;
};
export type ServiceSignatureType = typeof ServiceSignatureType[keyof typeof ServiceSignatureType];
export declare namespace ServiceSignatureType {
type SERVICE_SIGNATURE_TYPE_UNKNOWN = typeof ServiceSignatureType.SERVICE_SIGNATURE_TYPE_UNKNOWN;
type SERVICE_SIGNATURE_TYPE_ETH = typeof ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH;
type UNRECOGNIZED = typeof ServiceSignatureType.UNRECOGNIZED;
}
export declare function serviceSignatureTypeFromJSON(object: any): ServiceSignatureType;
export declare function serviceSignatureTypeToJSON(object: ServiceSignatureType): string;
export declare const AttestorVersion: {
readonly ATTESTOR_VERSION_UNKNOWN: 0;
readonly ATTESTOR_VERSION_1_0_0: 1;
readonly ATTESTOR_VERSION_1_1_0: 2;
readonly ATTESTOR_VERSION_2_0_0: 3;
readonly ATTESTOR_VERSION_2_0_1: 4;
readonly ATTESTOR_VERSION_3_0_0: 5;
readonly ATTESTOR_VERSION_3_1_0: 6;
readonly ATTESTOR_VERSION_3_2_0: 7;
readonly UNRECOGNIZED: -1;
};
export type AttestorVersion = typeof AttestorVersion[keyof typeof AttestorVersion];
export declare namespace AttestorVersion {
type ATTESTOR_VERSION_UNKNOWN = typeof AttestorVersion.ATTESTOR_VERSION_UNKNOWN;
type ATTESTOR_VERSION_1_0_0 = typeof AttestorVersion.ATTESTOR_VERSION_1_0_0;
type ATTESTOR_VERSION_1_1_0 = typeof AttestorVersion.ATTESTOR_VERSION_1_1_0;
type ATTESTOR_VERSION_2_0_0 = typeof AttestorVersion.ATTESTOR_VERSION_2_0_0;
type ATTESTOR_VERSION_2_0_1 = typeof AttestorVersion.ATTESTOR_VERSION_2_0_1;
type ATTESTOR_VERSION_3_0_0 = typeof AttestorVersion.ATTESTOR_VERSION_3_0_0;
type ATTESTOR_VERSION_3_1_0 = typeof AttestorVersion.ATTESTOR_VERSION_3_1_0;
type ATTESTOR_VERSION_3_2_0 = typeof AttestorVersion.ATTESTOR_VERSION_3_2_0;
type UNRECOGNIZED = typeof AttestorVersion.UNRECOGNIZED;
}
export declare function attestorVersionFromJSON(object: any): AttestorVersion;
export declare function attestorVersionToJSON(object: AttestorVersion): string;
export declare const ErrorCode: {
/**
* ERROR_NO_ERROR - 0 should be treated as the absence of an error
* should be used when gracefully closing the connection
*/
readonly ERROR_NO_ERROR: 0;
/**
* ERROR_INTERNAL - internal error in the attestor -- all "Error/TypeError"
* messages are mapped to this
*/
readonly ERROR_INTERNAL: 1;
/** ERROR_BAD_REQUEST - bad request from the client */
readonly ERROR_BAD_REQUEST: 2;
/** ERROR_NOT_FOUND - the item requested was not found */
readonly ERROR_NOT_FOUND: 3;
/** ERROR_PROXY_ERROR - error in the proxy */
readonly ERROR_PROXY_ERROR: 4;
/**
* ERROR_INVALID_CLAIM - claim creation failed -- i.e. the transcript
* did not result in a valid claim
*/
readonly ERROR_INVALID_CLAIM: 5;
/** ERROR_NETWORK_ERROR - any network error */
readonly ERROR_NETWORK_ERROR: 6;
/** ERROR_PAYMENT_REFUSED - attestor refused to pay the costs */
readonly ERROR_PAYMENT_REFUSED: 7;
/**
* ERROR_BGP_ANNOUNCEMENT_OVERLAP - BGP announcement overlapped, potentially
* compromising the claim's authenticity
*/
readonly ERROR_BGP_ANNOUNCEMENT_OVERLAP: 8;
/** ERROR_AUTHENTICATION_FAILED - authentication failed */
readonly ERROR_AUTHENTICATION_FAILED: 9;
/** ERROR_TIMEOUT - timed out waiting for the server to respond */
readonly ERROR_TIMEOUT: 10;
/** ERROR_TOPRF_OUT_OF_BOUNDS - toprf couldn't be computed, as it went out of bounds */
readonly ERROR_TOPRF_OUT_OF_BOUNDS: 11;
/** ERROR_CERTIFICATE_FETCH_FAILED - failed to fetch certificate bytes from the URL */
readonly ERROR_CERTIFICATE_FETCH_FAILED: 12;
readonly UNRECOGNIZED: -1;
};
export type ErrorCode = typeof ErrorCode[keyof typeof ErrorCode];
export declare namespace ErrorCode {
type ERROR_NO_ERROR = typeof ErrorCode.ERROR_NO_ERROR;
type ERROR_INTERNAL = typeof ErrorCode.ERROR_INTERNAL;
type ERROR_BAD_REQUEST = typeof ErrorCode.ERROR_BAD_REQUEST;
type ERROR_NOT_FOUND = typeof ErrorCode.ERROR_NOT_FOUND;
type ERROR_PROXY_ERROR = typeof ErrorCode.ERROR_PROXY_ERROR;
type ERROR_INVALID_CLAIM = typeof ErrorCode.ERROR_INVALID_CLAIM;
type ERROR_NETWORK_ERROR = typeof ErrorCode.ERROR_NETWORK_ERROR;
type ERROR_PAYMENT_REFUSED = typeof ErrorCode.ERROR_PAYMENT_REFUSED;
type ERROR_BGP_ANNOUNCEMENT_OVERLAP = typeof ErrorCode.ERROR_BGP_ANNOUNCEMENT_OVERLAP;
type ERROR_AUTHENTICATION_FAILED = typeof ErrorCode.ERROR_AUTHENTICATION_FAILED;
type ERROR_TIMEOUT = typeof ErrorCode.ERROR_TIMEOUT;
type ERROR_TOPRF_OUT_OF_BOUNDS = typeof ErrorCode.ERROR_TOPRF_OUT_OF_BOUNDS;
type ERROR_CERTIFICATE_FETCH_FAILED = typeof ErrorCode.ERROR_CERTIFICATE_FETCH_FAILED;
type UNRECOGNIZED = typeof ErrorCode.UNRECOGNIZED;
}
export declare function errorCodeFromJSON(object: any): ErrorCode;
export declare function errorCodeToJSON(object: ErrorCode): string;
export declare const ZKProofEngine: {
readonly ZK_ENGINE_SNARKJS: 0;
readonly ZK_ENGINE_GNARK: 1;
readonly ZK_ENGINE_STWO: 2;
readonly UNRECOGNIZED: -1;
};
export type ZKProofEngine = typeof ZKProofEngine[keyof typeof ZKProofEngine];
export declare namespace ZKProofEngine {
type ZK_ENGINE_SNARKJS = typeof ZKProofEngine.ZK_ENGINE_SNARKJS;
type ZK_ENGINE_GNARK = typeof ZKProofEngine.ZK_ENGINE_GNARK;
type ZK_ENGINE_STWO = typeof ZKProofEngine.ZK_ENGINE_STWO;
type UNRECOGNIZED = typeof ZKProofEngine.UNRECOGNIZED;
}
export declare function zKProofEngineFromJSON(object: any): ZKProofEngine;
export declare function zKProofEngineToJSON(object: ZKProofEngine): string;
export interface ClaimContext {
/**
* Extracted parameters from the TLS transcript
* by the provider. Any parameters provided by the
* user will be overwritten
*/
extractedParameters: {
[]: string;
};
/** Provider hash. TODO: docs */
providerHash: string;
}
export interface ClaimContext_ExtractedParametersEntry {
key: string;
value: string;
}
export interface ProviderClaimData {
/**
* Name of the provider to generate the
* claim using.
* @example "http"
*/
provider: string;
/**
* Canonically JSON stringified parameters
* of the claim, as specified by the provider.
* @example '{"url":"https://example.com","method":"GET"}'
*/
parameters: string;
/**
* Owner of the claim. Must be the public key/address
* @example "0x1234..."
*/
owner: string;
/**
* Unix timestamp in seconds of the claim being made.
* Cannot be more than 10 minutes in the past or future
*/
timestampS: number;
/**
* Any additional data you want to store with the claim.
* Also expected to be a canonical JSON string.
*/
context: string;
/**
* identifier of the claim;
* Hash of (provider, parameters, context)
*/
identifier: string;
/** Legacy V1 Beacon epoch number */
epoch: number;
}
export interface ProviderClaimInfo {
provider: string;
parameters: string;
context: string;
}
export interface ErrorData {
code: ErrorCode;
message: string;
data: string;
}
export interface CreateTunnelRequest {
/**
* Assign a unique ID to the client for this tunnel
* request. This ID will be used to identify the tunnel
* to later send messages or disconnect the tunnel.
*/
id: number;
host: string;
port: number;
/**
* Geo location from which the request will be made.
* Provide 2 letter ISO country code. Leave empty
* if you don't want to use geo location.
*
* Geo location is implemented using an https proxy
* eg. US, IN, GB, etc.
*/
geoLocation: string;
/**
* Session identifier for proxy IP persistence.
*
* When provided, ensures all requests within the same session
* are routed through the same proxy IP address. Useful for
* maintaining IP consistency across multiple requests.
*
* Can be a smallcase alphanumeric string of length 8-14 characters.
* eg. "mystring12345", "something1234".
*/
proxySessionId: string;
}
export interface FetchCertificateBytesRequest {
url: string;
}
export interface FetchCertificateBytesResponse {
bytes: Uint8Array;
}
export interface DisconnectTunnelRequest {
id: number;
}
/** empty message */
export interface Empty {
}
export interface TunnelMessage {
/** ID of the tunnel where this message belongs */
tunnelId: number;
message: Uint8Array;
}
export interface TunnelDisconnectEvent {
tunnelId: number;
error: ErrorData | undefined;
}
export interface MessageReveal {
/**
* direct reveal of the block via the key & IV
* cipher (aes, chacha) for decryption
* selected based on `cipherSuite`
* determined by the server hello packet
*/
directReveal?: MessageReveal_MessageRevealDirect | undefined;
/** partially or fully reveal the block via a zk proof */
zkReveal?: MessageReveal_MessageRevealZk | undefined;
}
export interface MessageReveal_MessageRevealDirect {
/** key for the block */
key: Uint8Array;
/** IV for the block */
iv: Uint8Array;
/**
* used to generate IV in authenticated
* cipher suites
*/
recordNumber: number;
}
export interface MessageReveal_MessageRevealZk {
proofs: MessageReveal_ZKProof[];
toprfs: MessageReveal_TOPRFProof[];
/** Markers for server-side OPRF computation (oprf-raw mode) */
oprfRawMarkers: MessageReveal_OPRFRawMarker[];
/**
* If an oprf-raw marker from the previous packet overshot into this packet,
* this indicates how many bytes of plaintext from this packet should be
* collected to complete the server-side OPRF computation.
*/
overshotOprfRawLength: number;
}
/** Marker for server-side OPRF computation (oprf-raw mode). */
export interface MessageReveal_OPRFRawMarker {
/** Location of the data to OPRF in the revealed plaintext */
dataLocation: DataSlice | undefined;
}
export interface MessageReveal_ZKProof {
/** the decrypted ciphertext as output by the ZK proof */
decryptedRedactedCiphertext: Uint8Array;
/** the plaintext that is fully or partially revealed */
redactedPlaintext: Uint8Array;
/**
* start of this specific block
* in the redactedPlaintext
*/
startIdx: number;
proofData: Uint8Array;
}
export interface MessageReveal_TOPRFProof {
/**
* start of this specific block
* in the redactedPlaintext
*/
startIdx: number;
proofData: Uint8Array;
/**
* If this block's proof contains an OPRF'd piece of data,
* then provide the OPRF data here
*/
payload: TOPRFPayload | undefined;
}
export interface TOPRFPayload {
/** Location of the data in the chunk that was masked */
dataLocation: DataSlice | undefined;
/** OPRF hash of the data */
nullifier: Uint8Array;
responses: TOPRFResponse[];
}
export interface DataSlice {
fromIndex: number;
length: number;
}
export interface ClaimRequestData {
provider: string;
parameters: string;
/**
* Owner of the claim. Must be the public key/address
* of the signatures
*/
owner: string;
/**
* Timestamp of the claim being made.
* Cannot be more than 10 minutes in the past
* or in the future
*/
timestampS: number;
context: string;
}
export interface ClaimTeeBundleRequest {
/** TEE verification bundle containing attestations and signed data */
verificationBundle: Uint8Array;
/** Data describing the claim you want to prove */
data: ClaimRequestData | undefined;
/** User signature on the request */
signatures: ClaimTeeBundleRequest_Signatures | undefined;
}
export interface ClaimTeeBundleRequest_Signatures {
/**
* Signature of ClaimTeeBundleRequest
* with empty "signatures" field
*/
requestSignature: Uint8Array;
}
export interface ClaimTeeBundleResponse {
/** The original request that was made */
request: ClaimTeeBundleRequest | undefined;
claim?: ProviderClaimData | undefined;
error?: ErrorData | undefined;
signatures: ClaimTeeBundleResponse_Signatures | undefined;
}
export interface ClaimTeeBundleResponse_Signatures {
/** Address of the attestor that has signed the claim */
attestorAddress: string;
/**
* Signature of `stringifyProviderClaimData(claim)`,
* if the claim was successful
*/
claimSignature: Uint8Array;
/**
* Signature of the complete ClaimTeeBundleResponse
* structure with empty "signatures" field
*/
resultSignature: Uint8Array;
}
export interface ClaimTunnelRequest {
/**
* parameters supplied to establish the tunnel
* & connect to the end server
*/
request: CreateTunnelRequest | undefined;
/** data describing the claim you want to prove */
data: ClaimRequestData | undefined;
/**
* messages from the client & server
* in the order they were sent/received
*
* Attach a proof (if any) to each message
* to reveal the contents of the message inside
*
* The revealed messages should support the proving
* of the claim as defined in the provider's implementation
*/
transcript: ClaimTunnelRequest_TranscriptMessage[];
signatures: ClaimTunnelRequest_Signatures | undefined;
/** type of ZK engine used. SnarkJS or Gnark */
zkEngine: ZKProofEngine;
/** server and client fixed IVs needed for ZK validation */
fixedServerIV: Uint8Array;
fixedClientIV: Uint8Array;
}
export interface ClaimTunnelRequest_Signatures {
/**
* signature of ClaimTunnelRequest
* with empty "signatures" field
*/
requestSignature: Uint8Array;
}
export interface ClaimTunnelRequest_TranscriptMessage {
/** client or server */
sender: TranscriptMessageSenderType;
/** packet data */
message: Uint8Array;
reveal: MessageReveal | undefined;
}
export interface ClaimTunnelResponse {
/** The original request that was made to claim the tunnel */
request: ClaimTunnelRequest | undefined;
claim?: ProviderClaimData | undefined;
error?: ErrorData | undefined;
signatures: ClaimTunnelResponse_Signatures | undefined;
}
export interface ClaimTunnelResponse_Signatures {
/** Address of the attestor that has signed the claim */
attestorAddress: string;
/**
* signature of `stringifyProviderClaimData(claim)`,
* if the claim was successful
*/
claimSignature: Uint8Array;
/**
* signature of the complete ClaimTunnelResponse
* structure with empty "signatures" field
*/
resultSignature: Uint8Array;
}
export interface RequestClaimOnAvsRequest {
/**
* Chain ID of the chain on which the claim is to be made
* @example 17000 (holesky)
*/
chainId: number;
/** Serialised JSON string of the ClaimRequest struct */
jsonCreateClaimRequest: string;
/** ETH signature of the `ClaimRequest` struct */
requestSignature: Uint8Array;
}
export interface RequestClaimOnAvsResponse {
txHash: string;
taskIndex: number;
jsonTask: string;
}
export interface CompleteClaimOnAvsRequest {
/**
* Chain ID of the chain on which the claim is to be made
* @example 17000 (holesky)
*/
chainId: number;
taskIndex: number;
completedTaskJson: string;
}
export interface CompleteClaimOnAvsResponse {
txHash: string;
taskCompletedObjectJson: string;
}
export interface CreateTaskOnMechainRequest {
timestamp: number;
}
export interface CreateTaskOnMechainResponse {
taskId: number;
requiredAttestors: number;
hosts: string[];
}
export interface AuthenticatedUserData {
/** Unique identifier for the user */
id: string;
createdAt: number;
/**
* Unix timestamp in seconds when the user's
* authentication will expire.
*/
expiresAt: number;
/**
* List of allowed hosts the user is allowed to connect to.
* Will throw a BAD_REQUEST error if the user tries to connect.
* Pass an empty list to allow all hosts.
*/
hostWhitelist: string[];
}
export interface AuthenticationRequest {
data: AuthenticatedUserData | undefined;
/** Signature of the `userData` */
signature: Uint8Array;
}
export interface InitRequest {
/** Attestor client version */
clientVersion: AttestorVersion;
/** Signature type used & expected by the user */
signatureType: ServiceSignatureType;
/**
* Request the attestor to authenticate the user
* with the given data. If auth fails, will return
* an AUTHENTICATION_FAILED error.
*/
auth: AuthenticationRequest | undefined;
}
export interface InitResponse {
toprfPublicKey: Uint8Array;
/** Address of the attestor */
attestorAddress: string;
}
export interface TOPRFRequest {
maskedData: Uint8Array;
engine: ZKProofEngine;
}
export interface TOPRFResponse {
publicKeyShare: Uint8Array;
/** OPRF output */
evaluated: Uint8Array;
c: Uint8Array;
r: Uint8Array;
}
export interface RPCMessage {
/**
* Per connection unique RPC message ID. Either party sending a
* duplicate ID will do nothing except confuse the other party.
*
* For response messages, the ID should be the same as the request
* to which it is responding.
*/
id: number;
initRequest?: InitRequest | undefined;
/** Response to the init request. */
initResponse?: InitResponse | undefined;
/**
* Data representing an error in the WebSocket connection.
* The party sending this message should close the connection
* immediately after sending this message.
*/
connectionTerminationAlert?: ErrorData | undefined;
/**
* Data representing an error in the attestor's
* request to the server. This should be sent in case
* there was an error in processing the request.
*/
requestError?: ErrorData | undefined;
/** Create a tunnel to the specified host & port. */
createTunnelRequest?: CreateTunnelRequest | undefined;
createTunnelResponse?: Empty | undefined;
/** Disconnect a tunnel. */
disconnectTunnelRequest?: DisconnectTunnelRequest | undefined;
disconnectTunnelResponse?: Empty | undefined;
/**
* Message to send through a tunnel. Client can send
* this message to forward data to the server.
*/
tunnelMessage?: TunnelMessage | undefined;
/**
* Event indicating that a tunnel has been disconnected.
* The client should not send any more messages through
* this tunnel.
*/
tunnelDisconnectEvent?: TunnelDisconnectEvent | undefined;
/**
* Using the transcript of a tunnel, make a claim.
* The tunnel must be disconnected before making a claim.
*/
claimTunnelRequest?: ClaimTunnelRequest | undefined;
claimTunnelResponse?: ClaimTunnelResponse | undefined;
/**
* Request the attestor to pay for the claim on the chain.
* The Attestor can choose to reject the request.
*/
createClaimOnChainRequest?: RequestClaimOnAvsRequest | undefined;
createClaimOnChainResponse?: RequestClaimOnAvsResponse | undefined;
/** Submit the work done for the claim on the chain. */
completeClaimOnChainRequest?: CompleteClaimOnAvsRequest | undefined;
completeClaimOnChainResponse?: CompleteClaimOnAvsResponse | undefined;
/** Request to perform thresholded OPRF */
toprfRequest?: TOPRFRequest | undefined;
toprfResponse?: TOPRFResponse | undefined;
/** Request the attestor to create a Task on the ReclaimTask contract. */
createTaskOnMechainRequest?: CreateTaskOnMechainRequest | undefined;
createTaskOnMechainResponse?: CreateTaskOnMechainResponse | undefined;
/** Claim a TEE verification bundle instead of traditional TLS transcript */
claimTeeBundleRequest?: ClaimTeeBundleRequest | undefined;
claimTeeBundleResponse?: ClaimTeeBundleResponse | undefined;
/**
* Request the attestor to fetch certificate bytes from a URL. This RPC
* is there as a helper for clients that cannot directly fetch certificates
* due to network restrictions.
*/
fetchCertificateBytesRequest?: FetchCertificateBytesRequest | undefined;
fetchCertificateBytesResponse?: FetchCertificateBytesResponse | undefined;
}
export interface RPCMessages {
messages: RPCMessage[];
}
export declare const ClaimContext: MessageFns<ClaimContext>;
export declare const ClaimContext_ExtractedParametersEntry: MessageFns<ClaimContext_ExtractedParametersEntry>;
export declare const ProviderClaimData: MessageFns<ProviderClaimData>;
export declare const ProviderClaimInfo: MessageFns<ProviderClaimInfo>;
export declare const ErrorData: MessageFns<ErrorData>;
export declare const CreateTunnelRequest: MessageFns<CreateTunnelRequest>;
export declare const FetchCertificateBytesRequest: MessageFns<FetchCertificateBytesRequest>;
export declare const FetchCertificateBytesResponse: MessageFns<FetchCertificateBytesResponse>;
export declare const DisconnectTunnelRequest: MessageFns<DisconnectTunnelRequest>;
export declare const Empty: MessageFns<Empty>;
export declare const TunnelMessage: MessageFns<TunnelMessage>;
export declare const TunnelDisconnectEvent: MessageFns<TunnelDisconnectEvent>;
export declare const MessageReveal: MessageFns<MessageReveal>;
export declare const MessageReveal_MessageRevealDirect: MessageFns<MessageReveal_MessageRevealDirect>;
export declare const MessageReveal_MessageRevealZk: MessageFns<MessageReveal_MessageRevealZk>;
export declare const MessageReveal_OPRFRawMarker: MessageFns<MessageReveal_OPRFRawMarker>;
export declare const MessageReveal_ZKProof: MessageFns<MessageReveal_ZKProof>;
export declare const MessageReveal_TOPRFProof: MessageFns<MessageReveal_TOPRFProof>;
export declare const TOPRFPayload: MessageFns<TOPRFPayload>;
export declare const DataSlice: MessageFns<DataSlice>;
export declare const ClaimRequestData: MessageFns<ClaimRequestData>;
export declare const ClaimTeeBundleRequest: MessageFns<ClaimTeeBundleRequest>;
export declare const ClaimTeeBundleRequest_Signatures: MessageFns<ClaimTeeBundleRequest_Signatures>;
export declare const ClaimTeeBundleResponse: MessageFns<ClaimTeeBundleResponse>;
export declare const ClaimTeeBundleResponse_Signatures: MessageFns<ClaimTeeBundleResponse_Signatures>;
export declare const ClaimTunnelRequest: MessageFns<ClaimTunnelRequest>;
export declare const ClaimTunnelRequest_Signatures: MessageFns<ClaimTunnelRequest_Signatures>;
export declare const ClaimTunnelRequest_TranscriptMessage: MessageFns<ClaimTunnelRequest_TranscriptMessage>;
export declare const ClaimTunnelResponse: MessageFns<ClaimTunnelResponse>;
export declare const ClaimTunnelResponse_Signatures: MessageFns<ClaimTunnelResponse_Signatures>;
export declare const RequestClaimOnAvsRequest: MessageFns<RequestClaimOnAvsRequest>;
export declare const RequestClaimOnAvsResponse: MessageFns<RequestClaimOnAvsResponse>;
export declare const CompleteClaimOnAvsRequest: MessageFns<CompleteClaimOnAvsRequest>;
export declare const CompleteClaimOnAvsResponse: MessageFns<CompleteClaimOnAvsResponse>;
export declare const CreateTaskOnMechainRequest: MessageFns<CreateTaskOnMechainRequest>;
export declare const CreateTaskOnMechainResponse: MessageFns<CreateTaskOnMechainResponse>;
export declare const AuthenticatedUserData: MessageFns<AuthenticatedUserData>;
export declare const AuthenticationRequest: MessageFns<AuthenticationRequest>;
export declare const InitRequest: MessageFns<InitRequest>;
export declare const InitResponse: MessageFns<InitResponse>;
export declare const TOPRFRequest: MessageFns<TOPRFRequest>;
export declare const TOPRFResponse: MessageFns<TOPRFResponse>;
export declare const RPCMessage: MessageFns<RPCMessage>;
export declare const RPCMessages: MessageFns<RPCMessages>;
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
[]?: DeepPartial<T[K]>;
} : Partial<T>;
export interface MessageFns<T> {
encode(message: T, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): T;
fromJSON(object: any): T;
toJSON(message: T): unknown;
create(base?: DeepPartial<T>): T;
fromPartial(object: DeepPartial<T>): T;
}
export {};