'use strict';

require('../abstract/index.cjs');
require('../../types/blob/index.cjs');
require('../../types/attest/index.cjs');
require('../../types/did/index.cjs');
require('../../types/generic/typed-enum.cjs');
require('../../types/generic/typed-bytes.cjs');
require('../../types/generic/typed-string.cjs');
require('../../types/generic/typed-array.cjs');
require('../../types/generic/typed-tuple.cjs');
require('../../types/generic/typed-null.cjs');
require('../../utils/types/array.cjs');
require('crypto');
require('bs58');
require('multiformats/bases/base58');
require('varint');
require('../../utils/encoding/ss-58.cjs');
require('../../types/generic/typed-number.cjs');
require('../../types/generic/typed-set.cjs');
require('../../types/generic/typed-map.cjs');
require('../../types/generic/typed-struct.cjs');
require('uuid');
require('js-sha256');
require('../../types/offchain-signatures/params/index.cjs');
require('../../types/offchain-signatures/public-keys/index.cjs');
require('../../types/offchain-signatures/curve-type.cjs');
require('../../types/payload/cheqd.cjs');
require('../../types/policy/index.cjs');
require('../../types/public-keys/public-key.cjs');
require('../../types/public-keys/public-key-sr25519-value.cjs');
require('../../types/public-keys/public-key-ed25519-value.cjs');
require('../../types/public-keys/public-key-secp256k1-value.cjs');
require('../../types/public-keys/public-key-x25519-value.cjs');
require('../../types/signatures/signature-value.cjs');
require('../../types/signatures/signature.cjs');
require('../../types/status-list-credential/index.cjs');
require('../../types/anchor/index.cjs');
require('../../types/accumulator/keys.cjs');
require('../../types/accumulator/params.cjs');
require('../../types/accumulator/public-key.cjs');
require('../../types/accumulator/accumulator.cjs');
var types_accumulator_id = require('../../types/accumulator/id.cjs');
require('../../types/trust-registry/id.cjs');
var modules_multiApi_common = require('./common.cjs');
var modules_abstract_accumulator_module = require('../abstract/accumulator/module.cjs');
var types_did_onchain_typedDid_index = require('../../types/did/onchain/typed-did/index.cjs');
require('../../utils/inheritance.cjs');
require('../../utils/types/object.cjs');
require('../../utils/types/iterable.cjs');
require('../../utils/types/set.cjs');
require('../abstract/anchor/module.cjs');
require('mrklt');
require('../abstract/common/abstract-api-provider.cjs');
require('../abstract/common/abstract-base-module.cjs');
require('../abstract/attest/module.cjs');
require('../abstract/blob/module.cjs');
require('../abstract/did/module.cjs');
require('../abstract/offchain-signatures/module.cjs');
require('../abstract/common/with-abstract-params.cjs');
require('../../types/generic/with-prop.cjs');
require('../../types/generic/with-props.cjs');
require('blake2b');
require('../../utils/types/bytes.cjs');
require('../../utils/interfaces.cjs');
require('../../utils/assert.cjs');
require('../../utils/error.cjs');
require('../../utils/types/string.cjs');
require('../../types/generic/with-base.cjs');
require('../../types/generic/with-catch-null.cjs');
require('../../types/generic/with-eq.cjs');
require('../../types/generic/any-of.cjs');
require('../../types/generic/with-from.cjs');
require('../../types/generic/with-from-json-bytes.cjs');
require('../../types/generic/create-placeholder.cjs');
require('../../types/blob/id.cjs');
require('../../types/generic/sized.cjs');
require('../../utils/types/number.cjs');
require('../../types/generic/typed-uuid.cjs');
require('../../types/generic/with-qualifier.cjs');
require('../../types/generic/with-from-dock-id.cjs');
require('../../types/did/onchain/typed-did/did-method-key/did-method-key-public-key.cjs');
require('../../utils/encoding/base-58-btc.cjs');
require('../../types/did/onchain/constants.cjs');
require('../../types/did/onchain/typed-did/signature.cjs');
require('../../types/did/onchain/typed-did/did-method-key/did-method-key-signature.cjs');
require('../../types/signatures/signature-ed25519-value.cjs');
require('../../vc/crypto/constants.cjs');
require('../../types/signatures/signature-secp256k1-value.cjs');
require('../../types/signatures/signature-sr25519-value.cjs');
require('../../types/did/onchain/typed-did/dock-did-value.cjs');
require('../../types/generic/utils.cjs');
require('../../types/generic/typed-bytes-array.cjs');
require('../../types/did/onchain/typed-did/cheqd-did.cjs');
require('../../types/blob/const.cjs');
require('../../utils/mappings/dock-did-by-id.cjs');
require('../../types/blob/blob.cjs');
require('../../types/generic/option.cjs');
require('../../types/did/offchain/index.cjs');
require('../../types/did/offchain/doc-ref.cjs');
require('../../types/did/onchain/index.cjs');
require('../../types/did/onchain/controllers.cjs');
require('../../types/did/onchain/verification-relationship.cjs');
require('../../types/did/onchain/did-key.cjs');
require('../../vc/crypto/Bls12381BBDT16KeyPairDock2024.cjs');
require('@docknetwork/crypto-wasm-ts');
require('../../vc/crypto/common/DockCryptoKeyPair.cjs');
require('../../vc/crypto/Bls12381BBDT16MACDock2024.cjs');
require('@docknetwork/crypto-wasm-ts/lib/index.js');
require('../../vc/crypto/common/DockCryptoSignature.cjs');
require('jsonld-signatures');
require('json-stringify-deterministic');
require('semver/preload.js');
require('../../vc/crypto/common/CustomLinkedDataSignature.cjs');
require('base64url');
require('jsonld');
require('../../types/did/document/verification-method-ref.cjs');
require('../../vc/jws.cjs');
require('../../vc/crypto/Bls12381BBDT16MACProofDock2024.cjs');
require('../../vc/crypto/common/DockCryptoSignatureProof.cjs');
require('../../vc/crypto/Bls12381BBSKeyPairDock2023.cjs');
require('../../vc/crypto/Bls12381BBSSignatureDock2022.cjs');
require('../../vc/crypto/Bls12381G2KeyPairDock2022.cjs');
require('../../vc/crypto/Bls12381BBSSignatureDock2023.cjs');
require('../../vc/crypto/Bls12381BBSSignatureProofDock2022.cjs');
require('../../vc/crypto/Bls12381BBSSignatureProofDock2023.cjs');
require('../../vc/crypto/Bls12381BDDT16KeyPairDock2024.cjs');
require('../../vc/crypto/Bls12381BDDT16MACDock2024.cjs');
require('../../vc/crypto/Bls12381BDDT16MACProofDock2024.cjs');
require('../../vc/crypto/Bls12381PSKeyPairDock2023.cjs');
require('../../vc/crypto/Bls12381PSSignatureDock2023.cjs');
require('../../vc/crypto/Bls12381PSSignatureProofDock2023.cjs');
require('@juanelas/base64');
require('../../keypairs/keypair-secp256k1.cjs');
require('elliptic');
require('../../keypairs/dock-keypair.cjs');
require('@stablelib/ed25519');
require('@transmute/json-web-signature');
require('../../types/offchain-signatures/public-keys/value.cjs');
require('../../types/offchain-signatures/public-keys/ref.cjs');
require('../../types/offchain-signatures/params/id.cjs');
require('../../types/offchain-signatures/params/value.cjs');
require('../../types/offchain-signatures/public-keys/id.cjs');
require('../../types/did/onchain/verification-method-signature.cjs');
require('../../keypairs/did-keypair.cjs');
require('../../types/did/document/verification-method-ref-or-ident-ref.cjs');
require('../../types/did/document/ident-ref.cjs');
require('../../types/did/document/index.cjs');
require('../../types/did/document/service-endpoint.cjs');
require('../../types/did/document/verification-method.cjs');
require('../../utils/encoding/base-58.cjs');
require('../../types/generic/with-base58.cjs');
require('../../types/generic/with-base58btc.cjs');
require('../../types/generic/with-multibase.cjs');
require('../../utils/encoding/multibase.cjs');
require('../../types/did/document/verification-method-type.cjs');
require('../../types/did/document/verification-method-ref-or-cheqd-verification-method.cjs');
require('../../types/did/document/const.cjs');
require('../../types/policy/one-of-policy-value.cjs');
require('../../types/status-list-credential/status-list-credential-value.cjs');
require('../../vc/status-list2021-credential.cjs');
require('@digitalcredentials/vc-status-list');
require('pako');
require('../../vc/verifiable-credential.cjs');
require('../../vc/helpers.cjs');
require('../../vc/document-loader.cjs');
require('../../vc/contexts.cjs');
require('../../vc/contexts/vc-examples-v1.cjs');
require('../../vc/contexts/security_context.cjs');
require('../../vc/contexts/status-list-21.cjs');
require('../../vc/contexts/private-status-list-21.cjs');
require('../../utils/json-fetch.cjs');
require('../../vc/crypto/EcdsaSecp256k1Signature2019.cjs');
require('../../vc/crypto/EcdsaSecp256k1VerificationKey2019.cjs');
require('../../vc/crypto/Ed25519Signature2018.cjs');
require('../../vc/crypto/Ed25519VerificationKey2018.cjs');
require('../../keypairs/keypair-ed25519.cjs');
require('../../vc/crypto/Ed25519Signature2020.cjs');
require('../../vc/crypto/Ed25519VerificationKey2020.cjs');
require('../../vc/crypto/JsonWebSignature2020.cjs');
require('../../vc/credentials.cjs');
require('../../vc/CredentialIssuancePurpose.cjs');
require('../../vc/schema.cjs');
require('jsonschema');
require('../../vc/constants.cjs');
require('../../vc/revocation.cjs');
require('blakejs');
require('../../utils/ident/ensure-ident.cjs');
require('../../utils/ident/matchers.cjs');
require('../../types/status-list-credential/id.cjs');
require('../../types/accumulator/variants.cjs');
require('../abstract/status-list-credential/module.cjs');
require('../abstract/trust-registry/module.cjs');
require('../abstract/schema/module.cjs');
require('json-canonicalize');
require('../../vc/schemas/schema-draft-07.cjs');
require('../abstract/common/with-abstract-public-keys.cjs');

class MultiApiAccumulatorModule extends modules_multiApi_common.injectModuleRouter(
  modules_abstract_accumulator_module.default,
) {
  /**
   * Adds a public key associated with a target DID for cryptographic operations.
   * This method allows you to store or update a public key within an accumulator module,
   * which can be used in various cryptographic accumulations and verifications.
   *
   * @param {*} id - Unique identifier for the public key entry
   * @param {*} publicKey - The public key value being added/updated
   * @param {*} targetDid - DID that will control this public key
   * @param {DidKeypair} didKeypair - Keypair used to sign the transaction
   * @param {object} [params] - Optional parameters for additional configuration
   * @returns {Promise<*>} Promise resolving to the transaction result
   */
  async addPublicKey(id, publicKey, targetDid, didKeypair, params) {
    const did = types_did_onchain_typedDid_index.NamespaceDid.from(targetDid);

    return await this.moduleById(did).addPublicKey(
      id,
      publicKey,
      did,
      didKeypair,
      params,
    );
  }

  /**
   * Creates and stores a new accumulator on the blockchain
   *
   * An accumulator is a cryptographic data structure used to maintain an aggregate value that can be updated incrementally.
   * This method creates a new accumulator instance with the given ID and initial state.
   *
   * @param {string} id - Unique identifier for the accumulator
   * @param {Accumulator} accumulator - Initial accumulator value to store
   * @param {DidKeypair} didKeypair - Keypair used to sign the transaction
   * @returns {Promise<*>} Promise resolving to the transaction result
   */
  async addAccumulator(id, accumulator, didKeypair, params) {
    const accId = types_accumulator_id.AccumulatorId.from(id);

    return await this.moduleById(accId).addAccumulator(
      id,
      accumulator,
      didKeypair,
      params,
    );
  }

  /**
   * Add a positive (add-only) accumulator
   * @param id - Unique accumulator id
   * @param accumulated - Current accumulated value.
   * @param publicKeyRef - Reference to accumulator public key. If the reference contains the key id 0, it means the accumulator does not
   * have any public key on the chain. This is useful for KVAC.
   * @param signingKeyRef - Signer's keypair reference
   * @returns {Promise<*>}
   */
  async addPositiveAccumulator(
    id,
    accumulated,
    publicKeyRef,
    didKeypair,
    params,
  ) {
    const accId = types_accumulator_id.AccumulatorId.from(id);

    return await this.moduleById(accId).addPositiveAccumulator(
      accId,
      accumulated,
      publicKeyRef,
      didKeypair,
      params,
    );
  }

  /**
   * Add universal (supports add/remove) accumulator
   * @param id - Unique accumulator id
   * @param accumulated - Current accumulated value.
   * @param publicKeyRef - Reference to accumulator public key. If the reference contains the key id 0, it means the accumulator does not
   * have any public key on the chain. This is useful for KVAC.
   * @param maxSize - Maximum size of the accumulator
   * @param signingKeyRef - Signer's keypair reference
   * @returns {Promise<*>}
   */
  async addUniversalAccumulator(
    id,
    accumulated,
    publicKeyRef,
    maxSize,
    didKeypair,
    params,
  ) {
    const accId = types_accumulator_id.AccumulatorId.from(id);

    return await this.moduleById(accId).addUniversalAccumulator(
      accId,
      accumulated,
      publicKeyRef,
      maxSize,
      didKeypair,
      params,
    );
  }

  /**
   * Add KB universal (supports add/remove) accumulator
   * @param id - Unique accumulator id
   * @param accumulated - Current accumulated value.
   * @param publicKeyRef - Reference to accumulator public key. If the reference contains the key id 0, it means the accumulator does not
   * have any public key on the chain. This is useful for KVAC.
   * @param signingKeyRef - Signer's keypair reference
   * @returns {Promise<*>}
   */
  async addKBUniversalAccumulator(
    id,
    accumulated,
    publicKeyRef,
    didKeypair,
    params,
  ) {
    const accId = types_accumulator_id.AccumulatorId.from(id);

    return await this.moduleById(accId).addKBUniversalAccumulator(
      accId,
      accumulated,
      publicKeyRef,
      didKeypair,
      params,
    );
  }

  /**
   * Update existing a positive (add-only) accumulator
   * @param id - Unique accumulator id
   * @param accumulated - Current accumulated value.
   * @param {{ additions: Array<Uint8Array>, removals: Array<Uint8Array>, witnessUpdateInfo: Uint8Array }} updates
   * @param publicKeyRef - Reference to accumulator public key. If the reference contains the key id 0, it means the accumulator does not
   * have any public key on the chain. This is useful for KVAC.
   * @param signingKeyRef - Signer's keypair reference
   * @returns {Promise<*>}
   */
  async updatePositiveAccumulator(
    id,
    accumulated,
    { additions, removals, witnessUpdateInfo },
    publicKeyRef,
    didKeypair,
    params,
  ) {
    const accId = types_accumulator_id.AccumulatorId.from(id);

    return await this.moduleById(accId).updatePositiveAccumulator(
      accId,
      accumulated,
      { additions, removals, witnessUpdateInfo },
      publicKeyRef,
      didKeypair,
      params,
    );
  }

  /**
   * Update existing universal (supports add/remove) accumulator
   * @param id - Unique accumulator id
   * @param accumulated - Current accumulated value.
   * @param publicKeyRef - Reference to accumulator public key. If the reference contains the key id 0, it means the accumulator does not
   * have any public key on the chain. This is useful for KVAC.
   * @param maxSize - Maximum size of the accumulator
   * @param signingKeyRef - Signer's keypair reference
   * @returns {Promise<*>}
   */
  async updateUniversalAccumulator(
    id,
    accumulated,
    { additions, removals, witnessUpdateInfo },
    publicKeyRef,
    maxSize,
    didKeypair,
    params,
  ) {
    const accId = types_accumulator_id.AccumulatorId.from(id);

    return await this.moduleById(accId).updateUniversalAccumulator(
      accId,
      accumulated,
      { additions, removals, witnessUpdateInfo },
      publicKeyRef,
      maxSize,
      didKeypair,
      params,
    );
  }

  /**
   * Update existing KB universal (supports add/remove) accumulator
   * @param id - Unique accumulator id
   * @param accumulated - Current accumulated value.
   * @param publicKeyRef - Reference to accumulator public key. If the reference contains the key id 0, it means the accumulator does not
   * have any public key on the chain. This is useful for KVAC.
   * @param signingKeyRef - Signer's keypair reference
   * @returns {Promise<*>}
   */
  async updateKBUniversalAccumulator(
    id,
    accumulated,
    { additions, removals, witnessUpdateInfo },
    publicKeyRef,
    didKeypair,
    params,
  ) {
    const accId = types_accumulator_id.AccumulatorId.from(id);

    return await this.moduleById(accId).updateKBUniversalAccumulator(
      accId,
      accumulated,
      { additions, removals, witnessUpdateInfo },
      publicKeyRef,
      didKeypair,
      params,
    );
  }

  /**
   * Remove the accumulator from chain. This frees up the id for reuse.
   * @param id - id to remove
   * @param signingKeyRef - Signer's keypair reference
   * @returns {Promise<*>}
   */
  async removeAccumulator(id, didKeypair, params) {
    const accId = types_accumulator_id.AccumulatorId.from(id);

    return await this.moduleById(accId).removeAccumulator(
      id,
      didKeypair,
      params,
    );
  }

  /**
   * Get the accumulator as an object. The field `type` in object specifies whether it is "positive" or "universal".
   * Fields `created` and `lastModified` are block nos where the accumulator was created and last updated respectively.
   * Field `nonce` is the last accepted nonce by the chain, the next write to the accumulator should increment the nonce by 1.
   * Field `accumulated` contains the current accumulated value.
   * @param id
   * @param includeKey - Fetch public key for the given accumulator.
   * @param includeKeyParams - Fetch public key params.
   * @returns {Promise<Accumulator|null>}
   */
  async getAccumulator(id, includeKey = false, includeKeyParams = false) {
    const accId = types_accumulator_id.AccumulatorId.from(id);

    return await this.moduleById(accId).getAccumulator(
      accId,
      includeKey,
      includeKeyParams,
    );
  }

  /**
   * Update given witness by downloading necessary accumulators (blocks) and applying the updates if found.
   * **Both `from` and `to` are inclusive.**
   *
   * @param accumulatorId
   * @param member
   * @param witness - this will be updated to the latest witness
   * @param from - identifier to start from (block number or collection item id)
   * @param to - identifier to end in (block number or collection item id)
   * @returns {Promise<void>}
   */
  async updateWitness(accumulatorId, member, witness, from, to) {
    const accId = types_accumulator_id.AccumulatorId.from(accumulatorId);

    return await this.moduleById(accId).updateWitness(
      accId,
      member,
      witness,
      from,
      to,
    );
  }

  async getPublicKey(did, id, includeParams) {
    const parsedDid = types_did_onchain_typedDid_index.NamespaceDid.from(did);

    return await this.moduleById(parsedDid).getPublicKey(
      parsedDid,
      id,
      includeParams,
    );
  }

  /**
   * Retrieves all accumulator public keys by a DID.
   * @param {*} did
   * @returns {Promise<Map<*, AccumulatorPublicKey>>}
   */
  async getAllPublicKeysByDid(did, includeParams) {
    const id = types_did_onchain_typedDid_index.NamespaceDid.from(did);

    return await this.moduleById(id).getAllPublicKeysByDid(did, includeParams);
  }

  async addPublicKeyTx(...args) {
    const did = types_did_onchain_typedDid_index.NamespaceDid.from(args[2]);

    return await this.moduleById(did).addPublicKeyTx(...args);
  }

  /**
   * Remove public key
   * @param removeKeyId - The key index for key to remove.
   * @param targetDid - The DID from which key is being removed
   * @param signerDid - The DID that is removing the key by signing the payload because it controls `targetDid`
   * @param signingKeyRef - Signer's signing key reference
   * @returns {Promise<*>}
   */
  async removePublicKeyTx(...args) {
    const did = types_did_onchain_typedDid_index.NamespaceDid.from(args[1]);

    return await this.moduleById(did).removePublicKeyTx(...args);
  }

  /**
   * Retrieves accumulator params by a DID and unique idetnfier.
   * @param {*} did
   * @param {*} id
   * @returns {Promise<AccumulatorParams>}
   */
  async getParams(did, id) {
    const parsedDid = types_did_onchain_typedDid_index.NamespaceDid.from(did);

    return await this.moduleById(parsedDid).getParams(parsedDid, id);
  }

  /**
   * Retrieves all accumulator params by a DID.
   * @param {*} did
   * @returns {Promise<Map<*, AccumulatorParams>>}
   */
  async getAllParamsByDid(did) {
    const id = types_did_onchain_typedDid_index.NamespaceDid.from(did);

    return await this.moduleById(id).getAllParamsByDid(did);
  }

  /**
   * Add new accumulator params.
   * @param id - Unique identifier of the new params to be added.
   * @param param - The signature params to add.
   * @param targetDid
   * @param keyPair - Signer's keypair

   * @returns {Promise<*>}
   */
  async addParams(...args) {
    const did = types_did_onchain_typedDid_index.NamespaceDid.from(args[2]);

    return await this.moduleById(did).addParams(...args);
  }

  async addParamsTx(...args) {
    const did = types_did_onchain_typedDid_index.NamespaceDid.from(args[2]);

    return await this.moduleById(did).addParamsTx(...args);
  }

  /**
   * Creates and stores a new accumulator on the blockchain
   *
   * An accumulator is a cryptographic data structure used to maintain an aggregate value that can be updated incrementally.
   * This method creates a new accumulator instance with the given ID and initial state.
   *
   * @param {string} id - Unique identifier for the accumulator
   * @param {Accumulator} accumulator - Initial accumulator value to store
   * @param {DidKeypair} didKeypair - Keypair used to sign the transaction
   * @returns {Promise<*>} Promise resolving to the transaction result
   */
  async addAccumulatorTx(id, accumulator, didKeypair) {
    const accId = types_accumulator_id.AccumulatorId.from(id);

    return await this.moduleById(accId).addAccumulatorTx(
      accId,
      accumulator,
      didKeypair,
    );
  }

  /**
   * Updates an existing accumulator on the blockchain
   *
   * This method replaces the current state of an accumulator with a new value.
   * The accumulator must already exist (be previously created) to be updated.
   *
   * @param {string} id - Unique identifier of the accumulator to update
   * @param {AccumulatorValue} accumulator - New accumulator value to set
   * @param {{ additions: Array<Uint8Array>, removals: Array<Uint8Array>, witnessUpdateInfo: Uint8Array }} updates
   * @param {DidKeypair} didKeypair - Keypair used to sign the transaction
   * @returns {Promise<*>} Promise resolving to the transaction result
   */
  async updateAccumulatorTx(
    id,
    accumulator,
    { additions, removals, witnessUpdateInfo },
    didKeypair,
  ) {
    const accId = types_accumulator_id.AccumulatorId.from(id);

    return await this.moduleById(accId).updateAccumulatorTx(
      accId,
      accumulator,
      { additions, removals, witnessUpdateInfo },
      didKeypair,
    );
  }

  /**
   * Remove the accumulator from chain. This frees up the id for reuse.
   * @param id - id to remove
   * @param signerDid - Signer of the transaction payload
   * @param signingKeyRef - Signer's keypair reference
   * @returns {Promise<*>}
   */
  async removeAccumulatorTx(id, didKeypair) {
    const accId = types_accumulator_id.AccumulatorId.from(id);

    return await this.moduleById(accId).removeAccumulatorTx(accId, didKeypair);
  }

  async lastPublicKeyId(targetDid) {
    const did = types_did_onchain_typedDid_index.NamespaceDid.from(targetDid);

    return await this.moduleById(did).lastPublicKeyId(did);
  }

  async nextPublicKeyId(targetDid) {
    const did = types_did_onchain_typedDid_index.NamespaceDid.from(targetDid);

    return await this.moduleById(did).nextPublicKeyId(did);
  }

  async lastParamsId(targetDid) {
    const did = types_did_onchain_typedDid_index.NamespaceDid.from(targetDid);

    return await this.moduleById(did).lastParamsId(did);
  }

  async nextParamsId(targetDid) {
    const did = types_did_onchain_typedDid_index.NamespaceDid.from(targetDid);

    return await this.moduleById(did).nextParamsId(did);
  }

  async accumulatorHistory(id) {
    const accId = types_accumulator_id.AccumulatorId.from(id);

    return await this.moduleById(accId).accumulatorHistory(accId);
  }

  async accumulatorVersions(id) {
    const accId = types_accumulator_id.AccumulatorId.from(id);

    return await this.moduleById(accId).accumulatorVersions(accId);
  }
}

module.exports = MultiApiAccumulatorModule;
//# sourceMappingURL=accumulator.cjs.map
