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

package/dist/types/identity/identity-wallet.d.ts

@@ -0,0 +1,248 @@
+import { KMS, KmsKeyId, KmsKeyType } from '../kms';
+import { Blockchain, Claim, DID, DidMethod, NetworkId } from '@iden3/js-iden3-core';
+import { Signature } from '@iden3/js-crypto';
+import { IDataStorage } from '../storage/interfaces/data-storage';
+import { W3CCredential, MerkleTreeProofWithTreeState } from '../verifiable';
+import { CredentialRequest, ICredentialWallet } from '../credentials';
+import { TreesModel } from '../credentials/revocation';
+import { TreeState } from '../circuits';
+/**
+ * Credential issue options
+ * with publishing to chain and to reverse hash service
+ *
+ * @export
+ * @beta
+ * @interface   CredentialIssueOptions
+ */
+export interface CredentialIssueOptions {
+    /**
+     * option to show if reverse hash service is used to check the Credential Status
+     *
+     */
+    withRHS: string;
+}
+/**
+ * DID creation options
+ * seed - seed to generate BJJ keypair
+ * rhsUrl - rhsUrl is url to reverse hash service, so revocation status can be fetched for Auth BJJ credential
+ * @export
+ * @interface IdentityCreationOptions
+ */
+export interface IdentityCreationOptions {
+    method: DidMethod;
+    blockchain: Blockchain;
+    networkId: NetworkId;
+    seed?: Uint8Array;
+    rhsUrl?: string;
+}
+/**
+ *  Proof creation result
+ *
+ * @export
+ * @beta
+ * @interface   Iden3ProofCreationResult
+ */
+export interface Iden3ProofCreationResult {
+    credentials: W3CCredential[];
+    oldTreeState: TreeState;
+    newTreeState: TreeState;
+}
+/**
+ * Interface for IdentityWallet
+ * @public
+ * @beta
+ */
+export interface IIdentityWallet {
+    /**
+     * Create Identity creates Auth BJJ credential,
+     * Merkle trees for claims, revocations and root of roots,
+     * adds auth BJJ credential to claims tree and generates mtp of inclusion
+     * based on the resulting state it provides an identifier in DID form.
+     *
+     * @param {string} hostUrl - hostUrl is used as a part of the identifier of Auth BJJ credential
+     * @param {IdentityCreationOptions} opts - default is did:iden3:polygon:mumbai** with generated key.
+     * @returns `Promise<{ did: DID; credential: W3CCredential }>` - returns did and Auth BJJ credential
+     * @beta
+     */
+    createIdentity(hostUrl: string, opts?: IdentityCreationOptions): Promise<{
+        did: DID;
+        credential: W3CCredential;
+    }>;
+    /**
+     * Creates profile based on genesis identifier
+     *
+     * @param {DID} did - identity to derive profile from
+     * @param {number} nonce - unique integer number to generate a profile
+     * @param {string} verifier - verifier identity/alias in a string from
+     * @returns `Promise<DID>` - profile did
+     */
+    createProfile(did: DID, nonce: number, verifier: string): Promise<DID>;
+    /**
+     * Generates a new key
+     *
+     * @param {KmsKeyType} keyType - supported key type by KMS
+     * @returns `Promise<KmsKeyId>` - creates a new key BJJ or ECDSA
+     */
+    generateKey(keyType: KmsKeyType): Promise<KmsKeyId>;
+    /**
+     * Issues new credential from issuer according to the claim request
+     *
+     * @param {DID} issuerDID - issuer identity
+     * @param {CredentialRequest} req - claim request
+     * @param {string} hostUrl - url that will be a part of credential id prefix
+     * @param {CredentialIssueOptions} [opts] - with / without RHS
+     * @returns `Promise<W3CCredential>` - returns created W3CCredential
+     */
+    issueCredential(issuerDID: DID, req: CredentialRequest, hostUrl: string, opts?: CredentialIssueOptions): Promise<W3CCredential>;
+    /**
+     * Gets a tree model for given did that includes claims tree, revocation tree, the root of roots tree and calculated state hash
+     *
+     * @param {DID} did - did which trees info we need to receive
+     * @returns `Promise<TreesModel>`
+     * */
+    getDIDTreeModel(did: DID): Promise<TreesModel>;
+    /**
+     * Generates proof of credential inclusion / non-inclusion to the given claims tree
+     * and its root or to the current root of the Claims tree in the given Merkle tree storage.
+     *
+     * @param {DID} did - issuer did
+     * @param {W3CCredential} credential - credential to generate mtp
+     * @param {TreeState} [treeState] - tree state when to generate a proof
+     * @returns `Promise<MerkleTreeProofWithTreeState>` - MerkleTreeProof and TreeState on which proof has been generated
+     */
+    generateCredentialMtp(did: DID, credential: W3CCredential, treeState?: TreeState): Promise<MerkleTreeProofWithTreeState>;
+    /**
+     * Generates proof of credential revocation nonce inclusion / non-inclusion to the given revocation tree
+     * and its root or to the current root of the Revocation tree in the given Merkle tree storage.
+     *
+     * @param {DID} did
+     * @param {W3CCredential} credential
+     * @param {TreeState} [treeState]
+     * @returns `Promise<MerkleTreeProofWithTreeState>` -  MerkleTreeProof and TreeState on which proof has been generated
+     */
+    generateNonRevocationMtp(did: DID, credential: W3CCredential, treeState?: TreeState): Promise<MerkleTreeProofWithTreeState>;
+    /**
+     * Signs a payload of arbitrary size with an Auth BJJ Credential that identifies a key for signing.
+     *
+     * @param {Uint8Array} payload
+     * @param {W3CCredential} credential - Auth BJJ Credential
+     * @returns `Promise<Signature>`-  the signature object with R8 and S params
+     */
+    sign(payload: Uint8Array, credential: W3CCredential): Promise<Signature>;
+    /**
+     * Signs a big integer with an Auth BJJ Credential that identifies a key for signing.
+     *
+     *
+     * @param {bigint} payload - big number in Field
+     * @param {W3CCredential} credential - Auth BJJ credential
+     * @returns `Promise<Signature>` - the signature object with R8 and S params
+     */
+    signChallenge(payload: bigint, credential: W3CCredential): Promise<Signature>;
+    /**
+     *
+     *
+     * @param {DID} issuerDID  - identifier of the issuer
+     * @param {W3CCredential} credential - credential to revoke
+     * @returns `Promise<number>` a revocation nonce of credential
+     */
+    revokeCredential(issuerDID: DID, credential: W3CCredential): Promise<number>;
+    /**
+     * Generate Iden3SparseMerkleTree proof of inclusion to issuer state of specific credentials
+     *
+     * @param {DID} issuerDID - issuer did
+     * @param {W3CCredential[]} credentials - list of verifiable credentials to generate a proof
+     * @param {string} txId - transaction hash in which state transition has been done
+     * @param {number} [blockNumber] - block number in which state transition has been done
+     * @param {number} [blockTimestamp] - block timestamp in which state transition has been done
+     * @returns `Promise<W3CCredential[]>` credentials with an Iden3SparseMerkleTreeProof
+     */
+    generateIden3SparseMerkleTreeProof(issuerDID: DID, credentials: W3CCredential[], txId: string, blockNumber?: number, blockTimestamp?: number): Promise<W3CCredential[]>;
+    /**
+     * Adds verifiable credentials to issuer Claims Merkle tree
+     *
+     * @param {W3CCredential[]} credentials - credentials to include in the claims tree
+     * @param {DID} issuerDID - issuer did
+     * @returns `Promise<Iden3ProofCreationResult>`- old tree state and tree state with included credentials
+     */
+    addCredentialsToMerkleTree(credentials: W3CCredential[], issuerDID: DID): Promise<Iden3ProofCreationResult>;
+    /**
+     *
+     *
+     * @param {DID} issuerDID - issuer did
+     * @param {string} rhsURL - reverse hash service URL
+     * @param {number[]} [revokedNonces] - revoked nonces for the period from the last published
+     * @returns `Promise<void>`
+     */
+    publishStateToRHS(issuerDID: DID, rhsURL: string, revokedNonces?: number[]): Promise<void>;
+    /**
+     * Extracts core claim from signature or merkle tree proof. If both proof persists core claim must be the same
+     *
+     * @exports
+     * @beta
+     * @param {W3CCredential} credential - credential to extract core claim
+     * @returns `{Promise<Claim>}`
+     */
+    getCoreClaimFromCredential(credential: W3CCredential): Promise<Claim>;
+}
+/**
+ * @public
+ * Wallet instance to manage the digital identity based on iden3 protocol
+ * allows to: create identity/profile, sign payloads (bigint / bytes), generate keys,
+ * generate Merkle tree proofs of inclusion / non-inclusion to Merkle trees, issue credentials with a BJJSignature and Iden3SparseMerkleTree Proofs,
+ * revoke credentials, add credentials to Merkle trees, push states to reverse hash service
+ *
+ *
+ * @export
+ * @beta
+ * @class IdentityWallet - class
+ * @beta
+ * @implements implements IIdentityWallet interface
+ */
+export declare class IdentityWallet implements IIdentityWallet {
+    private readonly _kms;
+    private readonly _storage;
+    private readonly _credentialWallet;
+    /**
+     * Constructs a new instance of the `IdentityWallet` class
+     *
+     * @param {KMS} _kms - Key Management System that allows signing data with BJJ key
+     * @param {IDataStorage} _storage - data storage to access credential / identity / Merkle tree data
+     * @param {ICredentialWallet} _credentialWallet - credential wallet instance to quickly access credential CRUD functionality
+     * @public
+     */
+    constructor(_kms: KMS, _storage: IDataStorage, _credentialWallet: ICredentialWallet);
+    /**
+     * {@inheritDoc IIdentityWallet.createIdentity}
+     */
+    createIdentity(hostUrl: string, opts?: IdentityCreationOptions): Promise<{
+        did: DID;
+        credential: W3CCredential;
+    }>;
+    /** {@inheritDoc IIdentityWallet.createProfile} */
+    createProfile(did: DID, nonce: number, verifier: string): Promise<DID>;
+    /** {@inheritDoc IIdentityWallet.generateKey} */
+    generateKey(keyType: KmsKeyType): Promise<KmsKeyId>;
+    /** {@inheritDoc IIdentityWallet.getDIDTreeModel} */
+    getDIDTreeModel(did: DID): Promise<TreesModel>;
+    /** {@inheritDoc IIdentityWallet.generateClaimMtp} */
+    generateCredentialMtp(did: DID, credential: W3CCredential, treeState?: TreeState): Promise<MerkleTreeProofWithTreeState>;
+    /** {@inheritDoc IIdentityWallet.generateNonRevocationMtp} */
+    generateNonRevocationMtp(did: DID, credential: W3CCredential, treeState?: TreeState): Promise<MerkleTreeProofWithTreeState>;
+    /** {@inheritDoc IIdentityWallet.sign} */
+    sign(message: Uint8Array, credential: W3CCredential): Promise<Signature>;
+    /** {@inheritDoc IIdentityWallet.signChallenge} */
+    signChallenge(challenge: bigint, credential: W3CCredential): Promise<Signature>;
+    /** {@inheritDoc IIdentityWallet.issueCredential} */
+    issueCredential(issuerDID: DID, req: CredentialRequest, hostUrl: string, opts?: CredentialIssueOptions): Promise<W3CCredential>;
+    /** {@inheritDoc IIdentityWallet.revokeCredential} */
+    revokeCredential(issuerDID: DID, credential: W3CCredential): Promise<number>;
+    /** {@inheritDoc IIdentityWallet.addCredentialsToMerkleTree} */
+    addCredentialsToMerkleTree(credentials: W3CCredential[], issuerDID: DID): Promise<Iden3ProofCreationResult>;
+    /** {@inheritDoc IIdentityWallet.generateIden3SparseMerkleTreeProof} */
+    generateIden3SparseMerkleTreeProof(issuerDID: DID, credentials: W3CCredential[], txId: string, blockNumber?: number, blockTimestamp?: number): Promise<W3CCredential[]>;
+    /** {@inheritDoc IIdentityWallet.publishStateToRHS} */
+    publishStateToRHS(issuerDID: DID, rhsURL: string, revokedNonces?: number[]): Promise<void>;
+    private getKMSIdByAuthCredential;
+    private defineMTRootPosition;
+    getCoreClaimFromCredential(credential: W3CCredential): Promise<Claim>;
+}

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

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

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+export * from './identity';
+export * from './credentials';
+export * from './kms';
+export * from './storage';
+export * from './verifiable';
+export * from './schema-processor';
+export * from './proof';
+export * from './iden3comm';
+export * from './circuits';
+export * from './loaders';
+import * as core from '@iden3/js-iden3-core';
+export { core };

package/dist/types/kms/bjj-provider.d.ts

@@ -0,0 +1,47 @@
+import { PublicKey } from '@iden3/js-crypto';
+import { IKeyProvider } from './kms';
+import { AbstractPrivateKeyStore, KmsKeyId, KmsKeyType } from './store';
+/**
+ * Provider for Baby Jub Jub keys
+ * @beta
+ * @export
+ * @beta
+ * @class BjjProvider
+ * @implements implements IKeyProvider interface
+ */
+export declare class BjjProvider implements IKeyProvider {
+    /**
+     * key type that is handled by BJJ Provider
+     * @type {KmsKeyType}
+     */
+    keyType: KmsKeyType;
+    private keyStore;
+    /**
+     * Creates an instance of BjjProvider.
+     * @param {KmsKeyType} keyType - kms key type
+     * @param {AbstractPrivateKeyStore} keyStore - key store for kms
+     */
+    constructor(keyType: KmsKeyType, keyStore: AbstractPrivateKeyStore);
+    /**
+     * generates a baby jub jub key from a seed phrase
+     * @param {Uint8Array} seed - byte array seed
+     * @returns kms key identifier
+     */
+    newPrivateKeyFromSeed(seed: Uint8Array): Promise<KmsKeyId>;
+    /**
+     * Gets public key by kmsKeyId
+     *
+     * @param {KmsKeyId} keyId - key identifier
+     */
+    publicKey(keyId: KmsKeyId): Promise<PublicKey>;
+    /**
+     * signs prepared payload of size,
+     * with a key id
+     *
+     * @param {KmsKeyId} keyId  - key identifier
+     * @param {Uint8Array} data - data to sign (32 bytes)
+     * @returns Uint8Array signature
+     */
+    sign(keyId: KmsKeyId, data: Uint8Array): Promise<Uint8Array>;
+    private privateKey;
+}

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

@@ -0,0 +1,3 @@
+export * from './kms';
+export * from './bjj-provider';
+export * from './store';

package/dist/types/kms/kms.d.ts

@@ -0,0 +1,80 @@
+import { PublicKey } from '@iden3/js-crypto';
+import { KmsKeyId, KmsKeyType } from './store';
+/**
+ * KeyProvider is responsible for signing and creation of the keys
+ *
+ * @export
+ * @beta
+ * @interface   IKeyProvider
+ */
+export interface IKeyProvider {
+    /**
+     * property to store key type
+     *
+     * @type {KmsKeyType}
+     */
+    keyType: KmsKeyType;
+    /**
+     * gets public key by key id
+     *
+     * @param {KmsKeyId} keyID - kms key identifier
+     * @returns `Promise<PublicKey>`
+     */
+    publicKey(keyID: KmsKeyId): Promise<PublicKey>;
+    /**
+     * sign data with kms key
+     *
+     * @param {KmsKeyId} keyId - key identifier
+     * @param {Uint8Array} data  - bytes payload
+     * @returns `Promise<Uint8Array>`
+     */
+    sign(keyId: KmsKeyId, data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * creates new key pair from given seed
+     *
+     * @param {Uint8Array} seed - seed
+     * @returns `Promise<KmsKeyId>`
+     */
+    newPrivateKeyFromSeed(seed: Uint8Array): Promise<KmsKeyId>;
+}
+/**
+ * Key management system class contains different key providers.
+ * allows to register custom provider, create key, get public key and sign
+ *
+ * @beta
+ * @export
+ * @class KMS - class
+ */
+export declare class KMS {
+    private registry;
+    /**
+     * register key provider in the KMS
+     *
+     * @param {KmsKeyType} keyType - kms key type
+     * @param {IKeyProvider} keyProvider - key provider implementation
+     */
+    registerKeyProvider(keyType: KmsKeyType, keyProvider: IKeyProvider): void;
+    /**
+     * generates a new key and returns it kms key id
+     *
+     * @param {KmsKeyType} keyType
+     * @param {Uint8Array} bytes
+     * @returns kms key id
+     */
+    createKeyFromSeed(keyType: KmsKeyType, bytes: Uint8Array): Promise<KmsKeyId>;
+    /**
+     * gets public key for key id
+     *
+     * @param {KmsKeyId} keyId -- key id
+     * @returns public key
+     */
+    publicKey(keyId: KmsKeyId): Promise<PublicKey>;
+    /**
+     * sign Uint8Array with giv KmsKeyIden
+     *
+     * @param {KmsKeyId} keyId - key id
+     * @param {Uint8Array} data - prepared data bytes
+     * @returns `Promise<Uint8Array>` - return signature
+     */
+    sign(keyId: KmsKeyId, data: Uint8Array): Promise<Uint8Array>;
+}

package/dist/types/kms/provider-helpers.d.ts

@@ -0,0 +1,18 @@
+import { KmsKeyType } from './store';
+/**
+ * builds key path
+ *
+ * @export
+ * @param {KmsKeyType} keyType - key type
+ * @param {string} keyID - key id
+ * @returns string path
+ */
+export declare function keyPath(keyType: KmsKeyType, keyID: string): string;
+/**
+ * generates Uint8Array with random bytes of size n
+ *
+ * @export
+ * @param {number} n - size of array
+ * @returns Uint8Array
+ */
+export declare function getRandomBytes(n: number): Uint8Array;

package/dist/types/kms/store/abstract-key-store.d.ts

@@ -0,0 +1,31 @@
+/**
+ * KeyStore that allows to import and get keys by alias.
+ *
+ * @export
+ * @abstract
+ * @beta
+ * @class AbstractPrivateKeyStore
+ */
+export declare abstract class AbstractPrivateKeyStore {
+    /**
+     * imports key by alias
+     *
+     * @abstract
+     * @param {{ alias: string; key: string }} args - key alias and hex representation
+     * @returns `Promise<void>`
+     */
+    abstract import(args: {
+        alias: string;
+        key: string;
+    }): Promise<void>;
+    /**
+     * get key by alias
+     *
+     * @abstract
+     * @param {{ alias: string }} args -key alias
+     * @returns `Promise<string>`
+     */
+    abstract get(args: {
+        alias: string;
+    }): Promise<string>;
+}

package/dist/types/kms/store/index.d.ts

@@ -0,0 +1,4 @@
+export * from './abstract-key-store';
+export * from './memory-key-store';
+export * from './types';
+export * from './local-storage-key-store';

package/dist/types/kms/store/local-storage-key-store.d.ts

@@ -0,0 +1,32 @@
+import { AbstractPrivateKeyStore } from './abstract-key-store';
+/**
+ * Allows storing keys in the local storage of the browser
+ * (NOT ENCRYPTED: DO NOT USE IN THE PRODUCTION)
+ *
+ * @export
+ * @beta
+ * @class LocalStoragePrivateKeyStore
+ * @implements implements AbstractPrivateKeyStore interface
+ */
+export declare class LocalStoragePrivateKeyStore implements AbstractPrivateKeyStore {
+    static readonly storageKey = "keystore";
+    /**
+     * Gets key from the local storage
+     *
+     * @param {{ alias: string }} args
+     * @returns hex string
+     */
+    get(args: {
+        alias: string;
+    }): Promise<string>;
+    /**
+     * Import key to the local storage
+     *
+     * @param {{ alias: string; key: string }} args - alias and private key in the hex
+     * @returns void
+     */
+    import(args: {
+        alias: string;
+        key: string;
+    }): Promise<void>;
+}

package/dist/types/kms/store/memory-key-store.d.ts

@@ -0,0 +1,20 @@
+import { AbstractPrivateKeyStore } from './abstract-key-store';
+/**
+ * Key Store to use in memory
+ *
+ * @export
+ * @beta
+ * @class InMemoryPrivateKeyStore
+ * @implements implements AbstractPrivateKeyStore interface
+ */
+export declare class InMemoryPrivateKeyStore implements AbstractPrivateKeyStore {
+    private _data;
+    constructor();
+    get(args: {
+        alias: string;
+    }): Promise<string>;
+    import(args: {
+        alias: string;
+        key: string;
+    }): Promise<void>;
+}

package/dist/types/kms/store/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Key type that can be used in the key management system
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum KmsKeyType {
+    BabyJubJub = "BJJ",
+    Ethereum = "ETH"
+}
+/**
+ * ID of the key that describe contain key type
+ *
+ * @export
+ * @beta
+ * @interface   KmsKeyId
+ */
+export interface KmsKeyId {
+    type: KmsKeyType;
+    id: string;
+}

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

@@ -0,0 +1,2 @@
+export * from './key';
+export * from './schema';

package/dist/types/loaders/key.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Loader interface to load from different sources
+ *
+ * @export
+ * @beta
+ * @interface   IKeyLoader
+ */
+export interface IKeyLoader {
+    /**
+     * loads file as a byte array
+     *
+     * @param {string} path - path to file
+     * @returns `Promise<Uint8Array>`
+     */
+    load(path: string): Promise<Uint8Array>;
+}
+/**
+ * Loader from file system
+ *
+ * @export
+ * @beta
+ * @class FSKeyLoader
+ * @implements implements IKeyLoader interface
+ */
+export declare class FSKeyLoader implements IKeyLoader {
+    readonly dir: string;
+    constructor(dir: string);
+    load(path: string): Promise<Uint8Array>;
+}

package/dist/types/loaders/schema.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Loader interface to load schema
+ *
+ * @export
+ * @beta
+ * @interface   ISchemaLoader
+ */
+export interface ISchemaLoader {
+    /**
+     * loads schema by its url
+     *
+     * @param {string} url
+     * @returns `Promise<Uint8Array>`
+     */
+    load(url: string): Promise<Uint8Array>;
+}
+/**
+ * loads schemas from ipfs and http sources
+ *
+ * @export
+ * @beta
+ * @class UniversalSchemaLoader
+ * @implements implements ISchemaLoader interface
+ */
+export declare class UniversalSchemaLoader implements ISchemaLoader {
+    private ipfsUrl;
+    constructor(ipfsUrl: string);
+    /**
+     * loads schema by URL
+     *
+     * @param {string} url - schema URL
+     * @returns `Promise<Uint8Array>`
+     */
+    load(url: string): Promise<Uint8Array>;
+}
+/**
+ * loads schemas from http source
+ *
+ * @export
+ * @beta
+ * @class HttpSchemaLoader
+ * @implements implements ISchemaLoader interface
+ */
+export declare class HttpSchemaLoader implements ISchemaLoader {
+    /**
+     *
+     *
+     * @param {string} url - schema URL
+     * @returns `Promise<Uint8Array>`
+     */
+    load(url: string): Promise<Uint8Array>;
+}
+/**
+ * loads schemas from ipfs source
+ *
+ * @export
+ * @beta
+ * @class IpfsSchemaLoader
+ * @implements implements ISchemaLoader interface
+ */
+export declare class IpfsSchemaLoader implements ISchemaLoader {
+    private readonly url;
+    private readonly client;
+    /**
+     * Creates an instance of IpfsSchemaLoader.
+     * @param {string} url - host of the ipfs node
+     */
+    constructor(url: string);
+    /**
+     * loads schema from ipfs by its identifier
+     *
+     * @param {string} url - schema IPFS identifier
+     * @returns `Promise<Uint8Array>`
+     */
+    load(url: string): Promise<Uint8Array>;
+}
+/**
+ * returns loader for schemas based on the URL protocol
+ *
+ * @export
+ * @param {string} url - schema url
+ * @param {string} [ipfsConfigUrl] - ipfs node host url
+ * @returns ISchemaLoader
+ */
+export declare function getLoader(url: string, ipfsConfigUrl?: string): ISchemaLoader;

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

@@ -0,0 +1,17 @@
+import { ClaimNonRevStatus, GISTProof } from '../circuits';
+import { StateProof } from '../storage/entities/state';
+import { RevocationStatus } from '../verifiable';
+/**
+ * converts verifiable RevocationStatus model to circuits structure
+ *
+ * @param {RevocationStatus} - credential.status of the verifiable credential
+ * @returns {ClaimNonRevStatus}
+ */
+export declare const toClaimNonRevStatus: (s: RevocationStatus) => ClaimNonRevStatus;
+/**
+ * converts state info from smart contract to gist proof
+ *
+ * @param {StateProof} smtProof  - state proof from smart contract
+ * @returns {GISTProof}
+ */
+export declare const toGISTProof: (smtProof: StateProof) => GISTProof;

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

@@ -0,0 +1,3 @@
+export * from './proof-service';
+export * from './prover';
+export * from './common';