@docknetwork/wallet-sdk-wasm 1.7.6 → 1.9.0

package/lib/services/blockchain/service.mjs

@@ -1,306 +0,0 @@
-import { DirectSecp256k1HdWallet } from '@cosmjs/proto-signing';
-import { CheqdAPI } from '@docknetwork/cheqd-blockchain-api';
-import { CheqdCoreModules } from '@docknetwork/cheqd-blockchain-modules';
-import { MultiApiCoreModules } from '@docknetwork/credential-sdk/modules';
-import { UniversalResolver, DIDKeyResolver, CoreResolver, ResolverRouter, WILDCARD } from '@docknetwork/credential-sdk/resolver';
-import { initializeWasm } from '@docknetwork/crypto-wasm-ts/lib/index';
-import { EventEmitter } from 'events';
-import { Logger } from '../../core/logger.mjs';
-import { once } from '../../modules/event-manager.mjs';
-import { utilCryptoService } from '../util-crypto/service.mjs';
-import { AccumulatorPublicKey, AccumulatorId, AccumulatorCommon } from '@docknetwork/credential-sdk/types';
-import { CachedDIDResolver } from './cached-did-resolver.mjs';
-import 'assert';
-import '@docknetwork/credential-sdk/utils';
-import '@scure/bip39';
-import '@scure/bip39/wordlists/english';
-import '../util-crypto/configs.mjs';
-import '../storage/index.mjs';
-import '../storage/service.mjs';
-import '../storage/service-rpc.mjs';
-import '../rpc-service-client.mjs';
-import '../../rpc-client.mjs';
-import 'json-rpc-2.0';
-import '../../core/crypto.mjs';
-import 'crypto';
-import '../../logger.mjs';
-import '../../rpc-util.mjs';
-
-// @ts-nocheck
-/**
- * Universal resolver URL for DID resolution fallback
- * @constant {string}
- */
-const universalResolverUrl = 'https://uniresolver.truvera.io';
-/**
- * Resolver that accepts any DID method using wildcard matching
- * @class
- * @extends ResolverRouter
- * @private
- */
-class AnyDIDResolver extends ResolverRouter {
-    method = WILDCARD;
-}
-/**
- * Main blockchain service class for managing blockchain connections and DID resolution
- * @class
- * @description Provides methods for connecting to Cheqd blockchain, resolving DIDs,
- * and managing blockchain-related operations
- */
-class BlockchainService {
-    dock;
-    modules;
-    cheqdApi;
-    cheqdApiUrl;
-    isBlockchainReady = false;
-    _resolver;
-    get resolver() {
-        return this._resolver;
-    }
-    /**
-     * Event names emitted by the blockchain service
-     * @static
-     * @readonly
-     * @property {string} BLOCKCHAIN_READY - Emitted when blockchain connection is established
-     */
-    static Events = {
-        BLOCKCHAIN_READY: 'blockchain-ready',
-    };
-    rpcMethods = [
-        BlockchainService.prototype.disconnect,
-        BlockchainService.prototype.ensureBlockchainReady,
-        BlockchainService.prototype.init,
-        BlockchainService.prototype.isApiConnected,
-        BlockchainService.prototype.getAddress,
-        BlockchainService.prototype.resolveDID,
-        BlockchainService.prototype.getCachedDIDs,
-        BlockchainService.prototype.clearCache,
-        BlockchainService.prototype.getCacheEntry,
-    ];
-    /**
-     * Creates a new BlockchainService instance
-     * @constructor
-     */
-    constructor() {
-        this.name = 'blockchain';
-        this.cheqdApi = new CheqdAPI();
-        this.cheqdModules = new CheqdCoreModules(this.cheqdApi);
-        this.modules = new MultiApiCoreModules([this.cheqdModules]);
-        this.emitter = new EventEmitter();
-        // Blockchain is not ready yet, but we can use fallback resolvers
-        this._resolver = this.createDIDResolver();
-    }
-    /**
-     * Gets the types and modules needed for DID or accumulator operations
-     * @param {string} didOrRegistryId - DID or registry identifier
-     * @returns {Object} Object containing accumulator-related types and modules
-     * @returns {typeof AccumulatorPublicKey} returns.PublicKey - Accumulator public key type
-     * @returns {typeof AccumulatorId} returns.AccumulatorId - Accumulator ID type
-     * @returns {typeof AccumulatorCommon} returns.AccumulatorCommon - Common accumulator type
-     * @returns {Object} returns.AccumulatorModule - Accumulator module instance
-     */
-    getTypesForDIDOrAccumulator(didOrRegistryId) {
-        return {
-            PublicKey: AccumulatorPublicKey,
-            AccumulatorId,
-            AccumulatorCommon,
-            AccumulatorModule: this.modules.accumulator,
-        };
-    }
-    /**
-     * Ensures the blockchain connection is ready before proceeding
-     * @returns {Promise<void>} Resolves when blockchain is ready
-     * @example
-     * await blockchainService.ensureBlockchainReady();
-     * // Blockchain is now connected and ready
-     */
-    async ensureBlockchainReady() {
-        if (await this.isApiConnected()) {
-            return;
-        }
-        return once(this.emitter, BlockchainService.Events.BLOCKCHAIN_READY);
-    }
-    /**
-     * Gets the cached DIDs
-     * @returns {Promise<string[]>} Cached DIDs
-     */
-    getCachedDIDs() {
-        return this.resolver.getCachedDIDs();
-    }
-    /**
-     * Gets the cached DID resolution data
-     * @param {string} did - The DID to get the cache entry for
-     * @returns {Promise<any>} Cached DID resolution data
-     */
-    getCacheEntry(did) {
-        return this.resolver.getCacheEntry(did);
-    }
-    /**
-     * Clears cached data for a specific DID
-     * @param {string} did - The DID to clear from cache
-     * @returns {void}
-     */
-    clearCache(did) {
-        return this.resolver.clearCache(did);
-    }
-    /**
-     * Creates a DID resolver with caching support
-     * @private
-     * @returns {CachedDIDResolver} Cached DID resolver instance
-     */
-    createDIDResolver(isBlockchainReady) {
-        let resolvers = [
-            new UniversalResolver(universalResolverUrl),
-            new DIDKeyResolver(),
-        ];
-        // Add blockchain resolvers if the blockchain is ready
-        if (isBlockchainReady) {
-            resolvers = [
-                new CoreResolver(this.modules),
-                ...resolvers
-            ];
-        }
-        const router = new AnyDIDResolver(resolvers);
-        return new CachedDIDResolver(router);
-    }
-    /**
-     * Initializes the blockchain service with connection parameters
-     * @param {InitParams} params - Initialization parameters
-     * @param {string} params.cheqdApiUrl - URL of the Cheqd API endpoint
-     * @param {string} [params.networkId] - Cheqd network identifier
-     * @param {string} [params.cheqdMnemonic] - Mnemonic for Cheqd wallet (auto-generated if not provided)
-     * @returns {Promise<boolean>} True if initialization successful
-     * @throws {Error} If cheqdApiUrl is not provided
-     * @example
-     * await blockchainService.init({
-     *   cheqdApiUrl: 'https://api.cheqd.network',
-     *   networkId: 'mainnet'
-     * });
-     */
-    async init(params) {
-        if (!params?.cheqdApiUrl) {
-            throw new Error('cheqdApiUrl is required');
-        }
-        if (this.cheqdApi && this.cheqdApi.isInitialized()) {
-            Logger.info('Disconnecting from cheqd');
-            await this.cheqdApi.disconnect();
-        }
-        this.modules = new MultiApiCoreModules([this.cheqdModules]);
-        const checkdApiUrl = params?.cheqdApiUrl;
-        const cheqdNetworkId = params?.networkId;
-        const cheqdMnemonic = params?.cheqdMnemonic || (await utilCryptoService.mnemonicGenerate(12));
-        const wallet = await DirectSecp256k1HdWallet.fromMnemonic(cheqdMnemonic, {
-            prefix: 'cheqd',
-        });
-        const walletAccounts = await wallet.getAccounts();
-        const [{ address }] = walletAccounts;
-        console.log('Using cheqd account:', address);
-        Logger.info(`Attempt to initialized cheqd at: ${checkdApiUrl} with networkId: ${cheqdNetworkId}`);
-        Logger.info(`Using cheqd account: ${address}`);
-        try {
-            await this.cheqdApi.init({
-                wallet,
-                urls: Array.isArray(checkdApiUrl) ? checkdApiUrl : [checkdApiUrl],
-                network: cheqdNetworkId,
-            });
-            Logger.info(`Cheqd initialized at: ${checkdApiUrl}`);
-        }
-        catch (err) {
-            debugger;
-            Logger.error(`Failed to initialize cheqd at: ${checkdApiUrl}`, err);
-        }
-        // Re-create the resolver with the new blockchain connection
-        this._resolver = this.createDIDResolver(true);
-        if (process.env.NODE_ENV !== 'test' ||
-            process.env.API_MOCK_DISABLED === 'true') {
-            await initializeWasm();
-        }
-        this._setBlockchainReady(true);
-        return true;
-    }
-    /**
-     * Disconnects from the blockchain
-     * @returns {Promise<void>} Resolves when disconnection is complete
-     * @example
-     * await blockchainService.disconnect();
-     */
-    async disconnect() {
-        let result;
-        if (this.cheqdApi && this.cheqdApi.isInitialized()) {
-            result = await this.cheqdApi.disconnect();
-        }
-        this._setBlockchainReady(false);
-        return result;
-    }
-    /**
-     * Waits for the blockchain to be ready
-     * @returns {Promise<void>} Resolves when blockchain is ready
-     * @private
-     */
-    async waitBlockchainReady() {
-        return new Promise(resolve => {
-            if (this.isBlockchainReady) {
-                resolve();
-            }
-            else {
-                this.emitter.once(BlockchainService.Events.BLOCKCHAIN_READY, resolve);
-            }
-        });
-    }
-    /**
-     * Resolves a DID to its document
-     * @param {string} did - The DID to resolve
-     * @returns {Promise<Object>} The resolved DID document
-     * @example
-     * const didDoc = await blockchainService.resolveDID('did:key:z6Mk...');
-     */
-    async resolveDID(did) {
-        return this.resolver.resolve(did);
-    }
-    /**
-     * Checks if the blockchain API is connected
-     * @returns {Promise<boolean>} True if connected, false otherwise
-     * @example
-     * const isConnected = await blockchainService.isApiConnected();
-     */
-    async isApiConnected() {
-        return this.cheqdApi.isInitialized();
-    }
-    /**
-     * Gets the current Cheqd API URL
-     * @returns {Promise<string>} The Cheqd API URL
-     * @example
-     * const apiUrl = await blockchainService.getAddress();
-     */
-    async getAddress() {
-        return this.cheqdApiUrl;
-    }
-    /**
-     * Sets the blockchain ready state and emits events
-     * @private
-     * @param {boolean} isBlockchainReady - Whether blockchain is ready
-     */
-    _setBlockchainReady(isBlockchainReady) {
-        this.isBlockchainReady = isBlockchainReady;
-        if (isBlockchainReady) {
-            this.emitter.emit(BlockchainService.Events.BLOCKCHAIN_READY);
-        }
-    }
-}
-/**
- * Singleton instance of the blockchain service
- * @type {BlockchainService}
- * @example
- * import { blockchainService } from '@docknetwork/wallet-sdk-wasm/services/blockchain';
- *
- * // Initialize the service
- * await blockchainService.init({
- *   cheqdApiUrl: 'https://api.cheqd.network'
- * });
- *
- * // Resolve a DID
- * const didDoc = await blockchainService.resolveDID('did:key:z6Mk...');
- */
-const blockchainService = new BlockchainService();
-
-export { BlockchainService, blockchainService, universalResolverUrl };

package/lib/services/credential/bbs-revocation.js

@@ -1,92 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var cryptoWasmTs = require('@docknetwork/crypto-wasm-ts');
-var utils = require('@docknetwork/credential-sdk/utils');
-var services_blockchain_service = require('../blockchain/service.js');
-require('@cosmjs/proto-signing');
-require('@docknetwork/cheqd-blockchain-api');
-require('@docknetwork/cheqd-blockchain-modules');
-require('@docknetwork/credential-sdk/modules');
-require('@docknetwork/credential-sdk/resolver');
-require('@docknetwork/crypto-wasm-ts/lib/index');
-require('events');
-require('../../core/logger.js');
-require('../../modules/event-manager.js');
-require('assert');
-require('../util-crypto/service.js');
-require('@scure/bip39');
-require('@scure/bip39/wordlists/english');
-require('../util-crypto/configs.js');
-require('@docknetwork/credential-sdk/types');
-require('../blockchain/cached-did-resolver.js');
-require('../storage/index.js');
-require('../storage/service.js');
-require('../storage/service-rpc.js');
-require('../rpc-service-client.js');
-require('../../rpc-client.js');
-require('json-rpc-2.0');
-require('../../core/crypto.js');
-require('crypto');
-require('../../logger.js');
-require('../../rpc-util.js');
-
-const getWitnessDetails = async (credential, _membershipWitness) => {
-    let witness = _membershipWitness;
-    let blockNo;
-    try {
-        ({ witness, blockNo } = JSON.parse(_membershipWitness));
-    }
-    catch (err) {
-        console.error(err);
-    }
-    const { credentialStatus } = credential;
-    const registryId = credentialStatus?.id;
-    const revocationIndex = credentialStatus.revocationId;
-    const queriedAccumulator = await services_blockchain_service.blockchainService.modules.accumulator.getAccumulator(registryId, false);
-    if (!queriedAccumulator) {
-        throw new Error('Accumulator not found');
-    }
-    const accumulator = cryptoWasmTs.PositiveAccumulator.fromAccumulated(queriedAccumulator.accumulated.bytes);
-    const encodedRevId = cryptoWasmTs.Encoder.defaultEncodeFunc()(revocationIndex.toString());
-    const publicKey = await services_blockchain_service.blockchainService.modules.accumulator.getPublicKey(queriedAccumulator.keyRef[0], queriedAccumulator.keyRef[1]);
-    const params = cryptoWasmTs.dockAccumulatorParams();
-    const pk = new cryptoWasmTs.AccumulatorPublicKey(publicKey.bytes);
-    const membershipWitness = new cryptoWasmTs.VBMembershipWitness(utils.hexToU8a(witness));
-    try {
-        const credentialStatusId = credential.credentialStatus.id;
-        const accumulatorId = services_blockchain_service.blockchainService
-            .getTypesForDIDOrAccumulator(credentialStatusId)
-            .AccumulatorId.from(credentialStatusId);
-        const history = await services_blockchain_service.blockchainService.modules.accumulator.accumulatorHistory(accumulatorId);
-        const blockNoIndex = history.updates.findIndex(update => update.id.toString() === blockNo);
-        const nextBlockNo = history.updates[blockNoIndex + 1]?.id?.toString();
-        if (nextBlockNo) {
-            await services_blockchain_service.blockchainService.modules.accumulator.updateWitness(registryId, encodedRevId, membershipWitness, nextBlockNo, queriedAccumulator.lastModified);
-        }
-    }
-    catch (err) {
-        console.error(err);
-    }
-    return {
-        encodedRevId,
-        membershipWitness,
-        pk,
-        params,
-        accumulator,
-    };
-};
-const getIsRevoked = async (credential, _membershipWitness) => {
-    const { encodedRevId, membershipWitness, pk, params, accumulator } = await getWitnessDetails(credential, _membershipWitness);
-    try {
-        return !accumulator.verifyMembershipWitness(encodedRevId, membershipWitness, pk, params);
-    }
-    catch (err) {
-        console.error(err);
-        return false;
-    }
-};
-
-exports.getIsRevoked = getIsRevoked;
-exports.getWitnessDetails = getWitnessDetails;

package/lib/services/credential/bbs-revocation.mjs

@@ -1,87 +0,0 @@
-import { PositiveAccumulator, Encoder, dockAccumulatorParams, AccumulatorPublicKey, VBMembershipWitness } from '@docknetwork/crypto-wasm-ts';
-import { hexToU8a } from '@docknetwork/credential-sdk/utils';
-import { blockchainService } from '../blockchain/service.mjs';
-import '@cosmjs/proto-signing';
-import '@docknetwork/cheqd-blockchain-api';
-import '@docknetwork/cheqd-blockchain-modules';
-import '@docknetwork/credential-sdk/modules';
-import '@docknetwork/credential-sdk/resolver';
-import '@docknetwork/crypto-wasm-ts/lib/index';
-import 'events';
-import '../../core/logger.mjs';
-import '../../modules/event-manager.mjs';
-import 'assert';
-import '../util-crypto/service.mjs';
-import '@scure/bip39';
-import '@scure/bip39/wordlists/english';
-import '../util-crypto/configs.mjs';
-import '@docknetwork/credential-sdk/types';
-import '../blockchain/cached-did-resolver.mjs';
-import '../storage/index.mjs';
-import '../storage/service.mjs';
-import '../storage/service-rpc.mjs';
-import '../rpc-service-client.mjs';
-import '../../rpc-client.mjs';
-import 'json-rpc-2.0';
-import '../../core/crypto.mjs';
-import 'crypto';
-import '../../logger.mjs';
-import '../../rpc-util.mjs';
-
-const getWitnessDetails = async (credential, _membershipWitness) => {
-    let witness = _membershipWitness;
-    let blockNo;
-    try {
-        ({ witness, blockNo } = JSON.parse(_membershipWitness));
-    }
-    catch (err) {
-        console.error(err);
-    }
-    const { credentialStatus } = credential;
-    const registryId = credentialStatus?.id;
-    const revocationIndex = credentialStatus.revocationId;
-    const queriedAccumulator = await blockchainService.modules.accumulator.getAccumulator(registryId, false);
-    if (!queriedAccumulator) {
-        throw new Error('Accumulator not found');
-    }
-    const accumulator = PositiveAccumulator.fromAccumulated(queriedAccumulator.accumulated.bytes);
-    const encodedRevId = Encoder.defaultEncodeFunc()(revocationIndex.toString());
-    const publicKey = await blockchainService.modules.accumulator.getPublicKey(queriedAccumulator.keyRef[0], queriedAccumulator.keyRef[1]);
-    const params = dockAccumulatorParams();
-    const pk = new AccumulatorPublicKey(publicKey.bytes);
-    const membershipWitness = new VBMembershipWitness(hexToU8a(witness));
-    try {
-        const credentialStatusId = credential.credentialStatus.id;
-        const accumulatorId = blockchainService
-            .getTypesForDIDOrAccumulator(credentialStatusId)
-            .AccumulatorId.from(credentialStatusId);
-        const history = await blockchainService.modules.accumulator.accumulatorHistory(accumulatorId);
-        const blockNoIndex = history.updates.findIndex(update => update.id.toString() === blockNo);
-        const nextBlockNo = history.updates[blockNoIndex + 1]?.id?.toString();
-        if (nextBlockNo) {
-            await blockchainService.modules.accumulator.updateWitness(registryId, encodedRevId, membershipWitness, nextBlockNo, queriedAccumulator.lastModified);
-        }
-    }
-    catch (err) {
-        console.error(err);
-    }
-    return {
-        encodedRevId,
-        membershipWitness,
-        pk,
-        params,
-        accumulator,
-    };
-};
-const getIsRevoked = async (credential, _membershipWitness) => {
-    const { encodedRevId, membershipWitness, pk, params, accumulator } = await getWitnessDetails(credential, _membershipWitness);
-    try {
-        return !accumulator.verifyMembershipWitness(encodedRevId, membershipWitness, pk, params);
-    }
-    catch (err) {
-        console.error(err);
-        return false;
-    }
-};
-
-export { getIsRevoked, getWitnessDetails };

package/lib/services/credential/bound-check.js

@@ -1,77 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var legosnark = require('@docknetwork/crypto-wasm-ts/lib/legosnark');
-var base64url = require('base64url');
-var services_credential_pexHelpers = require('./pex-helpers.js');
-var services_utilCrypto_service = require('../util-crypto/service.js');
-require('@astronautlabs/jsonpath');
-require('@docknetwork/credential-sdk/utils');
-require('@scure/bip39');
-require('@scure/bip39/wordlists/english');
-require('../util-crypto/configs.js');
-require('assert');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var base64url__default = /*#__PURE__*/_interopDefaultLegacy(base64url);
-
-/**
- * Receive a presentation builder and a proof request template
- * Convert the proof request template into enforce bound calls on the presentation builder
- * @param param0
- */
-function applyEnforceBounds({ builder, proofRequest, provingKeyId, provingKey, selectedCredentials, }) {
-    const descriptorBounds = services_credential_pexHelpers.pexToBounds(proofRequest.request, selectedCredentials);
-    let skipProvingKey = false;
-    descriptorBounds.forEach((items, credentialIdx) => {
-        if (!selectedCredentials[credentialIdx]) {
-            return;
-        }
-        items.forEach((bound) => {
-            builder.enforceBounds(credentialIdx, bound.attributeName, bound.min, bound.max, provingKeyId, skipProvingKey ? undefined : provingKey);
-            skipProvingKey = true;
-        });
-    });
-    return descriptorBounds;
-}
-async function fetchBlobFromUrl(url) {
-    try {
-        const response = await fetch(url);
-        const arrayBuffer = await response.arrayBuffer();
-        return new Uint8Array(arrayBuffer);
-    }
-    catch (err) {
-        throw new Error(`Error fetching proving key: ${err.message}`);
-    }
-}
-function blobFromBase64(base64String) {
-    const cleanedBase64 = base64String.replace(/^data:application\/octet-stream;base64,/, '');
-    return new Uint8Array(base64url__default["default"].toBuffer(cleanedBase64));
-}
-async function isBase64OrDataUrl(str) {
-    return ((await services_utilCrypto_service.utilCryptoService.isBase64(str)) ||
-        str.indexOf('data:application/octet-stream') > -1);
-}
-async function fetchProvingKey(proofRequest) {
-    let blob;
-    if (await isBase64OrDataUrl(proofRequest.boundCheckSnarkKey)) {
-        console.log('Is base64');
-        blob = blobFromBase64(proofRequest.boundCheckSnarkKey);
-    }
-    else {
-        console.log('is not base64');
-        blob = await fetchBlobFromUrl(proofRequest.boundCheckSnarkKey);
-    }
-    const provingKey = new legosnark.LegoProvingKey(blob);
-    return { provingKey, provingKeyId: 'key0' };
-}
-const hasProvingKey = (proofRequest) => !!proofRequest.boundCheckSnarkKey;
-
-exports.applyEnforceBounds = applyEnforceBounds;
-exports.blobFromBase64 = blobFromBase64;
-exports.fetchBlobFromUrl = fetchBlobFromUrl;
-exports.fetchProvingKey = fetchProvingKey;
-exports.hasProvingKey = hasProvingKey;
-exports.isBase64OrDataUrl = isBase64OrDataUrl;

package/lib/services/credential/bound-check.mjs

@@ -1,64 +0,0 @@
-import { LegoProvingKey } from '@docknetwork/crypto-wasm-ts/lib/legosnark';
-import base64url from 'base64url';
-import { pexToBounds } from './pex-helpers.mjs';
-import { utilCryptoService } from '../util-crypto/service.mjs';
-import '@astronautlabs/jsonpath';
-import '@docknetwork/credential-sdk/utils';
-import '@scure/bip39';
-import '@scure/bip39/wordlists/english';
-import '../util-crypto/configs.mjs';
-import 'assert';
-
-/**
- * Receive a presentation builder and a proof request template
- * Convert the proof request template into enforce bound calls on the presentation builder
- * @param param0
- */
-function applyEnforceBounds({ builder, proofRequest, provingKeyId, provingKey, selectedCredentials, }) {
-    const descriptorBounds = pexToBounds(proofRequest.request, selectedCredentials);
-    let skipProvingKey = false;
-    descriptorBounds.forEach((items, credentialIdx) => {
-        if (!selectedCredentials[credentialIdx]) {
-            return;
-        }
-        items.forEach((bound) => {
-            builder.enforceBounds(credentialIdx, bound.attributeName, bound.min, bound.max, provingKeyId, skipProvingKey ? undefined : provingKey);
-            skipProvingKey = true;
-        });
-    });
-    return descriptorBounds;
-}
-async function fetchBlobFromUrl(url) {
-    try {
-        const response = await fetch(url);
-        const arrayBuffer = await response.arrayBuffer();
-        return new Uint8Array(arrayBuffer);
-    }
-    catch (err) {
-        throw new Error(`Error fetching proving key: ${err.message}`);
-    }
-}
-function blobFromBase64(base64String) {
-    const cleanedBase64 = base64String.replace(/^data:application\/octet-stream;base64,/, '');
-    return new Uint8Array(base64url.toBuffer(cleanedBase64));
-}
-async function isBase64OrDataUrl(str) {
-    return ((await utilCryptoService.isBase64(str)) ||
-        str.indexOf('data:application/octet-stream') > -1);
-}
-async function fetchProvingKey(proofRequest) {
-    let blob;
-    if (await isBase64OrDataUrl(proofRequest.boundCheckSnarkKey)) {
-        console.log('Is base64');
-        blob = blobFromBase64(proofRequest.boundCheckSnarkKey);
-    }
-    else {
-        console.log('is not base64');
-        blob = await fetchBlobFromUrl(proofRequest.boundCheckSnarkKey);
-    }
-    const provingKey = new LegoProvingKey(blob);
-    return { provingKey, provingKeyId: 'key0' };
-}
-const hasProvingKey = (proofRequest) => !!proofRequest.boundCheckSnarkKey;
-
-export { applyEnforceBounds, blobFromBase64, fetchBlobFromUrl, fetchProvingKey, hasProvingKey, isBase64OrDataUrl };

package/lib/services/credential/config.js

@@ -1,56 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var assert = require('assert');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
-
-// @ts-nocheck
-const serviceName = 'credentials';
-const validation = {
-    generateCredential: params => {
-        const { subject } = params;
-        if (subject) {
-            assert__default["default"](typeof subject === 'object', 'invalid subject');
-            assert__default["default"](Object.keys(subject).length > 0, 'invalid subject');
-        }
-    },
-    verifyCredential: params => {
-        const { credential } = params;
-        assert__default["default"](typeof credential === 'object' || typeof credential === 'string', 'invalid credential');
-        if (typeof credential === 'object') {
-            assert__default["default"](Object.keys(credential).length > 0, 'invalid credential');
-        }
-    },
-    createBBSPresentation: params => {
-        const { credentials } = params;
-        assert__default["default"](Array.isArray(credentials), 'invalid credentials');
-        assert__default["default"](credentials.length > 0, 'no credential found');
-    },
-    deriveVCFromPresentation: params => {
-        const { credentials } = params;
-        assert__default["default"](Array.isArray(credentials), 'invalid credentials');
-        assert__default["default"](credentials.length > 0, 'no credential found');
-    },
-    signCredential: params => {
-        const { vcJson, keyDoc } = params;
-        assert__default["default"](typeof vcJson === 'object', 'invalid vcJson');
-        assert__default["default"](typeof keyDoc === 'object', 'invalid keyDoc');
-        assert__default["default"](typeof keyDoc.publicKeyBase58 === 'string', 'publicKeyBase58 is not present');
-    },
-    createPresentation: params => {
-        const { credentials, keyDoc, challenge, id } = params;
-        assert__default["default"](typeof id === 'string', 'invalid id');
-        assert__default["default"](typeof keyDoc === 'object', 'invalid KeyDoc');
-        assert__default["default"](typeof challenge === 'string', 'invalid challenge');
-        assert__default["default"](Array.isArray(credentials), 'invalid credentials');
-        assert__default["default"](credentials.length > 0, 'no credential found');
-        assert__default["default"](typeof keyDoc.publicKeyBase58 === 'string', 'publicKeyBase58 is not present');
-    },
-};
-
-exports.serviceName = serviceName;
-exports.validation = validation;