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

package/dist/types/storage/interfaces/data-source.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Generic Key/Value Data Source for crud operation
+ *
+ * @export
+ * @beta
+ * @interface   IDataSource
+ * @template Type - generic type
+ */
+export interface IDataSource<Type> {
+    /**
+     * load all object with Type from data source
+     *
+     * @returns `{Type[]}`
+     */
+    load(): Type[];
+    /**
+     * Save value under the key with optional key name
+     *
+     * @param {string} key - key value
+     * @param {Type} value - value to store
+     * @param {string} [keyName] - key name
+     */
+    save(key: string, value: Type, keyName?: string): void;
+    /**
+     * returns data value for key value and optional key name
+     *
+     * @param {string} key - key value
+     * @param {string} [keyName] -  key name
+     * @returns ` {(Type | undefined)}`
+     */
+    get(key: string, keyName?: string): Type | undefined;
+    /**
+     * deletes data value for given key with an optional key name
+     *
+     * @param {string} key - key value
+     * @param {string} [keyName] -  key name
+     */
+    delete(key: string, keyName?: string): void;
+}

package/dist/types/storage/interfaces/data-storage.d.ts

@@ -0,0 +1,17 @@
+import { ICredentialStorage } from './credentials';
+import { IIdentityStorage } from './identity';
+import { IMerkleTreeStorage } from './merkletree';
+import { IStateStorage } from './state';
+/**
+ * General Data storage interface that union identity, credential, merkletree and states storage.
+ *
+ * @export
+ * @beta
+ * @interface   IDataStorage
+ */
+export interface IDataStorage {
+    credential: ICredentialStorage;
+    identity: IIdentityStorage;
+    mt: IMerkleTreeStorage;
+    states: IStateStorage;
+}

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

@@ -0,0 +1,63 @@
+import { Identity } from '../entities';
+import { Profile } from '../entities';
+/**
+ * storage for identities and profiles
+ *
+ * @export
+ * @beta
+ * @interface   IIdentityStorage
+ */
+export interface IIdentityStorage {
+    /**
+     * saves identity to the data source
+     *
+     * @param {Identity} identity
+     * @returns `{Promise<void>}`
+     */
+    saveIdentity(identity: Identity): Promise<void>;
+    /**
+     * gets identity from the the data source
+     *
+     *
+     * @param {string} identifier - id of identity
+     * @returns `{(Promise<Identity | undefined>)}`
+     */
+    getIdentity(identifier: string): Promise<Identity | undefined>;
+    /**
+     *
+     * gets all identity from the data source
+     *
+     * @returns `{Promise<Identity[]>}`
+     */
+    getAllIdentities(): Promise<Identity[]>;
+    /**
+     *
+     * saves profile identity to data
+     *
+     * @param {Profile} profile - identity profile
+     * @returns `{Promise<void>}`
+     */
+    saveProfile(profile: Profile): Promise<void>;
+    /**
+     * gets profile by verifier
+     *
+     * @param {string} verifier - verifier to which profile has been shared
+     * @returns `{Promise<Profile>}`
+     */
+    getProfileByVerifier(verifier: string): Promise<Profile>;
+    /**
+     * gets profile by identifier
+     *
+     * @param {string} identifier - profile id
+     * @returns `{Promise<Profile>}`
+     */
+    getProfileById(identifier: string): Promise<Profile>;
+    /**
+     *
+     * gets profile identity by genesis identifiers
+     *
+     * @param {string} genesisIdentifier - genesis identifier from which profile has been derived
+     * @returns `{Promise<Profile[]>}`
+     */
+    getProfilesByGenesisIdentifier(genesisIdentifier: string): Promise<Profile[]>;
+}

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

@@ -0,0 +1,7 @@
+export * from './credentials';
+export * from './identity';
+export * from './merkletree';
+export * from './state';
+export * from './data-storage';
+export * from './data-source';
+export * from './circuits';

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

@@ -0,0 +1,44 @@
+import { Merkletree } from '@iden3/js-merkletree';
+import { IdentityMerkleTreeMetaInformation, MerkleTreeType } from '../entities/mt';
+/**
+ * Interface to work with a merkle tree storage
+ *
+ * @export
+ * @beta
+ * @interface   IMerkleTreeStorage
+ */
+export interface IMerkleTreeStorage {
+    /**
+     * creates merkle tree in the storage
+     *
+     * @param {string} identifier
+     * @returns `Promise<IdentityMerkleTreeMetaInformation[]>`
+     */
+    createIdentityMerkleTrees(identifier: string): Promise<IdentityMerkleTreeMetaInformation[]>;
+    /**
+     * adds entry to merkle tree
+     *
+     * @param {string} identifier - identifier to which tree belongs
+     * @param {MerkleTreeType} mtType - merkle tree type
+     * @param {bigint} hindex - hash index
+     * @param {bigint} hvalue - hash value
+     * @returns `Promise<void>`
+     */
+    addToMerkleTree(identifier: string, mtType: MerkleTreeType, hindex: bigint, hvalue: bigint): Promise<void>;
+    /**
+     * gets merkle tree by identifier and type
+     *
+     * @param {string} identifier     - identifier for tree
+     * @param {MerkleTreeType} mtType - merkle tree type
+     * @returns `{Promise<Merkletree>}`
+     */
+    getMerkleTreeByIdentifierAndType(identifier: string, mtType: MerkleTreeType): Promise<Merkletree>;
+    /**
+     * binding to be able to update identifier that belongs to tree
+     *
+     * @param {string} oldIdentifier -
+     * @param {string} newIdentifier -
+     * @returns `{Promise<void>}`
+     */
+    bindMerkleTreeToNewIdentifier(oldIdentifier: string, newIdentifier: string): Promise<void>;
+}

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

@@ -0,0 +1,41 @@
+import { ZKProof } from '@iden3/js-jwz';
+import { Signer } from 'ethers';
+import { RootInfo, StateInfo, StateProof } from '../entities/state';
+/**
+ * Interface that defines methods for state storage
+ *
+ * @export
+ * @beta
+ * @interface   IStateStorage
+ */
+export interface IStateStorage {
+    /**
+     * gets latest state of identity
+     *
+     * @param {bigint} id - id to check
+     * @returns `Promise<StateInfo>`
+     */
+    getLatestStateById(id: bigint): Promise<StateInfo>;
+    /**
+     * method to publish state onchain
+     *
+     * @param {ZKProof} proof - proof to publish
+     * @param {Signer} signer  - signer of transaction
+     * @returns `Promise<string>` - transaction identifier
+     */
+    publishState(proof: ZKProof, signer: Signer): Promise<string>;
+    /**
+     * generates proof of inclusion / non-inclusion to global identity state for given identity
+     *
+     * @param {bigint} id - id to check
+     * @returns `Promise<StateProof>`
+     */
+    getGISTProof(id: bigint): Promise<StateProof>;
+    /**
+     *
+     *
+     * @param {bigint} root - returns info about global state root
+     * @returns `{Promise<RootInfo>}`
+     */
+    getGISTRootInfo(root: bigint): Promise<RootInfo>;
+}

package/dist/types/storage/local-storage/data-source.d.ts

@@ -0,0 +1,47 @@
+import { IDataSource } from '../interfaces/data-source';
+/**
+ * Storage in the browser, uses local storage
+ *
+ * @export
+ * @beta
+ * @class BrowserDataSource
+ * @template Type
+ */
+export declare class BrowserDataSource<Type> implements IDataSource<Type> {
+    private _localStorageKey;
+    /**
+     * Creates an instance of BrowserDataSource.
+     * @param {string} _localStorageKey - key string to put storage name in the local storage
+     */
+    constructor(_localStorageKey: string);
+    /**
+     *
+     * saves value to the local storage
+     * @param {string} key - key value
+     * @param {Type} value - value to store
+     * @param {string} [keyName='id'] -  key name
+     */
+    save(key: string, value: Type, keyName?: string): void;
+    /**
+     * updates data with a total reset
+     *
+     * @param {Type[]} value - value array to update
+     */
+    patchData(value: Type[]): void;
+    /**
+     * gets value from the local storage by given key
+     * @param {string} key - key value
+     * @param {string}  [keyName='id'] -  key name
+     */
+    get(key: string, keyName?: string): Type | undefined;
+    /**
+     * loads all from the local storage
+     */
+    load(): Type[];
+    /**
+     * deletes item from the local storage
+     * @param {string} key - key value
+     * @param {string}  [keyName='id'] -  key name
+     */
+    delete(key: string, keyName?: string): void;
+}

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

@@ -0,0 +1,2 @@
+export * from './data-source';
+export * from './merkletree';

package/dist/types/storage/local-storage/merkletree.d.ts

@@ -0,0 +1,46 @@
+import { Merkletree } from '@iden3/js-merkletree';
+import { IdentityMerkleTreeMetaInformation, MerkleTreeType } from '../entities/mt';
+import { IMerkleTreeStorage } from '../interfaces/merkletree';
+/**
+ * Merkle tree storage that uses browser local storage
+ *
+ * @export
+ * @beta
+ * @class MerkleTreeLocalStorage
+ * @implements implements IMerkleTreeStorage interface
+ */
+export declare class MerkleTreeLocalStorage implements IMerkleTreeStorage {
+    private readonly _mtDepth;
+    /**
+     * key for the local storage
+     *
+     * @static
+     */
+    static readonly storageKey = "merkle-tree";
+    /**
+     * key for the storage key metadata
+     *
+     * @static
+     */
+    static readonly storageKeyMeta = "merkle-tree-meta";
+    /**
+     * Creates an instance of MerkleTreeLocalStorage.
+     * @param {number} _mtDepth
+     */
+    constructor(_mtDepth: number);
+    /** creates a tree in the local storage */
+    createIdentityMerkleTrees(identifier: string): Promise<IdentityMerkleTreeMetaInformation[]>;
+    /**
+     *
+     * getIdentityMerkleTreesInfo from the local storage
+     * @param {string} identifier
+     * @returns `{Promise<IdentityMerkleTreeMetaInformation[]>}`
+     */
+    getIdentityMerkleTreesInfo(identifier: string): Promise<IdentityMerkleTreeMetaInformation[]>;
+    /** get merkle tree from the local storage */
+    getMerkleTreeByIdentifierAndType(identifier: string, mtType: MerkleTreeType): Promise<Merkletree>;
+    /** adds to merkle tree in the local storage */
+    addToMerkleTree(identifier: string, mtType: MerkleTreeType, hindex: bigint, hvalue: bigint): Promise<void>;
+    /** binds merkle tree in the local storage to the new identifiers */
+    bindMerkleTreeToNewIdentifier(oldIdentifier: string, newIdentifier: string): Promise<void>;
+}

package/dist/types/storage/memory/data-source.d.ts

@@ -0,0 +1,22 @@
+import { IDataSource } from '../interfaces/data-source';
+/**
+ * Generic Memory Data Source
+ *
+ * @export
+ * @beta
+ * @class InMemoryDataSource - class
+ * @template Type
+ */
+export declare class InMemoryDataSource<Type> implements IDataSource<Type> {
+    private _data;
+    /** saves in the memory */
+    save(key: string, value: Type, keyName?: string): void;
+    /** updates in the memory */
+    patchData(value: Type[]): void;
+    /** gets value from from the memory */
+    get(key: string, keyName?: string): Type | undefined;
+    /** loads from value from the memory */
+    load(): Type[];
+    /** deletes from value from the memory */
+    delete(key: string, keyName?: string): void;
+}

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

@@ -0,0 +1,2 @@
+export * from './merkletree';
+export * from './data-source';

package/dist/types/storage/memory/merkletree.d.ts

@@ -0,0 +1,49 @@
+import { Merkletree } from '@iden3/js-merkletree';
+import { IdentityMerkleTreeMetaInformation, MerkleTreeType } from '../entities/mt';
+import { IMerkleTreeStorage } from '../interfaces/merkletree';
+declare type TreeWithMetaInfo = {
+    tree: Merkletree;
+    metaInfo: IdentityMerkleTreeMetaInformation;
+};
+/**
+ *
+ *
+ * @export
+ * @beta
+ * @class InMemoryMerkleTreeStorage
+ * @implements implements IMerkleTreeStorage interface
+ */
+export declare class InMemoryMerkleTreeStorage implements IMerkleTreeStorage {
+    /**
+     * key value storage for trees where key is identifier
+     *
+     * @type {{
+     *     [v in string]: TreeWithMetaInfo[];
+     *   }}
+     */
+    _data: {
+        [v in string]: TreeWithMetaInfo[];
+    };
+    /**
+     * tree depth
+     *
+     * @type {number}
+     */
+    mtDepth: number;
+    /**
+     * Creates an instance of InMemoryMerkleTreeStorage.
+     * @param {number} _mtDepth
+     */
+    constructor(_mtDepth: number);
+    /** create trees in the  memory*/
+    createIdentityMerkleTrees(identifier: string): Promise<IdentityMerkleTreeMetaInformation[]>;
+    /** get trees meta info from the memory */
+    getIdentityMerkleTreesInfo(identifier: string): Promise<IdentityMerkleTreeMetaInformation[]>;
+    /** get merkle tree by identifier and type from memory */
+    getMerkleTreeByIdentifierAndType(identifier: string, mtType: MerkleTreeType): Promise<Merkletree>;
+    /** adds entry to merkle tree in the memory */
+    addToMerkleTree(identifier: string, mtType: MerkleTreeType, hindex: bigint, hvalue: bigint): Promise<void>;
+    /** bind merkle tree identifier in memory */
+    bindMerkleTreeToNewIdentifier(oldIdentifier: string, newIdentifier: string): Promise<void>;
+}
+export {};

package/dist/types/storage/shared/circuit-storage.d.ts

@@ -0,0 +1,35 @@
+import { CircuitId } from '../../circuits';
+import { CircuitData } from '../entities/circuitData';
+import { ICircuitStorage } from '../interfaces/circuits';
+import { IDataSource } from '../interfaces/data-source';
+/**
+ * Implementation of ICircuitStorage to store keys data
+ *
+ * @export
+ * @beta
+ * @class CircuitStorage
+ * @implements implements ICircuitStorage interface
+ */
+export declare class CircuitStorage implements ICircuitStorage {
+    private readonly _dataSource;
+    /**
+     * Creates an instance of CircuitStorage.
+     * @param {IDataSource<CircuitData>} _dataSource - data source to store circuit keys
+     */
+    constructor(_dataSource: IDataSource<CircuitData>);
+    /**
+     * loads circuit data by id
+     * {@inheritdoc  ICircuitStorage.loadCircuitData}
+     * @param {CircuitId} circuitId - id of the circuit
+     * @returns `Promise<CircuitData>`
+     */
+    loadCircuitData(circuitId: CircuitId): Promise<CircuitData>;
+    /**
+     * {@inheritdoc  ICircuitStorage.loadCircuitData}
+     * saves circuit data for circuit id
+     * @param {CircuitId} circuitId - id of the circuit
+     * @param {CircuitData} circuitData - circuit keys
+     * @returns `Promise<void>`
+     */
+    saveCircuitData(circuitId: CircuitId, circuitData: CircuitData): Promise<void>;
+}

package/dist/types/storage/shared/credential-storage.d.ts

@@ -0,0 +1,39 @@
+import { ProofQuery, W3CCredential } from '../../verifiable';
+import { ICredentialStorage } from '../interfaces/credentials';
+import { IDataSource } from '../interfaces/data-source';
+/**
+ * Implementation of ICredentialStorage with KV Data source
+ *
+ * @export
+ * @beta
+ * @class CredentialStorage
+ * @implements {ICredentialStorage}
+ */
+export declare class CredentialStorage implements ICredentialStorage {
+    private readonly _dataSource;
+    /**
+     * key for storage
+     *
+     * @static
+     */
+    static readonly storageKey = "credentials";
+    /**
+     * Creates an instance of CredentialStorage.
+     * @param {IDataSource<W3CCredential>} _dataSource - W3CCredential credential KV data source
+     */
+    constructor(_dataSource: IDataSource<W3CCredential>);
+    /** {@inheritdoc ICredentialStorage.listCredentials } */
+    listCredentials(): Promise<W3CCredential[]>;
+    /** @inheritdoc */
+    saveCredential(credential: W3CCredential): Promise<void>;
+    /** {@inheritdoc ICredentialStorage.listCredentials } */
+    saveAllCredentials(credentials: W3CCredential[]): Promise<void>;
+    /** {@inheritdoc ICredentialStorage.listCredentials } */
+    removeCredential(id: string): Promise<void>;
+    /** {@inheritdoc ICredentialStorage.listCredentials } */
+    findCredentialById(id: string): Promise<W3CCredential | undefined>;
+    /** {@inheritdoc ICredentialStorage.listCredentials }
+     * uses JSON query
+     */
+    findCredentialsByQuery(query: ProofQuery): Promise<W3CCredential[]>;
+}

package/dist/types/storage/shared/identity-storage.d.ts

@@ -0,0 +1,40 @@
+import { Identity, Profile } from '../entities';
+import { IDataSource } from '../interfaces/data-source';
+import { IIdentityStorage } from '../interfaces/identity';
+/**
+ * Implementation of the IIdentityStorage with KV data source
+ *
+ * @export
+ * @beta
+ * @class IdentityStorage
+ * @implements implements IIdentityStorage interface
+ */
+export declare class IdentityStorage implements IIdentityStorage {
+    private readonly _identityDataSource;
+    private readonly _profileDataSource;
+    /**
+     * storage key for identities
+     *
+     * @static
+     */
+    static readonly identitiesStorageKey = "identities";
+    /**
+     * storage key for profiles
+     *
+     * @static
+     */
+    static readonly profilesStorageKey = "profiles";
+    /**
+     * Creates an instance of IdentityStorage.
+     * @param {IDataSource<Identity>} _identityDataSource - data source for identities
+     * @param {IDataSource<Profile>} _profileDataSource - data source for profiles
+     */
+    constructor(_identityDataSource: IDataSource<Identity>, _profileDataSource: IDataSource<Profile>);
+    saveProfile(profile: Profile): Promise<void>;
+    getProfileByVerifier(verifier: string): Promise<Profile>;
+    getProfileById(profileId: string): Promise<Profile>;
+    getProfilesByGenesisIdentifier(genesisIdentifier: string): Promise<Profile[]>;
+    getAllIdentities(): Promise<Identity[]>;
+    saveIdentity(identity: Identity): Promise<void>;
+    getIdentity(identifier: string): Promise<Identity>;
+}

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

@@ -0,0 +1,3 @@
+export * from './circuit-storage';
+export * from './credential-storage';
+export * from './identity-storage';

package/dist/types/verifiable/constants.d.ts

@@ -0,0 +1,78 @@
+/** Verifiable constants */
+export declare const VerifiableConstants: Readonly<{
+    ERRORS: {
+        FiELD_IS_EMPTY: string;
+        CONTEXT_TYPE_IS_EMPTY: string;
+        IDENTITY_DOES_NOT_EXIST: string;
+    };
+    CREDENTIAL_TYPE: {
+        W3C_VERIFIABLE: string;
+    };
+    JSONLD_SCHEMA: {
+        IDEN3_CREDENTIAL: string;
+        W3C_CREDENTIAL_2018: string;
+    };
+    JSON_SCHEMA_VALIDATOR: "JsonSchemaValidator2018";
+    SERVICE_TYPE: {
+        IDEN3_COMM: string;
+        PUSH_NOTIFICATION: string;
+    };
+    AUTH: {
+        AUTH_BJJ_CREDENTAIL_HASH: string;
+        AUTH_BJJ_CREDENTIAL_SCHEMA_JSON_URL: string;
+        AUTH_BJJ_CREDENTIAL_SCHEMA_JSONLD_URL: string;
+        AUTH_BJJ_CREDENTIAL_TYPE: string;
+        AUTH_BJJ_CREDENTIAL_SCHEMA_JSON: string;
+    };
+}>;
+/**
+ * Proof type for Verifiable Credential supported by sdk
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum ProofType {
+    BJJSignature = "BJJSignature2021",
+    Iden3SparseMerkleTreeProof = "Iden3SparseMerkleTreeProof"
+}
+/**
+ * CredentialStatusType type for revocation type
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum CredentialStatusType {
+    SparseMerkleTreeProof = "SparseMerkleTreeProof",
+    Iden3ReverseSparseMerkleTreeProof = "Iden3ReverseSparseMerkleTreeProof"
+}
+/**
+ * W3C Proof purpose
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum ProofPurpose {
+    Authentication = "Authentication"
+}
+/**
+ * Merklized Core.Claim root position for vc creation
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum MerklizedRootPosition {
+    Index = "index",
+    Value = "value",
+    None = ""
+}
+/**
+ * Subject Core.Claim position for vc creation
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum SubjectPosition {
+    None = "",
+    Index = "index",
+    Value = "value"
+}