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

package/dist/types/proof/proof-service.d.ts

@@ -0,0 +1,121 @@
+import { TreeState } from './../circuits/models';
+import { W3CCredential } from '../verifiable/credential';
+import { DID } from '@iden3/js-iden3-core';
+import { CircuitId, Query } from '../circuits';
+import { IIdentityWallet } from '../identity';
+import { ICredentialWallet } from '../credentials';
+import { Signature } from '@iden3/js-crypto';
+import { ICircuitStorage } from '../storage/interfaces/circuits';
+import { IStateStorage } from '../storage/interfaces';
+import { Signer } from 'ethers';
+import { ZKProof } from '@iden3/js-jwz';
+import { ZeroKnowledgeProofRequest } from '../iden3comm';
+export interface QueryWithFieldName {
+    query: Query;
+    fieldName: string;
+}
+export interface ProofGenerationOptions {
+    authProfileNonce: number;
+    credentialSubjectProfileNonce: number;
+    skipRevocation: boolean;
+}
+export interface IProofService {
+    /**
+     * Verification of zkp proof for given circuit id
+     *
+     * @param {ZKProof} zkp  - proof to verify
+     * @param {CircuitId} circuitId - circuit id
+     * @returns `{Promise<boolean>}`
+     */
+    verifyProof(zkp: ZKProof, circuitName: CircuitId): Promise<boolean>;
+    /**
+     * Generate proof from given identity and credential for protocol proof request
+     *
+     * @param {ZeroKnowledgeProofRequest} proofReq - protocol zkp request
+     * @param {DID} identifier - did that will generate proof
+     * @param {W3CCredential} credential - credential that will be used for proof generation
+     * @param {ProofGenerationOptions} opts - options that will be used for proof generation
+     *
+     * @returns `Promise<{ proof: ZKProof; credential: W3CCredential }>`
+     */
+    generateProof(proofReq: ZeroKnowledgeProofRequest, identifier: DID, credential: W3CCredential, opts?: ProofGenerationOptions): Promise<{
+        proof: ZKProof;
+        credential: W3CCredential;
+    }>;
+    /**
+     * generates auth inputs
+     *
+     * @param {Uint8Array} hash - challenge that will be signed
+     * @param {DID} did - identity that will generate a proof
+     * @param {Number} profileNonce - identity that will generate a proof
+     * @param {CircuitId} circuitId - circuit id for authentication
+     * @returns `Promise<Uint8Array>`
+     */
+    generateAuthV2Inputs(hash: Uint8Array, did: DID, profileNonce: number, circuitId: CircuitId): Promise<Uint8Array>;
+    /**
+     * state verification function
+     *
+     * @param {string} circuitId - id of authentication circuit
+     * @param {Array<string>} pubSignals - public signals of authentication circuit
+     * @returns `Promise<boolean>`
+     */
+    verifyState(circuitId: string, pubSignals: Array<string>): Promise<boolean>;
+    /**
+     * transitState is done always to the latest state
+     *
+     * Generates a state transition proof and publishes state to the blockchain
+     *
+     * @param {DID} did - identity that will transit state
+     * @param {TreeState} oldTreeState - previous tree state
+     * @param {boolean} isOldStateGenesis - is a transition state is done from genesis state
+     * @param {IStateStorage} stateStorage - storage of identity states (only eth based storage currently)
+     * @param {Signer} ethSigner - signer for transaction
+     * @returns `{Promise<string>}` - transaction hash is returned
+     */
+    transitState(did: DID, oldTreeState: TreeState, isOldStateGenesis: boolean, stateStorage: IStateStorage, ethSigner: Signer): Promise<string>;
+}
+/**
+ * Proof service is an implementation of IProofService
+ * that works with a native groth16 prover
+ *
+ * @export
+ * @beta
+ * @class ProofService
+ * @implements implements IProofService interface
+ */
+export declare class ProofService implements IProofService {
+    private readonly _identityWallet;
+    private readonly _credentialWallet;
+    private readonly _circuitStorage;
+    private readonly _stateStorage;
+    private readonly _prover;
+    /**
+     * Creates an instance of ProofService.
+     * @param {IIdentityWallet} _identityWallet - identity wallet
+     * @param {ICredentialWallet} _credentialWallet - credential wallet
+     * @param {ICircuitStorage} _circuitStorage - circuit storage to load proving / verification files
+     * @param {IStateStorage} _stateStorage - state storage to get GIST proof / publish state
+     */
+    constructor(_identityWallet: IIdentityWallet, _credentialWallet: ICredentialWallet, _circuitStorage: ICircuitStorage, _stateStorage: IStateStorage);
+    /** {@inheritdoc IProofService.verifyProof} */
+    verifyProof(zkp: ZKProof, circuitId: CircuitId): Promise<boolean>;
+    /** {@inheritdoc IProofService.generateProof} */
+    generateProof(proofReq: ZeroKnowledgeProofRequest, identifier: DID, credential: W3CCredential, opts?: ProofGenerationOptions): Promise<{
+        proof: ZKProof;
+        credential: W3CCredential;
+    }>;
+    /** {@inheritdoc IProofService.transitState} */
+    transitState(did: DID, oldTreeState: TreeState, isOldStateGenesis: boolean, stateStorage: IStateStorage, ethSigner: Signer): Promise<string>;
+    private getPreparedCredential;
+    private prepareAuthBJJCredential;
+    private generateInputs;
+    private newCircuitClaimData;
+    private toCircuitsQuery;
+    private prepareMerklizedQuery;
+    private prepareNonMerklizedQuery;
+    private parseRequest;
+    /** {@inheritdoc IProofService.generateAuthV2Inputs} */
+    generateAuthV2Inputs(hash: Uint8Array, did: DID, profileNonce: number, circuitId: CircuitId): Promise<Uint8Array>;
+    verifyState(circuitId: string, pubSignals: Array<string>): Promise<boolean>;
+}
+export declare const bJJSignatureFromHexString: (sigHex: string) => Promise<Signature>;

package/dist/types/proof/prover.d.ts

@@ -0,0 +1,11 @@
+import { ZKProof } from '@iden3/js-jwz';
+import { CircuitId } from '../circuits';
+import { ICircuitStorage } from '../storage/interfaces/circuits';
+export declare class NativeProver {
+    private readonly _circuitStorage;
+    private static readonly curveName;
+    constructor(_circuitStorage: ICircuitStorage);
+    verify(zkp: ZKProof, circuitName: CircuitId): Promise<boolean>;
+    generate(inputs: Uint8Array, circuitId: CircuitId): Promise<ZKProof>;
+    private terminateCurve;
+}

package/dist/types/proof/witness_calculator.d.ts

@@ -0,0 +1,16 @@
+export declare function witnessBuilder(code: any, options?: any): Promise<WitnessCalculator>;
+declare class WitnessCalculator {
+    private instance;
+    version: any;
+    n32: any;
+    prime: any;
+    witnessSize: any;
+    sanityCheck: any;
+    constructor(instance: any, sanityCheck: any);
+    circom_version(): any;
+    _doCalculateWitness(input: any, sanityCheck: any): Promise<void>;
+    calculateWitness(input: any, sanityCheck: any): Promise<any[]>;
+    calculateBinWitness(input: any, sanityCheck: any): Promise<Uint8Array>;
+    calculateWTNSBin(input: any, sanityCheck: any): Promise<Uint8Array>;
+}
+export {};

package/dist/types/schema-processor/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils';
+export * from './json';

package/dist/types/schema-processor/json/index.d.ts

@@ -0,0 +1,2 @@
+export * from './parser';
+export * from './validator';

package/dist/types/schema-processor/json/parser.d.ts

@@ -0,0 +1,103 @@
+import { W3CCredential } from '../../verifiable';
+import { Claim as CoreClaim } from '@iden3/js-iden3-core';
+/**
+ * Parsed slots of core.Claim
+ *
+ * @export
+ * @beta
+ * @interface   ParsedSlots
+ */
+export interface ParsedSlots {
+    indexA: Uint8Array;
+    indexB: Uint8Array;
+    valueA: Uint8Array;
+    valueB: Uint8Array;
+}
+/**
+ * Serialization of data slots for the fields non-merklized claims
+ *
+ * @export
+ * @beta
+ * @interface   SerializationSchema
+ */
+export interface SerializationSchema {
+    indexDataSlotA: string;
+    indexDataSlotB: string;
+    valueDataSlotA: string;
+    valueDataSlotB: string;
+}
+/**
+ * schema metadata in the json credential schema
+ *
+ * @export
+ * @beta
+ * @interface   SchemaMetadata
+ */
+export interface SchemaMetadata {
+    uris: {
+        [key: string]: string;
+    };
+    serialization?: SerializationSchema;
+}
+/**
+ * JSON credential Schema
+ *
+ * @export
+ * @beta
+ * @interface   Schema
+ */
+export interface JSONSchema {
+    $metadata: SchemaMetadata;
+    $schema: string;
+    type: string;
+}
+/**
+ * CoreClaimOptions is params for core claim parsing
+ *
+ * @export
+ * @beta
+ * @interface   CoreClaimOptions
+ */
+export interface CoreClaimOptions {
+    revNonce: number;
+    version: number;
+    subjectPosition: string;
+    merklizedRootPosition: string;
+    updatable: boolean;
+}
+/**
+ * Parser can parse claim data according to specification
+ *
+ * @export
+ * @beta
+ * @class Parser
+ */
+export declare class Parser {
+    /**
+     *  ParseClaim creates core.Claim object from W3CCredential
+     *
+     * @param {W3CCredential} credential - Verifiable Credential
+     * @param {string} credentialType  - credential type that will be used as schema hash e.g. https://url-to-ld-schema.com#AuthBJJCredential
+     * @param {Uint8Array} jsonSchemaBytes - json schema bytes
+     * @param {CoreClaimOptions} [opts] - options to parse core claim
+     * @returns `Promise<CoreClaim>`
+     */
+    parseClaim(credential: W3CCredential, credentialType: string, jsonSchemaBytes: Uint8Array, opts?: CoreClaimOptions): Promise<CoreClaim>;
+    /**
+     * ParseSlots converts payload to claim slots using provided schema
+     *
+     * @param {W3CCredential} credential - Verifiable Credential
+     * @param {Uint8Array} schemaBytes - JSON schema bytes
+     * @returns `ParsedSlots`
+     */
+    parseSlots(credential: W3CCredential, schemaBytes: Uint8Array): ParsedSlots;
+    private assignSlots;
+    /**
+     * GetFieldSlotIndex return index of slot from 0 to 7 (each claim has by default 8 slots) for non-merklized claims
+     *
+     * @param {string} field - field name
+     * @param {Uint8Array} schemaBytes -json schema bytes
+     * @returns `number`
+     */
+    getFieldSlotIndex(field: string, schemaBytes: Uint8Array): number;
+}

package/dist/types/schema-processor/json/validator.d.ts

@@ -0,0 +1,22 @@
+/**
+ * JSON Schema Validator
+ *
+ * @export
+ * @beta
+ * @class JsonSchemaValidator
+ */
+export declare class JsonSchemaValidator {
+    private _ajv;
+    /**
+     * Creates an instance of JsonSchemaValidator.
+     */
+    constructor();
+    /**
+     * Validate data according to the given schema
+     *
+     * @param {Uint8Array} dataB - payload to validate
+     * @param {Uint8Array} schemaB - schema to process
+     * @returns `Promise<boolean>`
+     */
+    validate(dataB: Uint8Array, schemaB: Uint8Array): Promise<boolean>;
+}

package/dist/types/schema-processor/utils.d.ts

@@ -0,0 +1,49 @@
+import { SchemaHash } from '@iden3/js-iden3-core';
+/**
+ * SwapEndianness swaps the endianness of the value encoded in buf. If buf is
+ * Big-Endian, the result will be Little-Endian and vice-versa.
+ *
+ * @param {Uint8Array} buf - bytes to swap
+ * @returns Uint8Array - swapped bytes
+ */
+export declare const swapEndianness: (buf: Uint8Array) => Uint8Array;
+/**
+ * FieldToByteArray convert fields to byte representation based on type
+ *
+ * @export
+ * @param {unknown} field - field to convert
+ * @returns Uint8Array
+ */
+export declare function fieldToByteArray(field: unknown): Uint8Array;
+/**
+ * checks if data fills into slot capacity ()
+ *
+ * @export
+ * @param {Uint8Array} slot - current slot data
+ * @param {Uint8Array} newData - new slot data
+ * @returns boolean
+ */
+export declare function dataFillsSlot(slot: Uint8Array, newData: Uint8Array): boolean;
+/**
+ * check if byte data is in Q field
+ *
+ * @export
+ * @param {Uint8Array} data - bytes payload
+ * @returns boolean
+ */
+export declare function checkDataInField(data: Uint8Array): boolean;
+/**
+ * Calculates schema hash
+ *
+ * @param {Uint8Array} schemaId
+ * @returns {*}  {SchemaHash}
+ */
+export declare const createSchemaHash: (schemaId: Uint8Array) => SchemaHash;
+/**
+ * checks if data can fill the slot
+ *
+ * @param {*} data - object that contains field
+ * @param {string} fieldName - field name
+ * @returns Uint8Array - filled slot
+ */
+export declare const fillSlot: (data: any, fieldName: string) => Uint8Array;

package/dist/types/storage/blockchain/index.d.ts

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

package/dist/types/storage/blockchain/state.d.ts

@@ -0,0 +1,52 @@
+import { RootInfo, StateProof } from './../entities/state';
+import { ZKProof } from '@iden3/js-jwz';
+import { IStateStorage } from '../interfaces/state';
+import { ethers, Signer } from 'ethers';
+import { StateInfo } from '../entities/state';
+/**
+ * Configuration of ethereum based blockchain connection
+ *
+ * @export
+ * @beta
+ * @interface   EthConnectionConfig
+ */
+export interface EthConnectionConfig {
+    url: string;
+    defaultGasLimit: number;
+    minGasPrice?: string;
+    maxGasPrice?: string;
+    confirmationBlockCount: number;
+    confirmationTimeout: number;
+    contractAddress: string;
+    receiptTimeout: number;
+    rpcResponseTimeout: number;
+    waitReceiptCycleTime: number;
+    waitBlockCycleTime: number;
+}
+export declare const defaultEthConnectionConfig: EthConnectionConfig;
+/**
+ *
+ *
+ * @export
+ * @beta
+ * @class EthStateStorage
+ * @implements implements IStateStorage interface
+ */
+export declare class EthStateStorage implements IStateStorage {
+    private readonly ethConfig;
+    readonly stateContract: ethers.Contract;
+    readonly provider: ethers.providers.JsonRpcProvider;
+    /**
+     * Creates an instance of EthStateStorage.
+     * @param {EthConnectionConfig} [ethConfig=defaultEthConnectionConfig]
+     */
+    constructor(ethConfig?: EthConnectionConfig);
+    /** {@inheritdoc IStateStorage.getLatestStateById} */
+    getLatestStateById(id: bigint): Promise<StateInfo>;
+    /** {@inheritdoc IStateStorage.publishState} */
+    publishState(proof: ZKProof, signer: Signer): Promise<string>;
+    /** {@inheritdoc IStateStorage.getGISTProof} */
+    getGISTProof(id: bigint): Promise<StateProof>;
+    /** {@inheritdoc IStateStorage.getGISTRootInfo} */
+    getGISTRootInfo(id: bigint): Promise<RootInfo>;
+}

package/dist/types/storage/entities/circuitData.d.ts

@@ -0,0 +1,7 @@
+/** Circuit data that includes id, wasm file, verification key and proving key */
+export type CircuitData = {
+    circuitId: string;
+    wasm: Uint8Array;
+    verificationKey: Uint8Array;
+    provingKey: Uint8Array;
+};

package/dist/types/storage/entities/identity.d.ts

@@ -0,0 +1,15 @@
+import { Hash } from '@iden3/js-merkletree';
+/** Identity structure that can be used for identity storage */
+export type Identity = {
+    identifier: string;
+    state: Hash;
+    published: boolean;
+    genesis: boolean;
+};
+/** Profile structure that can be used for profiles  storage */
+export type Profile = {
+    id: string;
+    nonce: number;
+    genesisIdentifier: string;
+    verifier: string;
+};

package/dist/types/storage/entities/index.d.ts

@@ -0,0 +1,4 @@
+export * from './identity';
+export * from './mt';
+export * from './state';
+export * from './circuitData';

package/dist/types/storage/entities/mt.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Interface to store metadata about merkle tree
+ *
+ * @export
+ * @beta
+ * @interface   IdentityMerkleTreeMetaInformation
+ */
+export interface IdentityMerkleTreeMetaInformation {
+    treeId: string;
+    identifier: string;
+    type: MerkleTreeType;
+}
+/**
+ * Type of MerkleTree
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum MerkleTreeType {
+    Claims = 0,
+    Revocations = 1,
+    Roots = 2
+}

package/dist/types/storage/entities/state.d.ts

@@ -0,0 +1,48 @@
+/**
+ * state information of identity from chain.
+ *
+ * @export
+ * @beta
+ * @interface   StateInfo
+ */
+export interface StateInfo {
+    id?: bigint;
+    state?: bigint;
+    replacedByState?: bigint;
+    createdAtTimestamp?: bigint;
+    replacedAtTimestamp?: bigint;
+    createdAtBlock?: bigint;
+    replacedAtBlock?: bigint;
+}
+/**
+ * state proof of identity from chain
+ *
+ * @export
+ * @beta
+ * @interface   StateProof
+ */
+export interface StateProof {
+    root: bigint;
+    existence: boolean;
+    siblings: bigint[];
+    index: bigint;
+    value: bigint;
+    auxExistence: boolean;
+    auxIndex: bigint;
+    auxValue: bigint;
+}
+/**
+ * global identity state root info from chain
+ *
+ * @export
+ * @beta
+ * @interface   RootInfo
+ */
+export interface RootInfo {
+    root: bigint;
+    replacedByRoot: bigint;
+    createdAtTimestamp: bigint;
+    replacedAtTimestamp: bigint;
+    createdAtBlock: bigint;
+    replacedAtBlock: bigint;
+}

package/dist/types/storage/errors.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Storage Errors definition
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum StorageErrors {
+    ItemNotFound = "item not found"
+}

package/dist/types/storage/filters/index.d.ts

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

package/dist/types/storage/filters/jsonQuery.d.ts

@@ -0,0 +1,82 @@
+import { W3CCredential, ProofQuery } from '../../verifiable';
+/**
+ * search errors
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum SearchError {
+    NotDefinedQueryKey = "not defined query key",
+    NotDefinedComparator = "not defined comparator"
+}
+/** allowed operators to search */
+export type FilterOperatorMethod = '$noop' | '$eq' | '$in' | '$nin' | '$gt' | '$lt' | '$ne';
+/** filter function type */
+export type FilterOperatorFunction = (a: any, b: any) => boolean;
+/**
+ * query filter interface that allows to query Verifiable Credential
+ *
+ * @export
+ * @beta
+ * @interface   IFilterQuery
+ */
+export interface IFilterQuery {
+    /**
+     * applies filter to verifiable credential
+     *
+     * @param {W3CCredential} credential - credential to query
+     * @returns boolean
+     */
+    execute(credential: W3CCredential): boolean;
+}
+export declare const comparatorOptions: {
+    [v in FilterOperatorMethod]: FilterOperatorFunction;
+};
+/**
+ * credential search path resolver
+ *
+ * @param {object} object - object to query
+ * @param {string} path - given path
+ * @param {*} [defaultValue=null]
+ */
+export declare const resolvePath: (object: object, path: string, defaultValue?: any) => any;
+/**
+ * filter creation factory
+ *
+ * @param {string} path - given query path
+ * @param {*} operatorFunc - filter operation
+ * @param {*} value - filter value
+ * @param {*} [isReverseParams=false] - reversed params
+ */
+export declare const createFilter: (path: string, operatorFunc: any, value: any, isReverseParams?: boolean) => (credential: W3CCredential) => boolean;
+/**
+ * Filter for queries of credentialSubject with a json path e.g  birthday.date
+ *
+ *
+ * @export
+ * @beta
+ * @class FilterQuery
+ * @implements implements IFilterQuery interface
+ */
+export declare class FilterQuery implements IFilterQuery {
+    path: string;
+    operatorFunc: FilterOperatorFunction;
+    value: any;
+    isReverseParams: boolean;
+    /**
+     * Creates an instance of FilterQuery.
+     * @param {string} path
+     * @param {FilterOperatorFunction} operatorFunc
+     * @param {*} value
+     * @param {boolean} [isReverseParams=false]
+     */
+    constructor(path: string, operatorFunc: FilterOperatorFunction, value: any, isReverseParams?: boolean);
+    /** {@inheritdoc IFilterQuery} */
+    execute(credential: W3CCredential): boolean;
+}
+/**
+ * creates filters based on proof query
+ * @param {ProofQuery} query - proof query
+ * @returns {*}  {FilterQuery[]} - array of filters to apply
+ */
+export declare const StandardJSONCredentialsQueryFilter: (query: ProofQuery) => FilterQuery[];

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

@@ -0,0 +1,7 @@
+export * from './interfaces';
+export * from './blockchain';
+export * from './entities';
+export * from './filters';
+export * from './memory';
+export * from './local-storage';
+export * from './shared';

package/dist/types/storage/interfaces/circuits.d.ts

@@ -0,0 +1,26 @@
+import { CircuitId } from '../../circuits';
+import { CircuitData } from '../entities/circuitData';
+/**
+ * Interface to work with circuit files
+ *
+ * @export
+ * @beta
+ * @interface   ICircuitStorage
+ */
+export interface ICircuitStorage {
+    /**
+     * load circuit keys by id
+     *
+     * @param {CircuitId} circuitId - circuit id
+     * @returns `{Promise<CircuitData>}`
+     */
+    loadCircuitData(circuitId: CircuitId): Promise<CircuitData>;
+    /**
+     * saves circuit files by circuit id
+     *
+     * @param {CircuitId} circuitId - circuit id
+     * @param {CircuitData} circuitData - circuit keys
+     * @returns `Promise<void>`
+     */
+    saveCircuitData(circuitId: CircuitId, circuitData: CircuitData): Promise<void>;
+}

package/dist/types/storage/interfaces/credentials.d.ts

@@ -0,0 +1,53 @@
+import { ProofQuery, W3CCredential } from '../../verifiable';
+/**
+ * Interface for credential storages
+ *
+ * @export
+ * @beta
+ * @interface   ICredentialStorage
+ */
+export interface ICredentialStorage {
+    /**
+     *
+     * save credential to the storage
+     *
+     * @param {W3CCredential} credential - credential to save
+     * @returns `{Promise<void>}`
+     */
+    saveCredential(credential: W3CCredential): Promise<void>;
+    /**
+     *
+     * save all credential (upsert) to the storage
+     *
+     * @param {W3CCredential[]} credentials - credentials to save
+     * @returns `Promise<void>`
+     */
+    saveAllCredentials(credentials: W3CCredential[]): Promise<void>;
+    /**
+     * returns all credentials in the storage
+     *
+     * @returns `Promise<W3CCredential[]>`
+     */
+    listCredentials(): Promise<W3CCredential[]>;
+    /**
+     * Removes credential from storage
+     *
+     * @param {string} id  - id of credential
+     * @returns `Promise<void>`
+     */
+    removeCredential(id: string): Promise<void>;
+    /**
+     * finds credential in the storage for given query
+     *
+     * @param {ProofQuery} query - query to apply
+     * @returns `{Promise<W3CCredential[]>}`
+     */
+    findCredentialsByQuery(query: ProofQuery): Promise<W3CCredential[]>;
+    /**
+     * finds credential by identifier
+     *
+     * @param {string} id - id of credential
+     * @returns `{(Promise<W3CCredential | undefined>)}`
+     */
+    findCredentialById(id: string): Promise<W3CCredential | undefined>;
+}