@docknetwork/wallet-sdk-wasm 0.4.19

package/lib/services/credential/range-proofs-example.js

@@ -0,0 +1,107 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var lib = require('@docknetwork/crypto-wasm-ts/lib');
+var boundCheck = require('@docknetwork/crypto-wasm-ts/lib/bound-check');
+var index = require('@docknetwork/crypto-wasm-ts/lib/index');
+
+const stringToBytes = (string) => Uint8Array.from(Buffer.from(string, 'utf-8'));
+function getRevealedUnrevealed(messages, revealedIndices) {
+    const revealedMsgs = new Map();
+    const unrevealedMsgs = new Map();
+    for (let i = 0; i < messages.length; i++) {
+        if (revealedIndices.has(i)) {
+            revealedMsgs.set(i, messages[i]);
+        }
+        else {
+            unrevealedMsgs.set(i, messages[i]);
+        }
+    }
+    return [revealedMsgs, unrevealedMsgs];
+}
+async function rangeProofExample() {
+    await index.initializeWasm();
+    const pk = boundCheck.BoundCheckSnarkSetup();
+    const snarkProvingKey = pk.decompress();
+    const snarkVerifyingKey = pk.getVerifyingKeyUncompressed();
+    const earliestIssuance = 642709800000; // Timestamp of the earliest acceptable issuance, used as lower bound
+    const latestIssuance = 1588271400000; // Timestamp of the latest acceptable issuance, used as upper bound
+    const bornAfter = 642709800000; // Timestamp of the latest acceptable birth date, used as lower bound
+    const now = 1620585000000; // Timestamp as of now, i.e proof generation
+    const someDistantFuture = 1777746600000; // Timestamp from future
+    const attributes = [];
+    attributes.push(lib.BBSSignature.encodeMessageForSigning(stringToBytes('John Smith'))); // Name
+    attributes.push(lib.BBSSignature.encodeMessageForSigning(stringToBytes('123-456789-0'))); // SSN
+    attributes.push(lib.BBSSignature.encodePositiveNumberForSigning(bornAfter + 100000)); // Birth date as no. of milliseconds since epoch
+    attributes.push(lib.BBSSignature.encodePositiveNumberForSigning(earliestIssuance + 100000)); // Issuance date as no. of milliseconds since epoch
+    attributes.push(lib.BBSSignature.encodePositiveNumberForSigning(now + 2000000)); // Expiration date as no. of milliseconds since epoch
+    const messageCount = attributes.length;
+    const sigParams = lib.BBSSignatureParams.generate(messageCount);
+    const sigKeypair1 = lib.BBSKeypair.generate(sigParams);
+    const sigSecretKey = sigKeypair1.secretKey;
+    const sigPublicKey = sigKeypair1.publicKey;
+    // Signer creates the signature and shares with prover
+    const sig = lib.BBSSignature.generate(attributes, sigSecretKey, sigParams, false);
+    const proverSetupParams = [];
+    proverSetupParams.push(lib.SetupParam.legosnarkProvingKeyUncompressed(snarkProvingKey));
+    const revealedIndices = new Set();
+    revealedIndices.add(0);
+    const [revealedAttrs, unrevealedAttrs] = getRevealedUnrevealed(attributes, revealedIndices);
+    const statement1 = lib.Statement.bbsSignature(sigParams, sigPublicKey, revealedAttrs, false);
+    const statement2 = lib.Statement.boundCheckProverFromSetupParamRefs(bornAfter, now, 0);
+    // For proving issuance date was between `earliestIssuance` and `latestIssuance`
+    const statement3 = lib.Statement.boundCheckProverFromSetupParamRefs(earliestIssuance, latestIssuance, 0);
+    // For proving expiration date was between `now` and `someDistantFuture`, i.e. its not expired as of now.
+    const statement4 = lib.Statement.boundCheckProverFromSetupParamRefs(now, someDistantFuture, 0);
+    const proverStatements = new lib.Statements(statement1);
+    proverStatements.add(statement2);
+    proverStatements.add(statement3);
+    proverStatements.add(statement4);
+    // For birth date attribute
+    const witnessEq1 = new lib.WitnessEqualityMetaStatement();
+    witnessEq1.addWitnessRef(0, 2);
+    witnessEq1.addWitnessRef(1, 0);
+    // For issuance date attribute
+    const witnessEq2 = new lib.WitnessEqualityMetaStatement();
+    witnessEq2.addWitnessRef(0, 3);
+    witnessEq2.addWitnessRef(2, 0);
+    // For expiration date attribute
+    const witnessEq3 = new lib.WitnessEqualityMetaStatement();
+    witnessEq3.addWitnessRef(0, 4);
+    witnessEq3.addWitnessRef(3, 0);
+    const metaStatements = new lib.MetaStatements();
+    metaStatements.add(lib.MetaStatement.witnessEquality(witnessEq1));
+    metaStatements.add(lib.MetaStatement.witnessEquality(witnessEq2));
+    metaStatements.add(lib.MetaStatement.witnessEquality(witnessEq3));
+    const witnesses = new lib.Witnesses();
+    witnesses.add(lib.Witness.bbsSignature(sig, unrevealedAttrs, false));
+    witnesses.add(lib.Witness.boundCheckLegoGroth16(attributes[2]));
+    witnesses.add(lib.Witness.boundCheckLegoGroth16(attributes[3]));
+    witnesses.add(lib.Witness.boundCheckLegoGroth16(attributes[4]));
+    const proverProofSpec = new lib.QuasiProofSpecG1(proverStatements, metaStatements, proverSetupParams);
+    const nonce = stringToBytes('a nonce');
+    const proof = lib.CompositeProofG1.generateUsingQuasiProofSpec(proverProofSpec, witnesses, nonce);
+    console.log(proof);
+    // Verify the proof
+    const verifierSetupParams = [];
+    verifierSetupParams.push(lib.SetupParam.legosnarkVerifyingKeyUncompressed(snarkVerifyingKey));
+    // For verifying birth date was after `bornAfter`
+    const statement5 = lib.Statement.boundCheckVerifierFromSetupParamRefs(bornAfter, now, 0);
+    // For verifying issuance date was between `earliestIssuance` and `latestIssuance`
+    const statement6 = lib.Statement.boundCheckVerifierFromSetupParamRefs(earliestIssuance, latestIssuance, 0);
+    // For verifying expiration date was between `now` and `someDistantFuture`, i.e. its not expired as of now.
+    const statement7 = lib.Statement.boundCheckVerifierFromSetupParamRefs(now, someDistantFuture, 0);
+    const verifierStatements = new lib.Statements();
+    verifierStatements.add(statement1);
+    verifierStatements.add(statement5);
+    verifierStatements.add(statement6);
+    verifierStatements.add(statement7);
+    const verifierProofSpec = new lib.QuasiProofSpecG1(verifierStatements, metaStatements, verifierSetupParams);
+    const result = proof.verifyUsingQuasiProofSpec(verifierProofSpec, nonce);
+    console.log(result);
+    return true;
+}
+rangeProofExample();
+
+exports.rangeProofExample = rangeProofExample;

package/lib/services/credential/range-proofs-example.mjs

@@ -0,0 +1,103 @@
+import { BBSSignature, BBSSignatureParams, BBSKeypair, SetupParam, Statement, Statements, WitnessEqualityMetaStatement, MetaStatements, MetaStatement, Witnesses, Witness, QuasiProofSpecG1, CompositeProofG1 } from '@docknetwork/crypto-wasm-ts/lib';
+import { BoundCheckSnarkSetup } from '@docknetwork/crypto-wasm-ts/lib/bound-check';
+import { initializeWasm } from '@docknetwork/crypto-wasm-ts/lib/index';
+
+const stringToBytes = (string) => Uint8Array.from(Buffer.from(string, 'utf-8'));
+function getRevealedUnrevealed(messages, revealedIndices) {
+    const revealedMsgs = new Map();
+    const unrevealedMsgs = new Map();
+    for (let i = 0; i < messages.length; i++) {
+        if (revealedIndices.has(i)) {
+            revealedMsgs.set(i, messages[i]);
+        }
+        else {
+            unrevealedMsgs.set(i, messages[i]);
+        }
+    }
+    return [revealedMsgs, unrevealedMsgs];
+}
+async function rangeProofExample() {
+    await initializeWasm();
+    const pk = BoundCheckSnarkSetup();
+    const snarkProvingKey = pk.decompress();
+    const snarkVerifyingKey = pk.getVerifyingKeyUncompressed();
+    const earliestIssuance = 642709800000; // Timestamp of the earliest acceptable issuance, used as lower bound
+    const latestIssuance = 1588271400000; // Timestamp of the latest acceptable issuance, used as upper bound
+    const bornAfter = 642709800000; // Timestamp of the latest acceptable birth date, used as lower bound
+    const now = 1620585000000; // Timestamp as of now, i.e proof generation
+    const someDistantFuture = 1777746600000; // Timestamp from future
+    const attributes = [];
+    attributes.push(BBSSignature.encodeMessageForSigning(stringToBytes('John Smith'))); // Name
+    attributes.push(BBSSignature.encodeMessageForSigning(stringToBytes('123-456789-0'))); // SSN
+    attributes.push(BBSSignature.encodePositiveNumberForSigning(bornAfter + 100000)); // Birth date as no. of milliseconds since epoch
+    attributes.push(BBSSignature.encodePositiveNumberForSigning(earliestIssuance + 100000)); // Issuance date as no. of milliseconds since epoch
+    attributes.push(BBSSignature.encodePositiveNumberForSigning(now + 2000000)); // Expiration date as no. of milliseconds since epoch
+    const messageCount = attributes.length;
+    const sigParams = BBSSignatureParams.generate(messageCount);
+    const sigKeypair1 = BBSKeypair.generate(sigParams);
+    const sigSecretKey = sigKeypair1.secretKey;
+    const sigPublicKey = sigKeypair1.publicKey;
+    // Signer creates the signature and shares with prover
+    const sig = BBSSignature.generate(attributes, sigSecretKey, sigParams, false);
+    const proverSetupParams = [];
+    proverSetupParams.push(SetupParam.legosnarkProvingKeyUncompressed(snarkProvingKey));
+    const revealedIndices = new Set();
+    revealedIndices.add(0);
+    const [revealedAttrs, unrevealedAttrs] = getRevealedUnrevealed(attributes, revealedIndices);
+    const statement1 = Statement.bbsSignature(sigParams, sigPublicKey, revealedAttrs, false);
+    const statement2 = Statement.boundCheckProverFromSetupParamRefs(bornAfter, now, 0);
+    // For proving issuance date was between `earliestIssuance` and `latestIssuance`
+    const statement3 = Statement.boundCheckProverFromSetupParamRefs(earliestIssuance, latestIssuance, 0);
+    // For proving expiration date was between `now` and `someDistantFuture`, i.e. its not expired as of now.
+    const statement4 = Statement.boundCheckProverFromSetupParamRefs(now, someDistantFuture, 0);
+    const proverStatements = new Statements(statement1);
+    proverStatements.add(statement2);
+    proverStatements.add(statement3);
+    proverStatements.add(statement4);
+    // For birth date attribute
+    const witnessEq1 = new WitnessEqualityMetaStatement();
+    witnessEq1.addWitnessRef(0, 2);
+    witnessEq1.addWitnessRef(1, 0);
+    // For issuance date attribute
+    const witnessEq2 = new WitnessEqualityMetaStatement();
+    witnessEq2.addWitnessRef(0, 3);
+    witnessEq2.addWitnessRef(2, 0);
+    // For expiration date attribute
+    const witnessEq3 = new WitnessEqualityMetaStatement();
+    witnessEq3.addWitnessRef(0, 4);
+    witnessEq3.addWitnessRef(3, 0);
+    const metaStatements = new MetaStatements();
+    metaStatements.add(MetaStatement.witnessEquality(witnessEq1));
+    metaStatements.add(MetaStatement.witnessEquality(witnessEq2));
+    metaStatements.add(MetaStatement.witnessEquality(witnessEq3));
+    const witnesses = new Witnesses();
+    witnesses.add(Witness.bbsSignature(sig, unrevealedAttrs, false));
+    witnesses.add(Witness.boundCheckLegoGroth16(attributes[2]));
+    witnesses.add(Witness.boundCheckLegoGroth16(attributes[3]));
+    witnesses.add(Witness.boundCheckLegoGroth16(attributes[4]));
+    const proverProofSpec = new QuasiProofSpecG1(proverStatements, metaStatements, proverSetupParams);
+    const nonce = stringToBytes('a nonce');
+    const proof = CompositeProofG1.generateUsingQuasiProofSpec(proverProofSpec, witnesses, nonce);
+    console.log(proof);
+    // Verify the proof
+    const verifierSetupParams = [];
+    verifierSetupParams.push(SetupParam.legosnarkVerifyingKeyUncompressed(snarkVerifyingKey));
+    // For verifying birth date was after `bornAfter`
+    const statement5 = Statement.boundCheckVerifierFromSetupParamRefs(bornAfter, now, 0);
+    // For verifying issuance date was between `earliestIssuance` and `latestIssuance`
+    const statement6 = Statement.boundCheckVerifierFromSetupParamRefs(earliestIssuance, latestIssuance, 0);
+    // For verifying expiration date was between `now` and `someDistantFuture`, i.e. its not expired as of now.
+    const statement7 = Statement.boundCheckVerifierFromSetupParamRefs(now, someDistantFuture, 0);
+    const verifierStatements = new Statements();
+    verifierStatements.add(statement1);
+    verifierStatements.add(statement5);
+    verifierStatements.add(statement6);
+    verifierStatements.add(statement7);
+    const verifierProofSpec = new QuasiProofSpecG1(verifierStatements, metaStatements, verifierSetupParams);
+    const result = proof.verifyUsingQuasiProofSpec(verifierProofSpec, nonce);
+    console.log(result);
+    return true;
+}
+rangeProofExample();
+
+export { rangeProofExample };

package/lib/services/credential/service-rpc.js

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_rpcServiceClient = require('../rpc-service-client.js');
+var services_credential_config = require('./config.js');
+require('assert');
+require('../../rpc-client.js');
+require('json-rpc-2.0');
+require('../../core/crypto.js');
+require('crypto');
+require('../../core/logger.js');
+require('../../logger.js');
+require('../../rpc-util.js');
+
+class CredentialServiceRPC extends services_rpcServiceClient.RpcService {
+  constructor() {
+    super(services_credential_config.serviceName);
+  }
+  generateCredential(params) {
+    return this.call('generateCredential', params);
+  }
+  async signCredential(params) {
+    return this.call('signCredential', params);
+  }
+  async createPresentation(params) {
+    return this.call('createPresentation', params);
+  }
+  async verifyCredential(params) {
+    return this.call('verifyCredential', params);
+  }
+  async createBBSPresentation(params) {
+    return this.call('createBBSPresentation', params);
+  }
+  async deriveVCFromBBSPresentation(params) {
+    return this.call('deriveVCFromBBSPresentation', params);
+  }
+  async isBBSPlusCredential(params) {
+    return this.call('isBBSPlusCredential', params);
+  }
+  async getAccumulatorId(params) {
+    return this.call('getAccumulatorId', params);
+  }
+}
+
+exports.CredentialServiceRPC = CredentialServiceRPC;

package/lib/services/credential/service-rpc.mjs

@@ -0,0 +1,42 @@
+import { RpcService } from '../rpc-service-client.mjs';
+import { serviceName } from './config.mjs';
+import 'assert';
+import '../../rpc-client.mjs';
+import 'json-rpc-2.0';
+import '../../core/crypto.mjs';
+import 'crypto';
+import '../../core/logger.mjs';
+import '../../logger.mjs';
+import '../../rpc-util.mjs';
+
+class CredentialServiceRPC extends RpcService {
+  constructor() {
+    super(serviceName);
+  }
+  generateCredential(params) {
+    return this.call('generateCredential', params);
+  }
+  async signCredential(params) {
+    return this.call('signCredential', params);
+  }
+  async createPresentation(params) {
+    return this.call('createPresentation', params);
+  }
+  async verifyCredential(params) {
+    return this.call('verifyCredential', params);
+  }
+  async createBBSPresentation(params) {
+    return this.call('createBBSPresentation', params);
+  }
+  async deriveVCFromBBSPresentation(params) {
+    return this.call('deriveVCFromBBSPresentation', params);
+  }
+  async isBBSPlusCredential(params) {
+    return this.call('isBBSPlusCredential', params);
+  }
+  async getAccumulatorId(params) {
+    return this.call('getAccumulatorId', params);
+  }
+}
+
+export { CredentialServiceRPC };

package/lib/services/credential/service.js

@@ -0,0 +1,271 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_credential_config = require('./config.js');
+var cryptoWasmTs = require('@docknetwork/crypto-wasm-ts');
+var VerifiableCredential = require('@docknetwork/sdk/verifiable-credential');
+var keypairs = require('@docknetwork/universal-wallet/methods/keypairs');
+var helpers = require('@docknetwork/sdk/utils/vc/helpers');
+var VerifiablePresentation = require('@docknetwork/sdk/verifiable-presentation');
+var BbsPlusPresentation = require('@docknetwork/sdk/presentation');
+var credentials = require('@docknetwork/sdk/utils/vc/credentials');
+var pex$1 = require('@sphereon/pex');
+var services_credential_utils = require('./utils.js');
+var services_dock_service = require('../dock/service.js');
+var services_credential_boundCheck = require('./bound-check.js');
+var assert = require('assert');
+var services_credential_bbsRevocation = require('./bbs-revocation.js');
+var services_credential_pexHelpers = require('./pex-helpers.js');
+require('base58-universal');
+require('@docknetwork/sdk/utils/misc');
+require('@polkadot/util-crypto');
+require('@polkadot/util');
+require('@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022');
+require('@docknetwork/sdk');
+require('@docknetwork/sdk/resolver');
+require('@docknetwork/crypto-wasm-ts/lib/index');
+require('events');
+require('../../core/logger.js');
+require('../../modules/event-manager.js');
+require('../dock/configs.js');
+require('@docknetwork/crypto-wasm-ts/lib/legosnark');
+require('base64url');
+require('@astronautlabs/jsonpath');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var VerifiableCredential__default = /*#__PURE__*/_interopDefaultLegacy(VerifiableCredential);
+var VerifiablePresentation__default = /*#__PURE__*/_interopDefaultLegacy(VerifiablePresentation);
+var BbsPlusPresentation__default = /*#__PURE__*/_interopDefaultLegacy(BbsPlusPresentation);
+var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+
+// @ts-nocheck
+const pex = new pex$1.PEX();
+function isBBSPlusCredential(credential) {
+    return ((typeof credential?.proof?.type === 'string' &&
+        (credential.proof.type.includes('BBS+SignatureDock')) ||
+        (Array.isArray(credential['@context']) && credential['@context'].find(context => typeof context === 'string' && context.indexOf('bbs') > -1))));
+}
+class CredentialService {
+    constructor() {
+        this.name = services_credential_config.serviceName;
+    }
+    rpcMethods = [
+        CredentialService.prototype.generateCredential,
+        CredentialService.prototype.signCredential,
+        CredentialService.prototype.createPresentation,
+        CredentialService.prototype.verifyCredential,
+        CredentialService.prototype.createBBSPresentation,
+        CredentialService.prototype.deriveVCFromBBSPresentation,
+        CredentialService.prototype.isBBSPlusCredential,
+    ];
+    generateCredential(params = {}) {
+        services_credential_config.validation.generateCredential(params);
+        const { subject } = params;
+        const vc = new VerifiableCredential__default["default"]();
+        vc.addType('DockAuthCredential');
+        vc.addContext({
+            dk: 'https://ld.dock.io/credentials#',
+            DockAuthCredential: 'dk:DockAuthCredential',
+        });
+        if (subject) {
+            vc.setSubject(subject);
+            vc.addContext({
+                state: 'dk:state',
+            });
+        }
+        return vc;
+    }
+    async signCredential(params) {
+        services_credential_config.validation.signCredential(params);
+        const { vcJson, keyDoc } = params;
+        const verifiableCredential = new VerifiableCredential__default["default"]();
+        verifiableCredential.setFromJSON(vcJson);
+        const kp = keypairs.getKeypairFromDoc(keyDoc);
+        kp.signer = kp.signer();
+        const suite = await helpers.getSuiteFromKeyDoc(kp);
+        verifiableCredential.setIssuer(keyDoc.controller);
+        await verifiableCredential.sign(suite);
+        return verifiableCredential;
+    }
+    async createPresentation(params) {
+        services_credential_config.validation.createPresentation(params);
+        const { credentials, keyDoc, challenge, id, domain } = params;
+        const vp = new VerifiablePresentation__default["default"](id);
+        let isBBS;
+        for (const signedVC of credentials) {
+            vp.addCredential(signedVC);
+            isBBS = isBBS || isBBSPlusCredential(signedVC);
+        }
+        if (!isBBS) {
+            vp.setHolder(keyDoc.controller);
+        }
+        keyDoc.keypair = services_credential_utils.keyDocToKeypair(keyDoc, services_dock_service.getDock());
+        if (isBBS) {
+            return vp.toJSON();
+        }
+        return vp.sign(keyDoc, challenge, domain, services_dock_service.dockService.resolver);
+    }
+    async verifyCredential(params) {
+        services_credential_config.validation.verifyCredential(params);
+        const { credential, membershipWitness } = params;
+        const result = await credentials.verifyCredential(credential, {
+            resolver: services_dock_service.dockService.resolver,
+            revocationApi: { dock: services_dock_service.getDock() },
+        });
+        const { credentialStatus } = credential;
+        if (result.verified && credentialStatus?.id) {
+            try {
+                const isRevoked = await services_credential_bbsRevocation.getIsRevoked(credential, membershipWitness);
+                if (isRevoked) {
+                    result.verified = false;
+                    result.error = 'revocation check: the credential is revoked';
+                }
+            }
+            catch (err) {
+                console.log('Unable to get revocation status');
+                console.error(err);
+            }
+        }
+        return result;
+    }
+    filterCredentials(params) {
+        const { credentials, presentationDefinition, holderDid } = params;
+        const result = pex.selectFrom(presentationDefinition, credentials, holderDid);
+        return result;
+    }
+    evaluatePresentation(params) {
+        const { presentation, presentationDefinition } = params;
+        const result = pex.evaluatePresentation(presentationDefinition, presentation);
+        return result;
+    }
+    isBBSPlusCredential(params) {
+        const { credential } = params;
+        return isBBSPlusCredential(credential);
+    }
+    async createBBSPresentation(params) {
+        services_credential_config.validation.createBBSPresentation(params);
+        const { credentials } = params;
+        const bbsPlusPresentation = new BbsPlusPresentation__default["default"]();
+        for (const { credential, attributesToReveal } of credentials) {
+            const idx = await bbsPlusPresentation.addCredentialToPresent(credential, {
+                resolver: services_dock_service.dockService.resolver,
+            });
+            if (Array.isArray(attributesToReveal) && attributesToReveal.length > 0) {
+                await bbsPlusPresentation.addAttributeToReveal(idx, attributesToReveal);
+            }
+        }
+        return bbsPlusPresentation.createPresentation();
+    }
+    getAccumulatorId({ credential }) {
+        assert__default["default"](!!credential, `credential is required`);
+        if (!credential?.credentialStatus) {
+            return null;
+        }
+        return credential?.credentialStatus.id.replace('dock:accumulator:', '');
+    }
+    async getAccumulatorData({ credential }) {
+        assert__default["default"](!!credential, `credential is required`);
+        const accumulatorId = await this.getAccumulatorId({ credential });
+        if (!accumulatorId) {
+            return null;
+        }
+        return services_dock_service.getDock().accumulatorModule.getAccumulator(accumulatorId, false);
+    }
+    /**
+     * Fetch the latest accumulator witness updates for a given credential and membership witness
+     * The witness is generated by the issuer when the credential is created and is stored in the wallet when the credential is imported
+     *
+     * @param param0
+     */
+    async updateMembershipWitness({ credential, membershipWitnessJSON }) {
+        const revocationId = credential.credentialStatus.revocationId;
+        const member = cryptoWasmTs.Accumulator.encodePositiveNumberAsAccumulatorMember(revocationId);
+        let updates = [];
+        try {
+            updates = await dock.accumulatorModule.getUpdatesFromBlock(accumulatorId, accumulator.lastModified);
+        }
+        catch (err) {
+            if (err.code === -32000) {
+                console.error(err);
+                // "-32000: Client error: UnknownBlock: State already discarded for BlockId::Hash(<hash>)"
+                // This means that the node has discarded old blocks to preserve space. This should not happen with a full node
+                updates = [];
+            }
+            else {
+                throw err;
+            }
+        }
+        const additions = [];
+        const removals = [];
+        if (updates.length && updates[0].additions !== null) {
+            for (const a of updates[0].additions) {
+                additions.push(hexToU8a(a));
+            }
+        }
+        if (updates.length && updates[0].removals !== null) {
+            for (const a of updates[0].removals) {
+                removals.push(hexToU8a(a));
+            }
+        }
+        const queriedWitnessInfo = new cryptoWasmTs.WitnessUpdatePublicInfo(hexToU8a(updates[0].witnessUpdateInfo));
+        const witness = cryptoWasmTs.MembershipWitness.fromJSON(membershipWitnessJSON);
+        witness.updateUsingPublicInfoPostBatchUpdate(member, additions, removals, queriedWitnessInfo);
+        return witness.toJSON();
+    }
+    async deriveVCFromBBSPresentation(params) {
+        services_credential_config.validation.deriveVCFromBBSPresentation(params);
+        const { credentials, options = {}, proofRequest } = params;
+        const bbsPlusPresentation = new BbsPlusPresentation__default["default"]();
+        const selectedCredentials = credentials.map(({ credential }) => credential);
+        let descriptorBounds = [];
+        for (const { credential } of credentials) {
+            await bbsPlusPresentation.addCredentialToPresent(credential, {
+                resolver: services_dock_service.dockService.resolver,
+            });
+        }
+        if (proofRequest && services_credential_boundCheck.hasProvingKey(proofRequest)) {
+            const { provingKey, provingKeyId } = await services_credential_boundCheck.fetchProvingKey(proofRequest);
+            descriptorBounds = services_credential_boundCheck.applyEnforceBounds({
+                builder: bbsPlusPresentation.presBuilder,
+                proofRequest,
+                provingKey,
+                provingKeyId,
+                selectedCredentials,
+            });
+        }
+        let pexRequiredAttributes = [];
+        if (proofRequest?.request) {
+            pexRequiredAttributes = services_credential_pexHelpers.getPexRequiredAttributes(proofRequest.request, selectedCredentials);
+        }
+        let idx = 0;
+        for (const { attributesToReveal, witness, credential } of credentials) {
+            const attributesToSkip = descriptorBounds[idx] ? descriptorBounds[idx].map((bound) => bound.attributeName) : [];
+            const filteredAttributes = attributesToReveal.filter((attribute) => !attributesToSkip.includes(attribute));
+            const _pexRequiredAttributes = pexRequiredAttributes[idx] || [];
+            _pexRequiredAttributes.forEach((attr) => {
+                if (!filteredAttributes.includes(attr)) {
+                    filteredAttributes.push(attr);
+                }
+            });
+            if (Array.isArray(filteredAttributes) && filteredAttributes.length > 0) {
+                bbsPlusPresentation.addAttributeToReveal(idx, filteredAttributes);
+            }
+            if (witness) {
+                const details = await services_credential_bbsRevocation.getWitnessDetails(credential, witness);
+                bbsPlusPresentation.presBuilder.addAccumInfoForCredStatus(idx, details.membershipWitness, details.accumulator.accumulated, details.pk, details.params);
+            }
+            idx++;
+        }
+        const credentialsFromPresentation = await bbsPlusPresentation.deriveCredentials(options);
+        return credentialsFromPresentation;
+    }
+    async testRangeProof() {
+        console.log('test');
+    }
+}
+const credentialService = new CredentialService();
+
+exports.credentialService = credentialService;
+exports.isBBSPlusCredential = isBBSPlusCredential;