@reclaimprotocol/js-sdk 1.3.11 → 2.0.0

package/dist/index.d.ts

@@ -1,51 +1,21 @@
-interface ProviderV2 {
-    id: string;
+interface ProviderData {
     httpProviderId: string;
     name: string;
-    logoUrl: string;
     url: string;
-    method?: 'GET' | 'POST';
     loginUrl: string;
-    responseSelections: {
-        invert: boolean;
-        responseMatch: string;
-        xPath?: string | undefined;
-        jsonPath?: string | undefined;
-    }[];
-    headers?: {
-        [key: string]: string;
-    };
-    creatorEmail: string;
-    applicationId: string[];
-    iconPath: {
-        uri: string;
-    };
-    customInjection?: string;
-    urlType: 'CONSTANT' | 'REGEX';
-    proofCardTitle: string;
-    proofCardText: string;
-    bodySniff?: {
-        enabled: boolean;
-        regex?: string;
-    };
-    userAgent?: {
-        ios?: string;
-        android?: string;
-    };
-    geoLocation?: string;
-    matchType?: string;
-    injectionType: string;
-    verificationType: string;
-    disableRequestReplay: boolean;
+    responseSelections: ResponseSelection[];
+    bodySniff?: BodySniff;
 }
 interface ResponseSelection {
-    JSONPath: string;
-    XPath: string;
+    invert: boolean;
     responseMatch: string;
+    xPath?: string;
+    jsonPath?: string;
 }
 interface BodySniff {
     enabled: boolean;
-    regex: string;
+    regex?: string;
+    template?: string;
 }
 interface Proof {
     identifier: string;
@@ -67,68 +37,13 @@ interface ProviderClaimData {
     owner: string;
     timestampS: number;
     context: string;
-    /**
-     * identifier of the claim;
-     * Hash of (provider, parameters, context)
-     *
-     * This is different from the claimId returned
-     * from the smart contract
-     */
     identifier: string;
     epoch: number;
 }
-interface RequestedProofs {
-    id: string;
-    sessionId: string;
-    name: string;
-    callbackUrl: string;
-    statusUrl: string;
-    claims: RequestedClaim[];
-}
-interface RequestedClaim {
-    provider: string;
-    context: string;
-    httpProviderId: string;
-    payload: Payload;
-}
-interface Payload {
-    metadata: {
-        name: string;
-        logoUrl: string;
-        proofCardTitle: string;
-        proofCardText: string;
-    };
+interface RequestedProof {
     url: string;
-    urlType: 'CONSTANT' | 'REGEX';
-    method: 'GET' | 'POST';
-    login: {
-        url: string;
-    };
-    responseSelections: {
-        invert: boolean;
-        responseMatch: string;
-        xPath?: string;
-        jsonPath?: string;
-    }[];
-    headers?: {
-        [key: string]: string;
-    };
-    customInjection?: string;
-    bodySniff?: {
-        enabled: boolean;
-        regex?: string;
-    };
-    userAgent?: {
-        ios?: string;
-        android?: string;
-    };
-    geoLocation?: string;
-    matchType?: string;
-    injectionType: string;
-    verificationType: string;
-    disableRequestReplay: boolean;
     parameters: {
-        [key: string]: string | undefined;
+        [key: string]: string;
     };
 }
 interface Context {
@@ -136,10 +51,6 @@ interface Context {
     contextMessage: string;
 }
 interface Beacon {
-    /**
-     * Get the witnesses for the epoch specified
-     * or the current epoch if none is specified
-     */
     getState(epoch?: number): Promise<BeaconState>;
     close?(): Promise<void>;
 }
@@ -151,72 +62,53 @@ type BeaconState = {
 };
 
 type StartSessionParams = {
-    onSuccessCallback: OnSuccessCallback;
-    onFailureCallback: OnFailureCallback;
+    onSuccess: OnSuccess;
+    onError: OnError;
 };
-type OnSuccessCallback = (proofs: Proof[]) => void;
-type OnFailureCallback = (error: Error) => void;
+type OnSuccess = (proof: Proof) => void;
+type OnError = (error: Error) => void;
 type ProofRequestOptions = {
     log?: boolean;
-    sessionId?: string;
+    acceptAiProviders?: boolean;
 };
-type ApplicationId = string;
-type Signature = string;
-type AppCallbackUrl = string;
-type SessionId = string;
-type StatusUrl = string;
-type NoReturn = void;
 
-declare class Reclaim {
-    static verifySignedProof(proof: Proof): Promise<boolean>;
-    static transformForOnchain(proof: Proof): {
-        claimInfo: {
-            [k: string]: string;
-        };
-        signedClaim: {
-            claim: {
-                [k: string]: string | number;
-            };
-            signatures: string[];
-        };
-    };
-    static verifyProvider(proof: Proof, providerHash: string): boolean;
-    static ProofRequest: {
-        new (applicationId: string, options?: ProofRequestOptions): {
-            applicationId: ApplicationId;
-            signature?: string | undefined;
-            appCallbackUrl?: string | undefined;
-            sessionId: SessionId;
-            statusUrl?: string | undefined;
-            context: Context;
-            requestedProofs?: RequestedProofs | undefined;
-            providerId?: string | undefined;
-            redirectUrl?: string | undefined;
-            intervals: Map<string, NodeJS.Timer>;
-            linkingVersion: string;
-            timeStamp: string;
-            addContext(address: string, message: string): NoReturn;
-            setAppCallbackUrl(url: string): NoReturn;
-            setRedirectUrl(url: string): NoReturn;
-            setStatusUrl(url: string): NoReturn;
-            setSignature(signature: Signature): NoReturn;
-            getAppCallbackUrl(): AppCallbackUrl;
-            getStatusUrl(): StatusUrl;
-            getRequestedProofs(): RequestedProofs;
-            generateSignature(applicationSecret: string): Promise<Signature>;
-            buildProofRequest(providerId: string, redirectUser?: boolean, linkingVersion?: string): Promise<RequestedProofs>;
-            createVerificationRequest(): Promise<{
-                statusUrl: StatusUrl;
-                requestUrl: string;
-            }>;
-            startSession({ onSuccessCallback, onFailureCallback }: StartSessionParams): Promise<void>;
-            scheduleIntervalEndingTask(onFailureCallback: OnFailureCallback): void;
-            availableParams(): string[];
-            setParams(params: {
-                [key: string]: string;
-            }): NoReturn;
-        };
-    };
+declare function verifyProof(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 requestedProof?;
+    private providerId;
+    private redirectUrl?;
+    private intervals;
+    private timeStamp;
+    private constructor();
+    static init(applicationId: string, appSecret: string, providerId: string, options?: ProofRequestOptions): Promise<ReclaimProofRequest>;
+    static fromJsonString(jsonString: string): Promise<ReclaimProofRequest>;
+    setAppCallbackUrl(url: string): void;
+    setRedirectUrl(url: string): void;
+    addContext(address: string, message: string): void;
+    setParams(params: {
+        [key: string]: string;
+    }): void;
+    getAppCallbackUrl(): string;
+    getStatusUrl(): string;
+    private setSignature;
+    private generateSignature;
+    private buildProofRequest;
+    private getRequestedProof;
+    private availableParams;
+    private clearInterval;
+    toJsonString(options?: ProofRequestOptions): string;
+    getRequestUrl(): Promise<string>;
+    startSession({ onSuccess, onError }: StartSessionParams): Promise<void>;
 }
 
-export { type Beacon, type BeaconState, type BodySniff, type Context, type Payload, type Proof, type ProviderClaimData, type ProviderV2, Reclaim, type RequestedClaim, type RequestedProofs, type ResponseSelection, type WitnessData };
+export { type Beacon, type BeaconState, type BodySniff, type Context, type Proof, type ProviderClaimData, type ProviderData, ReclaimProofRequest, type RequestedProof, type ResponseSelection, type WitnessData, transformForOnchain, verifyProof };