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

class MultiApiAccumulatorModule extends injectModuleRouter(
  AbstractAccumulatorModule,
) {
  /**
   * 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = AccumulatorId.from(accumulatorId);

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

  async getPublicKey(did, id, includeParams) {
    const parsedDid = 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 = NamespaceDid.from(did);

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

  async addPublicKeyTx(...args) {
    const did = 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 = 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 = 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 = 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 = NamespaceDid.from(args[2]);

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

  async addParamsTx(...args) {
    const did = 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 = 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 = 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 = AccumulatorId.from(id);

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

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

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

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

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

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

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

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

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

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

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

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

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

export { MultiApiAccumulatorModule as default };
//# sourceMappingURL=accumulator.js.map
