@0xpolygonid/js-sdk 1.0.0-beta.0

package/dist/types/auth/auth.d.ts

@@ -0,0 +1,131 @@
+import { IProofService } from '../proof/proof-service';
+import { AuthorizationRequestMessage, AuthorizationResponseMessage, IPackageManager, ZeroKnowledgeProofRequest } from '../iden3comm';
+import { DID } from '@iden3/js-iden3-core';
+import { ICredentialWallet } from '../credentials';
+import { W3CCredential } from '../verifiable';
+/**
+ * ZKP request and credential that satisfies the zkp query conditions
+ *
+ * @export
+ * @interface ZKPRequestWithCredential
+ */
+export interface ZKPRequestWithCredential {
+    req: ZeroKnowledgeProofRequest;
+    credential: W3CCredential;
+    credentialSubjectProfileNonce: number;
+}
+/**
+ * Interface that allows the processing of the authorization request in the raw format for given identifier
+ *
+ * @export
+ * @beta
+ * @interface IAuthHandler
+ */
+export interface IAuthHandler {
+    /**
+     * Handle authorization request protocol message
+     *
+     * @param {DID} id - identifier that will handle request
+     * @param {Uint8Array} request - request payload
+     * @returns `Promise<{
+     *     token: string;
+     *     authRequest: AuthorizationRequestMessage;
+     *     authResponse: AuthorizationResponseMessage;
+     *   }>`
+     */
+    handleAuthorizationRequestForGenesisDID(did: DID, request: Uint8Array): Promise<{
+        token: string;
+        authRequest: AuthorizationRequestMessage;
+        authResponse: AuthorizationResponseMessage;
+    }>;
+    /**
+     * unpacks authorization request
+     * @export
+     * @beta
+     * @param {Uint8Array} request - raw byte message
+     * @returns `Promise<AuthorizationRequestMessage>`
+     */
+    parseAuthorizationRequest(request: Uint8Array): Promise<AuthorizationRequestMessage>;
+    /**
+     * Generates zero-knowledge proofs for given requests and credentials
+     * @export
+     * @beta
+     * @param {DID} userGenesisDID      - user genesis identifier for which user holds key pair.
+     * @param {number} authProfileNonce - profile nonce that will be used for authorization.
+     * @param {AuthorizationRequestMessage} authRequest - authorization request, protocol message.
+     * @param {ZKPRequestWithCredential[]} zkpRequestsWithCreds - zero knowledge proof request with chosen credential to use.
+     * @returns `Promise<{
+     *     token: string;
+     *     authRequest: AuthorizationRequestMessage;
+     *     authResponse: AuthorizationResponseMessage;
+     *   }>}`
+     */
+    generateAuthorizationResponse(userGenesisDID: DID, authProfileNonce: number, authRequest: AuthorizationRequestMessage, zkpRequestsWithCreds: ZKPRequestWithCredential[]): Promise<{
+        token: string;
+        authRequest: AuthorizationRequestMessage;
+        authResponse: AuthorizationResponseMessage;
+    }>;
+}
+/**
+ *
+ * Allows to process AuthorizationRequest protocol message and produce JWZ response.
+ *
+ * @export
+ * @beta
+
+ * @class AuthHandler
+ * @implements implements IAuthHandler interface
+ */
+export declare class AuthHandler implements IAuthHandler {
+    private readonly _packerMgr;
+    private readonly _proofService;
+    private readonly _credentialWallet;
+    /**
+     * Creates an instance of AuthHandler.
+     * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
+     * @param {IProofService} _proofService -  proof service to verify zk proofs
+     * @param {ICredentialWallet} _credentialWallet -  wallet to search credentials
+     *
+     */
+    constructor(_packerMgr: IPackageManager, _proofService: IProofService, _credentialWallet: ICredentialWallet);
+    /**
+     * Handles only messages with authorization/v1.0/request type
+     * Generates all requested proofs and wraps authorization response message to JWZ token
+     * works when profiles are not supported
+     * @param {DID} did - an identity that will process the request
+     * @param {Uint8Array} request - raw request
+     * @returns `Promise<{token: string; authRequest: AuthorizationRequestMessage; authResponse: AuthorizationResponseMessage;}>` JWZ token, parsed request and response
+     */
+    handleAuthorizationRequestForGenesisDID(did: DID, request: Uint8Array): Promise<{
+        token: string;
+        authRequest: AuthorizationRequestMessage;
+        authResponse: AuthorizationResponseMessage;
+    }>;
+    /**
+     * unpacks authorization request
+     * @export
+     * @beta
+     * @param {Uint8Array} request - raw byte message
+     * @returns `Promise<AuthorizationRequestMessage>`
+     */
+    parseAuthorizationRequest(request: Uint8Array): Promise<AuthorizationRequestMessage>;
+    /**
+     * Generates zero-knowledge proofs for given requests and credentials
+     * @export
+     * @beta
+     * @param {DID} userGenesisDID      - user genesis identifier for which user holds key pair.
+     * @param {number} authProfileNonce - profile nonce that will be used for authorization.
+     * @param {AuthorizationRequestMessage} authRequest - authorization request, protocol message.
+     * @param {ZKPRequestWithCredential[]} zkpRequestsWithCreds - zero knowledge proof request with chosen credential to use.
+     * @returns `Promise<{
+     *     token: string;
+     *     authRequest: AuthorizationRequestMessage;
+     *     authResponse: AuthorizationResponseMessage;
+     *   }>}`
+     */
+    generateAuthorizationResponse(userGenesisDID: DID, authProfileNonce: number, authRequest: AuthorizationRequestMessage, zkpRequestsWithCreds?: ZKPRequestWithCredential[]): Promise<{
+        token: string;
+        authRequest: AuthorizationRequestMessage;
+        authResponse: AuthorizationResponseMessage;
+    }>;
+}

package/dist/types/auth/index.d.ts

@@ -0,0 +1 @@
+export * from './auth';

package/dist/types/circuits/atomic-query-mtp-v2.d.ts

@@ -0,0 +1,64 @@
+import { Id, SchemaHash } from '@iden3/js-iden3-core';
+import { Query, ClaimWithMTPProof } from './models';
+import { Hash } from '@iden3/js-merkletree';
+import { BaseConfig } from './common';
+/**
+ * AtomicQueryMTPInputs ZK private inputs for credentialAtomicQueryMTP.circom
+ *
+ * @export
+ * @beta
+ * @class AtomicQueryMTPV2Inputs
+ * @extends {BaseConfig}
+ */
+export declare class AtomicQueryMTPV2Inputs extends BaseConfig {
+    id: Id;
+    profileNonce: bigint;
+    claimSubjectProfileNonce: bigint;
+    claim: ClaimWithMTPProof;
+    skipClaimRevocationCheck: boolean;
+    requestID: bigint;
+    currentTimeStamp: number;
+    query: Query;
+    /**
+     * Validate AtomicQueryMTPV2 inputs
+     *
+     */
+    validate(): void;
+    /**
+     *
+     * Inputs marshalling
+     * @returns {Uint8Array}
+     */
+    inputsMarshal(): Uint8Array;
+}
+/**
+ * Public signals
+ *
+ * @export
+ * @beta
+ * @class AtomicQueryMTPV2PubSignals
+ * @extends {BaseConfig}
+ */
+export declare class AtomicQueryMTPV2PubSignals extends BaseConfig {
+    requestID?: bigint;
+    userID?: Id;
+    issuerID?: Id;
+    issuerClaimIdenState?: Hash;
+    issuerClaimNonRevState?: Hash;
+    claimSchema: SchemaHash;
+    slotIndex: number;
+    operator: number;
+    value: bigint[];
+    timestamp: number;
+    merklized: number;
+    claimPathKey?: bigint;
+    claimPathNotExists: number;
+    isRevocationChecked: number;
+    /**
+     * PubSignalsUnmarshal unmarshal credentialAtomicQueryMTP.circom public signals array to AtomicQueryMTPPubSignals
+     *
+     * @param {Uint8Array} data
+     * @returns AtomicQueryMTPV2PubSignals
+     */
+    pubSignalsUnmarshal(data: Uint8Array): AtomicQueryMTPV2PubSignals;
+}

package/dist/types/circuits/atomic-query-sig-v2.d.ts

@@ -0,0 +1,65 @@
+import { Id, SchemaHash } from '@iden3/js-iden3-core';
+import { Query, ClaimWithSigProof } from './models';
+import { Hash } from '@iden3/js-merkletree';
+import { BaseConfig } from './common';
+/**
+ * AtomicQuerySigV2Inputs representation for credentialAtomicQuerySig.circom
+ * Inputs and public signals declaration, marshalling and parsing
+ *
+ * @export
+ * @beta
+ * @class AtomicQuerySigV2Inputs
+ * @extends {BaseConfig}
+ */
+export declare class AtomicQuerySigV2Inputs extends BaseConfig {
+    requestID: bigint;
+    id: Id;
+    profileNonce: bigint;
+    claimSubjectProfileNonce: bigint;
+    claim: ClaimWithSigProof;
+    skipClaimRevocationCheck: boolean;
+    currentTimeStamp: number;
+    query: Query;
+    /**
+     *  Validate inputs
+     *
+     */
+    validate(): void;
+    /**
+     * marshal inputs
+     *
+     * @returns Uint8Array
+     */
+    inputsMarshal(): Uint8Array;
+}
+/**
+ *
+ * public signals
+ * @export
+ * @beta
+ * @class AtomicQuerySigV2PubSignals
+ * @extends {BaseConfig}
+ */
+export declare class AtomicQuerySigV2PubSignals extends BaseConfig {
+    requestID?: bigint;
+    userID?: Id;
+    issuerID?: Id;
+    issuerAuthState?: Hash;
+    issuerClaimNonRevState?: Hash;
+    claimSchema: SchemaHash;
+    slotIndex: number;
+    operator: number;
+    value: bigint[];
+    timestamp: number;
+    merklized: number;
+    claimPathKey?: bigint;
+    claimPathNotExists: number;
+    isRevocationChecked: number;
+    /**
+     *
+     * PubSignalsUnmarshal unmarshal credentialAtomicQuerySig.circom public signals array to AtomicQuerySugPubSignals
+     * @param {Uint8Array} data
+     * @returns AtomicQuerySigV2PubSignals
+     */
+    pubSignalsUnmarshal(data: Uint8Array): AtomicQuerySigV2PubSignals;
+}

package/dist/types/circuits/auth-v2.d.ts

@@ -0,0 +1,46 @@
+import { Hash, Proof } from '@iden3/js-merkletree';
+import { Claim, Id } from '@iden3/js-iden3-core';
+import { GISTProof, TreeState } from './models';
+import { BaseConfig } from './common';
+import { Signature } from '@iden3/js-crypto';
+/**
+ * Auth v2 circuit representation
+ * Inputs and public signals declaration, marshalling and parsing
+ *
+ * @export
+ * @beta
+ * @class AuthV2Inputs
+ * @extends {BaseConfig}
+ */
+export declare class AuthV2Inputs extends BaseConfig {
+    genesisID?: Id;
+    profileNonce?: bigint;
+    authClaim?: Claim;
+    authClaimIncMtp: Proof;
+    authClaimNonRevMtp: Proof;
+    treeState: TreeState;
+    gistProof: GISTProof;
+    signature?: Signature;
+    challenge?: bigint;
+    validate(): void;
+    inputsMarshal(): Uint8Array;
+}
+/**
+ * public signals
+ *
+ * @export
+ * @beta
+ * @class AuthV2PubSignals
+ */
+export declare class AuthV2PubSignals {
+    userID: Id;
+    challenge: bigint;
+    GISTRoot: Hash;
+    /**
+     * PubSignalsUnmarshal unmarshal auth.circom public inputs to AuthPubSignals
+     *
+     * @param {Uint8Array} data
+     * @returns AuthV2PubSignals
+     */
+    pubSignalsUnmarshal(data: Uint8Array): AuthV2PubSignals;
+}

package/dist/types/circuits/common.d.ts

@@ -0,0 +1,124 @@
+import { Hash, Proof } from '@iden3/js-merkletree';
+import { TreeState } from './models';
+export declare const defaultMTLevels = 40;
+export declare const defaultValueArraySize = 64;
+export declare const defaultMTLevelsOnChain = 64;
+export declare const defaultMTLevelsClaimsMerklization = 32;
+export declare const ErrorEmptyAuthClaimProof = "empty auth claim mtp proof";
+export declare const ErrorEmptyAuthClaimNonRevProof = "empty auth claim non-revocation mtp proof";
+export declare const ErrorEmptyChallengeSignature = "empty challenge signature";
+export declare const ErrorEmptyClaimSignature = "empty claim signature";
+export declare const ErrorEmptyClaimProof = "empty claim mtp proof";
+export declare const ErrorEmptyClaimNonRevProof = "empty claim non-revocation mtp proof";
+export declare const ErrorUserStateInRelayClaimProof = "empty user state in relay claim non-revocation mtp proof";
+export declare const ErrorEmptyIssuerAuthClaimProof = "empty issuer auth claim mtp proof";
+export declare const ErrorEmptyIssuerAuthClaimNonRevProof = "empty issuer auth claim non-revocation mtp proof";
+/**
+ * base config for circuit inputs
+ *
+ * @export
+ * @beta
+ * @class BaseConfig
+ */
+export declare class BaseConfig {
+    mtLevel: number;
+    valueArraySize: number;
+    mtLevelOnChain: number;
+    mtLevelClaimsMerklization: number;
+    /**
+     *  getMTLevel max circuit MT levels
+     *
+     * @returns number
+     */
+    getMTLevel(): number;
+    /**
+     *  getMTLevel max circuit MT levels
+     *
+     * @returns number
+     */
+    getMTLevelsClaimMerklization(): number;
+    /**
+     * GetValueArrSize return size of circuits value array size
+     *
+     * @returns number
+     */
+    getValueArrSize(): number;
+    /**
+     * getMTLevelOnChain return level on chain for given circuit
+     *
+     * @returns number
+     */
+    getMTLevelOnChain(): number;
+}
+/**
+ * converts hex to Hash
+ *
+ * @param {(string | undefined)} s - string hex
+ * @returns Hash
+ */
+export declare const strMTHex: (s: string | undefined) => Hash;
+/**
+ * converts hexes of tree roots to Hashes
+ *
+ * @param {(string | undefined)} state - state of tree hex
+ * @param {(string | undefined)} claimsTreeRoot - claims tree root hex
+ * @param {(string | undefined)} revocationTreeRoot - revocation tree root hex
+ * @param {(string | undefined)} rootOfRoots - root of roots tree root hex
+ * @returns TreeState
+ */
+export declare const buildTreeState: (state: string | undefined, claimsTreeRoot: string | undefined, revocationTreeRoot: string | undefined, rootOfRoots: string | undefined) => TreeState;
+/**
+ * siblings as string array
+ *
+ * @param {Proof} proof - proof with siblings
+ * @param {number} levels - levels number
+ * @returns string[]
+ */
+export declare const prepareSiblingsStr: (proof: Proof, levels: number) => string[];
+/**
+ * PrepareCircuitArrayValues padding values to size.
+ * Validate array size and throw an exception if array is bigger than size
+ * if array is bigger, circuit cannot compile because number of inputs does not match
+ *
+ *
+ * @param {bigint[]} arr - given values
+ * @param {number} size - size to pad
+ * @returns bigint[]
+ */
+export declare const prepareCircuitArrayValues: (arr: bigint[], size: number) => bigint[];
+/**
+ * converts each big integer in array to string
+ *
+ * @param {bigint[]} arr -  array of big numbers
+ * @returns string[]
+ */
+export declare const bigIntArrayToStringArray: (arr: bigint[]) => string[];
+/**
+ * auxiliary node
+ *
+ * @export
+ * @beta
+ * @interface   NodeAuxValue
+ */
+export interface NodeAuxValue {
+    key: Hash;
+    value: Hash;
+    noAux: string;
+}
+export declare const getNodeAuxValue: (p: Proof | undefined) => NodeAuxValue;
+/**
+ * converts boolean existence param to integer
+ * if true - 1, else - 0
+ *
+ * @param {boolean} b - existence
+ * @returns number
+ */
+export declare const existenceToInt: (b: boolean) => number;
+/**
+ * return object properties
+ *
+ * @export
+ * @param {object} obj
+ * @returns object
+ */
+export declare function getProperties(obj: object): object;

package/dist/types/circuits/comparer.d.ts

@@ -0,0 +1,87 @@
+/**
+ * List of available operators.
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum Operators {
+    NOOP = 0,
+    EQ = 1,
+    LT = 2,
+    GT = 3,
+    IN = 4,
+    NIN = 5,
+    NE = 6
+}
+/** QueryOperators represents operators for atomic circuits */
+export declare const QueryOperators: {
+    $noop: Operators;
+    $eq: Operators;
+    $lt: Operators;
+    $gt: Operators;
+    $in: Operators;
+    $nin: Operators;
+    $ne: Operators;
+};
+export interface IComparer {
+    compare(int: number): boolean;
+}
+/**
+ * Scalar is used to compare two scalar value.
+ *
+ * @export
+ * @beta
+ * @class Scalar
+ * @implements implements IComparer interface
+ */
+export declare class Scalar implements IComparer {
+    private x;
+    private y;
+    /**
+     * Creates an instance of Scalar.
+     * @param {bigint} x - val x
+     * @param {bigint} y - val y
+     */
+    constructor(x: bigint, y: bigint);
+    /**
+     * compares two  scalar values
+     *
+     * @param {Operators} operator - EQ / LT / GT
+     * @returns boolean
+     */
+    compare(operator: Operators): boolean;
+}
+/**
+ * Vector uses for find/not find x scalar type in y vector type.
+ *
+ * @export
+ * @beta
+ * @class Vector
+ * @implements implements IComparer interface
+ */
+export declare class Vector implements IComparer {
+    private x;
+    private y;
+    /**
+     * Creates an instance of Vector.
+     * @param {bigint} x - val x
+     * @param {bigint[]} y - array values y
+     */
+    constructor(x: bigint, y: bigint[]);
+    /**
+     *
+     *
+     * @param {Operators} operator - IN / NIN
+     * @returns boolean
+     */
+    compare(operator: Operators): boolean;
+}
+/**
+ * FactoryComparer depends on input data will return right comparer.
+ *
+ * @param {bigint} x - val x
+ * @param {bigint[]} y - array of values y
+ * @param {Operators} operator - EQ / LT / GT / IN / NIN
+ * @returns IComparer
+ */
+export declare const factoryComparer: (x: bigint, y: bigint[], operator: Operators) => IComparer;

package/dist/types/circuits/index.d.ts

@@ -0,0 +1,7 @@
+export * from './common';
+export * from './models';
+export * from './comparer';
+export * from './atomic-query-mtp-v2';
+export * from './atomic-query-sig-v2';
+export * from './auth-v2';
+export * from './state-transition';