@reclaimprotocol/js-sdk/dist/index.d.ts

Designed to request proofs from the Reclaim protocol and manage the flow of claims and witness interactions.

interface Proof {
    identifier: string;
    claimData: ProviderClaimData;
    signatures: string[];
    witnesses: WitnessData[];
    extractedParameterValues: any;
    publicData?: {
        [key: string]: string;
    };
    taskId?: number;
}
declare const RECLAIM_EXTENSION_ACTIONS: {
    CHECK_EXTENSION: string;
    EXTENSION_RESPONSE: string;
    START_VERIFICATION: string;
    STATUS_UPDATE: string;
};
interface ExtensionMessage {
    action: string;
    messageId: string;
    data?: any;
    extensionID?: string;
}
interface WitnessData {
    id: string;
    url: string;
}
interface ProviderClaimData {
    provider: string;
    parameters: string;
    owner: string;
    timestampS: number;
    context: string;
    identifier: string;
    epoch: number;
}
interface Context {
    contextAddress: string;
    contextMessage: string;
}
interface Beacon {
    getState(epoch?: number): Promise<BeaconState>;
    close?(): Promise<void>;
}
type BeaconState = {
    witnesses: WitnessData[];
    epoch: number;
    witnessesRequiredForClaim: number;
    nextEpochTimestampS: number;
};

type StartSessionParams = {
    onSuccess: OnSuccess;
    onError: OnError;
};
type OnSuccess = (proof?: Proof | Proof[] | string) => void;
type OnError = (error: Error) => void;
type ProofRequestOptions = {
    log?: boolean;
    acceptAiProviders?: boolean;
    useAppClip?: boolean;
    device?: string;
    envUrl?: string;
    useBrowserExtension?: boolean;
    extensionID?: string;
    providerVersion?: string;
};
type ModalOptions = {
    title?: string;
    description?: string;
    extensionUrl?: string;
    darkTheme?: boolean;
    onClose?: () => void;
};
declare enum ClaimCreationType {
    STANDALONE = "createClaim",
    ON_ME_CHAIN = "createClaimOnMechain"
}

declare function verifyProof(proofOrProofs: Proof | Proof[]): Promise<boolean>;
declare function transformForOnchain(proof: Proof): {
    claimInfo: any;
    signedClaim: any;
};
declare class ReclaimProofRequest {
    private applicationId;
    private signature?;
    private appCallbackUrl?;
    private sessionId;
    private options?;
    private context;
    private claimCreationType?;
    private providerId;
    private resolvedProviderVersion?;
    private parameters;
    private redirectUrl?;
    private intervals;
    private timeStamp;
    private sdkVersion;
    private jsonProofResponse;
    private lastFailureTime?;
    private templateData;
    private extensionID;
    private modalOptions?;
    private readonly FAILURE_TIMEOUT;
    private constructor();
    static init(applicationId: string, appSecret: string, providerId: string, options?: ProofRequestOptions): Promise<ReclaimProofRequest>;
    static fromJsonString(jsonString: string): Promise<ReclaimProofRequest>;
    setAppCallbackUrl(url: string, jsonProofResponse?: boolean): void;
    setRedirectUrl(url: string): void;
    setClaimCreationType(claimCreationType: ClaimCreationType): void;
    setModalOptions(options: ModalOptions): void;
    addContext(address: string, message: string): void;
    setParams(params: {
        [key: string]: string;
    }): void;
    getAppCallbackUrl(): string;
    getStatusUrl(): string;
    getSessionId(): string;
    private setSignature;
    private generateSignature;
    private clearInterval;
    toJsonString(options?: ProofRequestOptions): string;
    getRequestUrl(): Promise<string>;
    triggerReclaimFlow(): Promise<void>;
    isBrowserExtensionAvailable(timeout?: number): Promise<boolean>;
    private triggerBrowserExtensionFlow;
    private showQRCodeModal;
    private redirectToInstantApp;
    private redirectToAppClip;
    startSession({ onSuccess, onError }: StartSessionParams): Promise<void>;
}

export { type Beacon, type BeaconState, ClaimCreationType, type Context, type ExtensionMessage, type ModalOptions, type Proof, type ProviderClaimData, RECLAIM_EXTENSION_ACTIONS, ReclaimProofRequest, type WitnessData, transformForOnchain, verifyProof };