@0xpolygonid/js-sdk 1.10.4 → 1.11.1

package/dist/node/cjs/identity/identity-wallet.js

@@ -34,8 +34,11 @@ const schema_processor_1 = require("../schema-processor");
 const storage_1 = require("../storage");
 const verifiable_1 = require("../verifiable");
 const credentials_1 = require("../credentials");
+const circuits_1 = require("../circuits");
 const utils_1 = require("../utils");
 const credential_status_publisher_1 = require("../credentials/status/credential-status-publisher");
+const proof_1 = require("../proof");
+const blockchain_1 = require("../blockchain");
 /**
  * @public
  * Wallet instance to manage the digital identity based on iden3 protocol
@@ -62,6 +65,8 @@ class IdentityWallet {
         this._credentialWallet = _credentialWallet;
         this._opts = _opts;
         this._credentialStatusPublisherRegistry = this.getCredentialStatusPublisherRegistry(_opts);
+        this._inputsGenerator = new proof_1.InputGenerator(this, _credentialWallet, _storage.states);
+        this._transactionService = new blockchain_1.TransactionService(_storage.states.getRpcProvider());
     }
     getCredentialStatusPublisherRegistry(_opts) {
         if (!_opts?.credentialStatusPublisherRegistry) {
@@ -76,35 +81,16 @@ class IdentityWallet {
             return this._opts?.credentialStatusPublisherRegistry;
         }
     }
-    /**
-     * {@inheritDoc IIdentityWallet.createIdentity}
-     */
-    async createIdentity(opts) {
-        const tmpIdentifier = opts.seed ? uuid.v5(js_crypto_1.Hex.encode((0, js_crypto_1.sha256)(opts.seed)), uuid.NIL) : uuid.v4();
-        opts.method = opts.method ?? js_iden3_core_1.DidMethod.Iden3;
-        opts.blockchain = opts.blockchain ?? js_iden3_core_1.Blockchain.Polygon;
-        opts.networkId = opts.networkId ?? js_iden3_core_1.NetworkId.Amoy;
-        await this._storage.mt.createIdentityMerkleTrees(tmpIdentifier);
-        opts.seed = opts.seed ?? (0, js_crypto_1.getRandomBytes)(32);
-        const keyId = await this._kms.createKeyFromSeed(kms_1.KmsKeyType.BabyJubJub, opts.seed);
+    async createAuthCoreClaim(revNonce, seed) {
+        const keyId = await this._kms.createKeyFromSeed(kms_1.KmsKeyType.BabyJubJub, seed);
         const pubKeyHex = await this._kms.publicKey(keyId);
         const pubKey = js_crypto_1.PublicKey.newFromHex(pubKeyHex);
         const schemaHash = js_iden3_core_1.SchemaHash.authSchemaHash;
         const authClaim = js_iden3_core_1.Claim.newClaim(schemaHash, js_iden3_core_1.ClaimOptions.withIndexDataInts(pubKey.p[0], pubKey.p[1]), js_iden3_core_1.ClaimOptions.withRevocationNonce(BigInt(0)));
-        const revNonce = opts.revocationOpts.nonce ?? 0;
         authClaim.setRevocationNonce(BigInt(revNonce));
-        await this._storage.mt.addToMerkleTree(tmpIdentifier, storage_1.MerkleTreeType.Claims, authClaim.hiHv().hi, authClaim.hiHv().hv);
-        const claimsTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(tmpIdentifier, storage_1.MerkleTreeType.Claims);
-        const currentState = (0, js_merkletree_1.hashElems)([
-            (await claimsTree.root()).bigInt(),
-            js_merkletree_1.ZERO_HASH.bigInt(),
-            js_merkletree_1.ZERO_HASH.bigInt()
-        ]);
-        const didType = (0, js_iden3_core_1.buildDIDType)(opts.method, opts.blockchain, opts.networkId);
-        const identifier = js_iden3_core_1.Id.idGenesisFromIdenState(didType, currentState.bigInt());
-        const did = js_iden3_core_1.DID.parseFromId(identifier);
-        await this._storage.mt.bindMerkleTreeToNewIdentifier(tmpIdentifier, did.string());
-        const schema = JSON.parse(verifiable_1.VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_SCHEMA_JSON);
+        return { authClaim, pubKey };
+    }
+    async createAuthBJJCredential(did, pubKey, authClaim, currentState, revocationOpts) {
         const authData = authClaim.getExpirationDate();
         const expiration = authData ? (0, js_iden3_core_1.getUnixTimestamp)(authData) : 0;
         const request = {
@@ -118,29 +104,91 @@ class IdentityWallet {
             version: 0,
             expiration,
             revocationOpts: {
-                nonce: revNonce,
-                id: opts.revocationOpts.id.replace(/\/$/, ''),
-                type: opts.revocationOpts.type,
+                nonce: Number(authClaim.getRevocationNonce()),
+                id: revocationOpts.id.replace(/\/$/, ''),
+                type: revocationOpts.type,
                 issuerState: currentState.hex()
             }
         };
+        // Check if has already an auth credential
+        const authCredentials = await this._credentialWallet.getAllAuthBJJCredentials(did);
         let credential = new verifiable_1.W3CCredential();
-        try {
-            credential = this._credentialWallet.createCredential(did, request, schema);
+        if (authCredentials.length === 0) {
+            const schema = JSON.parse(verifiable_1.VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_SCHEMA_JSON);
+            try {
+                credential = this._credentialWallet.createCredential(did, request, schema);
+            }
+            catch (e) {
+                throw new Error(`Error create w3c credential ${e.message}`);
+            }
         }
-        catch (e) {
-            throw new Error(`Error create w3c credential ${e.message}`);
+        else {
+            // credential with sigProof signed with previous auth bjj credential
+            credential = await this.issueCredential(did, request);
         }
-        const index = authClaim.hIndex();
+        return credential;
+    }
+    /**
+     * {@inheritDoc IIdentityWallet.createIdentity}
+     */
+    async createIdentity(opts) {
+        const tmpIdentifier = opts.seed ? uuid.v5(js_crypto_1.Hex.encode((0, js_crypto_1.sha256)(opts.seed)), uuid.NIL) : uuid.v4();
+        opts.seed = opts.seed ?? (0, js_crypto_1.getRandomBytes)(32);
+        await this._storage.mt.createIdentityMerkleTrees(tmpIdentifier);
+        const revNonce = opts.revocationOpts.nonce ?? 0;
+        const { authClaim, pubKey } = await this.createAuthCoreClaim(revNonce, opts.seed);
+        const { hi, hv } = authClaim.hiHv();
+        await this._storage.mt.addToMerkleTree(tmpIdentifier, storage_1.MerkleTreeType.Claims, hi, hv);
+        const claimsTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(tmpIdentifier, storage_1.MerkleTreeType.Claims);
         const ctr = await claimsTree.root();
+        const currentState = (0, js_merkletree_1.hashElems)([ctr.bigInt(), js_merkletree_1.ZERO_HASH.bigInt(), js_merkletree_1.ZERO_HASH.bigInt()]);
+        const didType = (0, js_iden3_core_1.buildDIDType)(opts.method || js_iden3_core_1.DidMethod.Iden3, opts.blockchain || js_iden3_core_1.Blockchain.Polygon, opts.networkId || js_iden3_core_1.NetworkId.Amoy);
+        const identifier = js_iden3_core_1.Id.idGenesisFromIdenState(didType, currentState.bigInt());
+        const did = js_iden3_core_1.DID.parseFromId(identifier);
+        await this._storage.mt.bindMerkleTreeToNewIdentifier(tmpIdentifier, did.string());
+        const oldTreeState = {
+            revocationRoot: js_merkletree_1.ZERO_HASH,
+            claimsRoot: ctr,
+            state: currentState,
+            rootOfRoots: js_merkletree_1.ZERO_HASH
+        };
+        const identity = await this._storage.identity.getIdentity(did.string());
+        if (!identity) {
+            await this._storage.identity.saveIdentity({
+                did: did.string(),
+                state: currentState,
+                isStatePublished: false,
+                isStateGenesis: true
+            });
+        }
+        // check whether we have auth credential, if not - create a new one
+        const credentials = await this._credentialWallet.findByQuery({
+            credentialSubject: {
+                x: {
+                    $eq: pubKey.p[0].toString()
+                },
+                y: {
+                    $eq: pubKey.p[1].toString()
+                }
+            },
+            allowedIssuers: [did.string()]
+        });
+        if (credentials.length) {
+            return {
+                did,
+                credential: credentials[0]
+            };
+        }
+        const credential = await this.createAuthBJJCredential(did, pubKey, authClaim, currentState, opts.revocationOpts);
+        const index = authClaim.hIndex();
         const { proof } = await claimsTree.generateProof(index, ctr);
         const mtpProof = new verifiable_1.Iden3SparseMerkleTreeProof({
             mtp: proof,
             issuerData: {
                 id: did,
                 state: {
-                    rootOfRoots: js_merkletree_1.ZERO_HASH,
-                    revocationTreeRoot: js_merkletree_1.ZERO_HASH,
+                    rootOfRoots: oldTreeState.rootOfRoots,
+                    revocationTreeRoot: oldTreeState.revocationRoot,
                     claimsTreeRoot: ctr,
                     value: currentState
                 }
@@ -152,13 +200,45 @@ class IdentityWallet {
             rhsUrl: opts.revocationOpts.id,
             onChain: opts.revocationOpts.onChain
         });
+        await this._credentialWallet.save(credential);
+        return {
+            did,
+            credential
+        };
+    }
+    /**
+     * {@inheritDoc IIdentityWallet.createEthereumBasedIdentity}
+     */
+    async createEthereumBasedIdentity(opts) {
+        opts.seed = opts.seed ?? (0, js_crypto_1.getRandomBytes)(32);
+        opts.createBjjCredential = opts.createBjjCredential ?? true;
+        let credential;
+        const ethSigner = opts.ethSigner;
+        if (!ethSigner) {
+            throw new Error('Ethereum signer is required to create Ethereum identities in order to transit state');
+        }
+        const currentState = js_merkletree_1.ZERO_HASH; // In Ethereum identities we don't have an initial state with the auth credential
+        const didType = (0, js_iden3_core_1.buildDIDType)(opts.method || js_iden3_core_1.DidMethod.Iden3, opts.blockchain || js_iden3_core_1.Blockchain.Polygon, opts.networkId || js_iden3_core_1.NetworkId.Amoy);
+        const keyIdEth = await this._kms.createKeyFromSeed(kms_1.KmsKeyType.Secp256k1, opts.seed);
+        const pubKeyHexEth = (await this._kms.publicKey(keyIdEth)).slice(2); // 04 + x + y (uncompressed key)
+        const did = (0, utils_1.buildDIDFromEthPubKey)(didType, pubKeyHexEth);
+        await this._storage.mt.createIdentityMerkleTrees(did.string());
         await this._storage.identity.saveIdentity({
             did: did.string(),
             state: currentState,
             isStatePublished: false,
             isStateGenesis: true
         });
-        await this._credentialWallet.save(credential);
+        if (opts.createBjjCredential) {
+            // Old tree state genesis state
+            const oldTreeState = {
+                revocationRoot: js_merkletree_1.ZERO_HASH,
+                claimsRoot: js_merkletree_1.ZERO_HASH,
+                state: currentState,
+                rootOfRoots: js_merkletree_1.ZERO_HASH
+            };
+            credential = await this.addBJJAuthCredential(did, oldTreeState, true, ethSigner, opts);
+        }
         return {
             did,
             credential
@@ -232,7 +312,10 @@ class IdentityWallet {
     /** {@inheritDoc IIdentityWallet.generateClaimMtp} */
     async generateCredentialMtp(did, credential, treeState) {
         const coreClaim = await this.getCoreClaimFromCredential(credential);
-        // todo: Parser.parseClaim
+        return this.generateCoreClaimMtp(did, coreClaim, treeState);
+    }
+    /** {@inheritDoc IIdentityWallet.generateClaimMtp} */
+    async generateCoreClaimMtp(did, coreClaim, treeState) {
         const treesModel = await this.getDIDTreeModel(did);
         const claimsTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(did.string(), storage_1.MerkleTreeType.Claims);
         const claimsRoot = await treesModel.claimsTree.root();
@@ -366,14 +449,14 @@ class IdentityWallet {
                 };
             }
         }
-        throw new Error('no auth credentials found');
+        throw new Error(verifiable_1.VerifiableConstants.ERRORS.NO_AUTH_CRED_FOUND);
     }
     /** {@inheritDoc IIdentityWallet.revokeCredential} */
     async revokeCredential(issuerDID, credential) {
         const issuerTree = await this.getDIDTreeModel(issuerDID);
-        const coreClaim = credential.getCoreClaimFromProof(verifiable_1.ProofType.BJJSignature);
+        const coreClaim = await this.getCoreClaimFromCredential(credential);
         if (!coreClaim) {
-            throw new Error('credential must have coreClaim representation in the signature proof');
+            throw new Error('credential must have coreClaim representation in proofs');
         }
         const nonce = coreClaim.getRevocationNonce();
         await issuerTree.revocationTree.add(nonce, BigInt(0));
@@ -420,16 +503,17 @@ class IdentityWallet {
     }
     /** {@inheritDoc IIdentityWallet.generateIden3SparseMerkleTreeProof} */
     // treeState -  optional, if it is not passed proof of claim inclusion will be generated on the latest state in the tree.
-    async generateIden3SparseMerkleTreeProof(issuerDID, credentials, txId, blockNumber, blockTimestamp, treeState) {
+    async generateIden3SparseMerkleTreeProof(issuerDID, credentials, txId, blockNumber, blockTimestamp, treeState, opts) {
         for (let index = 0; index < credentials.length; index++) {
             const credential = credentials[index];
-            const mtpWithProof = await this.generateCredentialMtp(issuerDID, credential, treeState);
             // TODO: return coreClaim from generateCredentialMtp and use it below
             // credential must have a bjj signature proof
-            const coreClaim = credential.getCoreClaimFromProof(verifiable_1.ProofType.BJJSignature);
+            const coreClaim = credential.getCoreClaimFromProof(verifiable_1.ProofType.BJJSignature) ||
+                (await credential.toCoreClaim(opts));
             if (!coreClaim) {
                 throw new Error('credential must have coreClaim representation in the signature proof');
             }
+            const mtpWithProof = await this.generateCoreClaimMtp(issuerDID, coreClaim, treeState);
             const mtpProof = new verifiable_1.Iden3SparseMerkleTreeProof({
                 mtp: mtpWithProof.proof,
                 issuerData: {
@@ -450,7 +534,9 @@ class IdentityWallet {
                 credentials[index].proof.push(mtpProof);
             }
             else {
-                credentials[index].proof = [credentials[index].proof, mtpProof];
+                credentials[index].proof = credentials[index].proof
+                    ? [credentials[index].proof, mtpProof]
+                    : [mtpProof];
             }
         }
         return credentials;
@@ -539,5 +625,104 @@ class IdentityWallet {
             isStateGenesis: false
         });
     }
+    /** {@inheritdoc IIdentityWallet.transitState} */
+    async transitState(did, oldTreeState, isOldStateGenesis, ethSigner, prover) {
+        const newTreeModel = await this.getDIDTreeModel(did);
+        const claimsRoot = await newTreeModel.claimsTree.root();
+        const rootOfRoots = await newTreeModel.rootsTree.root();
+        const revocationRoot = await newTreeModel.revocationTree.root();
+        const newTreeState = {
+            revocationRoot,
+            claimsRoot,
+            state: newTreeModel.state,
+            rootOfRoots
+        };
+        const userId = js_iden3_core_1.DID.idFromDID(did);
+        let proof;
+        const isEthIdentity = (0, utils_1.isEthereumIdentity)(did); // don't generate proof for ethereum identities
+        let txId;
+        if (!isEthIdentity) {
+            if (!prover) {
+                throw new Error('prover is required to generate proofs for non ethereum identities');
+            }
+            // generate the proof
+            const authInfo = await this._inputsGenerator.prepareAuthBJJCredential(did, oldTreeState);
+            const challenge = js_crypto_1.Poseidon.hash([oldTreeState.state.bigInt(), newTreeState.state.bigInt()]);
+            const signature = await this.signChallenge(challenge, authInfo.credential);
+            const circuitInputs = new circuits_1.StateTransitionInputs();
+            circuitInputs.id = userId;
+            circuitInputs.signature = signature;
+            circuitInputs.isOldStateGenesis = isOldStateGenesis;
+            const authClaimIncProofNewState = await this.generateCredentialMtp(did, authInfo.credential, newTreeState);
+            circuitInputs.newTreeState = authClaimIncProofNewState.treeState;
+            circuitInputs.authClaimNewStateIncProof = authClaimIncProofNewState.proof;
+            circuitInputs.oldTreeState = oldTreeState;
+            circuitInputs.authClaim = {
+                claim: authInfo.coreClaim,
+                incProof: authInfo.incProof,
+                nonRevProof: authInfo.nonRevProof
+            };
+            const inputs = circuitInputs.inputsMarshal();
+            proof = await prover.generate(inputs, circuits_1.CircuitId.StateTransition);
+            txId = await this._storage.states.publishState(proof, ethSigner);
+        }
+        else {
+            const oldUserState = oldTreeState.state;
+            const newUserState = newTreeState.state;
+            const userStateTransitionInfo = {
+                userId,
+                oldUserState,
+                newUserState,
+                isOldStateGenesis,
+                methodId: BigInt(1),
+                methodParams: '0x'
+            };
+            txId = await this._storage.states.publishStateGeneric(ethSigner, userStateTransitionInfo);
+        }
+        await this.updateIdentityState(did, true, newTreeState);
+        return txId;
+    }
+    /** {@inheritdoc IIdentityWallet.addBJJAuthCredential} */
+    async addBJJAuthCredential(did, oldTreeState, isOldStateGenesis, ethSigner, opts, prover // it will be needed in case of non ethereum identities
+    ) {
+        opts.seed = opts.seed ?? (0, js_crypto_1.getRandomBytes)(32);
+        opts.revocationOpts.nonce =
+            opts.revocationOpts.nonce ??
+                (isOldStateGenesis
+                    ? 0
+                    : opts.revocationOpts.nonce ?? new DataView((0, js_crypto_1.getRandomBytes)(12).buffer).getUint32(0));
+        const { authClaim, pubKey } = await this.createAuthCoreClaim(opts.revocationOpts.nonce ?? 0, opts.seed);
+        const { hi, hv } = authClaim.hiHv();
+        await this._storage.mt.addToMerkleTree(did.string(), storage_1.MerkleTreeType.Claims, hi, hv);
+        // Calculate current state after adding credential to merkle tree
+        const claimsTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(did.string(), storage_1.MerkleTreeType.Claims);
+        const currentState = (0, js_merkletree_1.hashElems)([
+            (await claimsTree.root()).bigInt(),
+            oldTreeState.revocationRoot.bigInt(),
+            oldTreeState.rootOfRoots.bigInt()
+        ]);
+        let credential = await this.createAuthBJJCredential(did, pubKey, authClaim, currentState, opts.revocationOpts);
+        const txId = await this.transitState(did, oldTreeState, isOldStateGenesis, ethSigner, prover);
+        const { receipt, block } = await this._transactionService.getTransactionReceiptAndBlock(txId);
+        const credsWithIden3MTPProof = await this.generateIden3SparseMerkleTreeProof(did, [credential], txId, receipt?.blockNumber, block?.timestamp, undefined, {
+            revNonce: Number(authClaim.getRevocationNonce()),
+            subjectPosition: verifiable_1.SubjectPosition.None,
+            merklizedRootPosition: verifiable_1.MerklizedRootPosition.None,
+            updatable: false,
+            version: 0,
+            merklizeOpts: { documentLoader: (0, schema_processor_1.cacheLoader)() }
+        });
+        await this._credentialWallet.saveAll(credsWithIden3MTPProof);
+        const credRefreshed = await this._credentialWallet.findById(credential.id);
+        if (!credRefreshed) {
+            throw new Error('Credential not found in credential wallet');
+        }
+        credential = credRefreshed;
+        await this.publishRevocationInfoByCredentialStatusType(did, opts.revocationOpts.type, {
+            rhsUrl: opts.revocationOpts.id,
+            onChain: opts.revocationOpts.onChain
+        });
+        return credential;
+    }
 }
 exports.IdentityWallet = IdentityWallet;

package/dist/node/cjs/index.js

@@ -38,6 +38,7 @@ __exportStar(require("./iden3comm"), exports);
 __exportStar(require("./circuits"), exports);
 __exportStar(require("./iden3comm"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./blockchain"), exports);
 const core = __importStar(require("@iden3/js-iden3-core"));
 exports.core = core;
 const jsonLDMerklizer = __importStar(require("@iden3/js-jsonld-merklization"));

package/dist/node/cjs/kms/key-providers/bjj-provider.js

@@ -26,7 +26,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BjjProvider = void 0;
 const js_crypto_1 = require("@iden3/js-crypto");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
+const store_1 = require("../store");
 const providerHelpers = __importStar(require("../provider-helpers"));
+const utils_1 = require("../../utils");
 /**
  * Provider for Baby Jub Jub keys
  * @public
@@ -40,6 +42,9 @@ class BjjProvider {
      * @param {AbstractPrivateKeyStore} keyStore - key store for kms
      */
     constructor(keyType, keyStore) {
+        if (keyType !== store_1.KmsKeyType.BabyJubJub) {
+            throw new Error('Key type must be BabyJubJub');
+        }
         this.keyType = keyType;
         this.keyStore = keyStore;
     }
@@ -94,5 +99,9 @@ class BjjProvider {
         const privateKeyHex = await this.keyStore.get({ alias: keyId.id });
         return new js_crypto_1.PrivateKey(js_crypto_1.Hex.decodeString(privateKeyHex));
     }
+    async verify(message, signatureHex, keyId) {
+        const publicKey = await this.publicKey(keyId);
+        return js_crypto_1.PublicKey.newFromCompressed((0, utils_1.hexToBytes)(publicKey)).verifyPoseidon(js_iden3_core_1.BytesHelper.bytesToInt(message), js_crypto_1.Signature.newFromCompressed((0, utils_1.hexToBytes)(signatureHex)));
+    }
 }
 exports.BjjProvider = BjjProvider;

package/dist/node/cjs/kms/key-providers/ed25519-provider.js

@@ -77,12 +77,23 @@ class Ed25519Provider {
      * signs prepared payload of size,
      * with a key id
      * @param {KmsKeyId} keyId  - key identifier
-     * @param {Uint8Array} data - data to sign (32 bytes)
+     * @param {Uint8Array} digest - data to sign (32 bytes)
      * @returns {Promise<Uint8Array>} signature
      */
-    async sign(keyId, data) {
+    async sign(keyId, digest) {
         const privateKeyHex = await this.privateKey(keyId);
-        return ed25519_1.ed25519.sign(data, privateKeyHex);
+        return ed25519_1.ed25519.sign(digest, privateKeyHex);
+    }
+    /**
+     * Verifies a signature for the given message and key identifier.
+     * @param digest - 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.
+     */
+    async verify(digest, signatureHex, keyId) {
+        const publicKeyHex = await this.publicKey(keyId);
+        return ed25519_1.ed25519.verify(signatureHex, digest, publicKeyHex);
     }
     /**
      * Retrieves the private key for a given keyId from the key store.

package/dist/node/cjs/kms/key-providers/index.js

@@ -16,4 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./bjj-provider"), exports);
 __exportStar(require("./ed25519-provider"), exports);
-__exportStar(require("./sec256k1-provider"), exports);
+__exportStar(require("./secp256k1-provider"), exports);

package/dist/node/cjs/kms/key-providers/{sec256k1-provider.js → secp256k1-provider.js}

@@ -22,19 +22,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sec256k1Provider = void 0;
-const elliptic_1 = __importDefault(require("elliptic"));
+const store_1 = require("../store");
 const providerHelpers = __importStar(require("../provider-helpers"));
-const did_jwt_1 = require("did-jwt");
 const utils_1 = require("../../utils");
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const js_crypto_1 = require("@iden3/js-crypto");
+const did_jwt_1 = require("did-jwt");
 /**
- * Provider for Sec256p1 keys256p1
+ * Provider for Secp256k1
  * @public
- * @class Sec256p1Provider
+ * @class Secp256k1Provider
  * @implements implements IKeyProvider interface
  */
 class Sec256k1Provider {
@@ -44,9 +43,11 @@ class Sec256k1Provider {
      * @param {AbstractPrivateKeyStore} keyStore - key store for kms
      */
     constructor(keyType, keyStore) {
+        if (keyType !== store_1.KmsKeyType.Secp256k1) {
+            throw new Error('Key type must be Secp256k1');
+        }
         this.keyType = keyType;
         this._keyStore = keyStore;
-        this._ec = new elliptic_1.default.ec('secp256k1');
     }
     /**
      * generates a baby jub jub key from a seed phrase
@@ -57,12 +58,15 @@ class Sec256k1Provider {
         if (seed.length !== 32) {
             throw new Error('Seed should be 32 bytes');
         }
-        const keyPair = this._ec.keyFromPrivate(seed);
+        const publicKey = secp256k1_1.secp256k1.getPublicKey(seed);
         const kmsId = {
             type: this.keyType,
-            id: providerHelpers.keyPath(this.keyType, keyPair.getPublic().encode('hex', false))
+            id: providerHelpers.keyPath(this.keyType, (0, utils_1.bytesToHex)(publicKey))
         };
-        await this._keyStore.importKey({ alias: kmsId.id, key: keyPair.getPrivate().toString('hex') });
+        await this._keyStore.importKey({
+            alias: kmsId.id,
+            key: (0, utils_1.bytesToHex)(seed).padStart(64, '0')
+        });
         return kmsId;
     }
     /**
@@ -72,27 +76,34 @@ class Sec256k1Provider {
      */
     async publicKey(keyId) {
         const privateKeyHex = await this.privateKey(keyId);
-        return this._ec.keyFromPrivate(privateKeyHex, 'hex').getPublic().encode('hex', false);
+        const publicKey = secp256k1_1.secp256k1.getPublicKey(privateKeyHex, false); // 04 + x + y (uncompressed key)
+        return (0, utils_1.bytesToHex)(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
+     * 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.
      */
     async sign(keyId, data, opts = { alg: 'ES256K' }) {
         const privateKeyHex = await this.privateKey(keyId);
-        if (!privateKeyHex) {
-            throw new Error('Private key not found for keyId: ' + keyId.id);
+        const signatureBase64 = await (0, did_jwt_1.ES256KSigner)((0, did_jwt_1.hexToBytes)(privateKeyHex), opts.alg === 'ES256K-R')(data);
+        if (typeof signatureBase64 !== 'string') {
+            throw new Error('signatureBase64 must be a string');
         }
-        const signatureBase64 = await (0, did_jwt_1.ES256KSigner)((0, utils_1.hexToBytes)(privateKeyHex), opts.alg === 'ES256K-R')(data);
-        const signatureHex = (0, utils_1.bytesToHex)((0, utils_1.base64UrlToBytes)(signatureBase64.toString()));
-        if (typeof signatureHex !== 'string') {
-            throw new Error('Signature is not a string');
-        }
-        return utils_1.byteEncoder.encode(signatureBase64.toString());
+        return (0, utils_1.base64UrlToBytes)(signatureBase64);
+    }
+    /**
+     * 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.
+     */
+    async verify(message, signatureHex, keyId) {
+        const publicKeyHex = await this.publicKey(keyId);
+        return secp256k1_1.secp256k1.verify(signatureHex, (0, js_crypto_1.sha256)(message), publicKeyHex);
     }
     async privateKey(keyId) {
         return this._keyStore.get({ alias: keyId.id });

package/dist/node/cjs/kms/kms.js

@@ -65,5 +65,20 @@ class KMS {
         }
         return keyProvider.sign(keyId, data, opts);
     }
+    /**
+     * 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, signatureHex, keyId) {
+        const keyProvider = this._registry.get(keyId.type);
+        if (!keyProvider) {
+            throw new Error(`keyProvider not found for: ${keyId.type}`);
+        }
+        return keyProvider.verify(data, signatureHex, keyId);
+    }
 }
 exports.KMS = KMS;

package/dist/node/cjs/proof/proof-service.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProofService = void 0;
-const js_crypto_1 = require("@iden3/js-crypto");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const js_merkletree_1 = require("@iden3/js-merkletree");
 const circuits_1 = require("../circuits");
@@ -133,38 +132,9 @@ class ProofService {
         };
     }
     /** {@inheritdoc IProofService.transitState} */
-    async transitState(did, oldTreeState, isOldStateGenesis, stateStorage, ethSigner) {
-        const authInfo = await this._inputsGenerator.prepareAuthBJJCredential(did, oldTreeState);
-        const newTreeModel = await this._identityWallet.getDIDTreeModel(did);
-        const claimsRoot = await newTreeModel.claimsTree.root();
-        const rootOfRoots = await newTreeModel.rootsTree.root();
-        const revocationRoot = await newTreeModel.revocationTree.root();
-        const newTreeState = {
-            revocationRoot,
-            claimsRoot,
-            state: newTreeModel.state,
-            rootOfRoots
-        };
-        const challenge = js_crypto_1.Poseidon.hash([oldTreeState.state.bigInt(), newTreeState.state.bigInt()]);
-        const signature = await this._identityWallet.signChallenge(challenge, authInfo.credential);
-        const circuitInputs = new circuits_1.StateTransitionInputs();
-        circuitInputs.id = js_iden3_core_1.DID.idFromDID(did);
-        circuitInputs.signature = signature;
-        circuitInputs.isOldStateGenesis = isOldStateGenesis;
-        const authClaimIncProofNewState = await this._identityWallet.generateCredentialMtp(did, authInfo.credential, newTreeState);
-        circuitInputs.newTreeState = authClaimIncProofNewState.treeState;
-        circuitInputs.authClaimNewStateIncProof = authClaimIncProofNewState.proof;
-        circuitInputs.oldTreeState = oldTreeState;
-        circuitInputs.authClaim = {
-            claim: authInfo.coreClaim,
-            incProof: authInfo.incProof,
-            nonRevProof: authInfo.nonRevProof
-        };
-        const inputs = circuitInputs.inputsMarshal();
-        const proof = await this._prover.generate(inputs, circuits_1.CircuitId.StateTransition);
-        const txId = await stateStorage.publishState(proof, ethSigner);
-        await this._identityWallet.updateIdentityState(did, true, newTreeState);
-        return txId;
+    async transitState(did, oldTreeState, isOldStateGenesis, stateStorage, // for compatibility with previous versions we leave this parameter
+    ethSigner) {
+        return this._identityWallet.transitState(did, oldTreeState, isOldStateGenesis, ethSigner, this._prover);
     }
     async generateInputs(preparedCredential, identifier, proofReq, params, circuitQueries) {
         return this._inputsGenerator.generateInputs({

package/dist/node/cjs/proof/provers/inputs-generator.js

@@ -6,6 +6,7 @@ const verifiable_1 = require("../../verifiable");
 const circuits_1 = require("../../circuits");
 const common_1 = require("../common");
 const credentials_1 = require("../../credentials");
+const utils_1 = require("../../utils");
 const allOperations = Object.values(circuits_1.QueryOperators);
 const v2Operations = [
     circuits_1.Operators.NOOP,
@@ -269,13 +270,7 @@ class InputGenerator {
             circuitInputs.nullifierSessionID = proofReq.params?.nullifierSessionId
                 ? BigInt(proofReq.params?.nullifierSessionId?.toString())
                 : BigInt(0);
-            let isEthIdentity = true;
-            try {
-                js_iden3_core_1.Id.ethAddressFromId(circuitInputs.id);
-            }
-            catch {
-                isEthIdentity = false;
-            }
+            const isEthIdentity = (0, utils_1.isEthereumIdentity)(identifier);
             circuitInputs.isBJJAuthEnabled = isEthIdentity ? 0 : 1;
             circuitInputs.challenge = BigInt(params.challenge ?? 0);
             const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(identifier);