@mocanetwork/privado-js-sdk 1.0.0

package/dist/types/kms/key-providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/kms/key-providers/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC"}

package/dist/types/kms/key-providers/secp256k1-provider.d.ts

@@ -0,0 +1,62 @@
+import { IKeyProvider } from '../kms';
+import { AbstractPrivateKeyStore, KmsKeyId, KmsKeyType } from '../store';
+/**
+ * Provider for Secp256k1
+ * @public
+ * @class Secp256k1Provider
+ * @implements implements IKeyProvider interface
+ */
+export declare class Sec256k1Provider 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);
+    /**
+     * get all keys
+     * @returns list of keys
+     */
+    list(): Promise<{
+        alias: string;
+        key: string;
+    }[]>;
+    /**
+     * 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<string>;
+    /**
+     * Signs the given data using the private key associated with the specified key identifier.
+     * @param keyId - The key identifier to use for signing.
+     * @param data - The data to sign.
+     * @param opts - Signing options, such as the algorithm to use.
+     * @returns A Promise that resolves to the signature as a Uint8Array.
+     */
+    sign(keyId: KmsKeyId, data: Uint8Array, opts?: {
+        [key: string]: unknown;
+    }): Promise<Uint8Array>;
+    /**
+     * Verifies a signature for the given message and key identifier.
+     * @param message - The message to verify the signature against.
+     * @param signatureHex - The signature to verify, as a hexadecimal string.
+     * @param keyId - The key identifier to use for verification.
+     * @returns A Promise that resolves to a boolean indicating whether the signature is valid.
+     */
+    verify(message: Uint8Array, signatureHex: string, keyId: KmsKeyId): Promise<boolean>;
+    private privateKey;
+}
+//# sourceMappingURL=secp256k1-provider.d.ts.map

package/dist/types/kms/key-providers/secp256k1-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secp256k1-provider.d.ts","sourceRoot":"","sources":["../../../../src/kms/key-providers/secp256k1-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,uBAAuB,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAOzE;;;;;GAKG;AACH,qBAAa,gBAAiB,YAAW,YAAY;IACnD;;;OAGG;IACH,OAAO,EAAE,UAAU,CAAC;IACpB,OAAO,CAAC,SAAS,CAA0B;IAE3C;;;;OAIG;gBACS,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,uBAAuB;IAQlE;;;OAGG;IACG,IAAI,IAAI,OAAO,CACnB;QACE,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;KACb,EAAE,CACJ;IAKD;;;;OAIG;IACG,qBAAqB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC;IAkBhE;;;;OAIG;IACG,SAAS,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;IAMjD;;;;;;OAMG;IACG,IAAI,CACR,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,UAAU,EAChB,IAAI,GAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAsB,GACnD,OAAO,CAAC,UAAU,CAAC;IAetB;;;;;;OAMG;IACG,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;YAK5E,UAAU;CAGzB"}

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

@@ -0,0 +1,120 @@
+import { KmsKeyId, KmsKeyType } from './store';
+/**
+ * KeyProvider is responsible for signing and creation of the keys
+ *
+ * @public
+ * @interface   IKeyProvider
+ */
+export interface IKeyProvider {
+    /**
+     * property to store key type
+     *
+     * @type {KmsKeyType}
+     */
+    keyType: KmsKeyType;
+    /**
+     * get all keys
+     *
+     * @returns list of keys
+     */
+    list(): Promise<{
+        alias: string;
+        key: string;
+    }[]>;
+    /**
+     * gets public key by key id
+     *
+     * @param {KmsKeyId} keyID - kms key identifier
+     * @returns `Promise<PublicKey>`
+     */
+    publicKey(keyID: KmsKeyId): Promise<string>;
+    /**
+     * sign data with kms key
+     *
+     * @param {KmsKeyId} keyId - key identifier
+     * @param {Uint8Array} data  - bytes payload
+     * @param {{ [key: string]: unknown }} opts  - additional options for signing
+     * @returns `Promise<Uint8Array>`
+     */
+    sign(keyId: KmsKeyId, data: Uint8Array, opts?: {
+        [key: string]: unknown;
+    }): Promise<Uint8Array>;
+    /**
+     * creates new key pair from given seed
+     *
+     * @param {Uint8Array} seed - seed
+     * @returns `Promise<KmsKeyId>`
+     */
+    newPrivateKeyFromSeed(seed: Uint8Array): Promise<KmsKeyId>;
+    /**
+     * Verifies a message signature using the provided key ID.
+     *
+     * @param message - The message bytes to verify.
+     * @param signatureHex - The signature in hexadecimal format.
+     * @param keyId - The KMS key ID used to verify the signature.
+     * @returns A promise that resolves to a boolean indicating whether the signature is valid.
+     */
+    verify(message: Uint8Array, signatureHex: string, keyId: KmsKeyId): Promise<boolean>;
+}
+/**
+ * Key management system class contains different key providers.
+ * allows to register custom provider, create key, get public key and sign
+ *
+ * @public
+ * @class KMS - class
+ */
+export declare class KMS {
+    private readonly _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<string>;
+    /**
+     * 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, opts?: {
+        [key: string]: unknown;
+    }): Promise<Uint8Array>;
+    /**
+     * Verifies a signature against the provided data and key ID.
+     *
+     * @param data - The data to verify the signature against.
+     * @param signatureHex - The signature to verify, in hexadecimal format.
+     * @param keyId - The key ID to use for verification.
+     * @returns A promise that resolves to a boolean indicating whether the signature is valid.
+     */
+    verify(data: Uint8Array, signatureHex: string, keyId: KmsKeyId): Promise<boolean>;
+    /**
+     * get all keys by key type
+     *
+     * @param keyType - Key type
+     * @returns list of keys
+     */
+    list(keyType: KmsKeyType): Promise<{
+        alias: string;
+        key: string;
+    }[]>;
+}
+//# sourceMappingURL=kms.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kms.d.ts","sourceRoot":"","sources":["../../../src/kms/kms.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,OAAO,EAAE,UAAU,CAAC;IAEpB;;;;OAIG;IACH,IAAI,IAAI,OAAO,CACb;QACE,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;KACb,EAAE,CACJ,CAAC;IACF;;;;;OAKG;IACH,SAAS,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5C;;;;;;;OAOG;IACH,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAEhG;;;;;OAKG;IACH,qBAAqB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAE3D;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtF;AACD;;;;;;GAMG;AACH,qBAAa,GAAG;IACd,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuC;IAEjE;;;;;OAKG;IACH,mBAAmB,CAAC,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,GAAG,IAAI;IAOzE;;;;;;OAMG;IACG,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC;IAQlF;;;;;OAKG;IACG,SAAS,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;IASjD;;;;;;OAMG;IACG,IAAI,CACR,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,UAAU,EAChB,IAAI,CAAC,EAAE;QACL,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,GACA,OAAO,CAAC,UAAU,CAAC;IAStB;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAQjF;;;;;OAKG;IACH,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAChC;QACE,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;KACb,EAAE,CACJ;CAQF"}

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

@@ -0,0 +1,10 @@
+import { KmsKeyType } from './store';
+/**
+ * builds key path
+ *
+ * @param {KmsKeyType} keyType - key type
+ * @param {string} keyID - key id
+ * @returns string path
+ */
+export declare function keyPath(keyType: KmsKeyType, keyID: string): string;
+//# sourceMappingURL=provider-helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"provider-helpers.d.ts","sourceRoot":"","sources":["../../../src/kms/provider-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAGlE"}

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

@@ -0,0 +1,41 @@
+/**
+ * KeyStore that allows to import and get keys by alias.
+ *
+ * @abstract
+ * @public
+ * @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 importKey(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>;
+    /**
+     * get all keys
+     *
+     * @abstract
+     * @returns `Promise<{ alias: string; key: string }[]>`
+     */
+    abstract list(): Promise<{
+        alias: string;
+        key: string;
+    }[]>;
+}
+//# sourceMappingURL=abstract-key-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-key-store.d.ts","sourceRoot":"","sources":["../../../../src/kms/store/abstract-key-store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,8BAAsB,uBAAuB;IAC3C;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAEvE;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAEtD;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC3D"}

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

@@ -0,0 +1,6 @@
+export * from './abstract-key-store';
+export * from './memory-key-store';
+export * from './types';
+export * from './local-storage-key-store';
+export * from './indexed-db-key-store';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/kms/store/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,SAAS,CAAC;AACxB,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC"}

package/dist/types/kms/store/indexed-db-key-store.d.ts

@@ -0,0 +1,44 @@
+import { AbstractPrivateKeyStore } from './abstract-key-store';
+/**
+ * Allows storing keys in the indexed db storage of the browser
+ * (NOT ENCRYPTED: DO NOT USE IN THE PRODUCTION)
+ *
+ * @public
+ * @class IndexedDBPrivateKeyStore
+ * @implements implements AbstractPrivateKeyStore interface
+ */
+export declare class IndexedDBPrivateKeyStore implements AbstractPrivateKeyStore {
+    static readonly storageKey = "keystore";
+    private readonly _store;
+    constructor();
+    /**
+     * get all keys
+     *
+     * @abstract
+     * @returns `Promise<{ alias: string; key: string }[]>`
+     */
+    list(): Promise<{
+        alias: string;
+        key: string;
+    }[]>;
+    /**
+     * Gets key from the indexed db storage
+     *
+     * @param {{ alias: string }} args
+     * @returns hex string
+     */
+    get(args: {
+        alias: string;
+    }): Promise<string>;
+    /**
+     * Import key to the indexed db storage
+     *
+     * @param {{ alias: string; key: string }} args - alias and private key in the hex
+     * @returns void
+     */
+    importKey(args: {
+        alias: string;
+        key: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=indexed-db-key-store.d.ts.map

package/dist/types/kms/store/indexed-db-key-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexed-db-key-store.d.ts","sourceRoot":"","sources":["../../../../src/kms/store/indexed-db-key-store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE/D;;;;;;;GAOG;AACH,qBAAa,wBAAyB,YAAW,uBAAuB;IACtE,MAAM,CAAC,QAAQ,CAAC,UAAU,cAAc;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAW;;IASlC;;;;;OAKG;IACG,IAAI,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAQvD;;;;;OAKG;IACG,GAAG,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAQnD;;;;;OAKG;IACG,SAAS,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAGrE"}

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

@@ -0,0 +1,42 @@
+import { AbstractPrivateKeyStore } from './abstract-key-store';
+/**
+ * Allows storing keys in the local storage of the browser
+ * (NOT ENCRYPTED: DO NOT USE IN THE PRODUCTION)
+ *
+ * @public
+ * @class LocalStoragePrivateKeyStore
+ * @implements implements AbstractPrivateKeyStore interface
+ */
+export declare class LocalStoragePrivateKeyStore implements AbstractPrivateKeyStore {
+    static readonly storageKey = "keystore";
+    /**
+     * get all keys
+     *
+     * @abstract
+     * @returns `Promise<{ alias: string; key: string }[]>`
+     */
+    list(): Promise<{
+        alias: string;
+        key: string;
+    }[]>;
+    /**
+     * 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
+     */
+    importKey(args: {
+        alias: string;
+        key: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=local-storage-key-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"local-storage-key-store.d.ts","sourceRoot":"","sources":["../../../../src/kms/store/local-storage-key-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAG/D;;;;;;;GAOG;AACH,qBAAa,2BAA4B,YAAW,uBAAuB;IACzE,MAAM,CAAC,QAAQ,CAAC,UAAU,cAAc;IAExC;;;;;OAKG;IACH,IAAI,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAQjD;;;;;OAKG;IACG,GAAG,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAanD;;;;;OAKG;IACG,SAAS,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAerE"}

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

@@ -0,0 +1,24 @@
+import { AbstractPrivateKeyStore } from './abstract-key-store';
+/**
+ * Key Store to use in memory
+ *
+ * @public
+ * @class InMemoryPrivateKeyStore
+ * @implements implements AbstractPrivateKeyStore interface
+ */
+export declare class InMemoryPrivateKeyStore implements AbstractPrivateKeyStore {
+    private _data;
+    constructor();
+    list(): Promise<{
+        alias: string;
+        key: string;
+    }[]>;
+    get(args: {
+        alias: string;
+    }): Promise<string>;
+    importKey(args: {
+        alias: string;
+        key: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=memory-key-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory-key-store.d.ts","sourceRoot":"","sources":["../../../../src/kms/store/memory-key-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE/D;;;;;;GAMG;AACH,qBAAa,uBAAwB,YAAW,uBAAuB;IACrE,OAAO,CAAC,KAAK,CAAsB;;IAInC,IAAI,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAG3C,GAAG,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAQ7C,SAAS,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAGrE"}

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

@@ -0,0 +1,21 @@
+/**
+ * Key type that can be used in the key management system
+ *
+ * @enum {number}
+ */
+export declare enum KmsKeyType {
+    BabyJubJub = "BJJ",
+    Secp256k1 = "Secp256k1",
+    Ed25519 = "Ed25519"
+}
+/**
+ * ID of the key that describe contain key type
+ *
+ * @public
+ * @interface   KmsKeyId
+ */
+export interface KmsKeyId {
+    type: KmsKeyType;
+    id: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/kms/store/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,oBAAY,UAAU;IACpB,UAAU,QAAQ;IAClB,SAAS,cAAc;IACvB,OAAO,YAAY;CACpB;AAED;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,UAAU,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ"}

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

@@ -0,0 +1,49 @@
+import { ClaimNonRevStatus, GISTProof, Operators } from '../circuits';
+import { StateProof } from '../storage/entities/state';
+import { MerkleTreeProofWithTreeState, RevocationStatus, W3CCredential } from '../verifiable';
+import { Options, Path } from '@iden3/js-jsonld-merklization';
+import { JsonDocumentObject } from '../iden3comm';
+import { Claim } from '@mocanetwork/moca-iden3';
+export type PreparedCredential = {
+    credential: W3CCredential;
+    credentialCoreClaim: Claim;
+    revStatus?: RevocationStatus;
+};
+export type PreparedAuthBJJCredential = {
+    credential: W3CCredential;
+    incProof: MerkleTreeProofWithTreeState;
+    nonRevProof: MerkleTreeProofWithTreeState;
+    coreClaim: Claim;
+};
+/**
+ * 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;
+export type PropertyQuery = {
+    fieldName: string;
+    operator: Operators;
+    operatorValue?: unknown;
+};
+export type QueryMetadata = PropertyQuery & {
+    slotIndex: number;
+    values: bigint[];
+    path: Path;
+    claimPathKey: bigint;
+    datatype: string;
+    merklizedSchema: boolean;
+};
+export declare const parseCredentialSubject: (credentialSubject?: JsonDocumentObject) => PropertyQuery[];
+export declare const parseQueryMetadata: (propertyQuery: PropertyQuery, ldContextJSON: string, credentialType: string, options: Options) => Promise<QueryMetadata>;
+export declare const parseQueriesMetadata: (credentialType: string, ldContextJSON: string, credentialSubject: JsonDocumentObject, options: Options) => Promise<QueryMetadata[]>;
+export declare const transformQueryValueToBigInts: (value: unknown, ldType: string) => Promise<bigint[]>;
+//# sourceMappingURL=common.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/proof/common.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,iBAAiB,EACjB,SAAS,EAET,SAAS,EAEV,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EACL,4BAA4B,EAC5B,gBAAgB,EAChB,aAAa,EAId,MAAM,eAAe,CAAC;AACvB,OAAO,EAAa,OAAO,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAC;AAEzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGhD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,EAAE,aAAa,CAAC;IAC1B,mBAAmB,EAAE,KAAK,CAAC;IAC3B,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,UAAU,EAAE,aAAa,CAAC;IAC1B,QAAQ,EAAE,4BAA4B,CAAC;IACvC,WAAW,EAAE,4BAA4B,CAAC;IAC1C,SAAS,EAAE,KAAK,CAAC;CAClB,CAAC;AACF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,IAAI,gBAAgB,KAAG,iBAsB1D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,UAAU,UAAU,KAAG,SAyBlD,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,SAAS,CAAC;IACpB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,aAAa,GAAG;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,IAAI,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,oBAAoB,kBAAkB,KAAG,aAAa,EA+B5F,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,eAAe,aAAa,EAC5B,eAAe,MAAM,EACrB,gBAAgB,MAAM,EACtB,SAAS,OAAO,KACf,OAAO,CAAC,aAAa,CAqFvB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,gBAAgB,MAAM,EACtB,eAAe,MAAM,EACrB,mBAAmB,kBAAkB,EACrC,SAAS,OAAO,KACf,OAAO,CAAC,aAAa,EAAE,CAKzB,CAAC;AAEF,eAAO,MAAM,4BAA4B,GACvC,OAAO,OAAO,EACd,QAAQ,MAAM,KACb,OAAO,CAAC,MAAM,EAAE,CAWlB,CAAC"}

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

@@ -0,0 +1,5 @@
+export * from './proof-service';
+export * from './provers';
+export * from './common';
+export * from './verifiers';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/proof/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC"}

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

@@ -0,0 +1,169 @@
+import { DID } from '@mocanetwork/moca-iden3';
+import { CircuitId, Query, TreeState } from '../circuits';
+import { ICredentialWallet } from '../credentials';
+import { IIdentityWallet } from '../identity';
+import { ProofQuery, RevocationStatus, W3CCredential } from '../verifiable';
+import { IZKProver } from './provers/prover';
+import { Options } from '@iden3/js-jsonld-merklization';
+import { ZKProof } from '@iden3/js-jwz';
+import { Signer } from 'ethers';
+import { StateVerificationOpts, JSONObject, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse, ZeroKnowledgeProofAuthResponse } from '../iden3comm';
+import { ICircuitStorage, IStateStorage } from '../storage';
+import { AuthProofGenerationOptions, ProofGenerationOptions } from './provers/inputs-generator';
+import { VerifyOpts } from './verifiers';
+export interface QueryWithFieldName {
+    query: Query;
+    fieldName: string;
+    rawValue?: unknown;
+    isSelectiveDisclosure?: boolean;
+}
+/**
+ *  Metadata that returns on verification
+ * @type VerificationResultMetadata
+ */
+export type VerificationResultMetadata = {
+    linkID?: number;
+};
+/**
+ *  List of options to customize ProofService
+ */
+export type ProofServiceOptions = Options & {
+    prover?: IZKProver;
+};
+export interface ProofVerifyOpts {
+    query: ProofQuery;
+    sender: string;
+    opts?: VerifyOpts;
+    params?: JSONObject;
+}
+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>;
+    /**
+     * Verification of zkp proof and pub signals for given circuit id
+     *
+     * @param {ZeroKnowledgeProofResponse} response  - zero knowledge proof response
+     * @param {ProofVerifyOpts} opts - proof verification options
+     * @returns `{Promise<VerificationResultMetadata>}`
+     */
+    verifyZKPResponse(proofResp: ZeroKnowledgeProofResponse, opts: ProofVerifyOpts): Promise<VerificationResultMetadata>;
+    /**
+     * 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<ZeroKnowledgeProofResponse>`
+     */
+    generateProof(proofReq: ZeroKnowledgeProofRequest, identifier: DID, opts?: ProofGenerationOptions): Promise<ZeroKnowledgeProofResponse>;
+    /**
+     * generates auth inputs
+     *
+     * @param {Uint8Array} hash - challenge that will be signed
+     * @param {DID} did - identity that will generate a proof
+     * @param {CircuitId} circuitId - circuit id for authentication
+     * @returns `Promise<Uint8Array>`
+     */
+    generateAuthV2Inputs(hash: Uint8Array, did: DID, circuitId: CircuitId): Promise<Uint8Array>;
+    /**
+     * generates auth v2 proof from given identity
+     *
+     * @param {Uint8Array} hash - challenge that will be signed
+     * @param {DID} did - identity that will generate a proof
+     * @returns `Promise<ZKProof>`
+     */
+    generateAuthV2Proof(hash: Uint8Array, did: DID): Promise<ZKProof>;
+    /**
+     * Generate auth proof from given identity with generic params
+     *
+     * @param {CircuitId} circuitId - circuitId for the proof generation
+     * @param {DID} identifier - did that will generate proof
+     * @param {ProofGenerationOptions} opts - options that will be used for proof generation
+     *
+     * @returns `Promise<ZeroKnowledgeProofResponse>`
+     */
+    generateAuthProof(circuitId: CircuitId, identifier: DID, opts?: AuthProofGenerationOptions): Promise<ZeroKnowledgeProofAuthResponse>;
+    /**
+     * 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 {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>;
+    findCredentialByProofQuery(did: DID, query: ProofQuery, opts?: {
+        skipClaimRevocationCheck: boolean;
+    }): Promise<{
+        cred: W3CCredential;
+        revStatus: RevocationStatus | undefined;
+    }>;
+}
+/**
+ * Proof service is an implementation of IProofService
+ * that works with a native groth16 prover
+ *
+ * @public
+ * @class ProofService
+ * @implements implements IProofService interface
+ */
+export declare class ProofService implements IProofService {
+    private readonly _identityWallet;
+    private readonly _credentialWallet;
+    private readonly _stateStorage;
+    private readonly _prover;
+    private readonly _ldOptions;
+    private readonly _inputsGenerator;
+    private readonly _pubSignalsVerifier;
+    /**
+     * 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, opts?: ProofServiceOptions);
+    /** {@inheritdoc IProofService.verifyProof} */
+    verifyProof(zkp: ZKProof, circuitId: CircuitId): Promise<boolean>;
+    /** {@inheritdoc IProofService.verify} */
+    verifyZKPResponse(proofResp: ZeroKnowledgeProofResponse, opts: ProofVerifyOpts): Promise<VerificationResultMetadata>;
+    /** {@inheritdoc IProofService.generateProof} */
+    generateProof(proofReq: ZeroKnowledgeProofRequest, identifier: DID, opts?: ProofGenerationOptions): Promise<ZeroKnowledgeProofResponse>;
+    /** {@inheritdoc IProofService.generateAuthProof} */
+    generateAuthProof(circuitId: CircuitId, identifier: DID, opts?: AuthProofGenerationOptions): Promise<ZeroKnowledgeProofAuthResponse>;
+    /** {@inheritdoc IProofService.transitState} */
+    transitState(did: DID, oldTreeState: TreeState, isOldStateGenesis: boolean, stateStorage: IStateStorage, // for compatibility with previous versions we leave this parameter
+    ethSigner: Signer): Promise<string>;
+    private generateInputs;
+    private toCircuitsQuery;
+    private loadLdContext;
+    /** {@inheritdoc IProofService.generateAuthV2Inputs} */
+    generateAuthV2Inputs(hash: Uint8Array, did: DID, circuitId: CircuitId): Promise<Uint8Array>;
+    /** {@inheritdoc IProofService.generateAuthV2Proof} */
+    generateAuthV2Proof(challenge: Uint8Array, did: DID): Promise<ZKProof>;
+    verifyState(circuitId: string, pubSignals: string[], opts?: StateVerificationOpts): Promise<boolean>;
+    findCredentialByProofQuery(did: DID, query: ProofQuery): Promise<{
+        cred: W3CCredential;
+        revStatus: RevocationStatus | undefined;
+    }>;
+}
+//# sourceMappingURL=proof-service.d.ts.map