@cheqd/did-provider-cheqd 4.4.1 → 4.5.0-develop.1

package/build/cjs/did-manager/cheqd-did-provider.js

@@ -1,750 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CheqdDIDProvider = exports.CheqdSignInfoProvider = exports.EnglishMnemonic = exports.CheqdProviderErrorCodes = exports.CheqdProviderError = exports.DefaultStatusList2021Encodings = exports.DefaultStatusList2021ResourceTypes = exports.DefaultStatusList2021StatusPurposeTypes = exports.DefaultDkgSupportedChains = exports.DefaultRESTUrls = exports.DefaultRPCUrls = void 0;
-exports.createMsgCreateDidDocPayloadToSign = createMsgCreateDidDocPayloadToSign;
-exports.createMsgDeactivateDidDocPayloadToSign = createMsgDeactivateDidDocPayloadToSign;
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars, @typescript-eslint/no-non-null-assertion */
-// any is used for extensibility
-// unused vars are kept by convention
-// non-null assertion is used when we know better than the compiler that the value is not null or undefined
-const sdk_1 = require("@cheqd/sdk");
-const index_js_1 = require("@cheqd/ts-proto/cheqd/resource/v2/index.js");
-const proto_signing_1 = require("@cosmjs/proto-signing");
-const stargate_1 = require("@cosmjs/stargate");
-const utils_1 = require("@cosmjs/utils");
-const did_manager_1 = require("@veramo/did-manager");
-const utils_2 = require("@veramo/utils");
-const debug_1 = __importDefault(require("debug"));
-const crypto_1 = require("@cosmjs/crypto");
-const uint8arrays_1 = require("uint8arrays");
-const index_js_2 = require("@cheqd/ts-proto/cheqd/did/v2/index.js");
-const uuid_1 = require("uuid");
-const v6_js_1 = require("../dkg-threshold/lit-protocol/v6.js");
-const helpers_js_1 = require("../utils/helpers.js");
-const amino_1 = require("@cosmjs/amino");
-const ethers_1 = require("ethers");
-const debug = (0, debug_1.default)('veramo:did-provider-cheqd');
-exports.DefaultRPCUrls = {
-    [sdk_1.CheqdNetwork.Mainnet]: 'https://rpc.cheqd.net',
-    [sdk_1.CheqdNetwork.Testnet]: 'https://rpc.cheqd.network',
-};
-exports.DefaultRESTUrls = {
-    [sdk_1.CheqdNetwork.Mainnet]: 'https://api.cheqd.net',
-    [sdk_1.CheqdNetwork.Testnet]: 'https://api.cheqd.network',
-};
-exports.DefaultDkgSupportedChains = {
-    [sdk_1.CheqdNetwork.Mainnet]: v6_js_1.LitCompatibleCosmosChains.cheqdMainnet,
-    [sdk_1.CheqdNetwork.Testnet]: v6_js_1.LitCompatibleCosmosChains.cheqdTestnet,
-};
-exports.DefaultStatusList2021StatusPurposeTypes = {
-    revocation: 'revocation',
-    suspension: 'suspension',
-};
-exports.DefaultStatusList2021ResourceTypes = {
-    default: 'StatusList2021',
-    revocation: 'StatusList2021Revocation',
-    suspension: 'StatusList2021Suspension',
-};
-exports.DefaultStatusList2021Encodings = {
-    base64url: 'base64url',
-    hex: 'hex',
-};
-class CheqdProviderError extends Error {
-    errorCode;
-    constructor(message, errorCode) {
-        super(message);
-        this.errorCode = errorCode;
-        this.errorCode = errorCode;
-    }
-}
-exports.CheqdProviderError = CheqdProviderError;
-exports.CheqdProviderErrorCodes = {
-    DeactivatedController: 'DeactivatedController',
-    UnresolvedDID: 'UnresolvedDID',
-    EmptyVerificationMethod: 'EmptyVerificationMethod',
-};
-class EnglishMnemonic extends crypto_1.EnglishMnemonic {
-    static _mnemonicMatcher = /^[a-z]+( [a-z]+)*$/;
-}
-exports.EnglishMnemonic = EnglishMnemonic;
-class CheqdSignInfoProvider {
-    context;
-    signInfos;
-    publicKeyHexs;
-    controllers;
-    controllerKeys;
-    controllerKeyRefs;
-    constructor(context) {
-        this.signInfos = [];
-        this.publicKeyHexs = [];
-        this.controllerKeys = [];
-        this.controllerKeyRefs = [];
-        this.controllers = [];
-        this.context = context;
-    }
-    setPublicKeyHexs(publicKeyHexs) {
-        this.publicKeyHexs = publicKeyHexs;
-    }
-    setSignInfos(signInfos) {
-        this.signInfos = signInfos;
-    }
-    setControllers(controllers) {
-        this.controllers = controllers;
-    }
-    getSignInfos() {
-        return this.signInfos;
-    }
-    getPublicKeyHexs() {
-        return this.publicKeyHexs;
-    }
-    getControllerKeys() {
-        return this.controllerKeys;
-    }
-    getControllerKeyRefs() {
-        return this.controllerKeyRefs;
-    }
-    getControllerKeysForSigning() {
-        const keys = [];
-        this.controllers.forEach((controller) => {
-            const key = this.controllerKeys.find((key) => key.controller === controller);
-            if (key) {
-                keys.push(key);
-            }
-        });
-        return keys;
-    }
-    async compilePublicKeyHexs(controllers, options) {
-        const publicKeyHexs = options.publicKeyHexs || [];
-        if (publicKeyHexs.length === 0) {
-            for (const controller of controllers) {
-                const key = await this.context.agent
-                    .didManagerGet({ did: controller })
-                    .then((result) => result.keys[0]);
-                publicKeyHexs.push(key.kid);
-            }
-        }
-        this.setPublicKeyHexs(publicKeyHexs);
-    }
-    async compileSignInfos(payload, controllers) {
-        // 1. Iterate over the contollers and for each - get DIDDocument and get the verificationMethodId associated with one of publicKeyHexs
-        // 1.1 Iterate over the list of verificationMethods and make the checks:
-        // 1.1.1 Iterate over publicKeyHexs and convert each publicKeyHex to the verification Material
-        // 1.1.2 If it compares with the one in the verificationMethod, then we have a match and can store the pair of verificationMethodId and publicKeyHex
-        // 2. Iterate over the pair of verificationMethodIds and publicKeys and create SignInfo§
-        // Setup
-        const signInfos = [];
-        const publicKeyHexs = this.getPublicKeyHexs();
-        // Get verificationMethodIds
-        const verificationMethodIds = [];
-        // Iterate over list of controllers and tries to get the corresponding verificationMethodId associated with one of publicKeyHexs
-        for (const controller of controllers) {
-            // We need to get here current version of DIDDocument associated with the controller and cannot skip it even if document.id === controller
-            // cause in case of remooving verifcation method we need to sign the payload with the old verification method which is on ledger.
-            const controllerResolutionResult = await this.context.agent.resolveDid({ didUrl: controller });
-            const controllerDidDocument = controllerResolutionResult.didDocument;
-            // Check if controller DID document is resolved
-            if (!controllerDidDocument) {
-                throw new CheqdProviderError('[did-provider-cheqd]: compileSignInfos: Error while resolving the DID document for controller DID: ' +
-                    controller, exports.CheqdProviderErrorCodes.UnresolvedDID);
-            }
-            // Check that controller's DIDDocument is active
-            if (controllerResolutionResult.didDocumentMetadata.deactivated) {
-                throw new CheqdProviderError(`[did-provider-cheqd]: compileSignInfos: DIDDocument associated with controller ${controller} is deactivated`, exports.CheqdProviderErrorCodes.DeactivatedController);
-            }
-            // Check if controller DID document contains verification methods
-            if (!controllerDidDocument.verificationMethod) {
-                throw new CheqdProviderError('[did-provider-cheqd]: compileSignInfos: Controller DID document does not contain verification methods', exports.CheqdProviderErrorCodes.EmptyVerificationMethod);
-            }
-            // Iterate over verificationMethods and by comparing publicKeys get the verificationMethod Id
-            for (const vm of controllerDidDocument.verificationMethod) {
-                // Try to match verificationMethod with one of publicKeyHexs
-                for (const publicKeyHex of publicKeyHexs) {
-                    // Get publicKeyHex from verificationMethod
-                    const vmPublicKey = (0, utils_2.extractPublicKeyHex)(vm).publicKeyHex;
-                    // Compare publicKeys
-                    if (publicKeyHex === vmPublicKey) {
-                        // Create SignInfo object
-                        signInfos.push({
-                            verificationMethodId: vm.id,
-                            signature: (0, utils_2.base64ToBytes)(await this.context.agent.keyManagerSign({
-                                keyRef: publicKeyHex,
-                                data: (0, uint8arrays_1.toString)(payload, 'hex'),
-                                encoding: 'hex',
-                            })),
-                        });
-                        // Setup controllerKeyRefs
-                        this.controllerKeyRefs.push(publicKeyHex);
-                    }
-                }
-                // Setup key structure for display
-                const kid = (0, utils_2.extractPublicKeyHex)(vm).publicKeyHex;
-                const key = await this.context.agent.keyManagerGet({ kid });
-                this.controllerKeys.push({ ...key, controller: vm.controller });
-            }
-        }
-        // Setup signInfos
-        this.setSignInfos(signInfos);
-    }
-    async updateIdentifierCompileSignInfos(didDocument, options) {
-        // Steps to solve the issue:
-        // 1. Collect list of controllers. The user can remove, append and reqrite the controller.
-        //   But we need to send all the signatures, old and news
-        // 2. Generate payloads
-        // 3. Compile list of signInfos
-        // Get current version of DIDDocument
-        const actualDIDDocument = await this.context.agent.resolveDid({ didUrl: didDocument.id });
-        if (!actualDIDDocument.didDocument) {
-            throw new Error('[did-provider-cheqd]: updateIdentifierSignInfos: Error while resolving the DID document for updating with error: ' +
-                actualDIDDocument.didResolutionMetadata.error);
-        }
-        // Compile controllers
-        const updatedControllers = (0, helpers_js_1.getControllers)(didDocument);
-        const actualControllers = (0, helpers_js_1.getControllers)(actualDIDDocument.didDocument);
-        const controllers = [...new Set([...updatedControllers, ...actualControllers])];
-        // Generate payload
-        const versionId = options.versionId || (0, uuid_1.v4)();
-        const payload = await createMsgCreateDidDocPayloadToSign(didDocument, versionId);
-        // Setup publicKeyHexs
-        await this.compilePublicKeyHexs(controllers, options);
-        // Setup controllers. Here it's supposed to be a list of controllers which are associated with the DIDDocument
-        this.setControllers(updatedControllers);
-        // Setup SignInfos
-        await this.compileSignInfos(payload, controllers);
-    }
-    async deactivateIdentifierCompileSignInfos(didDocument, options) {
-        // Steps to solve the issue:
-        // 1. Collect list of controllers. The user can remove, append and reqrite the controller.
-        //   But we need to send all the signatures, old and news
-        // Generate payload to sign
-        // 3. Compile list of signInfos
-        // Get Controllers
-        const controllers = (0, helpers_js_1.getControllers)(didDocument);
-        // For did deactivation ledger requires the signature from original DID Document controller
-        // So we need to add the controller to the list of controllers
-        if (!controllers.includes(didDocument.id)) {
-            controllers.push(didDocument.id);
-        }
-        // Generate payload
-        const versionId = options.versionId || (0, uuid_1.v4)();
-        const payload = await createMsgDeactivateDidDocPayloadToSign(didDocument, versionId);
-        // Setup publicKeyHexs
-        await this.compilePublicKeyHexs(controllers, options);
-        // Setup SignInfos
-        await this.compileSignInfos(payload, controllers);
-    }
-    async resourceCreateCompileSignInfos(did, resourcePayload, options) {
-        // Steps to solve the issue:
-        // 1. Collect list of controllers. The user can remove, append and reqrite the controller.
-        //   But we need to send all the signatures, old and news
-        // Generate payload to sign
-        // 3. Compile list of signInfos
-        const didDocument = await this.context.agent.resolveDid({ didUrl: did }).then((result) => result.didDocument);
-        if (!didDocument) {
-            throw new Error('[did-provider-cheqd]: resourceCreateCompileSignInfos: Erro while resolving the DID document for controller DID: ' +
-                did);
-        }
-        // Get Controllers
-        const controllers = (0, helpers_js_1.getControllers)(didDocument);
-        // For resource creation ledger requires the signature from original DID Document controller
-        // So we need to add the controller to the list of controllers
-        if (!controllers.includes(did)) {
-            controllers.push(did);
-        }
-        // Generate payload
-        const payload = await index_js_1.MsgCreateResourcePayload.encode(index_js_1.MsgCreateResourcePayload.fromPartial(resourcePayload)).finish();
-        // Setup publicKeyHexs
-        await this.compilePublicKeyHexs(controllers, options);
-        // Setup SignInfos
-        await this.compileSignInfos(payload, controllers);
-    }
-    async keysAreInKMS(publicKeys) {
-        for (const keyRef of publicKeys) {
-            try {
-                await this.context.agent.keyManagerGet({ kid: keyRef });
-            }
-            catch (e) {
-                return {
-                    placed: false,
-                    error: `PublicKey: ${keyRef} is not placed in kms`,
-                };
-            }
-        }
-        return {
-            placed: true,
-        };
-    }
-}
-exports.CheqdSignInfoProvider = CheqdSignInfoProvider;
-/**
- * {@link @veramo/did-manager#DIDManager} identifier provider for `did:cheqd` identifiers.
- * @public
- */
-class CheqdDIDProvider extends did_manager_1.AbstractIdentifierProvider {
-    defaultKms;
-    network;
-    rpcUrl;
-    cosmosPayerWallet;
-    _aminoSigner;
-    ethereumAuthWallet;
-    dkgOptions;
-    sdk;
-    fee;
-    static defaultGasPrice = stargate_1.GasPrice.fromString('50ncheq');
-    constructor(options) {
-        super();
-        this.defaultKms = options.defaultKms;
-        this.network = options.networkType ? options.networkType : sdk_1.CheqdNetwork.Testnet;
-        this.rpcUrl = options.rpcUrl ? options.rpcUrl : exports.DefaultRPCUrls[this.network];
-        this.dkgOptions = options.dkgOptions
-            ? {
-                chain: options.dkgOptions.chain
-                    ? options.dkgOptions.chain
-                    : exports.DefaultDkgSupportedChains[this.network],
-                network: options.dkgOptions.network ? options.dkgOptions.network : v6_js_1.LitNetworks.datildev,
-            }
-            : { chain: exports.DefaultDkgSupportedChains[this.network], network: v6_js_1.LitNetworks.datildev };
-        if (!options?.cosmosPayerSeed || options.cosmosPayerSeed === '') {
-            // generate mnemonic, if not provided
-            const mnemonic = crypto_1.Bip39.encode(crypto_1.Random.getBytes(32)).toString();
-            // setup wallets - case: cosmos direct payer wallet
-            this.cosmosPayerWallet = proto_signing_1.DirectSecp256k1HdWallet.fromMnemonic(mnemonic);
-            // setup wallets - case: ethereum signer wallet
-            this.ethereumAuthWallet = ethers_1.ethers.Wallet.fromPhrase(mnemonic);
-            // setup wallets - case: amino signer wallet
-            this._aminoSigner = amino_1.Secp256k1HdWallet.fromMnemonic(mnemonic);
-            return;
-        }
-        const isMnemonic = EnglishMnemonic._mnemonicMatcher.test(options.cosmosPayerSeed);
-        this.cosmosPayerWallet = isMnemonic
-            ? proto_signing_1.DirectSecp256k1HdWallet.fromMnemonic(options.cosmosPayerSeed, { prefix: 'cheqd' })
-            : proto_signing_1.DirectSecp256k1Wallet.fromKey((0, uint8arrays_1.fromString)(options.cosmosPayerSeed.replace(/^0x/, ''), 'hex'), 'cheqd');
-        this.ethereumAuthWallet = isMnemonic
-            ? ethers_1.ethers.Wallet.fromPhrase(options.cosmosPayerSeed)
-            : new ethers_1.ethers.Wallet(options.cosmosPayerSeed);
-        this._aminoSigner = isMnemonic
-            ? amino_1.Secp256k1HdWallet.fromMnemonic(options.cosmosPayerSeed, { prefix: 'cheqd' })
-            : amino_1.Secp256k1Wallet.fromKey((0, uint8arrays_1.fromString)(options.cosmosPayerSeed.replace(/^0x/, ''), 'hex'), 'cheqd');
-    }
-    async getWalletAccounts() {
-        return await (await this.cosmosPayerWallet).getAccounts();
-    }
-    async getEthereumWalletAccounts() {
-        return [
-            {
-                address: this.ethereumAuthWallet.address,
-                pubkey: (0, uint8arrays_1.fromString)(this.ethereumAuthWallet.signingKey.publicKey, 'hex'),
-                algo: 'secp256k1',
-            },
-        ];
-    }
-    async getCheqdSDK(fee, gasPrice) {
-        if (!this.sdk) {
-            const wallet = await this.cosmosPayerWallet.catch(() => {
-                throw new Error(`[did-provider-cheqd]: network: ${this.network} valid cosmosPayerSeed is required`);
-            });
-            const sdkOptions = {
-                modules: [
-                    sdk_1.DIDModule,
-                    sdk_1.ResourceModule,
-                ],
-                rpcUrl: this.rpcUrl,
-                wallet: wallet,
-                gasPrice,
-            };
-            this.sdk = await (0, sdk_1.createCheqdSDK)(sdkOptions);
-            this.fee = fee;
-            if (this?.fee && !this?.fee?.payer) {
-                const feePayer = (await (await this.cosmosPayerWallet).getAccounts())[0].address;
-                this.fee.payer = feePayer;
-            }
-        }
-        return this.sdk;
-    }
-    async createIdentifier({ kms, options, }, context) {
-        const sdk = await this.getCheqdSDK(options?.fee);
-        const versionId = options.versionId || (0, uuid_1.v4)();
-        const signInputs = options.keys
-            ? (function () {
-                return options.keys.map((key) => (0, sdk_1.createSignInputsFromImportableEd25519Key)(key, options.document.verificationMethod || []));
-            })()
-            : await (async function (that) {
-                const data = await createMsgCreateDidDocPayloadToSign(options.document, versionId);
-                return await that.signPayload(context, data, options.document.verificationMethod);
-            })(this);
-        const tx = await sdk.createDidDocTx(signInputs, options.document, '', this?.fee, undefined, versionId, {
-            sdk: sdk,
-        });
-        (0, utils_1.assert)(tx.code === 0, `cosmos_transaction: Failed to create DID. Reason: ${tx.rawLog}`);
-        const identifier = {
-            did: options.document.id,
-            keys: [],
-            services: options.document.service || [],
-            provider: options.document.id.split(':').splice(0, 3).join(':'),
-        };
-        //* Currently, only one controller key is supported.
-        //* We assume that the first key in the list is the controller key.
-        //* This is subject to change in the near future.
-        identifier.keys = options.keys
-            ? await (async function (that) {
-                const scopedKeys = [];
-                for (const key of options.keys) {
-                    let managedKey;
-                    try {
-                        managedKey = await context.agent.keyManagerImport({
-                            ...key,
-                            kms: kms || that.defaultKms,
-                        });
-                    }
-                    catch (e) {
-                        debug(`Failed to import key ${key.kid}. Reason: ${e}`);
-                        // construct key, if it failed to import
-                        managedKey = { ...key, kms: kms || that.defaultKms };
-                    }
-                    if (managedKey) {
-                        scopedKeys.push(managedKey);
-                    }
-                }
-                return scopedKeys;
-            })(this)
-            : await (async function (that) {
-                const vmKeys = await that.getKeysFromVerificationMethod(context, options.document.verificationMethod);
-                // Setup controllerKeyRefs
-                identifier.controllerKeyRefs = vmKeys.map((key) => key.kid);
-                // Setup controllerKeys. It's a list of keys to display
-                identifier.controllerKeys = vmKeys.map((key) => ({ ...key, controller: options.document.id }));
-                // Here we are returning all keys associated with the DIDDocument (including keys for controllers)
-                // We already compiled it while discovering the verificationMethodIds
-                return vmKeys;
-            })(this);
-        await this.getKeysFromVerificationMethod(context, options.document.verificationMethod);
-        const controllerKey = identifier.keys[0];
-        identifier.controllerKeyId = controllerKey.kid;
-        debug('Created DID', identifier.did);
-        return identifier;
-    }
-    async updateIdentifier({ did, document, options, }, context) {
-        // Handle input parameters
-        const sdk = await this.getCheqdSDK(options?.fee);
-        const versionId = options.versionId || (0, uuid_1.v4)();
-        const keys = options.keys || [];
-        const signInfoProvider = new CheqdSignInfoProvider(context);
-        // It answers on question what the keys are actually in input
-        const areKeysImportable = keys.length > 0 &&
-            keys.every((key) => {
-                return Object.keys(key).includes('privateKeyHex');
-            });
-        // options.keys may be list of keys with privateKey ibside or just list of publicKeys
-        const publicKeyHexs = areKeysImportable ? [] : keys.map((key) => key.publicKeyHex);
-        // Check that publicKeyHexs are placed in kms if the user provides the keys
-        const _r = await signInfoProvider.keysAreInKMS(publicKeyHexs);
-        if (_r.error) {
-            throw Error(`[updateIdentifier]: ${_r.error}`);
-        }
-        // Check that verificationMethod on changed DIDDocument list exists and not empty
-        if (!document.verificationMethod || document.verificationMethod.length === 0) {
-            throw new CheqdProviderError('[updateIdentifier]: VerificationMethod should be placed and not be empty', exports.CheqdProviderErrorCodes.EmptyVerificationMethod);
-        }
-        const signInputs = areKeysImportable
-            ? (function () {
-                // We are sure here that keys are placed
-                return options.keys.map((key) => (0, sdk_1.createSignInputsFromImportableEd25519Key)(key, document.verificationMethod || []));
-            })()
-            : await (async function () {
-                await signInfoProvider.updateIdentifierCompileSignInfos(document, {
-                    publicKeyHexs,
-                    versionId,
-                });
-                return signInfoProvider.getSignInfos();
-            })();
-        debug(`[updateIdentifier]: DID: ${did}, VerificationMethodIds for signing: ${signInputs.map((signInput) => signInput.verificationMethodId)}`);
-        const tx = await sdk.updateDidDocTx(signInputs, document, '', this?.fee, undefined, versionId, { sdk: sdk });
-        (0, utils_1.assert)(tx.code === 0, `cosmos_transaction: Failed to update DID. Reason: ${tx.rawLog}`);
-        // Setup return value
-        const identifier = {
-            did: document.id,
-            keys: [],
-            services: document.service || [],
-            provider: document.id.split(':').splice(0, 3).join(':'),
-        };
-        // Get keys for updated DIDDocument
-        // Here we are importing only the keys which has privateKey field set up
-        identifier.keys =
-            options.keys && areKeysImportable
-                ? await (async function (that) {
-                    const scopedKeys = [];
-                    for (const key of options.keys) {
-                        let managedKey;
-                        try {
-                            managedKey = await context.agent.keyManagerImport({
-                                ...key,
-                                kms: options.kms || that.defaultKms,
-                            });
-                        }
-                        catch (e) {
-                            debug(`Failed to import key ${key.kid}. Reason: ${e}`);
-                            // construct key, if it failed to import
-                            managedKey = { ...key, kms: options.kms || that.defaultKms };
-                        }
-                        if (managedKey) {
-                            scopedKeys.push(managedKey);
-                        }
-                    }
-                    // Setup controllerKeyId
-                    identifier.controllerKeyId = scopedKeys[0].kid;
-                    return scopedKeys;
-                })(this)
-                : await (async function (that) {
-                    const vmKeys = await that.getKeysFromVerificationMethod(context, document.verificationMethod);
-                    // Setup controllerKeyId. It should be asocciated with verificationMethod list
-                    identifier.controllerKeyId = vmKeys[0].kid;
-                    // Setup controllerKeyRefs. It's a list of keys which were used for signing the transaction
-                    identifier.controllerKeyRefs = signInfoProvider.getControllerKeyRefs();
-                    // Setup controllerKeys. It's a list of keys to display
-                    identifier.controllerKeys = signInfoProvider.getControllerKeysForSigning();
-                    // Here we are returning all keys associated with the DIDDocument (including keys for controllers)
-                    // We already compiled it while discovering the verificationMethodIds
-                    return vmKeys;
-                })(this);
-        debug('Updated DID', did);
-        return identifier;
-    }
-    async deactivateIdentifier({ did, document, options, }, context) {
-        const sdk = await this.getCheqdSDK(options?.fee);
-        const versionId = options.versionId || (0, uuid_1.v4)();
-        const keys = options.keys || [];
-        // Providr for compiling SignInfos
-        const signInfoProvider = new CheqdSignInfoProvider(context);
-        // It answers on question what the keys are actually in input
-        const areKeysImportable = keys.length > 0 &&
-            keys.every((key) => {
-                return Object.keys(key).includes('privateKeyHex');
-            });
-        const publicKeyHexs = areKeysImportable ? [] : keys.map((key) => key.publicKeyHex);
-        // Check that publicKeyHexs are placed in kms
-        const _r = await signInfoProvider.keysAreInKMS(publicKeyHexs);
-        if (_r.error) {
-            throw Error(`[deactivateIdentifier]: ${_r.error}`);
-        }
-        const signInputs = areKeysImportable
-            ? (function () {
-                // We are sure here that keys are placed
-                return options.keys.map((key) => (0, sdk_1.createSignInputsFromImportableEd25519Key)(key, document.verificationMethod || []));
-            })()
-            : await (async function () {
-                await signInfoProvider.deactivateIdentifierCompileSignInfos(document, {
-                    publicKeyHexs,
-                    versionId,
-                });
-                return signInfoProvider.getSignInfos();
-            })();
-        debug(`[deactivateIdentifier]: DID: ${did}, VerificationMethodIds for signing: ${signInputs.map((signInput) => signInput.verificationMethodId)}`);
-        const tx = await sdk.deactivateDidDocTx(signInputs, document, '', this?.fee, undefined, versionId, { sdk: sdk });
-        (0, utils_1.assert)(tx.code === 0, `cosmos_transaction: Failed to update DID. Reason: ${tx.rawLog}`);
-        debug('Deactivated DID', did);
-        return true;
-    }
-    async createResource({ options, }, context) {
-        const sdk = await this.getCheqdSDK(options?.fee);
-        const signInfoProvider = new CheqdSignInfoProvider(context);
-        const inputKeys = options.signInputs || [];
-        const areSignInputs = inputKeys.length > 0 &&
-            inputKeys.every((key) => {
-                return Object.keys(key).includes('privateKeyHex');
-            });
-        // options.signInputs may be list of keys with privateKey ibside or just list of publicKeys
-        const publicKeyHexs = areSignInputs ? [] : inputKeys.map((key) => key.publicKeyHex);
-        // Check that publicKeyHexs are placed in kms
-        const _r = await signInfoProvider.keysAreInKMS(publicKeyHexs);
-        if (_r.error) {
-            throw Error(`[updateIdentifier]: ${_r.error}`);
-        }
-        const signInputs = areSignInputs
-            ? options.signInputs
-            : await (async function (that) {
-                const did = `did:cheqd:${that.network}:${options.payload.collectionId}`;
-                await signInfoProvider.resourceCreateCompileSignInfos(did, options.payload, {
-                    publicKeyHexs,
-                });
-                return signInfoProvider.getSignInfos();
-            })(this);
-        debug(`[createResource]: DID: did:cheqd:${this.network}:${options.payload.collectionId} , VerificationMethodIds for signing: ${signInputs.map((signInput) => signInput.verificationMethodId)}`);
-        const tx = await sdk.createLinkedResourceTx(signInputs, options.payload, '', this?.fee, undefined, {
-            sdk: sdk,
-        });
-        (0, utils_1.assert)(tx.code === 0, `cosmos_transaction: Failed to create Resource. Reason: ${tx.rawLog}`);
-        const mapKeyType = (keyType) => {
-            switch (keyType) {
-                case 'Ed25519':
-                    return 'Ed25519';
-                case 'Secp256k1':
-                    return 'Secp256k1';
-                default:
-                    return undefined;
-            }
-        };
-        if (areSignInputs) {
-            const signInput = inputKeys.filter((input) => mapKeyType(input.keyType) !== undefined);
-            const keys = [];
-            for (const input of signInput) {
-                let managedKey;
-                try {
-                    // get public key from private key in hex
-                    const publicKey = (0, uint8arrays_1.toString)((await crypto_1.Ed25519.makeKeypair((0, uint8arrays_1.fromString)(input.privateKeyHex, 'hex'))).pubkey, 'hex');
-                    managedKey = await context.agent.keyManagerImport({
-                        kid: publicKey,
-                        publicKeyHex: publicKey,
-                        privateKeyHex: input.privateKeyHex,
-                        type: mapKeyType(input.keyType),
-                        kms: options.kms || this.defaultKms,
-                    });
-                }
-                catch (e) {
-                    debug(`Failed to import key ${input.verificationMethodId}. Reason: ${e}`);
-                }
-                if (managedKey) {
-                    keys.push(managedKey);
-                }
-            }
-        }
-        debug('Created Resource', options.payload);
-        return true;
-    }
-    async deleteIdentifier(identity, context) {
-        for (const { kid } of identity.keys) {
-            await context.agent.keyManagerDelete({ kid });
-        }
-        return true;
-    }
-    async addKey({ identifier, key, options }, context) {
-        throw Error('CheqdDIDProvider addKey is not supported.');
-    }
-    async addService({ identifier, service, options }, context) {
-        throw Error('CheqdDIDProvider addService is not supported.');
-    }
-    async removeKey(args, context) {
-        throw Error('CheqdDIDProvider removeKey is not supported.');
-    }
-    async removeService(args, context) {
-        throw Error('CheqdDIDProvider removeService is not supported.');
-    }
-    async transactSendTokens(args) {
-        const sdk = await this.getCheqdSDK(undefined, CheqdDIDProvider.defaultGasPrice);
-        if (args?.txBytes) {
-            // broadcast txBytes
-            const tx = await sdk.signer.broadcastTx(args.txBytes, args?.timeoutMs, args?.pollIntervalMs);
-            // assert tx code is 0, in other words, tx succeeded
-            (0, utils_1.assert)(tx.code === 0, `cosmos_transaction: Failed to send tokens. Reason: ${tx.rawLog}`);
-            // keep log
-            debug('Sent tokens', 'txBytes', (0, uint8arrays_1.toString)(args.txBytes, 'hex'));
-            return tx;
-        }
-        // poll gas price
-        const gasPrice = await sdk.queryGasPrice(args.amount.denom);
-        // define fee
-        const fee = {
-            amount: [
-                {
-                    amount: (Number(gasPrice.price?.amount ?? '0') * 10 ** 9).toString(),
-                    denom: args.amount.denom,
-                },
-            ],
-            gas: '360000',
-        };
-        const tx = await sdk.signer.sendTokens((await (await this.cosmosPayerWallet).getAccounts())[0].address, args.recipientAddress, [args.amount], fee, args.memo);
-        (0, utils_1.assert)(tx.code === 0, `cosmos_transaction: Failed to send tokens. Reason: ${tx.rawLog}`);
-        debug('Sent tokens', args.amount.amount, args.amount.denom, 'to', args.recipientAddress);
-        return tx;
-    }
-    async mintCapacityCredit(args) {
-        // instantiate dkg-threshold contract client, in which case lit-protocol is used
-        const litContracts = await this.instantiateDkgThresholdContractClient();
-        // mint capacity credits
-        const result = await litContracts.mintCapacityCredits(args);
-        // keep log
-        debug('Minted capacity credits', result.capacityTokenIdStr, 'for', args.effectiveDays, 'days', 'with transaction hash', result.rliTxHash, 'from address', this.ethereumAuthWallet.address);
-        return result;
-    }
-    async delegateCapacityCredit(args) {
-        // instantiate dkg-threshold client, in which case lit-protocol is used
-        const litProtocol = await this.instantiateDkgThresholdProtocolClient();
-        // delegate capacity credits
-        const result = await litProtocol.delegateCapacitCredit({
-            dAppOwnerWallet: this.ethereumAuthWallet instanceof ethers_1.ethers.Wallet
-                ? this.ethereumAuthWallet
-                : new ethers_1.ethers.Wallet(this.ethereumAuthWallet.privateKey),
-            capacityTokenId: args.capacityTokenId,
-            delegateeAddresses: args.delegateeAddresses,
-            uses: args.uses.toString(),
-            expiration: args.expiration,
-            statement: args.statement,
-        });
-        // keep log
-        debug('Delegated capacity credits', args.capacityTokenId, 'to', args.delegateeAddresses.join(', '), 'with auth signature', result.capacityDelegationAuthSig.sig, 'from address', this.ethereumAuthWallet.address);
-        return result;
-    }
-    async instantiateDkgThresholdProtocolClient(dkgOptions = this.dkgOptions) {
-        return await v6_js_1.LitProtocol.create({
-            chain: dkgOptions.chain || this.dkgOptions.chain,
-            litNetwork: dkgOptions.network || this.dkgOptions.network,
-            cosmosAuthWallet: await this._aminoSigner,
-        });
-    }
-    async instantiateDkgThresholdContractClient(dkgNetwork = this.dkgOptions.network) {
-        return await v6_js_1.LitContracts.create({
-            ethereumAuthWallet: this.ethereumAuthWallet instanceof ethers_1.ethers.Wallet
-                ? this.ethereumAuthWallet
-                : new ethers_1.ethers.Wallet(this.ethereumAuthWallet.privateKey),
-            litNetwork: dkgNetwork,
-        });
-    }
-    async signPayload(context, data, verificationMethod = []) {
-        return Promise.all(verificationMethod.map(async (method) => {
-            const keyRef = (0, utils_2.extractPublicKeyHex)(method).publicKeyHex;
-            return {
-                verificationMethodId: method.id,
-                signature: (0, utils_2.base64ToBytes)(await context.agent.keyManagerSign({
-                    keyRef,
-                    data: (0, uint8arrays_1.toString)(data, 'hex'),
-                    encoding: 'hex',
-                })),
-            };
-        }));
-    }
-    async getKeysFromVerificationMethod(context, verificationMethod = []) {
-        return Promise.all(verificationMethod.map(async (method) => {
-            const kid = (0, utils_2.extractPublicKeyHex)(method).publicKeyHex;
-            const key = await context.agent.keyManagerGet({ kid });
-            return { ...key, controller: method.controller };
-        })).catch((error) => {
-            throw new Error(`Failed to sign payload: ${error}`);
-        });
-    }
-}
-exports.CheqdDIDProvider = CheqdDIDProvider;
-async function createMsgCreateDidDocPayloadToSign(didPayload, versionId) {
-    const { protobufVerificationMethod, protobufService } = await sdk_1.DIDModule.validateSpecCompliantPayload(didPayload);
-    return index_js_2.MsgCreateDidDocPayload.encode(index_js_2.MsgCreateDidDocPayload.fromPartial({
-        context: didPayload?.['@context'],
-        id: didPayload.id,
-        controller: didPayload.controller,
-        verificationMethod: protobufVerificationMethod,
-        authentication: didPayload.authentication,
-        assertionMethod: didPayload.assertionMethod,
-        capabilityInvocation: didPayload.capabilityInvocation,
-        capabilityDelegation: didPayload.capabilityDelegation,
-        keyAgreement: didPayload.keyAgreement,
-        service: protobufService,
-        alsoKnownAs: didPayload.alsoKnownAs,
-        versionId,
-    })).finish();
-}
-async function createMsgDeactivateDidDocPayloadToSign(didPayload, versionId) {
-    return index_js_2.MsgDeactivateDidDocPayload.encode(index_js_2.MsgDeactivateDidDocPayload.fromPartial({
-        id: didPayload.id,
-        versionId,
-    })).finish();
-}
-//# sourceMappingURL=cheqd-did-provider.js.map