@jibidieuw/dexes 0.0.0

package/dist/index.mjs

@@ -0,0 +1,4013 @@
+import { isHex, padHex, parseEventLogs, toEventSelector, toHex, toBytes, hexToBytes } from 'viem';
+import * as openpgp2 from 'openpgp';
+import pLimit from 'p-limit';
+
+// src/utils/0xstr.ts
+var InvalidHexError = class extends Error {
+  constructor(input) {
+    super(`Invalid hex string: "${input}"`);
+    this.code = "INVALID_HEX";
+    this.name = "InvalidHexError";
+    this.input = input;
+  }
+};
+var HexTooLongError = class extends Error {
+  constructor(input) {
+    super(`Hex string too long to fit in bytes32: "${input}"`);
+    this.code = "HEX_TOO_LONG";
+    this.name = "HexTooLongError";
+    this.input = input;
+  }
+};
+var BYTES32_ZERO = "0x" + "00".repeat(32);
+function toBytes32(hex) {
+  if (!isHex(hex, { strict: true }) || hex.length > 66) {
+    throw new HexTooLongError(hex);
+  }
+  return padHex(hex, { dir: "left", size: 32 });
+}
+function to0x(hexstr) {
+  const s = hexstr.trim().toLowerCase().startsWith("0x") ? hexstr.trim().toLowerCase() : "0x" + hexstr.trim().toLowerCase();
+  if (!isHex(s, { strict: true })) {
+    throw new InvalidHexError(hexstr);
+  }
+  return s;
+}
+
+// src/abis/FlatFee.ts
+var FlatFee = [{ "type": "receive", "stateMutability": "payable" }, { "type": "function", "name": "authority", "inputs": [], "outputs": [{ "name": "", "type": "address", "internalType": "address" }], "stateMutability": "view" }, { "type": "function", "name": "isConsumingScheduledOp", "inputs": [], "outputs": [{ "name": "", "type": "bytes4", "internalType": "bytes4" }], "stateMutability": "view" }, { "type": "function", "name": "requestedFee", "inputs": [], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "setAuthority", "inputs": [{ "name": "newAuthority", "type": "address", "internalType": "address" }], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", "name": "updateRequestedFee", "inputs": [{ "name": "newFee", "type": "uint256", "internalType": "uint256" }], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", "name": "withdrawFees", "inputs": [{ "name": "to", "type": "address", "internalType": "address" }], "outputs": [], "stateMutability": "nonpayable" }, { "type": "event", "name": "AuthorityUpdated", "inputs": [{ "name": "authority", "type": "address", "indexed": false, "internalType": "address" }], "anonymous": false }, { "type": "event", "name": "FeesWithdrawn", "inputs": [{ "name": "to", "type": "address", "indexed": true, "internalType": "address" }, { "name": "amount", "type": "uint256", "indexed": false, "internalType": "uint256" }], "anonymous": false }, { "type": "event", "name": "Initialized", "inputs": [{ "name": "version", "type": "uint64", "indexed": false, "internalType": "uint64" }], "anonymous": false }, { "type": "event", "name": "RequestedFeeUpdated", "inputs": [{ "name": "oldFee", "type": "uint256", "indexed": false, "internalType": "uint256" }, { "name": "newFee", "type": "uint256", "indexed": false, "internalType": "uint256" }], "anonymous": false }, { "type": "error", "name": "AccessManagedInvalidAuthority", "inputs": [{ "name": "authority", "type": "address", "internalType": "address" }] }, { "type": "error", "name": "AccessManagedRequiredDelay", "inputs": [{ "name": "caller", "type": "address", "internalType": "address" }, { "name": "delay", "type": "uint32", "internalType": "uint32" }] }, { "type": "error", "name": "AccessManagedUnauthorized", "inputs": [{ "name": "caller", "type": "address", "internalType": "address" }] }, { "type": "error", "name": "FeeRequired", "inputs": [{ "name": "provided", "type": "uint256", "internalType": "uint256" }, { "name": "required", "type": "uint256", "internalType": "uint256" }] }, { "type": "error", "name": "FeesWithdrawalFailed", "inputs": [] }, { "type": "error", "name": "InvalidInitialization", "inputs": [] }, { "type": "error", "name": "NoDirectPaymentsAllowed", "inputs": [] }, { "type": "error", "name": "NoFeesToWithdraw", "inputs": [] }, { "type": "error", "name": "NotInitializing", "inputs": [] }, { "type": "error", "name": "ReentrancyGuardReentrantCall", "inputs": [] }];
+
+// src/utils/viemutils.ts
+async function getBlockTimestamp(client, blockNumber) {
+  const block = await client.getBlock({ blockNumber });
+  return new Date(Number(block.timestamp) * 1e3);
+}
+
+// src/flatfee/flatefee.ts
+var FlatFee2 = class {
+  /**
+   * Creates a new FlatFee instance.
+   * 
+   * @param address The address of the contract implementing IFlatFee.
+   * @param client A Viem public client for interacting with the blockchain.
+   * @param walletClient Optional Viem wallet client for signing transactions.
+   */
+  constructor(address, client, walletClient) {
+    this._address = address;
+    this._client = client;
+    this._walletClient = walletClient;
+  }
+  /*****************************************************************************************************************/
+  /* GETTERS AND SETTERS                                                                                           */
+  /*****************************************************************************************************************/
+  /**
+   * Gets the contract address.
+   */
+  get address() {
+    return this._address;
+  }
+  /**
+   * Sets the contract address.
+   */
+  set address(value) {
+    this._address = value;
+  }
+  /**
+   * Gets the Viem public client.
+   */
+  get client() {
+    return this._client;
+  }
+  /**
+   * Sets the Viem public client.
+   */
+  set client(client) {
+    this._client = client;
+  }
+  /**
+   * Gets the Viem wallet client.
+   */
+  get walletClient() {
+    return this._walletClient;
+  }
+  /**
+   * Sets the Viem wallet client.
+   */
+  set walletClient(value) {
+    this._walletClient = value;
+  }
+  /**
+   * Validate that a wallet client is available for write operations.
+   * @throws Error if wallet client is not configured
+   */
+  ensureWalletClient() {
+    if (!this._walletClient) {
+      throw new Error("WalletClient is required for write operations. Please set walletClient before calling this method.");
+    }
+  }
+  /*****************************************************************************************************************/
+  /* WRITE FUNCTIONS                                                                                               */
+  /*****************************************************************************************************************/
+  /**
+   * Updates the requested service fee.
+   * 
+   * @param newFee The new requested fee to be set.
+   * @returns The transaction receipt of the update operation.
+   */
+  async updateRequestedFee(newFee) {
+    this.ensureWalletClient();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: FlatFee,
+      functionName: "updateRequestedFee",
+      args: [
+        newFee
+      ]
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /**
+   * Withdraws the full contract balance to the specified address.
+   * @param to The address to which the fees are withdrawn.
+   * @dev This function should be restricted to authorized users.
+   */
+  async withdrawFees(to) {
+    this.ensureWalletClient();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: FlatFee,
+      functionName: "withdrawFees",
+      args: [
+        to
+      ]
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /*****************************************************************************************************************/
+  /* READ FUNCTIONS                                                                                                */
+  /*****************************************************************************************************************/
+  /**
+   * Indicate the fee requested by the smart contract to perform its operations.
+   * @returns The requested fee in wei.
+   */
+  async requestedFee() {
+    return this.client.readContract({
+      address: this.address,
+      abi: FlatFee,
+      functionName: "requestedFee"
+    });
+  }
+  /*****************************************************************************************************************/
+  /* LOG SEARCH FUNCTIONS                                                                                          */
+  /*****************************************************************************************************************/
+  /**
+   * Searches for RequestedFeeUpdated events emitted by the smart contract.
+   * 
+   * @param fromBlock Filter events from this block number. Genesis block if not specified.
+   * @param toBlock Filter events up to this block number. Latest block if not specified.
+   * @returns The list of RequestedFeeUpdatedLog matching the provided filters.
+   */
+  async searchRequestedFeeUpdatedLogs(fromBlock, toBlock) {
+    const from = fromBlock ?? 0n;
+    const to = toBlock ?? await this.client.getBlockNumber();
+    const logs = await this.client.getLogs({
+      address: this.address,
+      event: FlatFee.find((item) => item.type === "event" && item.name === "RequestedFeeUpdated"),
+      fromBlock: from,
+      toBlock: to
+    });
+    return Promise.all(logs.map(async (log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: await getBlockTimestamp(this.client, log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      oldFee: log.args.oldFee,
+      newFee: log.args.newFee
+    })));
+  }
+  /**
+   * Searches for FeesWithdrawn events emitted by the smart contract.
+   * 
+   * @param recipients Filter by recipient addresses.
+   * @param fromBlock Filter events from this block number. Genesis block if not specified.
+   * @param toBlock Filter events up to this block number. Latest block if not specified.
+   * @returns The list of FeesWithdrawnLog matching the provided filters.
+   */
+  async searchFeesWithdrawnLogs(recipients, fromBlock, toBlock) {
+    const from = fromBlock ?? 0n;
+    const to = toBlock ?? await this.client.getBlockNumber();
+    const args = recipients ? { to: recipients } : void 0;
+    const logs = await this.client.getLogs({
+      address: this.address,
+      event: FlatFee.find((item) => item.type === "event" && item.name === "FeesWithdrawn"),
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    return Promise.all(logs.map(async (log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: await getBlockTimestamp(this.client, log.blockNumber),
+      transactionHash: log.transactionHash,
+      logIndex: log.logIndex,
+      to: log.args.to,
+      amount: log.args.amount
+    })));
+  }
+  /**
+   * Extracts FeesWithdrawnLog entries from a transaction receipt.
+   * @param receipt The transaction receipt to extract logs from.
+   * @returns The list of FeesWithdrawnLog extracted from the receipt.
+   */
+  async extractFeesWithdrawnLog(receipt) {
+    const parsed = parseEventLogs({
+      logs: receipt.logs,
+      abi: FlatFee,
+      eventName: "FeesWithdrawn"
+    });
+    return Promise.all(parsed.map(async (log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: await getBlockTimestamp(this.client, log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      to: log.args.to,
+      amount: log.args.amount
+    })));
+  }
+  /**
+   * Extracts RequestedFeeUpdatedLog entries from a transaction receipt.
+   * @param receipt The transaction receipt to extract logs from.
+   * @returns The list of RequestedFeeUpdatedLog extracted from the receipt.
+   */
+  async extractRequestedFeeUpdatedLog(receipt) {
+    const parsed = parseEventLogs({
+      logs: receipt.logs,
+      abi: FlatFee,
+      eventName: "RequestedFeeUpdated"
+    });
+    return Promise.all(parsed.map(async (log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: await getBlockTimestamp(this.client, log.blockNumber),
+      transactionHash: log.transactionHash,
+      oldFee: log.args.oldFee,
+      newFee: log.args.newFee,
+      logIndex: log.logIndex
+    })));
+  }
+};
+
+// src/web3pgp/types/types.ts
+var Web3PGPEvents = {
+  KeyRegistered: "KeyRegistered",
+  KeyUpdated: "KeyUpdated",
+  SubkeyAdded: "SubkeyAdded",
+  KeyRevoked: "KeyRevoked",
+  KeyCertified: "KeyCertified",
+  KeyCertificationRevoked: "KeyCertificationRevoked",
+  OwnershipChallenged: "OwnershipChallenged",
+  OwnershipProved: "OwnershipProved"
+};
+
+// src/abis/Web3PGP.ts
+var Web3PGP = [{ "type": "constructor", "inputs": [], "stateMutability": "nonpayable" }, { "type": "receive", "stateMutability": "payable" }, { "type": "function", "name": "UPGRADE_INTERFACE_VERSION", "inputs": [], "outputs": [{ "name": "", "type": "string", "internalType": "string" }], "stateMutability": "view" }, { "type": "function", "name": "addSubkey", "inputs": [{ "name": "primaryKeyFingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "subkeyFingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "openPGPMsg", "type": "bytes", "internalType": "bytes" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "authority", "inputs": [], "outputs": [{ "name": "", "type": "address", "internalType": "address" }], "stateMutability": "view" }, { "type": "function", "name": "certifyKey", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "issuerFingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "keyCertificate", "type": "bytes", "internalType": "bytes" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "challengeOwnership", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "challenge", "type": "bytes32", "internalType": "bytes32" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "exists", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }], "outputs": [{ "name": "isUsed", "type": "bool", "internalType": "bool" }], "stateMutability": "view" }, { "type": "function", "name": "getKeyPublicationBlock", "inputs": [{ "name": "fingerprints", "type": "bytes32[]", "internalType": "bytes32[]" }], "outputs": [{ "name": "", "type": "uint256[]", "internalType": "uint256[]" }], "stateMutability": "view" }, { "type": "function", "name": "getKeyPublicationBlock", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "initialize", "inputs": [{ "name": "fee", "type": "uint256", "internalType": "uint256" }, { "name": "manager", "type": "address", "internalType": "address" }], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", "name": "initializeUpgrade", "inputs": [], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", "name": "isConsumingScheduledOp", "inputs": [], "outputs": [{ "name": "", "type": "bytes4", "internalType": "bytes4" }], "stateMutability": "view" }, { "type": "function", "name": "isSubKey", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }], "outputs": [{ "name": "", "type": "bool", "internalType": "bool" }], "stateMutability": "view" }, { "type": "function", "name": "listCertificationRevocations", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "start", "type": "uint256", "internalType": "uint256" }, { "name": "limit", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "uint256[]", "internalType": "uint256[]" }], "stateMutability": "view" }, { "type": "function", "name": "listCertifications", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "start", "type": "uint256", "internalType": "uint256" }, { "name": "limit", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "uint256[]", "internalType": "uint256[]" }], "stateMutability": "view" }, { "type": "function", "name": "listKeyUpdates", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "start", "type": "uint256", "internalType": "uint256" }, { "name": "limit", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "uint256[]", "internalType": "uint256[]" }], "stateMutability": "view" }, { "type": "function", "name": "listRevocations", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "start", "type": "uint256", "internalType": "uint256" }, { "name": "limit", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "uint256[]", "internalType": "uint256[]" }], "stateMutability": "view" }, { "type": "function", "name": "listSubkeys", "inputs": [{ "name": "parentKeyFingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "start", "type": "uint256", "internalType": "uint256" }, { "name": "limit", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "bytes32[]", "internalType": "bytes32[]" }], "stateMutability": "view" }, { "type": "function", "name": "parentOf", "inputs": [{ "name": "subkeyFingerprint", "type": "bytes32", "internalType": "bytes32" }], "outputs": [{ "name": "", "type": "bytes32", "internalType": "bytes32" }], "stateMutability": "view" }, { "type": "function", "name": "proveOwnership", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "challenge", "type": "bytes32", "internalType": "bytes32" }, { "name": "signature", "type": "bytes", "internalType": "bytes" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "proxiableUUID", "inputs": [], "outputs": [{ "name": "", "type": "bytes32", "internalType": "bytes32" }], "stateMutability": "view" }, { "type": "function", "name": "register", "inputs": [{ "name": "primaryKeyFingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "subkeyFingerprints", "type": "bytes32[]", "internalType": "bytes32[]" }, { "name": "openPGPMsg", "type": "bytes", "internalType": "bytes" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "requestedFee", "inputs": [], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "revoke", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "revocationCertificate", "type": "bytes", "internalType": "bytes" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "revokeCertification", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "issuerFingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "revocationSignature", "type": "bytes", "internalType": "bytes" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "setAuthority", "inputs": [{ "name": "newAuthority", "type": "address", "internalType": "address" }], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", "name": "update", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "openPGPMsg", "type": "bytes", "internalType": "bytes" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "updateRequestedFee", "inputs": [{ "name": "newFee", "type": "uint256", "internalType": "uint256" }], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", "name": "upgradeToAndCall", "inputs": [{ "name": "newImplementation", "type": "address", "internalType": "address" }, { "name": "data", "type": "bytes", "internalType": "bytes" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "withdrawFees", "inputs": [{ "name": "to", "type": "address", "internalType": "address" }], "outputs": [], "stateMutability": "nonpayable" }, { "type": "event", "name": "AuthorityUpdated", "inputs": [{ "name": "authority", "type": "address", "indexed": false, "internalType": "address" }], "anonymous": false }, { "type": "event", "name": "FeesWithdrawn", "inputs": [{ "name": "to", "type": "address", "indexed": true, "internalType": "address" }, { "name": "amount", "type": "uint256", "indexed": false, "internalType": "uint256" }], "anonymous": false }, { "type": "event", "name": "Initialized", "inputs": [{ "name": "version", "type": "uint64", "indexed": false, "internalType": "uint64" }], "anonymous": false }, { "type": "event", "name": "KeyCertificationRevoked", "inputs": [{ "name": "fingerprint", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "issuer", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "revocationSignature", "type": "bytes", "indexed": false, "internalType": "bytes" }], "anonymous": false }, { "type": "event", "name": "KeyCertified", "inputs": [{ "name": "fingerprint", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "issuer", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "keyCertificate", "type": "bytes", "indexed": false, "internalType": "bytes" }], "anonymous": false }, { "type": "event", "name": "KeyRegistered", "inputs": [{ "name": "primaryKeyFingerprint", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "subkeyFingerprints", "type": "bytes32[]", "indexed": false, "internalType": "bytes32[]" }, { "name": "openPGPMsg", "type": "bytes", "indexed": false, "internalType": "bytes" }], "anonymous": false }, { "type": "event", "name": "KeyRevoked", "inputs": [{ "name": "fingerprint", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "revocationCertificate", "type": "bytes", "indexed": false, "internalType": "bytes" }], "anonymous": false }, { "type": "event", "name": "KeyUpdated", "inputs": [{ "name": "fingerprint", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "openPGPMsg", "type": "bytes", "indexed": false, "internalType": "bytes" }], "anonymous": false }, { "type": "event", "name": "OwnershipChallenged", "inputs": [{ "name": "fingerprint", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "challenge", "type": "bytes32", "indexed": true, "internalType": "bytes32" }], "anonymous": false }, { "type": "event", "name": "OwnershipProved", "inputs": [{ "name": "fingerprint", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "challenge", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "signature", "type": "bytes", "indexed": false, "internalType": "bytes" }], "anonymous": false }, { "type": "event", "name": "RequestedFeeUpdated", "inputs": [{ "name": "oldFee", "type": "uint256", "indexed": false, "internalType": "uint256" }, { "name": "newFee", "type": "uint256", "indexed": false, "internalType": "uint256" }], "anonymous": false }, { "type": "event", "name": "SubkeyAdded", "inputs": [{ "name": "primaryKeyFingerprint", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "subkeyFingerprint", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "openPGPMsg", "type": "bytes", "indexed": false, "internalType": "bytes" }], "anonymous": false }, { "type": "event", "name": "Upgraded", "inputs": [{ "name": "implementation", "type": "address", "indexed": true, "internalType": "address" }], "anonymous": false }, { "type": "error", "name": "AccessManagedInvalidAuthority", "inputs": [{ "name": "authority", "type": "address", "internalType": "address" }] }, { "type": "error", "name": "AccessManagedRequiredDelay", "inputs": [{ "name": "caller", "type": "address", "internalType": "address" }, { "name": "delay", "type": "uint32", "internalType": "uint32" }] }, { "type": "error", "name": "AccessManagedUnauthorized", "inputs": [{ "name": "caller", "type": "address", "internalType": "address" }] }, { "type": "error", "name": "AddressEmptyCode", "inputs": [{ "name": "target", "type": "address", "internalType": "address" }] }, { "type": "error", "name": "AlreadyRegistered", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }] }, { "type": "error", "name": "ERC1967InvalidImplementation", "inputs": [{ "name": "implementation", "type": "address", "internalType": "address" }] }, { "type": "error", "name": "ERC1967NonPayable", "inputs": [] }, { "type": "error", "name": "FailedCall", "inputs": [] }, { "type": "error", "name": "FeeRequired", "inputs": [{ "name": "provided", "type": "uint256", "internalType": "uint256" }, { "name": "required", "type": "uint256", "internalType": "uint256" }] }, { "type": "error", "name": "FeesWithdrawalFailed", "inputs": [] }, { "type": "error", "name": "InvalidInitialization", "inputs": [] }, { "type": "error", "name": "NoDirectPaymentsAllowed", "inputs": [] }, { "type": "error", "name": "NoFeesToWithdraw", "inputs": [] }, { "type": "error", "name": "NotInitializing", "inputs": [] }, { "type": "error", "name": "NotRegistered", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }] }, { "type": "error", "name": "ReentrancyGuardReentrantCall", "inputs": [] }, { "type": "error", "name": "SelfCertificationNotAllowed", "inputs": [] }, { "type": "error", "name": "TargetIsASubkey", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }] }, { "type": "error", "name": "UUPSUnauthorizedCallContext", "inputs": [] }, { "type": "error", "name": "UUPSUnsupportedProxiableUUID", "inputs": [{ "name": "slot", "type": "bytes32", "internalType": "bytes32" }] }];
+var _Web3PGP = class _Web3PGP extends FlatFee2 {
+  constructor(address, client, walletClient) {
+    super(address, client, walletClient);
+  }
+  /*****************************************************************************************************************/
+  /* READ FUNCTIONS                                                                                                */
+  /*****************************************************************************************************************/
+  /**
+   * Check if a given fingerprint has been used to register a key in the contract.
+   * @param fingerprint The fingerprint of the key to check.
+   * @return True if the fingerprint has been used to register a key in the contract, false otherwise.
+   */
+  exists(fingerprint) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3PGP,
+      functionName: "exists",
+      args: [toBytes32(fingerprint)]
+    });
+  }
+  /**
+   * Check if a given fingerprint corresponds to a key registered as a subkey in the contract.
+   * @param fingerprint The fingerprint of the key to check.
+   * @return True if the key is a subkey, false otherwise.
+   */
+  isSubKey(fingerprint) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3PGP,
+      functionName: "isSubKey",
+      args: [toBytes32(fingerprint)]
+    });
+  }
+  /**
+   * Get the fingerprint of the parent key for a given subkey.
+   * @param subkeyFingerprint The fingerprint of the subkey.
+   * @return The fingerprint of the parent key or zero bytes if there is no parent.
+   */
+  parentOf(subkeyFingerprint) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3PGP,
+      functionName: "parentOf",
+      args: [toBytes32(subkeyFingerprint)]
+    });
+  }
+  /**
+   * Get the block number when a key was published.
+   * @param fingerprint The fingerprint of the key to check.
+   * @return The block number when the key was published, or 0 if not published.
+   */
+  getKeyPublicationBlock(fingerprint) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3PGP,
+      functionName: "getKeyPublicationBlock",
+      args: [toBytes32(fingerprint)]
+    });
+  }
+  /**
+   * Get the block numbers when multiple keys were published.
+   * @param fingerprints The fingerprints of the keys to check.
+   * @return An array of block numbers corresponding to each fingerprint in the order they were provided.
+   */
+  getKeyPublicationBlockBatch(fingerprints) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3PGP,
+      functionName: "getKeyPublicationBlock",
+      args: [fingerprints.map((fp) => toBytes32(fp))]
+    });
+  }
+  /**
+   * List the block numbers when updates were published for the given fingerprint.
+   * @param fingerprint The fingerprint of the key to check.
+   * @param start The starting index in the list of updates.
+   * @param limit The maximum number of results to return.
+   * @return An array of block numbers when updates were published.
+   */
+  listKeyUpdates(fingerprint, start, limit) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3PGP,
+      functionName: "listKeyUpdates",
+      args: [toBytes32(fingerprint), start, limit]
+    });
+  }
+  /**
+   * List the block numbers when revocation certificates were published for the given fingerprint.
+   * @param fingerprint The fingerprint of the key to check.
+   * @param start The starting index in the list of revocations.
+   * @param limit The maximum number of results to return.
+   * @return An array of block numbers when revocation certificates were published.
+   */
+  listRevocations(fingerprint, start, limit) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3PGP,
+      functionName: "listRevocations",
+      args: [toBytes32(fingerprint), start, limit]
+    });
+  }
+  /**
+   * List the fingerprints of subkeys registered under a given parent key.
+   * @param parentKeyFingerprint The fingerprint of the parent key to check.
+   * @param start The starting index in the list of subkeys.
+   * @param limit The maximum number of results to return.
+   * @return An array of subkey fingerprints.
+   */
+  listSubkeys(parentKeyFingerprint, start, limit) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3PGP,
+      functionName: "listSubkeys",
+      args: [toBytes32(parentKeyFingerprint), start, limit]
+    });
+  }
+  /**
+   * List the block numbers when key certifications were issued for a given key.
+   * @param fingerprint The fingerprint of the key.
+   * @param start The starting index in the list of certifications.
+   * @param limit The maximum number of results to return.
+   * @return An array of block numbers when certifications were issued.
+   */
+  listCertifications(fingerprint, start, limit) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3PGP,
+      functionName: "listCertifications",
+      args: [toBytes32(fingerprint), start, limit]
+    });
+  }
+  /**
+   * List the block numbers when key certification revocations were issued for a given key.
+   * @param fingerprint The fingerprint of the key.
+   * @param start The starting index in the list of revocations.
+   * @param limit The maximum number of results to return.
+   * @return An array of block numbers when certification revocations were issued.
+   */
+  listCertificationRevocations(fingerprint, start, limit) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3PGP,
+      functionName: "listCertificationRevocations",
+      args: [toBytes32(fingerprint), start, limit]
+    });
+  }
+  /*****************************************************************************************************************/
+  /* WRITE FUNCTIONS (PAYABLE)                                                                                     */
+  /*****************************************************************************************************************/
+  /**
+   * Register a new primary public key and its optional subkeys.
+   * @param primaryKeyFingerprint The declared fingerprint of the primary public key.
+   * @param subkeyFingerprints Optional array of declared fingerprints of the subkeys attached to the primary key.
+   * @param openPGPMsg A binary OpenPGP message containing the primary key, binding signature, metadata, and subkeys.
+   * @return Transaction receipt after registration.
+   */
+  async register(primaryKeyFingerprint, subkeyFingerprints, openPGPMsg) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3PGP,
+      functionName: "register",
+      args: [
+        toBytes32(primaryKeyFingerprint),
+        subkeyFingerprints.map((fp) => toBytes32(fp)),
+        openPGPMsg
+      ],
+      value: fee
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /**
+   * Update an existing key with new OpenPGP metadata.
+   * @param fingerprint The fingerprint of the key to update.
+   * @param openPGPMsg A binary OpenPGP message containing updated key material and signatures.
+   * @return Transaction receipt after updating the key.
+   */
+  async update(fingerprint, openPGPMsg) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3PGP,
+      functionName: "update",
+      args: [toBytes32(fingerprint), openPGPMsg],
+      value: fee
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /**
+   * Add a new subkey to an already registered primary key.
+   * @param primaryKeyFingerprint The fingerprint of the primary key to which to attach the subkey.
+   * @param subkeyFingerprint The fingerprint of the subkey.
+   * @param openPGPMsg A binary OpenPGP message containing the subkey and its key binding signatures.
+   * @return Transaction receipt after adding the subkey.
+   */
+  async addSubkey(primaryKeyFingerprint, subkeyFingerprint, openPGPMsg) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3PGP,
+      functionName: "addSubkey",
+      args: [
+        toBytes32(primaryKeyFingerprint),
+        toBytes32(subkeyFingerprint),
+        openPGPMsg
+      ],
+      value: fee
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /**
+   * Publish a key revocation certificate for a target public key.
+   * @param fingerprint The fingerprint of the key to be revoked.
+   * @param revocationCertificate The binary OpenPGP message containing the key revocation certificate.
+   * @return Transaction receipt after publishing the revocation.
+   */
+  async revoke(fingerprint, revocationCertificate) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3PGP,
+      functionName: "revoke",
+      args: [
+        toBytes32(fingerprint),
+        revocationCertificate
+      ],
+      value: fee
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /**
+   * Certify a key by issuing a key certification signature.
+   * @param fingerprint The fingerprint of the key being certified.
+   * @param issuerFingerprint The fingerprint of the key issuing the certification.
+   * @param keyCertificate A binary OpenPGP signature constituting the key certification.
+   * @return Transaction receipt after publishing the certification.
+   */
+  async certifyKey(fingerprint, issuerFingerprint, keyCertificate) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3PGP,
+      functionName: "certifyKey",
+      args: [
+        toBytes32(fingerprint),
+        toBytes32(issuerFingerprint),
+        keyCertificate
+      ],
+      value: fee
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /**
+   * Revoke a key certification.
+   * @param fingerprint The fingerprint of the key whose certification is being revoked.
+   * @param issuerFingerprint The fingerprint of the issuer of the certification to revoke.
+   * @param revocationSignature A signature constituting the revocation of the certification.
+   * @return Transaction receipt after publishing the revocation.
+   */
+  async revokeCertification(fingerprint, issuerFingerprint, revocationSignature) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3PGP,
+      functionName: "revokeCertification",
+      args: [
+        toBytes32(fingerprint),
+        toBytes32(issuerFingerprint),
+        revocationSignature
+      ],
+      value: fee
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /**
+   * Challenge ownership of a public key.
+   * @param fingerprint The fingerprint of the key to challenge.
+   * @param challengeHash The keccak256 hash of the challenge data sent to the user for signing.
+   * @return Transaction receipt after issuing the challenge.
+   */
+  async challengeOwnership(fingerprint, challengeHash) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3PGP,
+      functionName: "challengeOwnership",
+      args: [
+        toBytes32(fingerprint),
+        toBytes32(challengeHash)
+      ],
+      value: fee
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /**
+   * Prove ownership of a public key by responding to a challenge.
+   * @param fingerprint The fingerprint of the key.
+   * @param challengeHash The keccak256 hash of the challenge data.
+   * @param signature A signature made over the challenge data.
+   * @return Transaction receipt after proving ownership.
+   */
+  async proveOwnership(fingerprint, challengeHash, signature) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3PGP,
+      functionName: "proveOwnership",
+      args: [
+        toBytes32(fingerprint),
+        toBytes32(challengeHash),
+        signature
+      ],
+      value: fee
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /*****************************************************************************************************************/
+  /* LOGS FUNCTIONS                                                                                                */
+  /*****************************************************************************************************************/
+  /**
+   * Get the log of a key registration event using the provided primary key fingerprint and block number.
+   *
+   * @param primaryKeyFingerprint The fingerprint of the primary key to retrieve the log for.
+   * @param blockNumber The block number where the event was emitted.
+   * @throws Error if the event log cannot be found.
+   * @return The KeyRegisteredLog object containing event details.
+   */
+  async getKeyRegisteredLog(primaryKeyFingerprint, blockNumber) {
+    const logs = await this.searchKeyRegisteredLogs(primaryKeyFingerprint, blockNumber, blockNumber);
+    if (logs.length === 1) return logs[0];
+    if (logs.length === 0) throw new Error(`KeyRegistered event log not found for primaryKeyFingerprint ${primaryKeyFingerprint} at block ${blockNumber}`);
+    throw new Error(`Multiple KeyRegistered logs found for primaryKeyFingerprint ${primaryKeyFingerprint} at block ${blockNumber}`);
+  }
+  /**
+   * Search for KeyRegistered event logs.
+   *
+   * @param primaryKeyFingerprint The fingerprint(s) of the primary key to search logs for. Default to all keys.
+   * @param fromBlock The starting block number of the search range. 'earliest' is used by default. 'pending' is not allowed.
+   * @param toBlock The ending block number of the search range. 'latest' is used by default. 'pending' is not allowed.
+   * @return An array of KeyRegisteredLog objects matching the search criteria.
+   */
+  async searchKeyRegisteredLogs(primaryKeyFingerprint, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    const args = primaryKeyFingerprint !== void 0 ? {
+      primaryKeyFingerprint: Array.isArray(primaryKeyFingerprint) ? primaryKeyFingerprint.map(toBytes32) : toBytes32(primaryKeyFingerprint)
+    } : void 0;
+    const logs = await this.client.getLogs({
+      strict: true,
+      address: this.address,
+      event: _Web3PGP.KEY_REGISTERED_EVENT,
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return logs.map((log) => ({
+      type: Web3PGPEvents.KeyRegistered,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      primaryKeyFingerprint: log.args.primaryKeyFingerprint,
+      subkeyFingerprints: log.args.subkeyFingerprints,
+      openPGPMsg: log.args.openPGPMsg
+    }));
+  }
+  /**
+  * Search for KeyUpdated event logs.
+  * @param fingerprint The fingerprint(s) of the key to search logs for. Default to all keys.
+  * @param fromBlock The starting block number of the search range. 'earliest' is used by default.
+  * @param toBlock The ending block number of the search range. 'latest' is used by default.
+  * @return An array of KeyUpdatedLog objects matching the search criteria.
+  */
+  async searchKeyUpdatedLogs(fingerprint, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    const args = fingerprint !== void 0 ? {
+      fingerprint: Array.isArray(fingerprint) ? fingerprint.map(toBytes32) : toBytes32(fingerprint)
+    } : void 0;
+    const logs = await this.client.getLogs({
+      strict: true,
+      address: this.address,
+      event: _Web3PGP.KEY_UPDATED_EVENT,
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return logs.map((log) => ({
+      type: Web3PGPEvents.KeyUpdated,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      fingerprint: log.args.fingerprint,
+      openPGPMsg: log.args.openPGPMsg
+    }));
+  }
+  /**
+   * Get the log of a subkey addition event using the provided primary key fingerprint, subkey fingerprint, and block number.
+   * @param primaryKeyFingerprint The fingerprint of the primary key.
+   * @param subkeyFingerprint The fingerprint of the subkey.
+   * @param blockNumber The block number where the event was emitted.
+   * @throws Error if the event log cannot be found.
+   * @return The SubkeyAddedLog object containing event details.
+   */
+  async getSubkeyAddedLog(primaryKeyFingerprint, subkeyFingerprint, blockNumber) {
+    const logs = await this.searchSubkeyAddedLogs(primaryKeyFingerprint, subkeyFingerprint, blockNumber, blockNumber);
+    if (logs.length === 1) return logs[0];
+    if (logs.length === 0) throw new Error(`SubkeyAdded event log not found for primaryKeyFingerprint ${primaryKeyFingerprint}, subkeyFingerprint ${subkeyFingerprint} at block ${blockNumber}`);
+    throw new Error(`Multiple SubkeyAdded logs found for primaryKeyFingerprint ${primaryKeyFingerprint}, subkeyFingerprint ${subkeyFingerprint} at block ${blockNumber}`);
+  }
+  /**
+   * Search for SubkeyAdded event logs.
+   * @param primaryKeyFingerprint The fingerprint(s) of the primary key to search logs for. Default to all keys.
+   * @param subkeyFingerprint The fingerprint(s) of the subkey to search logs for. Default to all subkeys.
+   * @param fromBlock The starting block number of the search range. 'earliest' is used by default. 'pending' is not allowed.
+   * @param toBlock The ending block number of the search range. 'latest' is used by default. 'pending' is not allowed.
+   * @return An array of SubkeyAddedLog objects matching the search criteria.
+   */
+  async searchSubkeyAddedLogs(primaryKeyFingerprint, subkeyFingerprint, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    let args = void 0;
+    if (primaryKeyFingerprint !== void 0 || subkeyFingerprint !== void 0) {
+      args = {};
+      if (primaryKeyFingerprint !== void 0) {
+        args.primaryKeyFingerprint = Array.isArray(primaryKeyFingerprint) ? primaryKeyFingerprint.map(toBytes32) : toBytes32(primaryKeyFingerprint);
+      }
+      if (subkeyFingerprint !== void 0) {
+        args.subkeyFingerprint = Array.isArray(subkeyFingerprint) ? subkeyFingerprint.map(toBytes32) : toBytes32(subkeyFingerprint);
+      }
+    }
+    const logs = await this.client.getLogs({
+      strict: true,
+      address: this.address,
+      event: _Web3PGP.SUBKEY_ADDED_EVENT,
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return logs.map((log) => ({
+      type: Web3PGPEvents.SubkeyAdded,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      primaryKeyFingerprint: log.args.primaryKeyFingerprint,
+      subkeyFingerprint: log.args.subkeyFingerprint,
+      openPGPMsg: log.args.openPGPMsg
+    }));
+  }
+  /**
+   * Search for KeyRevoked event logs.
+   * @param fingerprint The fingerprint(s) of the key to search logs for. Default to all keys.
+   * @param fromBlock The starting block number of the search range. 'earliest' is used by default. 'pending' is not allowed.
+   * @param toBlock The ending block number of the search range. 'latest' is used by default. 'pending' is not allowed.
+   * @return An array of KeyRevokedLog objects matching the search criteria.
+   */
+  async searchKeyRevokedLogs(fingerprint, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    const args = fingerprint !== void 0 ? {
+      fingerprint: Array.isArray(fingerprint) ? fingerprint.map(toBytes32) : toBytes32(fingerprint)
+    } : void 0;
+    const logs = await this.client.getLogs({
+      strict: true,
+      address: this.address,
+      event: _Web3PGP.KEY_REVOKED_EVENT,
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return logs.map((log) => ({
+      type: Web3PGPEvents.KeyRevoked,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      fingerprint: log.args.fingerprint,
+      revocationCertificate: log.args.revocationCertificate
+    }));
+  }
+  /**
+   * Search for OwnershipProved event logs.
+   * @param fingerprint The fingerprint(s) of the key whose ownership proofs to search for. Default to all keys.
+   * @param challenge The challenge(s) whose ownership proofs to search for. Default to all challenges.
+   * @param fromBlock Starting block number (inclusive). 'earliest' block is used if not provided. 'pending' is not allowed.
+   * @param toBlock Ending block number (inclusive). 'latest' block is used if not provided. 'pending' is not allowed.
+   * @returns An array of OwnershipProvedLog objects matching the search criteria.
+   */
+  async searchOwnershipChallengedLogs(fingerprint, challenge, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    let args = void 0;
+    if (fingerprint !== void 0 || challenge !== void 0) {
+      args = {};
+      if (fingerprint !== void 0) {
+        args.fingerprint = Array.isArray(fingerprint) ? fingerprint.map(toBytes32) : toBytes32(fingerprint);
+      }
+      if (challenge !== void 0) {
+        args.challenge = Array.isArray(challenge) ? challenge.map(toBytes32) : toBytes32(challenge);
+      }
+    }
+    const logs = await this.client.getLogs({
+      strict: true,
+      address: this.address,
+      event: _Web3PGP.OWNERSHIP_CHALLENGED_EVENT,
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return logs.map((log) => ({
+      type: Web3PGPEvents.OwnershipChallenged,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      fingerprint: log.args.fingerprint,
+      challenge: log.args.challenge
+    }));
+  }
+  /**
+   * Search for OwnershipProved event logs.
+   * @param fingerprint The fingerprint(s) of the key whose ownership proofs to search for. Default to all keys.
+   * @param challenge The challenge(s) associated with the ownership proofs. Default to all challenges.
+   * @param fromBlock Starting block number (inclusive). 'earliest' block is used if not provided. 'pending' is not allowed.
+   * @param toBlock Ending block number (inclusive). 'latest' block is used if not provided. 'pending' is not allowed.
+   * @returns An array of OwnershipProvedLog objects matching the search criteria.
+   */
+  async searchOwnershipProvedLogs(fingerprint, challenge, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    let args = void 0;
+    if (fingerprint !== void 0 || challenge !== void 0) {
+      args = {};
+      if (fingerprint !== void 0) {
+        args.fingerprint = Array.isArray(fingerprint) ? fingerprint.map(toBytes32) : toBytes32(fingerprint);
+      }
+      if (challenge !== void 0) {
+        args.challenge = Array.isArray(challenge) ? challenge.map(toBytes32) : toBytes32(challenge);
+      }
+    }
+    const logs = await this.client.getLogs({
+      strict: true,
+      address: this.address,
+      event: _Web3PGP.OWNERSHIP_PROVED_EVENT,
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return logs.map((log) => ({
+      type: Web3PGPEvents.OwnershipProved,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      fingerprint: log.args.fingerprint,
+      challenge: log.args.challenge,
+      signature: log.args.signature
+    }));
+  }
+  /**
+   * Search for KeyCertified event logs.
+   * 
+   * @param fingerprint The fingerprint(s) of the key being certified. Default to all keys.
+   * @param issuerFingerprint The fingerprint(s) of the issuer of the certification. Default to all issuers.
+   * @param fromBlock Starting block number (inclusive). 'earliest' block is used if not provided. 'pending' is not allowed.
+   * @param toBlock Ending block number (inclusive). 'latest' block is used if not provided. 'pending' is not allowed.
+   * @returns An array of KeyCertifiedLog objects matching the search criteria.
+   */
+  async searchKeyCertifiedLogs(fingerprint, issuerFingerprint, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    let args = void 0;
+    if (fingerprint !== void 0 || issuerFingerprint !== void 0) {
+      args = {};
+      if (fingerprint !== void 0) {
+        args.fingerprint = Array.isArray(fingerprint) ? fingerprint.map(toBytes32) : toBytes32(fingerprint);
+      }
+      if (issuerFingerprint !== void 0) {
+        args.issuerFingerprint = Array.isArray(issuerFingerprint) ? issuerFingerprint.map(toBytes32) : toBytes32(issuerFingerprint);
+      }
+    }
+    const logs = await this.client.getLogs({
+      strict: true,
+      address: this.address,
+      event: _Web3PGP.KEY_CERTIFIED_EVENT,
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return logs.map((log) => ({
+      type: Web3PGPEvents.KeyCertified,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      fingerprint: log.args.fingerprint,
+      issuerFingerprint: log.args.issuer,
+      keyCertificate: log.args.keyCertificate
+    }));
+  }
+  /**
+   * Search for KeyCertificationRevoked event logs.
+   * 
+   * @param fingerprint The fingerprint(s) of the key whose certification revocations to search for. Default to all keys.
+   * @param issuerFingerprint The fingerprint(s) of the issuers whose certification revocations to search for. Default to all issuers.
+   * @param fromBlock Starting block number (inclusive). 'earliest' block is used if not provided. 'pending' is not allowed.
+   * @param toBlock Ending block number (inclusive). 'latest' block is used if not provided. 'pending' is not allowed.
+   * @returns An array of KeyCertificationRevokedLog objects matching the search criteria.
+   */
+  async searchKeyCertificationRevokedLogs(fingerprint, issuerFingerprint, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    let args = void 0;
+    if (fingerprint !== void 0 || issuerFingerprint !== void 0) {
+      args = {};
+      if (fingerprint !== void 0) {
+        args.fingerprint = Array.isArray(fingerprint) ? fingerprint.map(toBytes32) : toBytes32(fingerprint);
+      }
+      if (issuerFingerprint !== void 0) {
+        args.issuerFingerprint = Array.isArray(issuerFingerprint) ? issuerFingerprint.map(toBytes32) : toBytes32(issuerFingerprint);
+      }
+    }
+    const logs = await this.client.getLogs({
+      strict: true,
+      address: this.address,
+      event: _Web3PGP.KEY_CERTIFICATION_REVOKED_EVENT,
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return logs.map((log) => ({
+      type: Web3PGPEvents.KeyCertificationRevoked,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      fingerprint: log.args.fingerprint,
+      issuerFingerprint: log.args.issuer,
+      revocationSignature: log.args.revocationSignature
+    }));
+  }
+  /**
+   * Searches for all key-related events within a specified block range. Optionally filters by fingerprints.
+   * 
+   * Note: The fingerprints are the subjects of the events (i.e., the keys being registered, updated, revoked, certified, etc.).
+   * Results will also include subkeys added, challenges, and proofs of ownership related to the listed fingerprints.
+   * 
+   * @param fingerprints The fingerprint(s) of the keys to filter events for. Can be a single fingerprint or an array. Defaults to all keys if not provided.
+   * @param fromBlock Starting block number (inclusive). Defaults to 'earliest' if not provided. 'pending' is not allowed.
+   * @param toBlock Ending block number (inclusive). Defaults to 'latest' if not provided. 'pending' is not allowed.
+   * @return An array of Web3PGPEventLog.
+   */
+  async searchKeyEvents(fingerprints, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    const eventSelectors = [
+      _Web3PGP.KEY_REGISTERED_EVENT,
+      _Web3PGP.SUBKEY_ADDED_EVENT,
+      _Web3PGP.KEY_REVOKED_EVENT,
+      _Web3PGP.KEY_UPDATED_EVENT,
+      _Web3PGP.OWNERSHIP_CHALLENGED_EVENT,
+      _Web3PGP.OWNERSHIP_PROVED_EVENT,
+      _Web3PGP.KEY_CERTIFIED_EVENT,
+      _Web3PGP.KEY_CERTIFICATION_REVOKED_EVENT
+    ].map((abi) => toEventSelector(abi));
+    const fingerprintsArray = fingerprints !== void 0 ? Array.isArray(fingerprints) ? fingerprints.map((fp) => toBytes32(fp)) : [toBytes32(fingerprints)] : void 0;
+    const rawLogs = await this.client.request({
+      method: "eth_getLogs",
+      params: [{
+        address: this.address,
+        fromBlock: typeof from === "bigint" ? `0x${from.toString(16)}` : from,
+        toBlock: typeof to === "bigint" ? `0x${to.toString(16)}` : to,
+        topics: fingerprintsArray !== void 0 ? [eventSelectors, fingerprintsArray] : [eventSelectors]
+      }]
+    });
+    const parsedLogs = parseEventLogs({
+      abi: Web3PGP,
+      logs: rawLogs,
+      strict: true
+    });
+    const uniqueBlocks = [...new Set(parsedLogs.map((l) => {
+      const blockNum = l.blockNumber;
+      return typeof blockNum === "string" ? BigInt(blockNum) : blockNum;
+    }))];
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return parsedLogs.map((log) => {
+      const blockNumber = typeof log.blockNumber === "string" ? BigInt(log.blockNumber) : log.blockNumber;
+      const baseLog = {
+        blockNumber,
+        blockHash: log.blockHash,
+        blockTimestamp: blockTimestamps.get(blockNumber),
+        transactionHash: log.transactionHash
+      };
+      switch (log.eventName) {
+        case "KeyRegistered":
+          return {
+            ...baseLog,
+            type: Web3PGPEvents.KeyRegistered,
+            primaryKeyFingerprint: log.args.primaryKeyFingerprint,
+            subkeyFingerprints: log.args.subkeyFingerprints,
+            openPGPMsg: log.args.openPGPMsg
+          };
+        case "SubkeyAdded":
+          return {
+            ...baseLog,
+            type: Web3PGPEvents.SubkeyAdded,
+            primaryKeyFingerprint: log.args.primaryKeyFingerprint,
+            subkeyFingerprint: log.args.subkeyFingerprint,
+            openPGPMsg: log.args.openPGPMsg
+          };
+        case "KeyRevoked":
+          return {
+            ...baseLog,
+            type: Web3PGPEvents.KeyRevoked,
+            fingerprint: log.args.fingerprint,
+            revocationCertificate: log.args.revocationCertificate
+          };
+        case "KeyUpdated":
+          return {
+            ...baseLog,
+            type: Web3PGPEvents.KeyUpdated,
+            fingerprint: log.args.fingerprint,
+            openPGPMsg: log.args.openPGPMsg
+          };
+        case "OwnershipChallenged":
+          return {
+            ...baseLog,
+            type: Web3PGPEvents.OwnershipChallenged,
+            fingerprint: log.args.fingerprint,
+            challenge: log.args.challenge
+          };
+        case "OwnershipProved":
+          return {
+            ...baseLog,
+            type: Web3PGPEvents.OwnershipProved,
+            fingerprint: log.args.fingerprint,
+            challenge: log.args.challenge,
+            signature: log.args.signature
+          };
+        case "KeyCertified":
+          return {
+            ...baseLog,
+            type: Web3PGPEvents.KeyCertified,
+            fingerprint: log.args.fingerprint,
+            issuerFingerprint: log.args.issuer,
+            keyCertificate: log.args.keyCertificate
+          };
+        case "KeyCertificationRevoked":
+          return {
+            ...baseLog,
+            type: Web3PGPEvents.KeyCertificationRevoked,
+            fingerprint: log.args.fingerprint,
+            issuerFingerprint: log.args.issuer,
+            revocationSignature: log.args.revocationSignature
+          };
+        default:
+          throw new Error(`Unhandled event type: ${log.eventName}`);
+      }
+    });
+  }
+  /**
+   * Extract KeyRegistered event logs from a transaction receipt.
+   * @param receipt The transaction receipt to extract logs from.
+   * @returns An array of KeyRegisteredLog objects extracted from the receipt.
+   */
+  async extractKeyRegisteredLog(receipt) {
+    let parsedLogs = parseEventLogs({
+      abi: Web3PGP,
+      eventName: "KeyRegistered",
+      logs: receipt.logs
+    });
+    const uniqueBlocks = Array.from(new Set(parsedLogs.map((log) => log.blockNumber)));
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return parsedLogs.map((log) => ({
+      type: Web3PGPEvents.KeyRegistered,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      primaryKeyFingerprint: log.args.primaryKeyFingerprint,
+      subkeyFingerprints: log.args.subkeyFingerprints,
+      openPGPMsg: log.args.openPGPMsg
+    }));
+  }
+  /**
+   * Extract KeyUpdated event logs from a transaction receipt.
+   * @param receipt The transaction receipt to extract logs from.
+   * @returns An array of KeyUpdatedLog objects extracted from the receipt.
+   */
+  async extractKeyUpdatedLog(receipt) {
+    let parsedLogs = parseEventLogs({
+      abi: Web3PGP,
+      eventName: "KeyUpdated",
+      logs: receipt.logs
+    });
+    const uniqueBlocks = Array.from(new Set(parsedLogs.map((log) => log.blockNumber)));
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return parsedLogs.map((log) => ({
+      type: Web3PGPEvents.KeyUpdated,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      fingerprint: log.args.fingerprint,
+      openPGPMsg: log.args.openPGPMsg
+    }));
+  }
+  /**
+   * Extract SubkeyAdded event logs from a transaction receipt.
+   * @param receipt The transaction receipt to extract logs from.
+   * @returns An array of SubkeyAddedLog objects extracted from the receipt.
+   */
+  async extractSubkeyAddedLog(receipt) {
+    let parsedLogs = parseEventLogs({
+      abi: Web3PGP,
+      eventName: "SubkeyAdded",
+      logs: receipt.logs
+    });
+    const uniqueBlocks = Array.from(new Set(parsedLogs.map((log) => log.blockNumber)));
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return parsedLogs.map((log) => ({
+      type: Web3PGPEvents.SubkeyAdded,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      primaryKeyFingerprint: log.args.primaryKeyFingerprint,
+      subkeyFingerprint: log.args.subkeyFingerprint,
+      openPGPMsg: log.args.openPGPMsg
+    }));
+  }
+  /**
+   * Extract KeyRevoked event logs from a transaction receipt.
+   * @param receipt The transaction receipt to extract logs from.
+   * @returns An array of KeyRevokedLog objects extracted from the receipt.
+   */
+  async extractKeyRevokedLog(receipt) {
+    let parsedLogs = parseEventLogs({
+      abi: Web3PGP,
+      eventName: "KeyRevoked",
+      logs: receipt.logs
+    });
+    const uniqueBlocks = Array.from(new Set(parsedLogs.map((log) => log.blockNumber)));
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return parsedLogs.map((log) => ({
+      type: Web3PGPEvents.KeyRevoked,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      fingerprint: log.args.fingerprint,
+      revocationCertificate: log.args.revocationCertificate
+    }));
+  }
+  /**
+   * Extract OwnershipChallenged event logs from a transaction receipt.
+   * 
+   * @param receipt The transaction receipt to extract logs from.
+   * @returns An array of OwnershipChallengedLog objects extracted from the receipt.
+   */
+  async extractOwnershipChallengedLog(receipt) {
+    let parsedLogs = parseEventLogs({
+      abi: Web3PGP,
+      eventName: "OwnershipChallenged",
+      logs: receipt.logs
+    });
+    const uniqueBlocks = Array.from(new Set(parsedLogs.map((log) => log.blockNumber)));
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return parsedLogs.map((log) => ({
+      type: Web3PGPEvents.OwnershipChallenged,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      fingerprint: log.args.fingerprint,
+      challenge: log.args.challenge
+    }));
+  }
+  /**
+   * Extract OwnershipProved event logs from a transaction receipt.
+   * 
+   * @param receipt The transaction receipt to extract logs from.
+   * @returns An array of OwnershipProvedLog objects extracted from the receipt.
+   */
+  async extractOwnershipProvedLog(receipt) {
+    let parsedLogs = parseEventLogs({
+      abi: Web3PGP,
+      eventName: "OwnershipProved",
+      logs: receipt.logs
+    });
+    const uniqueBlocks = Array.from(new Set(parsedLogs.map((log) => log.blockNumber)));
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return parsedLogs.map((log) => ({
+      type: Web3PGPEvents.OwnershipProved,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      fingerprint: log.args.fingerprint,
+      challenge: log.args.challenge,
+      signature: log.args.signature
+    }));
+  }
+  /**
+   * Extract KeyCertified event logs from a transaction receipt.
+   * 
+   * @param receipt The transaction receipt to extract logs from.
+   * @returns An array of KeyCertifiedLog objects extracted from the receipt.
+   */
+  async extractKeyCertifiedLog(receipt) {
+    let parsedLogs = parseEventLogs({
+      abi: Web3PGP,
+      eventName: "KeyCertified",
+      logs: receipt.logs
+    });
+    const uniqueBlocks = Array.from(new Set(parsedLogs.map((log) => log.blockNumber)));
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return parsedLogs.map((log) => ({
+      type: Web3PGPEvents.KeyCertified,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      fingerprint: log.args.fingerprint,
+      issuerFingerprint: log.args.issuer,
+      keyCertificate: log.args.keyCertificate
+    }));
+  }
+  /**
+   * Extract KeyCertificationRevoked event logs from a transaction receipt.
+   * 
+   * @param receipt The transaction receipt to extract logs from.
+   * @returns An array of KeyCertificationRevokedLog objects extracted from the receipt.
+   */
+  async extractKeyCertificationRevokedLog(receipt) {
+    let parsedLogs = parseEventLogs({
+      abi: Web3PGP,
+      eventName: "KeyCertificationRevoked",
+      logs: receipt.logs
+    });
+    const uniqueBlocks = Array.from(new Set(parsedLogs.map((log) => log.blockNumber)));
+    const blockTimestamps = await this.getBlockTimestamps(uniqueBlocks);
+    return parsedLogs.map((log) => ({
+      type: Web3PGPEvents.KeyCertificationRevoked,
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      logIndex: log.logIndex,
+      transactionHash: log.transactionHash,
+      fingerprint: log.args.fingerprint,
+      issuerFingerprint: log.args.issuer,
+      revocationSignature: log.args.revocationSignature
+    }));
+  }
+  /*****************************************************************************************************************/
+  /* UTILITY FUNCTIONS                                                                                             */
+  /*****************************************************************************************************************/
+  /**
+   * Get the current block number of the connected blockchain.
+   * @return The current block number as a bigint.
+   */
+  getBlockNumber() {
+    return this.client.getBlockNumber();
+  }
+  /**
+   * Helper to efficiently fetch timestamps for a list of logs.
+   * Deduplicates block lookups to minimize RPC calls.
+   */
+  async getBlockTimestamps(blockNumbers) {
+    const uniqueBlocks = [...new Set(blockNumbers)];
+    return new Map(
+      await Promise.all(uniqueBlocks.map(
+        async (bn) => [bn, await getBlockTimestamp(this.client, bn)]
+      ))
+    );
+  }
+};
+_Web3PGP.abi = Web3PGP;
+// Pre-computed event definitions for efficient log queries
+_Web3PGP.KEY_REGISTERED_EVENT = Web3PGP.find((item) => item.type === "event" && item.name === "KeyRegistered");
+_Web3PGP.SUBKEY_ADDED_EVENT = Web3PGP.find((item) => item.type === "event" && item.name === "SubkeyAdded");
+_Web3PGP.KEY_REVOKED_EVENT = Web3PGP.find((item) => item.type === "event" && item.name === "KeyRevoked");
+_Web3PGP.KEY_UPDATED_EVENT = Web3PGP.find((item) => item.type === "event" && item.name === "KeyUpdated");
+_Web3PGP.OWNERSHIP_CHALLENGED_EVENT = Web3PGP.find((item) => item.type === "event" && item.name === "OwnershipChallenged");
+_Web3PGP.OWNERSHIP_PROVED_EVENT = Web3PGP.find((item) => item.type === "event" && item.name === "OwnershipProved");
+_Web3PGP.KEY_CERTIFIED_EVENT = Web3PGP.find((item) => item.type === "event" && item.name === "KeyCertified");
+_Web3PGP.KEY_CERTIFICATION_REVOKED_EVENT = Web3PGP.find((item) => item.type === "event" && item.name === "KeyCertificationRevoked");
+var Web3PGP2 = _Web3PGP;
+var OpenPGPUtils = class {
+  /**
+   * Verify the validity of an OpenPGP public key, including its primary key and all subkeys.
+   *
+   * This checks that the keys are properly signed, not expired and not revoked as of the given date.
+   *
+   * @param key The OpenPGP public key to verify
+   * @param date The date to verify against (defaults to now)
+   * @param config Optional OpenPGP configuration
+   * 
+   * @throws - Error if the primary key or any subkey is invalid
+   */
+  static async verifyKey(key, date, config) {
+    await key.verifyPrimaryKey(date, void 0, config);
+    for (const subkey of key.getSubkeys()) {
+      await subkey.verify(date, config);
+    }
+  }
+  /**
+   * Prepare a primary key for blockchain publication by creating a copy of its without
+   * private key material and subkeys. The resulting certificate contains only the primary
+   * key with its user IDs for identity verification.
+   *
+   * Can also be used to sanitize certificates retrieved from blockchain: The smart contract
+   * only validates fingerprint uniqueness but not OpenPGP certificate validity and content.
+   *
+   * @param key The key to prepare (can be private or public)
+   * @returns A sanitized primary key certificate ready for blockchain storage
+   */
+  static async sanitizePrimaryKey(key) {
+    const clonedKey = await openpgp2.readKey({ binaryKey: key.toPublic().write() });
+    clonedKey.subkeys = [];
+    return clonedKey;
+  }
+  /**
+   * Prepare a specific subkey for blockchain publication by isolating it and removing
+   * user IDs to prevent identity collisions.
+   * 
+   * @description
+   *
+   * The resulting certificate contains the primary key (for signature verification
+   * interoperability) plus exactly one subkey.
+   *
+   * This creates a "subkey certificate" that can be combined with the primary
+   * key certificate using key.update() for full key reconstruction.
+   *
+   * Can also be used to sanitize certificates retrieved from blockchain for security,
+   * as the smart contract only validates fingerprint uniqueness but not OpenPGP
+   * certificate validity. While cryptographic verification of subkeys provides
+   * inherent security, this sanitization ensures clean certificate reconstruction.
+   * 
+   * The function does not verify the subkey's validity (signatures, expiration, revocation).
+   *
+   * @param key The key containing the target subkey
+   * @param fingerprint The subkey fingerprint that will be padded (bytes32 format, with or without 0x prefix)
+   * @returns A sanitized subkey certificate ready for blockchain storage
+   * @throws - Error if the specified subkey fingerprint is not found
+   */
+  static async sanitizeSubkey(key, fingerprint) {
+    const targetFingerprint = toBytes32(to0x(fingerprint));
+    const publicKey = key.toPublic();
+    const targetSubkey = publicKey.subkeys.find(
+      (sub) => toBytes32(to0x(sub.getFingerprint())) === targetFingerprint
+    );
+    if (!targetSubkey) {
+      throw new Error(`No subkey with fingerprint ${fingerprint} found in the provided key`);
+    }
+    publicKey.subkeys = [targetSubkey];
+    return publicKey;
+  }
+  /**
+   * Check if a subkey is revoked by verifying its revocation certificates.
+   *
+   * @param sub The subkey to check
+   * @param primaryKey The primary key that may have issued the revocation
+   * @param date The date to check against (defaults to now)
+   * 
+   * @returns True if the subkey is revoked, false otherwise
+   */
+  static async isSubkeyRevoked(sub, primaryKey, date = /* @__PURE__ */ new Date()) {
+    if (primaryKey.getFingerprint() !== sub.mainKey.getFingerprint()) {
+      throw new Error("The provided primary key does not own the specified subkey");
+    }
+    if (await primaryKey.isRevoked(void 0, void 0, date)) {
+      return true;
+    }
+    if (sub.revocationSignatures.length === 0) {
+      return false;
+    }
+    const primaryPublicKey = primaryKey.toPublic();
+    for (const revocationSig of sub.revocationSignatures) {
+      try {
+        await revocationSig.verify(
+          primaryPublicKey.keyPacket,
+          // verification key
+          openpgp2.enums.signature.subkeyRevocation,
+          // signature type
+          { key: primaryPublicKey.keyPacket, bind: sub.keyPacket },
+          // subkey revocation context
+          date
+          // verification date
+        );
+        return true;
+      } catch (error) {
+        continue;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a key contains private key material, including subkeys.
+   * This checks for the presence of private keys regardless of whether the primary key
+   * has private material or only subkeys do.
+   * 
+   * @param key The key to check
+   * @returns True if the key or any subkey contains private key material, false otherwise
+   */
+  static containsPrivateKeyMaterial(key) {
+    if (key.isPrivate()) {
+      return true;
+    } else {
+      for (const subkey of key.getSubkeys()) {
+        if (subkey.keyPacket instanceof openpgp2.SecretSubkeyPacket) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * List all fingerprints of keys that contain private key material.
+   * Includes the primary key if it has private material, and any subkeys with private material.
+   * 
+   * @param key The key to analyze
+   * @returns Array of fingerprints for keys containing private material
+   */
+  static listPrivateKeyFingerprints(key) {
+    const fingerprints = [];
+    if (key.isPrivate()) {
+      fingerprints.push(key.getFingerprint());
+    }
+    for (const subkey of key.getSubkeys()) {
+      if (subkey.keyPacket instanceof openpgp2.SecretSubkeyPacket) {
+        fingerprints.push(subkey.getFingerprint());
+      }
+    }
+    return fingerprints;
+  }
+  /**
+   * List all fingerprints of a key, including subkeys
+   * 
+   * @param key The key to list fingerprints from
+   * @returns An array of fingerprints
+   */
+  static listAllFingerprints(key) {
+    return [key.getFingerprint(), ...key.getSubkeys().map((sub) => sub.getFingerprint())];
+  }
+};
+var Web3PGPServiceError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Web3PGPServiceError";
+  }
+};
+var Web3PGPServiceCriticalError = class extends Web3PGPServiceError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "Web3PGPServiceCriticalError";
+  }
+};
+var Web3PGPServiceValidationError = class extends Web3PGPServiceError {
+  constructor(message) {
+    super(message);
+    this.name = "Web3PGPServiceValidationError";
+  }
+};
+var Web3PGPService = class {
+  /**
+   * Create a new Web3PGPService instance.
+   * 
+   * @param web3pgp The low-level Web3PGP contract instance to use for blockchain interactions
+   * 
+   * @example
+   * ```typescript
+   * import { Web3PGP } from './web3pgp';
+   * import { Web3PGPService } from './web3pgp.service';
+   * 
+   * const web3pgp = new Web3PGP(contractAddress, publicClient, walletClient);
+   * const service = new Web3PGPService(web3pgp);
+   * 
+   * // Now use the high-level service
+   * const receipt = await service.register(publicKey);
+   * ```
+   */
+  constructor(web3pgp, options) {
+    this.web3pgp = web3pgp;
+    this.concurrencyLimit = pLimit(options?.concurrencyLimit ?? 10);
+  }
+  /**
+   * Get the underlying Web3PGP contract instance.
+   * 
+   * @returns The low-level Web3PGP contract instance
+   * 
+   * @remarks
+   * Exposed for advanced use cases where direct contract access is needed.
+   */
+  get contract() {
+    return this.web3pgp;
+  }
+  /*****************************************************************************************************************/
+  /* WRITE OPERATIONS                                                                                              */
+  /*****************************************************************************************************************/
+  /**
+   * Register a new OpenPGP public key (primary key with optional subkeys) on the blockchain.
+   * 
+   * @description
+   * This method:
+   * 1. Verifies the provided public key and subkeys have a valid signature, are not expired and not revoked.
+   * 2. Extracts the primary key fingerprint and subkey fingerprints
+   * 3. Ensures the key and its subkeys are not registered on-chain (enforced by smart contract).
+   * 4. Serializes the key into the OpenPGP binary format.
+   * 5. Registers the key on-chain via the Web3PGP contract
+   * 
+   * @param key The OpenPGP public key to register (may include subkeys)
+   * @returns Transaction receipt after successful registration
+   * 
+   * @throws Error if the key or one of its subkeys are invalid
+   * @throws Error if the key or one of its subkeys are already registered on-chain
+   * @throws Error if wallet client is not configured
+   * @throws Error if transaction fails
+   * 
+   * @example
+   * ```typescript
+   * const armoredKey = '-----BEGIN PGP PUBLIC KEY BLOCK-----...';
+   * const publicKey = await openpgp.readKey({ armoredKey });
+   * const receipt = await service.register(publicKey);
+   * console.log(`Key registered at block ${receipt.blockNumber}`);
+   * ```
+   */
+  async register(key) {
+    try {
+      await OpenPGPUtils.verifyKey(key, /* @__PURE__ */ new Date());
+      return this.web3pgp.register(
+        toBytes32(to0x(key.getFingerprint())),
+        key.subkeys.map((subkey) => toBytes32(to0x(subkey.getFingerprint()))),
+        toHex(key.toPublic().write())
+      );
+    } catch (err) {
+      throw new Web3PGPServiceError(`Failed to register the OpenPGP key: ${err}`);
+    }
+  }
+  /**
+   * Update an existing OpenPGP public key on the blockchain to add or revoke user ID packets,
+   * change preferences or update key expiration.
+   * 
+   * @description
+   * This method:
+   * 1. Verifies the provided public key has a valid signature, is not expired and is not revoked.
+   * 2. Prunes subkeys from the key (isolating the primary key for metadata updates).
+   * 3. Extracts the primary key fingerprint.
+   * 4. Ensures the key is registered on-chain (enforced by smart contract).
+   * 5. Serializes the key into the OpenPGP binary format.
+   * 6. Calls the update function of the Web3PGP contract to store the updated key on-chain.
+   * 
+   * @param key The OpenPGP public key to update (must include primary key).
+   * @returns Transaction receipt after successful update.
+   * 
+   * @throws Error if the key is invalid.
+   * @throws Error if the key is not already registered on-chain.
+   * @throws Error if wallet client is not configured.
+   * @throws Error if the transaction fails.
+   * 
+   * @example
+   * ```typescript
+   * const armoredKey = '-----BEGIN PGP PUBLIC KEY BLOCK-----...';
+   * const publicKey = await openpgp.readKey({ armoredKey });
+   * const receipt = await service.update(publicKey);
+   * console.log(`Key updated at block ${receipt.blockNumber}`);
+   * ```
+   */
+  async update(key) {
+    try {
+      const pk = await OpenPGPUtils.sanitizePrimaryKey(key);
+      await OpenPGPUtils.verifyKey(key, /* @__PURE__ */ new Date());
+      return this.web3pgp.update(
+        toBytes32(to0x(pk.getFingerprint())),
+        toHex(pk.toPublic().write())
+      );
+    } catch (err) {
+      throw new Web3PGPServiceError(`Failed to update the OpenPGP key: ${err}`);
+    }
+  }
+  /**
+   * Add a new subkey to a primary key registered on the blockchain.
+   * 
+   * This method:
+   * 1. Validates the provided key contains the specified subkey
+   * 2. Removes extra subkeys.
+   * 3. Verifies the primary key is registered on-chain (enforced by smart contract)
+   * 4. Verifies the subkey is not registered on-chain (enforced by smart contract)
+   * 5. Extracts the primary key fingerprint
+   * 6. Verifies the provided key and subkey have valid signatures, are not expired and not revoked.
+   * 7. Serializes the key and its subkey into the OpenPGP binary format.
+   * 8. Adds the subkey on-chain via the Web3PGP contract
+   * 
+   * @param key The OpenPGP public key containing both the primary key and the new subkey
+   * @param subkeyFingerprint The fingerprint of the specific subkey to add (must exist in the key)
+   * @returns Transaction receipt after successful subkey addition
+   * 
+   * @throws Error if the key is invalid or doesn't contain the specified subkey
+   * @throws Error if the primary key is not registered on-chain
+   * @throws Error if the subkey is already registered on-chain
+   * @throws Error if wallet client is not configured
+   * @throws Error if transaction fails
+   * 
+   * @example
+   * ```typescript
+   * const armoredKey = '-----BEGIN PGP PUBLIC KEY BLOCK-----...';
+   * const publicKey = await openpgp.readKey({ armoredKey });
+   * const subkeyFp = '0x' + publicKey.subkeys[0].getFingerprint();
+   * const receipt = await service.addSubkey(publicKey, subkeyFp);
+   * ```
+   */
+  async addSubkey(key, subkeyFingerprint) {
+    try {
+      const pk = await OpenPGPUtils.sanitizeSubkey(key, subkeyFingerprint);
+      const sk = pk.getSubkeys()[0];
+      const now = /* @__PURE__ */ new Date();
+      await OpenPGPUtils.verifyKey(pk, now);
+      return this.web3pgp.addSubkey(
+        toBytes32(to0x(pk.getFingerprint())),
+        toBytes32(to0x(subkeyFingerprint)),
+        toHex(pk.toPublic().write())
+      );
+    } catch (err) {
+      throw new Web3PGPServiceError(`Failed to add the subkey: ${err}`);
+    }
+  }
+  /**
+   * Publish a key revocation certificate on the blockchain.
+   * 
+   * @description
+   * This method allows users who have revoked their key using standard OpenPGP tools to publish the key revocation
+   * certificate on-chain and inform others that the key is no longer valid.
+   * 
+   * The method accepts either a key object with the revocation signature or a standalone revocation certificate 
+   * in armored format. In the later case, the method will download and verify the public key from the blockchain 
+   * using the provided fingerprint as ID, apply the revocation certificate, verify the key is revoked at present time
+   * and publish the revoked key on-chain.
+   * 
+   * When a revoked key is provided, the method will verify the target key or subkey, identified by the provided 
+   * fingerprint, is indeed revoked in the key object at the present time and will publish the revoked key on-chain. 
+   * 
+   * @param keyOrCertificate The revoked OpenPGP public key or a revocation certificate
+   * @param fingerprint The fingerprint of the key being revoked (primary key or subkey)
+   * @returns Transaction receipt after successful revocation publication
+   * 
+   * @throws Error if the key doesn't contain a valid revocation signature at the present time
+   * @throws Error if the fingerprint doesn't match any key in the provided key object
+   * @throws Error if the target key is not registered on-chain
+   * @throws Error if wallet client is not configured
+   * @throws Error if transaction fails
+   * 
+   * @example
+   * ```typescript
+   * // After revoking the key with OpenPGP tools
+   * const revokedKey = await openpgp.readKey({ armoredKey: revokedArmoredKey });
+   * const fingerprint = '0x' + revokedKey.getFingerprint();
+   * const receipt = await service.revoke(revokedKey, fingerprint);
+   * ```
+   */
+  async revoke(keyOrCertificate, fingerprint) {
+    if (typeof keyOrCertificate === "string") {
+      return this.revokeWithCertificate(keyOrCertificate, fingerprint);
+    } else {
+      return this.revokeWithKey(keyOrCertificate, fingerprint);
+    }
+  }
+  /**
+   * Revoke a key or subkey using a key object containing the revocation signature.
+   * 
+   * The method will verify the target key or subkey, identified by the provided fingerprint, is indeed revoked
+   * in the key object at the present time and publish the revoked key on-chain.
+   * 
+   * @param key The OpenPGP public key containing the revocation signature 
+   * @param fingerprint The fingerprint of the key being revoked
+   * @returns Transaction receipt after successful revocation publication
+   */
+  async revokeWithKey(key, fingerprint) {
+    const normalizedFingerprint = toBytes32(to0x(fingerprint));
+    if (toBytes32(to0x(key.getFingerprint())) === normalizedFingerprint) {
+      const revoked = await OpenPGPUtils.sanitizePrimaryKey(key);
+      if (await revoked.isRevoked()) {
+        return this.web3pgp.revoke(normalizedFingerprint, toHex(revoked.toPublic().write()));
+      } else {
+        throw new Web3PGPServiceValidationError("The provided key does not contain a valid revocation signature.");
+      }
+    } else {
+      const pk = await OpenPGPUtils.sanitizeSubkey(key, fingerprint);
+      if (await OpenPGPUtils.isSubkeyRevoked(
+        pk.subkeys[0],
+        // We are sure this exists from sanitizeSubkey
+        key
+      )) {
+        return this.web3pgp.revoke(normalizedFingerprint, toHex(pk.toPublic().write()));
+      } else {
+        throw new Web3PGPServiceValidationError("The specified subkey does not contain a valid revocation signature.");
+      }
+    }
+  }
+  /**
+   * Revoke a key or subkey using a standalone revocation certificate.
+   * 
+   * The method will download and verify the public key from the blockchain using the provided fingerprint as ID,
+   * apply the revocation certificate, verify the key is revoked at present time and publish the revoked key on-chain.
+   * 
+   * @param certificate The armored revocation certificate
+   * @param fingerprint The fingerprint of the key being revoked
+   * @returns Transaction receipt after successful revocation publication
+   */
+  async revokeWithCertificate(certificate, fingerprint) {
+    const normalizedFingerprint = toBytes32(to0x(fingerprint));
+    const publicKey = await this.getPublicKey(normalizedFingerprint);
+    const revocationCheckDate = /* @__PURE__ */ new Date();
+    const revoked = await openpgp2.revokeKey({
+      key: publicKey,
+      revocationCertificate: certificate,
+      date: revocationCheckDate,
+      // To be explicit
+      format: "object"
+    });
+    if (toBytes32(to0x(revoked.publicKey.getFingerprint())) === normalizedFingerprint) {
+      const pk = await OpenPGPUtils.sanitizePrimaryKey(revoked.publicKey);
+      if (await pk.isRevoked()) {
+        return this.web3pgp.revoke(normalizedFingerprint, toHex(pk.toPublic().write()));
+      } else {
+        throw new Web3PGPServiceValidationError("The provided key does not contain a valid revocation signature.");
+      }
+    } else {
+      const pk = await OpenPGPUtils.sanitizeSubkey(revoked.publicKey, normalizedFingerprint);
+      if (await OpenPGPUtils.isSubkeyRevoked(pk.subkeys[0], pk, revocationCheckDate)) {
+        return this.web3pgp.revoke(normalizedFingerprint, toHex(pk.write()));
+      } else {
+        throw new Web3PGPServiceValidationError("The specified subkey does not contain a valid revocation signature.");
+      }
+    }
+  }
+  /**
+   * Initiate a challenge to prove ownership of an OpenPGP key registered on-chain.
+   * 
+   * This method submits a hash of a random challenge generated by the user to the blockchain. The owner
+   * of the private key corresponding to the public key must later sign the original challenge off-chain
+   * and submit the signature using the `proveOwnership` method to complete the ownership proof process.
+   * 
+   * @param fingerprint The fingerprint of the key to challenge ownership for (primary key or subkey)
+   * @param challengeHash The keccak256 hash of the random challenge generated and hashed by the user (32 bytes hex string)
+   * @returns Transaction receipt after successful challenge submission
+   * 
+   * @throws Error if the key is not registered on-chain
+   * @throws Error if wallet client is not configured
+   * @throws Error if transaction fails
+   */
+  async challengeOwnership(fingerprint, challengeHash) {
+    return this.web3pgp.challengeOwnership(fingerprint, challengeHash);
+  }
+  /**
+   * Prove ownership of an OpenPGP key by submitting a signature of a previously issued challenge.
+   * 
+   * This method verifies the provided signature against the challenge associated with the specified
+   * key fingerprint on-chain. If the signature is valid, ownership is proven.
+   * 
+   * The method:
+   * 1. Fetches the up-to-date public key from the blockchain using the provided fingerprint
+   * 2. Verifies the signature of the challenge (the bytes of the hash) using the public key
+   * 3. Submits the ownership proof on-chain via the Web3PGP contract
+   * 
+   * @param fingerprint The fingerprint of the key to prove ownership for (primary key or subkey)
+   * @param challengeHash The keccak256 hash of the original challenge that was issued
+   * @param signature The signature of the challenge created using the private key corresponding to the public key
+   * @returns Transaction receipt after successful ownership proof submission
+   * 
+   * @throws Error if the key is not registered on-chain
+   * @throws Error if the signature is invalid or the key is revoked or expired at present time
+   * @throws Error if wallet client is not configured
+   * @throws Error if transaction fails
+   */
+  async proveOwnership(fingerprint, challengeHash, signature) {
+    try {
+      const publicKey = await this.getPublicKey(fingerprint);
+      const verificationResult = await openpgp2.verify({
+        message: await openpgp2.createMessage({ binary: toBytes(challengeHash) }),
+        verificationKeys: publicKey,
+        signature
+      });
+      let isValid = false;
+      for (const sig of verificationResult.signatures) {
+        try {
+          await sig.verified;
+          isValid = true;
+          break;
+        } catch (e) {
+          console.debug(`[WEB3PGP SERVICE] Invalid ownership proof signature found and skipped: ${e}`);
+        }
+      }
+      if (!isValid) {
+        throw new Web3PGPServiceValidationError("The provided signature is invalid.");
+      }
+      return this.web3pgp.proveOwnership(fingerprint, challengeHash, toHex(signature.write()));
+    } catch (err) {
+      throw new Web3PGPServiceError(`Failed to prove ownership of the OpenPGP key: ${err}`);
+    }
+  }
+  /**
+   * Publish a third-party certification of an OpenPGP key on the blockchain.
+   * 
+   * This method allows a user (the issuer) to certify another user's OpenPGP public key by publishing
+   * the certification on-chain. The certified key is an OpenPGP public key that contains a certification
+   * signature made by the issuer over the target key.
+   * 
+   * @description
+   * This method:
+   * 1. Verifies the target key is registered on-chain (enforced by smart contract)
+   * 2. Extracts and verifies the certification signature in the certified key
+   * 3. Serializes the certified key into the OpenPGP binary format.
+   * 4. Publishes the certification on-chain via the Web3PGP contract.
+   * 
+   * @param issuer The OpenPGP public key of the issuer certifying the target key
+   * @param certifiedKey The public key containing the certification signature made by the issuer
+   * @returns Transaction receipt after successful certification publication
+   * 
+   * @throws Error if the target key is not registered on-chain
+   * @throws Error if the fingerprint doesn't match the fingerprint of the primary key
+   * @throws Error if the certification signature is invalid or not made by the issuer
+   * @throws Error if wallet client is not configured
+   * @throws Error if transaction fails
+   */
+  async certify(issuer, certifiedKey) {
+    try {
+      if (issuer.getFingerprint() === certifiedKey.getFingerprint()) {
+        throw new Web3PGPServiceValidationError("The issuer key must be different from the certified key.");
+      }
+      const pk = await OpenPGPUtils.sanitizePrimaryKey(certifiedKey);
+      let hasValidCertification = false;
+      for (const user of pk.users) {
+        console.debug(`[WEB3PGP SERVICE] Verifying ${user.otherCertifications.length} certifications for user ID "${user.userID?.toString()}"...`);
+        const validCertifications = [];
+        for (const cert of user.otherCertifications) {
+          try {
+            console.debug(`[WEB3PGP SERVICE] Verifying certification made by ${cert.issuerFingerprint ? toHex(cert.issuerFingerprint) : cert.issuerKeyID.toHex()}...`);
+            const verified = await user.verifyCertificate(cert, [issuer]);
+            if (verified) {
+              validCertifications.push(cert);
+              hasValidCertification = true;
+            } else {
+              console.debug(`[WEB3PGP SERVICE] Invalid certification signature found and skipped.`);
+            }
+          } catch (e) {
+            console.debug(`[WEB3PGP SERVICE] Invalid certification signature found and skipped: ${e}`);
+          }
+        }
+        user.otherCertifications = validCertifications;
+      }
+      if (!hasValidCertification) {
+        throw new Web3PGPServiceValidationError("The certified key does not contain a valid certification signature made by the issuer.");
+      }
+      pk.users = pk.users.filter((user) => user.otherCertifications.length > 0);
+      return this.web3pgp.certifyKey(
+        toBytes32(to0x(pk.getFingerprint())),
+        toBytes32(to0x(issuer.getFingerprint())),
+        toHex(pk.toPublic().write())
+      );
+    } catch (err) {
+      throw new Web3PGPServiceError(`Failed to certify the OpenPGP key: ${err}`);
+    }
+  }
+  /**
+   * Revoke a third-party certification of an OpenPGP key on the blockchain.
+   * 
+   * This method allows a user (the issuer) to revoke a previously published certification of another user's
+   * OpenPGP public key by publishing a revocation on-chain. The revoked key is an OpenPGP public key that
+   * contains a revocation signature made by the issuer over the target key.
+   * 
+   * @description
+   * This method:
+   * 1. Verifies the target key is registered on-chain (enforced by smart contract)
+   * 2. Extracts and verifies the revoked third-party signature in the key.
+   * 3. Serializes the certified key into the OpenPGP binary format.
+   * 4. Publishes the certification revocation on-chain via the Web3PGP contract.
+   * 
+   * @param issuer The OpenPGP public key of the issuer revoking the certification
+   * @param keyWithRevokedCertification The public key containing the revocation signature made by the issuer
+   * @returns Transaction receipt after successful revocation publication
+   * 
+   * @throws Error if the target key is not registered on-chain
+   * @throws Error if the fingerprint doesn't match the fingerprint of the primary key
+   * @throws Error if the revocation signature is invalid or not made by the issuer
+   * @throws Error if wallet client is not configured
+   * @throws Error if transaction fails
+   */
+  async revokeCertification(issuer, keyWithRevokedCertification) {
+    try {
+      if (issuer.getFingerprint() === keyWithRevokedCertification.getFingerprint()) {
+        throw new Web3PGPServiceValidationError("Issuer must be different from the target key.");
+      }
+      const now = /* @__PURE__ */ new Date();
+      const pk = keyWithRevokedCertification;
+      let hasValidRevocation = false;
+      for (const user of pk.users) {
+        console.debug(`[WEB3PGP SERVICE] Verifying ${user.revocationSignatures.length}  revocation signatures for user ID "${user.userID?.toString()}"...`);
+        const revokedCertifications = [];
+        const validRevocations = [];
+        for (const revSig of user.revocationSignatures) {
+          try {
+            const issuerKeyPacket = issuer.getKeys().find((k) => k.getKeyID().equals(revSig.issuerKeyID));
+            if (!issuerKeyPacket) {
+              throw new Web3PGPServiceValidationError(`Issuer key packet with Key ID ${revSig.issuerKeyID.toHex()} not found in issuer key.`);
+            }
+            console.debug(`[WEB3PGP SERVICE] Verifying revocation signature made by ${revSig.issuerFingerprint ? toHex(revSig.issuerFingerprint) : revSig.issuerKeyID.toHex()}...`);
+            console.debug(`[WEB3PGP SERVICE] Valid revocation signature found.`);
+            validRevocations.push(revSig);
+            hasValidRevocation = true;
+          } catch (e) {
+            console.debug(`[WEB3PGP SERVICE] Invalid revocation signature found and skipped: ${e}`);
+            continue;
+          }
+        }
+        for (const cert of user.otherCertifications) {
+          for (const revSig of validRevocations) {
+            if (cert.issuerKeyID.equals(revSig.issuerKeyID)) {
+              cert.revoked = cert.revoked || (cert.created || now) <= (revSig.created || now);
+              if (cert.revoked) {
+                revokedCertifications.push(cert);
+                break;
+              }
+            }
+          }
+        }
+        user.revocationSignatures = validRevocations;
+        user.otherCertifications = revokedCertifications;
+      }
+      if (!hasValidRevocation) {
+        throw new Web3PGPServiceValidationError("No valid certification revocation signature made by the issuer was found on the target key.");
+      }
+      return this.web3pgp.revokeCertification(
+        toBytes32(to0x(pk.getFingerprint())),
+        toBytes32(to0x(issuer.getFingerprint())),
+        toHex(pk.toPublic().write())
+      );
+    } catch (err) {
+      throw new Web3PGPServiceError(`Failed to revoke certification: ${err}`);
+    }
+  }
+  /*****************************************************************************************************************/
+  /* LOG VALIDATION AND EXTRACTION FUNCTIONS                                                                       */
+  /*****************************************************************************************************************/
+  /**
+   * Validate and extract the public key from a KeyRegisteredLog event.
+   * 
+   * @description
+   * 
+   * This method:
+   * 1.   Validates the log data contains required fields
+   * 2.   Extracts and parses the OpenPGP message from the log
+   * 3.   Verifies the primary key fingerprint matches the declared one
+   * 4.   (if verifications are enabled) Verifies the primary key has a valid signature, is not expired and is not 
+   *      revoked at the time of registration (uses the block timestamp)..
+   * 5.   Validates all declared subkeys are present in the key
+   * 6.   (if verifications are enabled) Verifies each subkey has a valid signature, is not expired and is not 
+   *      revoked at the time of registration (uses the block timestamp).
+   * 7.   Prunes any extra subkeys not declared in the log
+   * 
+   * Cryptographic verifications of the keys (steps 4 and 6) can be skipped by setting the `skipCryptographicVerifications`
+   * parameter to true. This is useful when users want to extract and parse the OpenPGP key material in order to perform
+   * custom validations or inspections in case the verification fails, is expected to fail or is performed by an external
+   * OpenPGP toolkit.
+   * 
+   * @param log The KeyRegisteredLog event data from the blockchain
+   * @param skipCryptographicVerifications If true, skips cryptographic verifications of key and subkeys. Defaults to false.
+   * @returns The validated OpenPGP public key extracted from the log
+   * 
+   * @throws Web3PGPServiceValidationError if the log data is invalid or missing required fields
+   * @throws Web3PGPServiceValidationError if the extracted OpenPGP message is invalid or corrupted
+   * @throws Web3PGPServiceValidationError if the primary key fingerprint does not match the log data
+   * @throws Web3PGPServiceValidationError if any declared subkey is missing from the extracted key
+   * 
+   * @example
+   * ```typescript
+   * const logs = await web3pgp.searchKeyRegisteredLogs();
+   * for (const log of logs) {
+   *   try {
+   *     const publicKey = await service.extractFromKeyRegisteredLog(log);
+   *     console.log(`Valid key: ${publicKey.getFingerprint()}`);
+   *   } catch (err) {
+   *     console.warn(`Invalid log data: ${err.message}`);
+   *   }
+   * }
+   * ```
+   */
+  async extractFromKeyRegisteredLog(log, skipCryptographicVerifications) {
+    try {
+      if (!log.openPGPMsg || !log.primaryKeyFingerprint) {
+        throw new Web3PGPServiceValidationError(`The KeyRegisteredLog event is missing the data needed to extract and validate the public key.`);
+      }
+      const primaryKey = await openpgp2.readKey({ binaryKey: toBytes(log.openPGPMsg) });
+      if (skipCryptographicVerifications !== true) {
+        await primaryKey.verifyPrimaryKey(log.blockTimestamp);
+      }
+      if (toBytes32(to0x(primaryKey.getFingerprint())) !== toBytes32(to0x(log.primaryKeyFingerprint))) {
+        throw new Web3PGPServiceValidationError(`The fingerprint of the retrieved primary key does not match the declared fingerprint in the KeyRegisteredLog event.`);
+      }
+      let subkeys = [];
+      for (const subkeyFingerprint of log.subkeyFingerprints || []) {
+        const normalizedSubkeyFingerprint = toBytes32(to0x(subkeyFingerprint));
+        const subkey = primaryKey.subkeys.find((sk) => toBytes32(to0x(sk.getFingerprint())) === normalizedSubkeyFingerprint);
+        if (subkey) {
+          if (skipCryptographicVerifications !== true) {
+            await subkey.verify(log.blockTimestamp);
+          }
+          subkeys.push(subkey);
+        } else {
+          throw new Web3PGPServiceValidationError(`The primary key does not contain the declared subkey with fingerprint ${subkeyFingerprint} from the KeyRegisteredLog event.`);
+        }
+      }
+      primaryKey.subkeys = subkeys;
+      console.debug(`[Web3PGP - Service] Successfully extracted primary key ${log.primaryKeyFingerprint} with ${subkeys.length} subkeys from KeyRegisteredLog event`);
+      return primaryKey.toPublic();
+    } catch (err) {
+      if (err instanceof Web3PGPServiceValidationError) {
+        throw err;
+      }
+      throw new Web3PGPServiceValidationError(`Failed to read the OpenPGP message from the KeyRegisteredLog event: ${err}`);
+    }
+  }
+  /**
+   * Validate and extract the subkey from a SubkeyAddedLog event.
+   * 
+   * @description
+   * This method:
+   * 1. Validates the log data contains required fields
+   * 2. Extracts and parses the OpenPGP message from the log
+   * 3. Verifies the primary key fingerprint matches the declared one
+   * 4. Verifies the subkey fingerprint matches the declared one
+   * 5. Prunes any extra subkeys and user ID packets, returning only the primary key and the added subkey
+   * 6. (if verifications are enabled) Verifies the primary key has a valid signature, is not expired and is not 
+   *    revoked at the time of subkey addition (uses the block timestamp).
+   * 7. (if verifications are enabled) Verifies the subkey has a valid signature, is not expired and is not 
+   *    revoked at the time of addition (uses the block timestamp).
+   * 
+   * Cryptographic verifications of the keys (steps 6 and 7) can be skipped by setting the `skipCryptographicVerifications`
+   * parameter to true. This is useful when users want to extract and parse the OpenPGP key material in order to perform
+   * custom validations or inspections in case the verification fails, is expected to fail or is performed by an external
+   * OpenPGP toolkit.
+   * 
+   * @param log The SubkeyAddedLog event data from the blockchain
+   * @param skipCryptographicVerifications If true, skips cryptographic verifications of key and subkey. Defaults to false.
+   * @returns The validated OpenPGP public key containing the primary key and the added subkey
+   * 
+   * @throws Web3PGPServiceValidationError if the log data is invalid or missing required fields
+   * @throws Web3PGPServiceValidationError if the extracted OpenPGP message is invalid or corrupted
+   * @throws Web3PGPServiceValidationError if the primary key fingerprint does not match the log data
+   * @throws Web3PGPServiceValidationError if the subkey is missing from the extracted key
+   * 
+   * @example
+   * ```typescript
+   * const logs = await web3pgp.searchSubkeyAddedLogs(primaryFingerprint);
+   * let primaryKey = await service.getPublicKey(primaryFingerprint);
+   * for (const log of logs) {
+   *   const subkey = await service.extractFromSubkeyAddedLog(log);
+   *   primaryKey = await primaryKey.update(subkey);
+   * }
+   * ```
+   */
+  async extractFromSubkeyAddedLog(log, skipCryptographicVerifications) {
+    try {
+      let pk;
+      try {
+        pk = await openpgp2.readKey({ binaryKey: toBytes(log.openPGPMsg) });
+        pk = await OpenPGPUtils.sanitizeSubkey(pk, log.subkeyFingerprint);
+        if (skipCryptographicVerifications !== true) {
+          await OpenPGPUtils.verifyKey(pk, log.blockTimestamp);
+        }
+      } catch (err) {
+        throw new Web3PGPServiceValidationError(`Failed to read and sanitize the OpenPGP message for subkey with fingerprint ${log.subkeyFingerprint} from SubkeyAddedLog event: ${err}`);
+      }
+      if (toBytes32(to0x(pk.getFingerprint())) !== toBytes32(to0x(log.primaryKeyFingerprint))) {
+        throw new Web3PGPServiceValidationError(`The primary key fingerprint ${pk.getFingerprint()} does not match the declared primary key fingerprint ${log.primaryKeyFingerprint} in SubkeyAddedLog event.`);
+      }
+      return pk.toPublic();
+    } catch (err) {
+      if (err instanceof Web3PGPServiceValidationError) {
+        throw err;
+      }
+      throw new Web3PGPServiceValidationError(`Failed to read the OpenPGP message from the SubkeyAddedLog event: ${err}`);
+    }
+  }
+  /**
+   * Validate and extract the revoked key or revocation certificate from a KeyRevokedLog event.
+   * 
+   * @description
+   * This method handles two types of revocation data:
+   * 1. Key certificates: Full OpenPGP keys with revocation signatures
+   * 2. Standalone revocation certificates: Revocation signature packets only
+   * 
+   * The method:
+   * 1.   Validates the log data contains required fields
+   * 2.   Attempts to parse as a key certificate first
+   * 3.   If that fails, attempts to parse as a standalone revocation certificate and returns the armored certificate.
+   *      It is the user's responsibility to verify and apply the revocation certificate to the target key.
+   * 4. For key certificates, validates the fingerprint matches the target key
+   * 5. (if verifications are enabled) Verifies the primary key has a valid signature, is not expired and is revoked
+   *    at the time of revocation (uses the block timestamp).
+   * 6. Returns either the revoked key or the armored revocation certificate
+   * 
+   * @param log The KeyRevokedLog event data from the blockchain
+   * @param skipCryptographicVerifications If true, skips cryptographic verifications of the revoked key. Defaults to false.
+   * @returns A tuple containing either:
+   *   - [revokedKey, undefined] if a valid key certificate was found
+   *   - [undefined, armoredCert] if a standalone revocation certificate was found
+   * 
+   * @throws Web3PGPServiceValidationError if the log data is invalid or missing required fields
+   * @throws Web3PGPServiceValidationError if the extracted OpenPGP message is invalid or corrupted
+   * @throws Web3PGPServiceValidationError if a key certificate does not effectively revoke the target key
+   * 
+   * @example
+   * ```typescript
+   * const logs = await web3pgp.searchKeyRevokedLogs(fingerprint);
+   * let publicKey = await service.getPublicKey(fingerprint);
+   * for (const log of logs) {
+   *   const [revokedKey, revocationCert] = await service.extractFromKeyRevokedLog(log);
+   *   if (revokedKey) {
+   *     publicKey = await publicKey.update(revokedKey);
+   *   } else if (revocationCert) {
+   *     const result = await openpgp.revokeKey({ 
+   *       key: publicKey, 
+   *       revocationCertificate: revocationCert 
+   *     });
+   *     publicKey = result.publicKey;
+   *   }
+   * }
+   * ```
+   */
+  async extractFromKeyRevokedLog(log, skipCryptographicVerifications) {
+    try {
+      if (!log.fingerprint || !log.revocationCertificate) {
+        throw new Web3PGPServiceValidationError(`The KeyRevokedLog event is missing the data needed to extract and validate the revocation.`);
+      }
+      let revokedKey;
+      try {
+        revokedKey = await openpgp2.readKey({ binaryKey: toBytes(log.revocationCertificate) });
+      } catch (err) {
+        const cert = await openpgp2.readMessage({
+          binaryMessage: toBytes(log.revocationCertificate),
+          config: {
+            // Standalone revocation certs do not have public keys needed to verify the revocations signature
+            // This causes OpenPGP.js to throw an error unless we allow unauthenticated messages
+            allowMissingKeyFlags: true,
+            allowUnauthenticatedMessages: true
+          }
+        });
+        console.debug(`[Web3PGP - Service] Successfully extracted revocation certificate for key ${log.fingerprint} from KeyRevokedLog event`);
+        return [void 0, cert.armor()];
+      }
+      if (toBytes32(to0x(revokedKey.getFingerprint())) === toBytes32(to0x(log.fingerprint))) {
+        const pk = await OpenPGPUtils.sanitizePrimaryKey(revokedKey);
+        if (skipCryptographicVerifications !== true && !await pk.isRevoked(void 0, void 0, log.blockTimestamp)) {
+          throw new Web3PGPServiceValidationError(`The primary key with fingerprint ${pk.getFingerprint()} is not revoked as expected in the KeyRevokedLog event.`);
+        }
+        console.debug(`[Web3PGP - Service] Successfully extracted revocation for primary key ${log.fingerprint} from KeyRevokedLog event`);
+        return [pk.toPublic(), void 0];
+      } else {
+        const pk = await OpenPGPUtils.sanitizeSubkey(revokedKey, log.fingerprint);
+        if (skipCryptographicVerifications !== true && !await OpenPGPUtils.isSubkeyRevoked(pk.subkeys[0], pk, log.blockTimestamp)) {
+          throw new Web3PGPServiceValidationError(`The subkey with fingerprint ${log.fingerprint} is not revoked as expected in the KeyRevokedLog event.`);
+        }
+        console.debug(`[Web3PGP - Service] Successfully extracted revocation for subkey ${log.fingerprint} from KeyRevokedLog event`);
+        return [pk.toPublic(), void 0];
+      }
+    } catch (err) {
+      if (err instanceof Web3PGPServiceValidationError) {
+        throw err;
+      }
+      throw new Web3PGPServiceValidationError(`Failed to read the OpenPGP message from the KeyRevokedLog event: ${err}`);
+    }
+  }
+  /**
+  * Validate and extract the updated public key from a KeyUpdatedLog event.
+  * 
+  * @description
+  * This method:
+  * 1. Validates the log data contains required fields
+  * 2. Extracts and parses the OpenPGP message from the log
+  * 3. Verifies the primary key fingerprint matches the declared one
+  * 4. (if verifications are enabled) Verifies the primary key has a valid signature, is not expired and is not 
+  *    revoked at the time of update (uses the block timestamp).
+  * 
+  * Cryptographic verifications of the key (step 4) can be skipped by setting the `skipCryptographicVerifications`
+  * parameter to true. This is useful when users want to extract and parse the OpenPGP key material in order to perform
+  * custom validations or inspections in case the verification fails, is expected to fail or is performed by an external
+  * OpenPGP toolkit.
+  * 
+  * @param log The KeyUpdatedLog event data from the blockchain
+  * @param skipCryptographicVerifications If true, skips cryptographic verifications of key. Defaults to false.
+  * @returns The validated OpenPGP public key extracted from the log
+  * 
+  * @throws Web3PGPServiceValidationError if the log data is invalid or missing required fields
+  * @throws Web3PGPServiceValidationError if the extracted OpenPGP message is invalid or corrupted
+  * @throws Web3PGPServiceValidationError if the primary key fingerprint does not match the log data
+  * 
+  * @example
+  * ```typescript
+  * const logs = await web3pgp.searchKeyUpdatedLogs();
+  * for (const log of logs) {
+  *   try {
+  *     const publicKey = await service.extractFromKeyUpdatedLog(log);
+  *     console.log(`Valid updated key: ${publicKey.getFingerprint()}`);
+  *   } catch (err) {
+  *     console.warn(`Invalid log data: ${err.message}`);
+  *   }
+  * }
+  * ```
+  */
+  async extractFromKeyUpdatedLog(log, skipCryptographicVerifications) {
+    try {
+      let pk = await openpgp2.readKey({ binaryKey: toBytes(log.openPGPMsg) });
+      const pkFp = toBytes32(to0x(pk.getFingerprint()));
+      if (pkFp !== toBytes32(to0x(log.fingerprint))) {
+        throw new Web3PGPServiceValidationError(`The fingerprint of the retrieved primary key ${pkFp} does not match the declared fingerprint in the KeyUpdatedLog event ${log.fingerprint}`);
+      }
+      pk = await OpenPGPUtils.sanitizePrimaryKey(pk);
+      if (skipCryptographicVerifications !== true) {
+        await OpenPGPUtils.verifyKey(pk, log.blockTimestamp);
+      }
+      console.debug(`[Web3PGP - Service] Successfully extracted updated key ${pk.getFingerprint()} from KeyUpdatedLog event`);
+      return pk.toPublic();
+    } catch (err) {
+      if (err instanceof Web3PGPServiceValidationError) {
+        throw err;
+      }
+      throw new Web3PGPServiceValidationError(`Failed to extract the public key form the OpenPGP message in the KeyUpdatedLog event: ${err}`);
+    }
+  }
+  /**
+   * Validate and extract the certified public key from a KeyCertifiedLog event.
+   * 
+   * @description
+   * This method:
+   * 1.   Validates the log data contains required fields
+   * 2.   Extracts and parses the OpenPGP message from the log
+   * 3.   Verifies the primary key fingerprint matches the declared one
+   * 4.   (if verifications are enabled) Verifies the primary key has a valid signature, is not expired and is not 
+   *        revoked at the time of certification (uses the block timestamp).
+   * 5.   Validates that at least one certification signature made by the issuer over the target key is present
+   * 
+   * Cryptographic verifications of the key (step 4) can be skipped by setting the `skipCryptographicVerifications`
+   * parameter to true. This is useful when users want to extract and parse the OpenPGP key material in order to perform
+   * custom validations or inspections in case the verification fails, is expected to fail or is performed by an external
+   * OpenPGP toolkit.
+   * 
+   * @param log The KeyCertifiedLog event data from the blockchain
+   * @param skipCryptographicVerifications If true, skips cryptographic verifications of key. Defaults to false.
+   * @returns The validated OpenPGP public key extracted from the log
+   * 
+   * @throws Web3PGPServiceValidationError if the log data is invalid or missing required fields
+   * @throws Web3PGPServiceValidationError if the extracted OpenPGP message is invalid or corrupted
+   * @throws Web3PGPServiceValidationError if the primary key fingerprint does not match the log data
+   * @throws Web3PGPServiceValidationError if no valid certification signature made by the issuer is found
+   * 
+   * @example
+   * ```typescript
+   * const logs = await web3pgp.searchKeyCertifiedLogs(issuerFingerprint, targetFingerprint);
+   * for (const log of logs) {
+   *   try {
+   *     const certifiedKey = await service.extractFromKeyCertifiedLog(log);
+   *     console.log(`Valid certified key: ${certifiedKey.getFingerprint()}`);
+   *   } catch (err) {
+   *     console.warn(`Invalid log data: ${err.message}`);
+   *   }
+   * }
+   * ```
+   */
+  async extractFromKeyCertifiedLog(log, skipCryptographicVerifications) {
+    try {
+      let pk = await openpgp2.readKey({ binaryKey: toBytes(log.keyCertificate) });
+      const pkFp = toBytes32(to0x(pk.getFingerprint()));
+      if (pkFp !== toBytes32(to0x(log.fingerprint))) {
+        throw new Web3PGPServiceValidationError(`The fingerprint of the retrieved primary key ${pkFp} does not match the declared fingerprint in the KeyCertifiedLog event ${log.fingerprint}`);
+      }
+      pk = await OpenPGPUtils.sanitizePrimaryKey(pk);
+      pk.users.forEach((user) => {
+        user.revocationSignatures = [];
+      });
+      if (skipCryptographicVerifications !== true) {
+        await OpenPGPUtils.verifyKey(pk, log.blockTimestamp);
+      }
+      console.debug(`[Web3PGP - Service] Successfully extracted updated key ${pk.getFingerprint()} from KeyUpdatedLog event`);
+      return pk.toPublic();
+    } catch (err) {
+      if (err instanceof Web3PGPServiceValidationError) {
+        throw err;
+      }
+      throw new Web3PGPServiceValidationError(`Failed to extract the public key form the OpenPGP message in the KeyUpdatedLog event: ${err}`);
+    }
+  }
+  /**
+   * Validate and extract the revoked certification from a KeyCertificationRevokedLog event.
+   * 
+   * @description
+   * This method:
+   * 1.   Validates the log data contains required fields
+   * 2.   Extracts and parses the OpenPGP message from the log
+   * 3.   Verifies the primary key fingerprint matches the declared one
+   * 4.   (if verifications are enabled) Verifies the primary key has a valid signature, is not expired and is not 
+   *        revoked at the time of certification revocation (uses the block timestamp).
+   * 5.   Validates that at least one certification revocation signature made by the issuer over the target key is present
+   * 
+   * Cryptographic verifications of the key (step 4) can be skipped by setting the `skipCryptographicVerifications`
+   * parameter to true. This is useful when users want to extract and parse the OpenPGP key material in order to perform
+   * custom validations or inspections in case the verification fails, is expected to fail or is performed by an external
+   * OpenPGP toolkit.
+   * 
+   * @param log The KeyCertificationRevokedLog event data from the blockchain
+   * @param skipCryptographicVerifications If true, skips cryptographic verifications of key. Defaults to false.
+   * @returns The validated OpenPGP public key extracted from the log
+   * 
+   * @throws Web3PGPServiceValidationError if the log data is invalid or missing required fields
+   * @throws Web3PGPServiceValidationError if the extracted OpenPGP message is invalid or corrupted
+   * @throws Web3PGPServiceValidationError if the primary key fingerprint does not match the log data
+   * @throws Web3PGPServiceValidationError if no valid certification revocation signature made by the issuer is found
+   * 
+   * @example
+   * ```typescript
+   * const logs = await web3pgp.searchKeyCertificationRevokedLogs(issuerFingerprint, targetFingerprint);
+   * for (const log of logs) {
+   *   try {
+   *     const revokedCertificationKey = await service.extractFromKeyCertificationRevokedLog(log);
+   *     console.log(`Valid revoked certification key: ${revokedCertificationKey.getFingerprint()}`);
+   *  } catch (err) {
+   *    console.warn(`Invalid log data: ${err.message}`);
+   *  }
+   * }
+   * ```
+   */
+  async extractFromKeyCertificationRevokedLog(log, skipCryptographicVerifications) {
+    try {
+      let pk = await openpgp2.readKey({ binaryKey: toBytes(log.revocationSignature) });
+      const pkFp = toBytes32(to0x(pk.getFingerprint()));
+      const issuerFp = toBytes32(to0x(log.issuerFingerprint));
+      if (pkFp !== toBytes32(to0x(log.fingerprint))) {
+        throw new Web3PGPServiceValidationError(`The fingerprint of the retrieved primary key ${pkFp} does not match the declared fingerprint in the KeyCertificationRevokedLog event ${log.fingerprint}`);
+      }
+      pk = await OpenPGPUtils.sanitizePrimaryKey(pk);
+      if (skipCryptographicVerifications !== true) {
+        await OpenPGPUtils.verifyKey(pk, log.blockTimestamp);
+      }
+      console.debug(`[Web3PGP - Service] Successfully extracted updated key ${pk.getFingerprint()} from KeyUpdatedLog event`);
+      return pk.toPublic();
+    } catch (err) {
+      if (err instanceof Web3PGPServiceValidationError) {
+        throw err;
+      }
+      throw new Web3PGPServiceValidationError(`Failed to extract the public key form the OpenPGP message in the KeyUpdatedLog event: ${err}`);
+    }
+  }
+  /**
+   * Extract the signature from an OwnershipChallengedLog event. The signature is not verified at this stage.
+   * 
+   * @description
+   * This method:
+   * 1.   Validates the log data contains required fields
+   * 2.   Extracts and parses the OpenPGP signature from the log
+   * 
+   * @param log The OwnershipProvedLog event data from the blockchain
+   * @returns The OpenPGP signature extracted from the log
+   * 
+   * @throws Web3PGPServiceValidationError if the log data is invalid or missing required fields
+   * @throws Web3PGPServiceValidationError if the extracted OpenPGP signature is invalid or corrupted
+   */
+  async extractFromOwnershipProvedLog(log) {
+    try {
+      return openpgp2.readSignature({ binarySignature: toBytes(log.signature) });
+    } catch (err) {
+      throw new Web3PGPServiceValidationError(`Failed to read the OpenPGP signature from the OwnershipProvedLog event: ${err}`);
+    }
+  }
+  /*****************************************************************************************************************/
+  /* KEY RETRIEVAL                                                                                                 */
+  /*****************************************************************************************************************/
+  /**
+   * Retrieve and reconstruct an OpenPGP public key from the blockchain by its fingerprint.
+   * 
+   * @param fingerprint The fingerprint of the key to retrieve (primary key or subkey)
+   * @returns The reconstructed and validated OpenPGP public key, with revocations applied if any
+   * 
+   * @throws Error if the key is not registered on-chain
+   * @throws Error if the key data cannot be retrieved from blockchain events
+   * @throws Error if the retrieved OpenPGP message is invalid or corrupted
+   */
+  async getPublicKey(fingerprint) {
+    const normalizedFingerprint = toBytes32(to0x(fingerprint));
+    console.debug(`[Web3PGP - Service] Retrieving public key for fingerprint: ${normalizedFingerprint}`);
+    const [publicationBlock, parent] = await Promise.allSettled([
+      this.web3pgp.getKeyPublicationBlock(normalizedFingerprint),
+      this.web3pgp.parentOf(normalizedFingerprint)
+    ]);
+    if (publicationBlock.status === "rejected") {
+      throw new Web3PGPServiceCriticalError(`Failed to retrieve key publication block: ${publicationBlock.reason}`, publicationBlock.reason);
+    }
+    if (parent.status === "rejected") {
+      throw new Web3PGPServiceCriticalError(`Failed to retrieve parent fingerprint: ${parent.reason}`, parent.reason);
+    }
+    const publicationBlockNumber = publicationBlock.value;
+    const parentFingerprint = parent.value;
+    if (publicationBlockNumber === BigInt(0)) {
+      console.debug(`[Web3PGP - Service] Key ${normalizedFingerprint} is not registered on-chain`);
+      throw new Web3PGPServiceError(`The key with fingerprint ${fingerprint} is not registered on-chain.`);
+    }
+    console.debug(`[Web3PGP - Service] Key ${normalizedFingerprint} published at block ${publicationBlockNumber}, parent: ${parentFingerprint}`);
+    if (parentFingerprint !== BYTES32_ZERO) {
+      console.debug(`[Web3PGP - Service] Key ${normalizedFingerprint} is a subkey, retrieving parent key to reconstruct full key`);
+      return await this.getPublicKey(parentFingerprint);
+    }
+    const subkeys = await this.fetchAllPaginated((start, limit) => this.web3pgp.listSubkeys(normalizedFingerprint, start, limit));
+    let blockNumbers = await Promise.all([
+      this.web3pgp.getKeyPublicationBlockBatch(subkeys),
+      this.fetchAllPaginated((start, limit) => this.web3pgp.listKeyUpdates(normalizedFingerprint, start, limit)),
+      this.fetchAllPaginated((start, limit) => this.web3pgp.listRevocations(normalizedFingerprint, start, limit)),
+      this.fetchAllPaginated((start, limit) => this.web3pgp.listCertifications(normalizedFingerprint, start, limit)),
+      this.fetchAllPaginated((start, limit) => this.web3pgp.listCertificationRevocations(normalizedFingerprint, start, limit)),
+      ...subkeys.map(
+        (subkeyFingerprint) => this.concurrencyLimit(
+          () => this.fetchAllPaginated(
+            (start, limit) => this.web3pgp.listRevocations(subkeyFingerprint, start, limit)
+          )
+        )
+      )
+    ]);
+    const rawBlocks = [publicationBlockNumber, ...blockNumbers.flat()];
+    const uniqueBlocks = [...new Set(rawBlocks)].filter((b) => b > 0n);
+    const expectationsMap = /* @__PURE__ */ new Map();
+    for (const blockNumber of uniqueBlocks) {
+      const isPublicationBlock = blockNumber === publicationBlockNumber;
+      const subkeyAddedEventsExpected = blockNumbers[0].filter((b) => b === blockNumber && b !== publicationBlockNumber).length;
+      const totalRegistrationEventsExpected = subkeyAddedEventsExpected + (isPublicationBlock ? 1 : 0);
+      const KeyUpdatedExpected = blockNumbers[1].filter((b) => b === blockNumber).length;
+      let KeyRevokedExpected = blockNumbers[2].filter((b) => b === blockNumber).length;
+      const KeyCertifiedExpected = blockNumbers[3].filter((b) => b === blockNumber).length;
+      const KeyCertificationRevokedExpected = blockNumbers[4].filter((b) => b === blockNumber).length;
+      for (let i = 5; i < blockNumbers.length; i++) {
+        KeyRevokedExpected += blockNumbers[i].filter((b) => b === blockNumber).length;
+      }
+      expectationsMap.set(blockNumber, (logs2) => {
+        const counts = {
+          [Web3PGPEvents.KeyRegistered]: 0,
+          [Web3PGPEvents.SubkeyAdded]: 0,
+          [Web3PGPEvents.KeyUpdated]: 0,
+          [Web3PGPEvents.KeyRevoked]: 0,
+          [Web3PGPEvents.KeyCertified]: 0,
+          [Web3PGPEvents.KeyCertificationRevoked]: 0
+        };
+        for (const log of logs2) {
+          if (counts.hasOwnProperty(log.type)) {
+            counts[log.type]++;
+          }
+        }
+        const keyRegisteredOrSubkeyAddedCount = counts[Web3PGPEvents.KeyRegistered] + counts[Web3PGPEvents.SubkeyAdded];
+        return keyRegisteredOrSubkeyAddedCount === totalRegistrationEventsExpected && counts[Web3PGPEvents.KeyUpdated] === KeyUpdatedExpected && counts[Web3PGPEvents.KeyRevoked] === KeyRevokedExpected && counts[Web3PGPEvents.KeyCertified] === KeyCertifiedExpected && counts[Web3PGPEvents.KeyCertificationRevoked] === KeyCertificationRevokedExpected;
+      });
+    }
+    const logs = await Promise.all(
+      uniqueBlocks.map(
+        (blockNumber) => this.concurrencyLimit(async () => {
+          for (let attempt = 1; attempt <= 3; attempt++) {
+            console.debug(`[Web3PGP - Service] Searching for key events for block ${blockNumber}, attempt ${attempt}...`);
+            let logs2 = await this.web3pgp.searchKeyEvents([normalizedFingerprint, ...subkeys], blockNumber, blockNumber);
+            const validate = expectationsMap.get(blockNumber);
+            if (!validate) {
+              throw new Web3PGPServiceCriticalError(`Missing expectations validator for block ${blockNumber}`);
+            }
+            if (validate(logs2)) {
+              console.debug(`[Web3PGP - Service] Retrieved all (${logs2.length}) expected logs for block ${blockNumber} after ${attempt} attempt(s)`);
+              return logs2;
+            } else {
+              const delay = 200 * Math.pow(2, attempt - 1);
+              console.debug(`[Web3PGP - Service] Retrieved logs for block ${blockNumber} do not match expectations on attempt ${attempt}. Retrying in ${delay}ms...`);
+              await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+          }
+          throw new Web3PGPServiceError(`Failed to retrieve expected logs for block ${blockNumber} after 3 attempts.`);
+        })
+      )
+    );
+    const flattenedLogs = logs.flat().sort((a, b) => {
+      if (a.blockNumber < b.blockNumber) return -1;
+      if (a.blockNumber > b.blockNumber) return 1;
+      if (a.logIndex < b.logIndex) return -1;
+      if (a.logIndex > b.logIndex) return 1;
+      return 0;
+    });
+    if (flattenedLogs[0].type !== Web3PGPEvents.KeyRegistered) {
+      throw new Web3PGPServiceError(
+        `Invalid event sequence: Key history must start with KeyRegistered. Found ${flattenedLogs[0].type} at block ${flattenedLogs[0].blockNumber} - tx ${flattenedLogs[0].transactionHash}.`
+      );
+    }
+    console.debug(`[Web3PGP - Service] Found KeyRegistered log for primary key ${normalizedFingerprint} at block ${flattenedLogs[0].blockNumber} - tx ${flattenedLogs[0].transactionHash}`);
+    let primaryKey = await this.extractFromKeyRegisteredLog(flattenedLogs[0]);
+    console.debug(`[Web3PGP - Service] Reconstructing primary key ${normalizedFingerprint} from ${flattenedLogs.length} logs`);
+    const historyLogs = flattenedLogs.slice(1);
+    for (const log of historyLogs) {
+      try {
+        switch (log.type) {
+          case Web3PGPEvents.SubkeyAdded:
+            console.debug(`[Web3PGP - Service] Processing SubkeyAdded log for subkey ${log.subkeyFingerprint} at block ${log.blockNumber} - tx ${log.transactionHash}`);
+            const subkey = await this.extractFromSubkeyAddedLog(log);
+            primaryKey = await primaryKey.update(subkey, log.blockTimestamp);
+            break;
+          case Web3PGPEvents.KeyRevoked:
+            console.debug(`[Web3PGP - Service] Processing KeyRevoked log for fingerprint ${log.fingerprint} at block ${log.blockNumber} - tx ${log.transactionHash}`);
+            const [revokedKey, revocationCert] = await this.extractFromKeyRevokedLog(log);
+            if (revokedKey) {
+              primaryKey = await primaryKey.update(revokedKey, log.blockTimestamp);
+            } else if (revocationCert) {
+              try {
+                const result = await openpgp2.revokeKey({
+                  key: primaryKey,
+                  revocationCertificate: revocationCert,
+                  date: log.blockTimestamp,
+                  format: "object"
+                });
+                primaryKey = await primaryKey.update(result.publicKey, log.blockTimestamp);
+              } catch (err) {
+                throw new Web3PGPServiceValidationError(`Failed to apply standalone revocation certificate for key ${log.fingerprint} from KeyRevokedLog event: ${err}`);
+              }
+            }
+            break;
+          case Web3PGPEvents.KeyUpdated:
+            console.debug(`[Web3PGP - Service] Processing KeyUpdated log at block ${log.blockNumber} - tx ${log.transactionHash}`);
+            const updatedKey = await this.extractFromKeyUpdatedLog(log);
+            primaryKey = await primaryKey.update(updatedKey, log.blockTimestamp);
+            break;
+          case Web3PGPEvents.KeyCertified:
+            console.debug(`[Web3PGP - Service] Processing KeyCertified log at block ${log.blockNumber} - tx ${log.transactionHash}`);
+            const certifiedKey = await this.extractFromKeyCertifiedLog(log);
+            primaryKey = await primaryKey.update(certifiedKey, log.blockTimestamp);
+            break;
+          case Web3PGPEvents.KeyCertificationRevoked:
+            console.debug(`[Web3PGP - Service] Processing KeyCertificationRevoked log at block ${log.blockNumber} - tx ${log.transactionHash}`);
+            const certRevokedKey = await this.extractFromKeyCertificationRevokedLog(log);
+            primaryKey = await primaryKey.update(certRevokedKey, log.blockTimestamp);
+            break;
+          default:
+            console.warn(`[Web3PGP - Service] Unused log type ${log.type} at block ${log.blockNumber} - tx ${log.transactionHash}`);
+            break;
+        }
+      } catch (err) {
+        if (err instanceof Web3PGPServiceValidationError) {
+          console.warn(`[Web3PGP - Service] Failed to process log of type ${log.type} at block ${log.blockNumber} for key ${primaryKey.getFingerprint()}: ${err}`);
+        } else {
+          throw err;
+        }
+      }
+    }
+    console.debug(`[Web3PGP - Service] Successfully retrieved and reconstructed the public key`);
+    return primaryKey;
+  }
+  /**
+   * Searches for all key-related events within a specified block range. Optionally filters by fingerprints.
+   * 
+   * Note: The fingerprints are the subjects of the events (i.e., the keys being registered, updated, revoked, certified, etc.).
+   * Results will also include subkeys added, challenges, and proofs of ownership related to the listed fingerprints.
+   * 
+   * @param fingerprints The fingerprint(s) of the keys to filter events for. Can be a single fingerprint or an array. Defaults to all keys if not provided.
+   * @param fromBlock Starting block number (inclusive). Defaults to 'earliest' if not provided. 'pending' is not allowed.
+   * @param toBlock Ending block number (inclusive). Defaults to 'latest' if not provided. 'pending' is not allowed.
+   * @return An array of Web3PGPEventLog.
+   */
+  async searchKeyEvents(fingerprints, fromBlock, toBlock) {
+    return this.web3pgp.searchKeyEvents(fingerprints, fromBlock, toBlock);
+  }
+  /**
+   * Get the current block number of the connected blockchain.
+   * @return The current block number as a bigint.
+   */
+  async getBlockNumber() {
+    return this.web3pgp.getBlockNumber();
+  }
+  /*****************************************************************************************************************/
+  /* UTILITY FUNCTIONS                                                                                             */
+  /*****************************************************************************************************************/
+  /**
+   * Helper method to fetch all items from a paginated contract method.
+   * @param fetchFn The paginated fetch function to call
+   * @param limit The number of items to fetch per page
+   * @param maxItems The maximum number of items to fetch in total (safety limit)
+   * @returns An array containing all fetched items
+   */
+  async fetchAllPaginated(fetchFn, limit = 1000n, maxItems = 100000n) {
+    const results = [];
+    let start = 0n;
+    do {
+      const batch = await fetchFn(start, limit);
+      results.push(...batch);
+      if (batch.length < Number(limit) || results.length >= Number(maxItems)) {
+        break;
+      }
+      start += limit;
+    } while (true);
+    return results;
+  }
+};
+
+// src/web3doc/types/types.ts
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2[EventType2["DOCUMENT"] = 0] = "DOCUMENT";
+  EventType2[EventType2["COPY"] = 1] = "COPY";
+  return EventType2;
+})(EventType || {});
+var Web3DocEvents = {
+  Document: "Document",
+  Copy: "Copy",
+  Notification: "Notification",
+  Signature: "Signature",
+  Timestamp: "Timestamp",
+  SignatureRevocation: "SignatureRevocation"
+};
+
+// src/abis/Web3Doc.ts
+var Web3Doc = [{ "type": "constructor", "inputs": [], "stateMutability": "nonpayable" }, { "type": "receive", "stateMutability": "payable" }, { "type": "function", "name": "UPGRADE_INTERFACE_VERSION", "inputs": [], "outputs": [{ "name": "", "type": "string", "internalType": "string" }], "stateMutability": "view" }, { "type": "function", "name": "authority", "inputs": [], "outputs": [{ "name": "", "type": "address", "internalType": "address" }], "stateMutability": "view" }, { "type": "function", "name": "copyOffChain", "inputs": [{ "name": "original", "type": "uint256", "internalType": "uint256" }, { "name": "emitter", "type": "bytes32", "internalType": "bytes32" }, { "name": "recipients", "type": "tuple[]", "internalType": "struct IWeb3Doc.Recipient[]", "components": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "signatureRequested", "type": "bool", "internalType": "bool" }] }, { "name": "uri", "type": "string", "internalType": "string" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "copyOnChain", "inputs": [{ "name": "original", "type": "uint256", "internalType": "uint256" }, { "name": "emitter", "type": "bytes32", "internalType": "bytes32" }, { "name": "recipients", "type": "tuple[]", "internalType": "struct IWeb3Doc.Recipient[]", "components": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "signatureRequested", "type": "bool", "internalType": "bool" }] }, { "name": "document", "type": "bytes", "internalType": "bytes" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "getDocumentBlockNumberByID", "inputs": [{ "name": "id", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "getDocumentBlockNumberByIDBatch", "inputs": [{ "name": "ids", "type": "uint256[]", "internalType": "uint256[]" }], "outputs": [{ "name": "", "type": "uint256[]", "internalType": "uint256[]" }], "stateMutability": "view" }, { "type": "function", "name": "getSignatureBlockNumberByHash", "inputs": [{ "name": "signatureHash", "type": "bytes32", "internalType": "bytes32" }], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "getSignatureBlockNumberByHashBatch", "inputs": [{ "name": "signatureHashes", "type": "bytes32[]", "internalType": "bytes32[]" }], "outputs": [{ "name": "", "type": "uint256[]", "internalType": "uint256[]" }], "stateMutability": "view" }, { "type": "function", "name": "getWeb3PGPAddress", "inputs": [], "outputs": [{ "name": "", "type": "address", "internalType": "address" }], "stateMutability": "view" }, { "type": "function", "name": "initialize", "inputs": [{ "name": "fee", "type": "uint256", "internalType": "uint256" }, { "name": "manager", "type": "address", "internalType": "address" }, { "name": "web3pgp", "type": "address", "internalType": "address" }], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", "name": "initializeUpgrade", "inputs": [], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", "name": "isConsumingScheduledOp", "inputs": [], "outputs": [{ "name": "", "type": "bytes4", "internalType": "bytes4" }], "stateMutability": "view" }, { "type": "function", "name": "isCopyOf", "inputs": [{ "name": "id", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "listDocumentIdsByHash", "inputs": [{ "name": "dochash", "type": "bytes32", "internalType": "bytes32" }, { "name": "start", "type": "uint256", "internalType": "uint256" }, { "name": "limit", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "uint256[]", "internalType": "uint256[]" }], "stateMutability": "view" }, { "type": "function", "name": "listSignatureRevocationsBlockNumbers", "inputs": [{ "name": "signatureHash", "type": "bytes32", "internalType": "bytes32" }, { "name": "start", "type": "uint256", "internalType": "uint256" }, { "name": "limit", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "uint256[]", "internalType": "uint256[]" }], "stateMutability": "view" }, { "type": "function", "name": "listSignatures", "inputs": [{ "name": "id", "type": "uint256", "internalType": "uint256" }, { "name": "start", "type": "uint256", "internalType": "uint256" }, { "name": "limit", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "uint256[]", "internalType": "uint256[]" }], "stateMutability": "view" }, { "type": "function", "name": "proxiableUUID", "inputs": [], "outputs": [{ "name": "", "type": "bytes32", "internalType": "bytes32" }], "stateMutability": "view" }, { "type": "function", "name": "requestedFee", "inputs": [], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "revokeSignature", "inputs": [{ "name": "id", "type": "uint256", "internalType": "uint256" }, { "name": "emitter", "type": "bytes32", "internalType": "bytes32" }, { "name": "signatureHash", "type": "bytes32", "internalType": "bytes32" }, { "name": "signature", "type": "bytes", "internalType": "bytes" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "sendOffChain", "inputs": [{ "name": "emitter", "type": "bytes32", "internalType": "bytes32" }, { "name": "recipients", "type": "tuple[]", "internalType": "struct IWeb3Doc.Recipient[]", "components": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "signatureRequested", "type": "bool", "internalType": "bool" }] }, { "name": "dochash", "type": "bytes32", "internalType": "bytes32" }, { "name": "signature", "type": "bytes", "internalType": "bytes" }, { "name": "uri", "type": "string", "internalType": "string" }, { "name": "mimeType", "type": "string", "internalType": "string" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "sendOnChain", "inputs": [{ "name": "emitter", "type": "bytes32", "internalType": "bytes32" }, { "name": "recipients", "type": "tuple[]", "internalType": "struct IWeb3Doc.Recipient[]", "components": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }, { "name": "signatureRequested", "type": "bool", "internalType": "bool" }] }, { "name": "dochash", "type": "bytes32", "internalType": "bytes32" }, { "name": "signature", "type": "bytes", "internalType": "bytes" }, { "name": "document", "type": "bytes", "internalType": "bytes" }, { "name": "mimeType", "type": "string", "internalType": "string" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "setAuthority", "inputs": [{ "name": "newAuthority", "type": "address", "internalType": "address" }], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", "name": "sign", "inputs": [{ "name": "id", "type": "uint256", "internalType": "uint256" }, { "name": "emitter", "type": "bytes32", "internalType": "bytes32" }, { "name": "signature", "type": "bytes", "internalType": "bytes" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "timestamp", "inputs": [{ "name": "emitter", "type": "bytes32", "internalType": "bytes32" }, { "name": "dochash", "type": "bytes32", "internalType": "bytes32" }, { "name": "signature", "type": "bytes", "internalType": "bytes" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "updateRequestedFee", "inputs": [{ "name": "newFee", "type": "uint256", "internalType": "uint256" }], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", "name": "upgradeToAndCall", "inputs": [{ "name": "newImplementation", "type": "address", "internalType": "address" }, { "name": "data", "type": "bytes", "internalType": "bytes" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "withdrawFees", "inputs": [{ "name": "to", "type": "address", "internalType": "address" }], "outputs": [], "stateMutability": "nonpayable" }, { "type": "event", "name": "AuthorityUpdated", "inputs": [{ "name": "authority", "type": "address", "indexed": false, "internalType": "address" }], "anonymous": false }, { "type": "event", "name": "Copy", "inputs": [{ "name": "copy", "type": "uint256", "indexed": true, "internalType": "uint256" }, { "name": "original", "type": "uint256", "indexed": true, "internalType": "uint256" }, { "name": "emitter", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "document", "type": "bytes", "indexed": false, "internalType": "bytes" }, { "name": "uri", "type": "string", "indexed": false, "internalType": "string" }], "anonymous": false }, { "type": "event", "name": "Document", "inputs": [{ "name": "id", "type": "uint256", "indexed": true, "internalType": "uint256" }, { "name": "emitter", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "dochash", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "signature", "type": "bytes", "indexed": false, "internalType": "bytes" }, { "name": "document", "type": "bytes", "indexed": false, "internalType": "bytes" }, { "name": "uri", "type": "string", "indexed": false, "internalType": "string" }, { "name": "mimeType", "type": "string", "indexed": false, "internalType": "string" }], "anonymous": false }, { "type": "event", "name": "FeesWithdrawn", "inputs": [{ "name": "to", "type": "address", "indexed": true, "internalType": "address" }, { "name": "amount", "type": "uint256", "indexed": false, "internalType": "uint256" }], "anonymous": false }, { "type": "event", "name": "Initialized", "inputs": [{ "name": "version", "type": "uint64", "indexed": false, "internalType": "uint64" }], "anonymous": false }, { "type": "event", "name": "Notification", "inputs": [{ "name": "id", "type": "uint256", "indexed": true, "internalType": "uint256" }, { "name": "emitter", "type": "bytes32", "indexed": false, "internalType": "bytes32" }, { "name": "recipient", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "source", "type": "uint8", "indexed": false, "internalType": "enum IWeb3Doc.EventType" }, { "name": "signatureRequested", "type": "bool", "indexed": true, "internalType": "bool" }], "anonymous": false }, { "type": "event", "name": "RequestedFeeUpdated", "inputs": [{ "name": "oldFee", "type": "uint256", "indexed": false, "internalType": "uint256" }, { "name": "newFee", "type": "uint256", "indexed": false, "internalType": "uint256" }], "anonymous": false }, { "type": "event", "name": "Signature", "inputs": [{ "name": "id", "type": "uint256", "indexed": true, "internalType": "uint256" }, { "name": "emitter", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "signatureHash", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "signature", "type": "bytes", "indexed": false, "internalType": "bytes" }], "anonymous": false }, { "type": "event", "name": "SignatureRevocation", "inputs": [{ "name": "id", "type": "uint256", "indexed": true, "internalType": "uint256" }, { "name": "emitter", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "signatureHash", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "signature", "type": "bytes", "indexed": false, "internalType": "bytes" }], "anonymous": false }, { "type": "event", "name": "Timestamp", "inputs": [{ "name": "id", "type": "uint256", "indexed": true, "internalType": "uint256" }, { "name": "emitter", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "dochash", "type": "bytes32", "indexed": true, "internalType": "bytes32" }, { "name": "signature", "type": "bytes", "indexed": false, "internalType": "bytes" }], "anonymous": false }, { "type": "event", "name": "Upgraded", "inputs": [{ "name": "implementation", "type": "address", "indexed": true, "internalType": "address" }], "anonymous": false }, { "type": "error", "name": "AccessManagedInvalidAuthority", "inputs": [{ "name": "authority", "type": "address", "internalType": "address" }] }, { "type": "error", "name": "AccessManagedRequiredDelay", "inputs": [{ "name": "caller", "type": "address", "internalType": "address" }, { "name": "delay", "type": "uint32", "internalType": "uint32" }] }, { "type": "error", "name": "AccessManagedUnauthorized", "inputs": [{ "name": "caller", "type": "address", "internalType": "address" }] }, { "type": "error", "name": "AddressEmptyCode", "inputs": [{ "name": "target", "type": "address", "internalType": "address" }] }, { "type": "error", "name": "DocumentIsACopy", "inputs": [{ "name": "id", "type": "uint256", "internalType": "uint256" }] }, { "type": "error", "name": "DocumentNotFound", "inputs": [{ "name": "id", "type": "uint256", "internalType": "uint256" }] }, { "type": "error", "name": "ERC1967InvalidImplementation", "inputs": [{ "name": "implementation", "type": "address", "internalType": "address" }] }, { "type": "error", "name": "ERC1967NonPayable", "inputs": [] }, { "type": "error", "name": "EmitterNotFound", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }] }, { "type": "error", "name": "FailedCall", "inputs": [] }, { "type": "error", "name": "FeeRequired", "inputs": [{ "name": "provided", "type": "uint256", "internalType": "uint256" }, { "name": "required", "type": "uint256", "internalType": "uint256" }] }, { "type": "error", "name": "FeesWithdrawalFailed", "inputs": [] }, { "type": "error", "name": "InvalidInitialization", "inputs": [] }, { "type": "error", "name": "NoDirectPaymentsAllowed", "inputs": [] }, { "type": "error", "name": "NoFeesToWithdraw", "inputs": [] }, { "type": "error", "name": "NotInitializing", "inputs": [] }, { "type": "error", "name": "RecipientNotFound", "inputs": [{ "name": "fingerprint", "type": "bytes32", "internalType": "bytes32" }] }, { "type": "error", "name": "ReentrancyGuardReentrantCall", "inputs": [] }, { "type": "error", "name": "SignatureNotFound", "inputs": [{ "name": "signatureHash", "type": "bytes32", "internalType": "bytes32" }] }, { "type": "error", "name": "UUPSUnauthorizedCallContext", "inputs": [] }, { "type": "error", "name": "UUPSUnsupportedProxiableUUID", "inputs": [{ "name": "slot", "type": "bytes32", "internalType": "bytes32" }] }];
+
+// src/web3doc/types/errors.ts
+var Web3DocError = class extends Error {
+  /**
+   * Creates a new Web3DocError instance.
+   * @param message - Human-readable error description
+   * @param cause - Optional underlying error that caused this error
+   */
+  constructor(message, cause) {
+    super(message);
+    this.name = "Web3DocError";
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var Web3DocCriticalError = class extends Web3DocError {
+  /**
+   * Creates a new Web3DocCriticalError instance.
+   * @param message - Human-readable error description
+   * @param cause - Optional underlying error that caused this error
+   */
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "Web3DocCriticalError";
+  }
+};
+
+// src/web3doc/web3doc.ts
+var _Web3Doc = class _Web3Doc extends FlatFee2 {
+  /**
+   * Creates a new Web3Doc instance.
+   * 
+   * @param address The address of the Web3Doc smart contract.
+   * @param web3pgp An instance implementing the IWeb3PGP interface for public key operations.
+   * @param client A Viem public client for interacting with the blockchain.
+   * @param walletClient Optional Viem wallet client for signing transactions.
+   */
+  constructor(address, web3pgp, client, walletClient) {
+    super(address, client, walletClient);
+  }
+  /*****************************************************************************************************************/
+  /* WRITE FUNCTIONS                                                                                               */
+  /*****************************************************************************************************************/
+  /**
+   * Sends a document and its detached signature on-chain and notifies the specified recipients.
+   *
+   * @param emitter The fingerprint of the key used by the emitter to produce the signature.
+   * @param recipients The list of recipients to notify and optionally prompt to sign the document.
+   * @param dochash The declared keccak256 hash of the document.
+   * @param signature A detached binary OpenPGP signature of the document.
+   * @param document The binary OpenPGP message which contains the document.
+   * @param mimeType Optional, The MIME type of the document and additional attributes (RFC6838)
+   */
+  async sendOnChain(emitter, recipients, dochash, signature, document, mimeType) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3Doc,
+      functionName: "sendOnChain",
+      args: [
+        toBytes32(to0x(emitter)),
+        recipients.map((recipient) => ({
+          fingerprint: toBytes32(to0x(recipient.fingerprint)),
+          signatureRequested: recipient.signatureRequested
+        })),
+        dochash,
+        signature,
+        document,
+        mimeType
+      ],
+      value: fee
+      // Include fee in the transaction value
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /**
+   * Sends a document using an off-chain channel, publishes its detached signature on-chain and notifies the specified recipients.
+   *
+   * @param emitter The fingerprint of the key used to produce the signature.
+   * @param recipients The list of recipients to notify and optionally prompt to sign the document.
+   * @param dochash The declared keccak256 hash of the document.
+   * @param signature A detached binary OpenPGP signature of the document.
+   * @param uri A URI which can be used to download the OpenPGP message (compressed and encrypted) which contains the document.
+   * @param mimeType Optional, The MIME type of the document and additional attributes (RFC6838)
+   */
+  async sendOffChain(emitter, recipients, dochash, signature, uri, mimeType) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3Doc,
+      functionName: "sendOffChain",
+      args: [
+        toBytes32(to0x(emitter)),
+        recipients.map((recipient) => ({
+          fingerprint: toBytes32(to0x(recipient.fingerprint)),
+          signatureRequested: recipient.signatureRequested
+        })),
+        dochash,
+        signature,
+        uri,
+        mimeType
+      ],
+      value: fee
+      // Include fee in the transaction value
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /**
+   * Send a certified copy of a document on-chain.
+   *
+   * @param original The ID of the original document that is the subject of the copy.
+   * @param emitter The fingerprint of the emitter's public key.
+   * @param recipients The list of recipient key fingerprints to be notified and, optionally, be prompted for a signature.
+   * @param document The binary OpenPGP message containing the copy of the original document.
+   */
+  async copyOnChain(original, emitter, recipients, document) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3Doc,
+      functionName: "copyOnChain",
+      args: [
+        original,
+        toBytes32(to0x(emitter)),
+        recipients.map((recipient) => ({
+          fingerprint: toBytes32(to0x(recipient.fingerprint)),
+          signatureRequested: recipient.signatureRequested
+        })),
+        document
+      ],
+      value: fee
+      // Include fee in the transaction value
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /**
+   * Send a certified copy of a document using an off-chain storage.
+   *
+   * @param original The ID of the original document being copied. Must reference a valid, non-copy document.
+   * @param emitter The fingerprint of the key used to produce the signature.
+   * @param recipients The list of recipient key fingerprints to be notified and, optionally, be prompted for a signature.
+   * @param uri A URI which can be used to download the OpenPGP message containing the (compressed, encrypted and signed) document itself.
+   */
+  async copyOffChain(original, emitter, recipients, uri) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3Doc,
+      functionName: "copyOffChain",
+      args: [
+        original,
+        toBytes32(to0x(emitter)),
+        recipients.map((recipient) => ({
+          fingerprint: toBytes32(to0x(recipient.fingerprint)),
+          signatureRequested: recipient.signatureRequested
+        })),
+        uri
+      ],
+      value: fee
+      // Include fee in the transaction value
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /**
+   * Publishes a binary detached OpenPGP signature of a document made with the emitter's key.
+   *
+   * @param id The unique ID of the document that has been signed.
+   * @param emitter The fingerprint of the key used to produce the signature.
+   * @param signature The detached binary OpenPGP signature made over the document.
+   */
+  async sign(id, emitter, signature) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3Doc,
+      functionName: "sign",
+      args: [
+        id,
+        toBytes32(to0x(emitter)),
+        signature
+      ],
+      value: fee
+      // Include fee in the transaction value
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /**
+   * Timestamps a document by publishing a detached signature of the hash of the document on-chain.
+   *
+   * @param emitter The fingerprint of the key used to produce the signature.
+   * @param dochash The keccak256 hash of the document used to find the timestamp from the document and verify their integrity.
+   * @param signature A detached binary OpenPGP signature made over the raw bytes of the keccak256 hash of the document.
+   */
+  async timestamp(emitter, dochash, signature) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3Doc,
+      functionName: "timestamp",
+      args: [
+        toBytes32(to0x(emitter)),
+        dochash,
+        signature
+      ],
+      value: fee
+      // Include fee in the transaction value
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /**
+   * Revokes a signature previously published on-chain.
+   *
+   * @param id The ID of the document associated with the signature.
+   * @param emitter The fingerprint of the key that made the signature.
+   * @param signatureHash The hash of the signature to revoke.
+   * @param signature A detached binary OpenPGP signature made over the raw bytes of the signature hash.
+   */
+  async revokeSignature(id, emitter, signatureHash, signature) {
+    this.ensureWalletClient();
+    const fee = await this.requestedFee();
+    const { request } = await this.client.simulateContract({
+      address: this.address,
+      account: this.walletClient.account,
+      abi: Web3Doc,
+      functionName: "revokeSignature",
+      args: [
+        id,
+        toBytes32(to0x(emitter)),
+        signatureHash,
+        signature
+      ],
+      value: fee
+      // Include fee in the transaction value
+    });
+    const txhash = await this.walletClient.writeContract(request);
+    return this.client.waitForTransactionReceipt({ hash: txhash });
+  }
+  /*****************************************************************************************************************/
+  /* READ FUNCTIONS                                                                                                */
+  /*****************************************************************************************************************/
+  /**
+   * Get the address of the Web3PGP contract used as a global public key registry.
+   *
+   * @return The address of the Web3PGP contract used by this contract.
+   */
+  async getWeb3PGPAddress() {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3Doc,
+      functionName: "getWeb3PGPAddress"
+    });
+  }
+  /**
+   * Returns the ID of the original document that the given document is a copy of.
+   *
+   * @param id The ID of a document that may be a copy of another previously published document.
+   * @return The ID of the original document if the given document is a copy, or 0 if it is not a copy.
+   */
+  async isCopyOf(id) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3Doc,
+      functionName: "isCopyOf",
+      args: [id]
+    });
+  }
+  /**
+   * Returns the block number in which the document or timestamps with the given ID was published.
+   *
+   * @param id The ID of the document whose block number is to be retrieved.
+   * @return The block number in which the document was published. 0 if the document does not exist.
+   */
+  async getDocumentBlockNumberByID(id) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3Doc,
+      functionName: "getDocumentBlockNumberByID",
+      args: [id]
+    });
+  }
+  /**
+   * Returns the block numbers in which the documents or timestamps with the given IDs were published.
+   *
+   * @param ids The IDs of the documents whose block numbers are to be retrieved.
+   * @return The block numbers in which the documents were published.
+   */
+  async getDocumentBlockNumberByIDBatch(ids) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3Doc,
+      functionName: "getDocumentBlockNumberByIDBatch",
+      args: [ids]
+    });
+  }
+  /**
+   * Lists the block numbers when were published the signatures associated with the given document.
+   *
+   * @param id The ID of the document whose signatures are to be listed.
+   * @param start The starting index from which to list signatures (0-based).
+   * @param limit The maximum number of signatures to list.
+   * @return An array of signature IDs associated with the document.
+   */
+  async listSignatures(id, start, limit) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3Doc,
+      functionName: "listSignatures",
+      args: [id, start, limit]
+    });
+  }
+  /**
+  * Returns the block number in which the signature with the given hash was created or 0 if the signature does not exist.
+  *
+  * @param signatureHash The hash of the signature.
+  * @return The block number in which the signature was created, or 0 if the signature does not exist.
+  */
+  async getSignatureBlockNumberByHash(signatureHash) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3Doc,
+      functionName: "getSignatureBlockNumberByHash",
+      args: [signatureHash]
+    });
+  }
+  /**
+   * Returns the block numbers in which the signatures with the given hashes were created.
+   *
+   * @param signatureHashes The hashes of the signatures.
+   * @return The block numbers in which the signatures were created.
+   */
+  async getSignatureBlockNumberByHashBatch(signatureHashes) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3Doc,
+      functionName: "getSignatureBlockNumberByHashBatch",
+      args: [signatureHashes]
+    });
+  }
+  /**
+   * Lists the document IDs by the given document hash.
+   *
+   * @param dochash The hash of the document.
+   * @param start The starting index from which to list documents (0-based).
+   * @param limit The maximum number of documents to list.
+   * @return An array of document IDs with the given hash.
+   */
+  async listDocumentIdsByHash(dochash, start, limit) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3Doc,
+      functionName: "listDocumentIdsByHash",
+      args: [dochash, start, limit]
+    });
+  }
+  /**
+   * Lists the block numbers of signature revocations for the given signature hash.
+   *
+   * @param signatureHash The hash of the signature.
+   * @param start The starting index from which to list revocations (0-based).
+   * @param limit The maximum number of revocations to list.
+   * @return An array of block numbers where the signature was revoked.
+   */
+  async listSignatureRevocationsBlockNumbers(signatureHash, start, limit) {
+    return this.client.readContract({
+      address: this.address,
+      abi: Web3Doc,
+      functionName: "listSignatureRevocationsBlockNumbers",
+      args: [signatureHash, start, limit]
+    });
+  }
+  /*****************************************************************************************************************/
+  /* LOGS SEARCH FUNCTIONS                                                                                         */
+  /*****************************************************************************************************************/
+  /**
+   * Searches for Document events emitted by the smart contract, filtered by the provided criteria.
+   * Each value in a filter is combined using a logical OR, while all defined filters are combined using a logical AND.
+   * 
+   * @param ids Filter by document IDs. IDs uniqueness is guaranteed by the smart contract.
+   * @param emitters Filter by emitter fingerprints.
+   * @param dochashes Filter by document hashes.
+   * @param fromBlock Filter events from this block number. Genesis block if not specified.
+   * @param toBlock Filter events up to this block number. Latest block if not specified.
+   * @returns The list of DocumentLog matching the provided filters.
+   */
+  async searchDocumentLogs(ids, emitters, dochashes, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    let args = void 0;
+    if (ids !== void 0 || emitters !== void 0 || dochashes !== void 0) {
+      args = {};
+      if (ids !== void 0) {
+        args.id = ids;
+      }
+      if (emitters !== void 0) {
+        args.emitter = emitters.map(toBytes32);
+      }
+      if (dochashes !== void 0) {
+        args.dochash = dochashes;
+      }
+    }
+    const logs = await this.client.getLogs({
+      strict: true,
+      address: this.address,
+      event: _Web3Doc.DOCUMENT_EVENT,
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+    const blockTimestamps = new Map(
+      await Promise.all(uniqueBlocks.map(
+        async (bn) => [bn, await getBlockTimestamp(this.client, bn)]
+      ))
+    );
+    return logs.map((log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      transactionHash: log.transactionHash,
+      logIndex: log.logIndex,
+      type: Web3DocEvents.Document,
+      id: log.args.id,
+      emitter: log.args.emitter,
+      dochash: log.args.dochash,
+      signature: log.args.signature,
+      document: log.args.document,
+      uri: log.args.uri,
+      mimeType: log.args.mimeType
+    }));
+  }
+  /**
+   * Retrieves a Document event by its unique ID.
+   * 
+   * @param id The unique ID of the document.
+   * @param blockNumber The block number where to search for the document.
+   * @returns The DocumentLog if found, otherwise undefined.
+   * @example
+   * ```typescript
+   * const targetID = 1n;
+   * const blockNumber = await web3Doc.getDocumentBlockNumberByID(targetID);
+   * const documentLog = await web3Doc.getDocumentLogByID(targetID, blockNumber);
+   * ```
+   */
+  async getDocumentLogByID(id, blockNumber) {
+    const logs = await this.searchDocumentLogs([id], void 0, void 0, blockNumber, blockNumber);
+    if (logs.length === 1) return logs[0];
+    if (logs.length === 0) return void 0;
+    throw new Web3DocCriticalError(`Multiple Document logs found for document ID ${id} at block ${blockNumber}`);
+  }
+  /**
+   * Searches for Copy events emitted by the smart contract, filtered by the provided criteria.
+   * Each value in a filter is combined using a logical OR, while all defined filters are combined using a logical AND.
+   * 
+   * @param copies Filter by copy IDs. Copy IDs uniqueness is guaranteed by the smart contract. 
+   * @param originals Filter by original document IDs.
+   * @param emitters Filter by emitter fingerprints.
+   * @param fromBlock Filter events from this block number. Genesis block if not specified.
+   * @param toBlock Filter events up to this block number. Latest block if not specified.
+   * @returns The list of CopyLog matching the provided filters.
+   */
+  async searchCopyLogs(copies, originals, emitters, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    let args = void 0;
+    if (copies !== void 0 || originals !== void 0 || emitters !== void 0) {
+      args = {};
+      if (copies !== void 0) {
+        args.copy = copies;
+      }
+      if (originals !== void 0) {
+        args.original = originals;
+      }
+      if (emitters !== void 0) {
+        args.emitter = emitters.map(toBytes32);
+      }
+    }
+    const logs = await this.client.getLogs({
+      strict: true,
+      address: this.address,
+      event: _Web3Doc.COPY_EVENT,
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+    const blockTimestamps = new Map(
+      await Promise.all(uniqueBlocks.map(
+        async (bn) => [bn, await getBlockTimestamp(this.client, bn)]
+      ))
+    );
+    return logs.map((log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      transactionHash: log.transactionHash,
+      logIndex: log.logIndex,
+      type: Web3DocEvents.Copy,
+      copy: log.args.copy,
+      original: log.args.original,
+      emitter: log.args.emitter,
+      document: log.args.document,
+      uri: log.args.uri
+    }));
+  }
+  /**
+   * Retrieves a Copy event by its unique ID.
+   * 
+   * @param copy The unique ID of the copy.
+   * @param blockNumber The block number where to search for the copy.
+   * @returns The CopyLog if found, otherwise undefined.
+   * @example
+   * ```typescript
+   * const targetCopyID = 1n;
+   * const blockNumber = await web3Doc.getDocumentBlockNumberByID(targetCopyID);
+   * const copyLog = await web3Doc.getCopyLogByID(targetCopyID, blockNumber);
+   * ```
+   */
+  async getCopyLogByID(copy, blockNumber) {
+    const logs = await this.searchCopyLogs([copy], void 0, void 0, blockNumber, blockNumber);
+    if (logs.length === 1) return logs[0];
+    if (logs.length === 0) return void 0;
+    throw new Web3DocCriticalError(`Multiple Copy logs found for copy ID ${copy} at block ${blockNumber}`);
+  }
+  /**
+   * Searches for Notification events emitted by the smart contract, filtered by the provided criteria.
+   * Each value in a filter is combined using a logical OR, while all defined filters are combined using a logical AND.
+   * 
+   * @param ids Filter by document IDs. Document IDs uniqueness is guaranteed by the smart contract.
+   * @param recipients Filter by recipient fingerprints.
+   * @param signatureRequested Filter by whether a signature was requested or not.
+   * @param fromBlock Filter events from this block number. Genesis block if not specified.
+   * @param toBlock Filter events up to this block number. Latest block if not specified.
+   * @returns The list of NotificationLog matching the provided filters.
+   */
+  async searchNotificationLogs(ids, recipients, signatureRequested, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    let args = void 0;
+    if (ids !== void 0 || recipients !== void 0 || signatureRequested !== void 0) {
+      args = {};
+      if (ids !== void 0) {
+        args.id = ids;
+      }
+      if (recipients !== void 0) {
+        args.recipient = recipients.map(toBytes32);
+      }
+      if (signatureRequested !== void 0) {
+        args.signatureRequested = signatureRequested;
+      }
+    }
+    const logs = await this.client.getLogs({
+      strict: true,
+      address: this.address,
+      event: _Web3Doc.NOTIFICATION_EVENT,
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+    const blockTimestamps = new Map(
+      await Promise.all(uniqueBlocks.map(
+        async (bn) => [bn, await getBlockTimestamp(this.client, bn)]
+      ))
+    );
+    return logs.map((log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      transactionHash: log.transactionHash,
+      logIndex: log.logIndex,
+      type: Web3DocEvents.Notification,
+      id: log.args.id,
+      recipient: log.args.recipient,
+      emitter: log.args.emitter,
+      source: log.args.source,
+      signatureRequested: log.args.signatureRequested
+    }));
+  }
+  /**
+   * Retrieves a Notification event by its unique ID and recipient.
+   * 
+   * @param id The unique ID of the document that is the subject of the notification. 
+   * @param recipient The fingerprint of the recipient who received the notification.
+   * @param blockNumber The block number where to search for the notification.
+   * @returns The NotificationLog if found, otherwise undefined.
+   * @example
+   * ```typescript
+   * const targetID = 1n;
+   * const recipientFingerprint = '0x...';
+   * const blockNumber = await web3Doc.getDocumentBlockNumberByID(targetID);
+   * const notificationLog = await web3Doc.getNotificationLog(targetID, recipientFingerprint, blockNumber);
+   * ```
+   */
+  async getNotificationLog(id, recipient, blockNumber) {
+    const logs = await this.searchNotificationLogs([id], [recipient], void 0, blockNumber, blockNumber);
+    if (logs.length === 1) return logs[0];
+    if (logs.length === 0) return void 0;
+    throw new Web3DocCriticalError(`Multiple Notification logs found for document ID ${id} and recipient ${recipient} at block ${blockNumber}`);
+  }
+  /**
+   * Searches for Signature events emitted by the smart contract, filtered by the provided criteria.
+   * Each value in a filter is combined using a logical OR, while all defined filters are combined using a logical AND.
+   * 
+   * @param ids Filter by signature IDs. Signature IDs uniqueness is guaranteed by the smart contract.
+   * @param emitters Filter by emitter fingerprints.
+   * @param signatureHashes Filter by signature hashes.
+   * @param fromBlock Filter events from this block number. Genesis block if not specified.
+   * @param toBlock Filter events up to this block number. Latest block if not specified.
+   * @returns The list of SignatureLog matching the provided filters.
+   */
+  async searchSignatureLogs(ids, emitters, signatureHashes, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    let args = void 0;
+    if (ids !== void 0 || emitters !== void 0 || signatureHashes !== void 0) {
+      args = {};
+      if (ids !== void 0) {
+        args.id = ids;
+      }
+      if (emitters !== void 0) {
+        args.emitter = emitters.map(toBytes32);
+      }
+      if (signatureHashes !== void 0) {
+        args.signatureHash = signatureHashes;
+      }
+    }
+    const logs = await this.client.getLogs({
+      strict: true,
+      address: this.address,
+      event: _Web3Doc.SIGNATURE_EVENT,
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+    const blockTimestamps = new Map(
+      await Promise.all(uniqueBlocks.map(
+        async (bn) => [bn, await getBlockTimestamp(this.client, bn)]
+      ))
+    );
+    return logs.map((log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      transactionHash: log.transactionHash,
+      logIndex: log.logIndex,
+      type: Web3DocEvents.Signature,
+      id: log.args.id,
+      emitter: log.args.emitter,
+      signatureHash: log.args.signatureHash,
+      signature: log.args.signature
+    }));
+  }
+  /**
+   * Retrieves Timestamp events emitted by the smart contract, filtered by the provided criteria.
+   * Each value in a filter is combined using a logical OR, while all defined filters are combined using a logical AND.
+   * 
+   * @param ids Filter by timestamp IDs. Timestamp IDs uniqueness is guaranteed by the smart contract. 
+   * @param emitters Filter by emitter fingerprints.
+   * @param dochashes Filter by document hashes.
+   * @param fromBlock Filter events from this block number. Genesis block if not specified.
+   * @param toBlock Filter events up to this block number. Latest block if not specified.
+   * @returns The list of TimestampLog matching the provided filters.
+   */
+  async searchTimestampLogs(ids, emitters, dochashes, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    let args = void 0;
+    if (ids !== void 0 || emitters !== void 0 || dochashes !== void 0) {
+      args = {};
+      if (ids !== void 0) {
+        args.id = ids;
+      }
+      if (emitters !== void 0) {
+        args.emitter = emitters.map(toBytes32);
+      }
+      if (dochashes !== void 0) {
+        args.dochash = dochashes;
+      }
+    }
+    const logs = await this.client.getLogs({
+      strict: true,
+      address: this.address,
+      event: _Web3Doc.TIMESTAMP_EVENT,
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+    const blockTimestamps = new Map(
+      await Promise.all(uniqueBlocks.map(
+        async (bn) => [bn, await getBlockTimestamp(this.client, bn)]
+      ))
+    );
+    return logs.map((log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      transactionHash: log.transactionHash,
+      logIndex: log.logIndex,
+      type: Web3DocEvents.Timestamp,
+      id: log.args.id,
+      emitter: log.args.emitter,
+      dochash: log.args.dochash,
+      signature: log.args.signature
+    }));
+  }
+  /**
+   * Retrieves a Timestamp event by its unique ID.
+   * @param id The unique ID of the timestamp.
+   * @param blockNumber The block number where to search for the timestamp.
+   * @returns The TimestampLog if found, otherwise undefined.
+   */
+  async getTimestampLogByID(id, blockNumber) {
+    const logs = await this.searchTimestampLogs([id], void 0, void 0, blockNumber, blockNumber);
+    if (logs.length === 1) return logs[0];
+    if (logs.length === 0) return void 0;
+    throw new Web3DocCriticalError(`Multiple Timestamp logs found for timestamp ID ${id} at block ${blockNumber}`);
+  }
+  /**
+   * Extracts Document logs from a transaction receipt.
+   * @param receipt The transaction receipt to extract logs from.
+   * @param timestamp Optional timestamp to assign to all extracted logs. This is useful when the receipt is from a transaction included in the latest block or in a block that has not been indexed yet.
+   * @returns A promise that resolves to an array of DocumentLog objects.
+   */
+  async extractDocumentLog(receipt, timestamp) {
+    const parsedLogs = parseEventLogs({
+      abi: Web3Doc,
+      eventName: "Document",
+      logs: receipt.logs
+    });
+    if (timestamp) {
+      return parsedLogs.map((log) => ({
+        blockNumber: log.blockNumber,
+        blockHash: log.blockHash,
+        blockTimestamp: timestamp,
+        transactionHash: log.transactionHash,
+        logIndex: log.logIndex,
+        type: Web3DocEvents.Document,
+        id: log.args.id,
+        emitter: log.args.emitter,
+        dochash: log.args.dochash,
+        signature: log.args.signature,
+        document: log.args.document,
+        uri: log.args.uri,
+        mimeType: log.args.mimeType
+      }));
+    }
+    const uniqueBlocks = [...new Set(parsedLogs.map((l) => l.blockNumber))];
+    const blockTimestamps = new Map(
+      await Promise.all(uniqueBlocks.map(
+        async (bn) => [bn, await getBlockTimestamp(this.client, bn)]
+      ))
+    );
+    return parsedLogs.map((log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      transactionHash: log.transactionHash,
+      id: log.args.id,
+      emitter: log.args.emitter,
+      dochash: log.args.dochash,
+      signature: log.args.signature,
+      document: log.args.document,
+      uri: log.args.uri,
+      mimeType: log.args.mimeType,
+      logIndex: log.logIndex,
+      type: Web3DocEvents.Document
+    }));
+  }
+  /**
+   * Extracts Copy logs from a transaction receipt.
+   * @param receipt The transaction receipt to extract logs from.
+   * @returns A promise that resolves to an array of CopyLog objects.
+   * @returns A promise that resolves to an array of CopyLog objects.
+   */
+  async extractCopyLog(receipt, timestamp) {
+    const parsedLogs = parseEventLogs({
+      abi: Web3Doc,
+      eventName: "Copy",
+      logs: receipt.logs
+    });
+    if (timestamp) {
+      return parsedLogs.map((log) => ({
+        blockNumber: log.blockNumber,
+        blockHash: log.blockHash,
+        blockTimestamp: timestamp,
+        transactionHash: log.transactionHash,
+        logIndex: log.logIndex,
+        type: Web3DocEvents.Copy,
+        copy: log.args.copy,
+        original: log.args.original,
+        emitter: log.args.emitter,
+        document: log.args.document,
+        uri: log.args.uri
+      }));
+    }
+    const uniqueBlocks = [...new Set(parsedLogs.map((l) => l.blockNumber))];
+    const blockTimestamps = new Map(
+      await Promise.all(uniqueBlocks.map(
+        async (bn) => [bn, await getBlockTimestamp(this.client, bn)]
+      ))
+    );
+    return parsedLogs.map((log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      transactionHash: log.transactionHash,
+      logIndex: log.logIndex,
+      type: Web3DocEvents.Copy,
+      copy: log.args.copy,
+      original: log.args.original,
+      emitter: log.args.emitter,
+      document: log.args.document,
+      uri: log.args.uri
+    }));
+  }
+  /**
+   * Extracts Signature logs from a transaction receipt.
+   * @param receipt The transaction receipt to extract logs from.
+   * @param timestamp Optional timestamp to assign to all extracted logs. This is useful when the receipt is from a transaction included in the latest block or in a block that has not been indexed yet.
+   * @returns A promise that resolves to an array of SignatureLog objects.
+   */
+  async extractSignatureLog(receipt, timestamp) {
+    const parsedLogs = parseEventLogs({
+      abi: Web3Doc,
+      eventName: "Signature",
+      logs: receipt.logs
+    });
+    if (timestamp) {
+      return parsedLogs.map((log) => ({
+        blockNumber: log.blockNumber,
+        blockHash: log.blockHash,
+        blockTimestamp: timestamp,
+        transactionHash: log.transactionHash,
+        logIndex: log.logIndex,
+        type: Web3DocEvents.Signature,
+        id: log.args.id,
+        emitter: log.args.emitter,
+        signatureHash: log.args.signatureHash,
+        signature: log.args.signature
+      }));
+    }
+    const uniqueBlocks = [...new Set(parsedLogs.map((l) => l.blockNumber))];
+    const blockTimestamps = new Map(
+      await Promise.all(uniqueBlocks.map(
+        async (bn) => [bn, await getBlockTimestamp(this.client, bn)]
+      ))
+    );
+    return parsedLogs.map((log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      transactionHash: log.transactionHash,
+      logIndex: log.logIndex,
+      type: Web3DocEvents.Signature,
+      id: log.args.id,
+      emitter: log.args.emitter,
+      signatureHash: log.args.signatureHash,
+      signature: log.args.signature
+    }));
+  }
+  /**
+   * Extracts Timestamp logs from a transaction receipt.
+   * @param receipt The transaction receipt to extract logs from.
+   * @param timestamp Optional timestamp to assign to all extracted logs. This is useful when the receipt is from a transaction included in the latest block or in a block that has not been indexed yet.
+   * @returns A promise that resolves to an array of TimestampLog objects.
+   */
+  async extractTimestampLog(receipt, timestamp) {
+    const parsedLogs = parseEventLogs({
+      abi: Web3Doc,
+      eventName: "Timestamp",
+      logs: receipt.logs
+    });
+    if (timestamp) {
+      return parsedLogs.map((log) => ({
+        blockNumber: log.blockNumber,
+        blockHash: log.blockHash,
+        blockTimestamp: timestamp,
+        transactionHash: log.transactionHash,
+        logIndex: log.logIndex,
+        type: Web3DocEvents.Timestamp,
+        id: log.args.id,
+        emitter: log.args.emitter,
+        dochash: log.args.dochash,
+        signature: log.args.signature
+      }));
+    }
+    const uniqueBlocks = [...new Set(parsedLogs.map((l) => l.blockNumber))];
+    const blockTimestamps = new Map(
+      await Promise.all(uniqueBlocks.map(
+        async (bn) => [bn, await getBlockTimestamp(this.client, bn)]
+      ))
+    );
+    return parsedLogs.map((log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      transactionHash: log.transactionHash,
+      logIndex: log.logIndex,
+      type: Web3DocEvents.Timestamp,
+      id: log.args.id,
+      emitter: log.args.emitter,
+      dochash: log.args.dochash,
+      signature: log.args.signature
+    }));
+  }
+  /**
+   * Extracts Notification logs from a transaction receipt.
+   * @param receipt The transaction receipt to extract logs from.
+   * @param timestamp Optional timestamp to assign to all extracted logs. This is useful when the receipt is from a transaction included in the latest block or in a block that has not been indexed yet.
+   * @returns A promise that resolves to an array of NotificationLog objects.
+   */
+  async extractNotificationLog(receipt, timestamp) {
+    const parsedLogs = parseEventLogs({
+      strict: true,
+      abi: Web3Doc,
+      eventName: "Notification",
+      logs: receipt.logs
+    });
+    if (timestamp) {
+      return parsedLogs.map((log) => ({
+        blockNumber: log.blockNumber,
+        blockHash: log.blockHash,
+        blockTimestamp: timestamp,
+        transactionHash: log.transactionHash,
+        logIndex: log.logIndex,
+        type: Web3DocEvents.Notification,
+        id: log.args.id,
+        recipient: log.args.recipient,
+        emitter: log.args.emitter,
+        source: log.args.source,
+        signatureRequested: log.args.signatureRequested
+      }));
+    }
+    const uniqueBlocks = [...new Set(parsedLogs.map((l) => l.blockNumber))];
+    const blockTimestamps = new Map(
+      await Promise.all(uniqueBlocks.map(
+        async (bn) => [bn, await getBlockTimestamp(this.client, bn)]
+      ))
+    );
+    return parsedLogs.map((log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      transactionHash: log.transactionHash,
+      logIndex: log.logIndex,
+      type: Web3DocEvents.Notification,
+      id: log.args.id,
+      recipient: log.args.recipient,
+      emitter: log.args.emitter,
+      source: log.args.source,
+      signatureRequested: log.args.signatureRequested
+    }));
+  }
+  /**
+   * Retireve signature revocation events emitted by the smart contract, filtered by the provided criteria.
+   * Each value in a filter is combined using a logical OR, while all defined filters are combined using a logical AND.
+   * 
+   * @param ids Filter by signature IDs. Signature IDs uniqueness is guaranteed by the smart contract.
+   * @param emitters Filter by emitter fingerprints.
+   * @param signatureHashes Filter by signature hashes.
+   * @param fromBlock Filter events from this block number. Genesis block if not specified.
+   * @param toBlock Filter events up to this block number. Latest block if not specified.
+   * @returns The list of SignatureRevocationLog matching the provided filters.
+   */
+  async searchSignatureRevocationLogs(ids, emitters, signatureHashes, fromBlock, toBlock) {
+    if (fromBlock === "pending" || toBlock === "pending") {
+      throw new Error('fromBlock and toBlock cannot be "pending" for log searches');
+    }
+    const from = fromBlock ?? "earliest";
+    const to = toBlock ?? "latest";
+    let args = void 0;
+    if (ids !== void 0 || emitters !== void 0 || signatureHashes !== void 0) {
+      args = {};
+      if (ids !== void 0) {
+        args.id = ids;
+      }
+      if (emitters !== void 0) {
+        args.emitter = emitters.map(toBytes32);
+      }
+      if (signatureHashes !== void 0) {
+        args.signatureHash = signatureHashes;
+      }
+    }
+    const logs = await this.client.getLogs({
+      strict: true,
+      address: this.address,
+      event: _Web3Doc.SIGNATURE_REVOCATION_EVENT,
+      fromBlock: from,
+      toBlock: to,
+      ...args !== void 0 && { args }
+    });
+    const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+    const blockTimestamps = new Map(
+      await Promise.all(uniqueBlocks.map(
+        async (bn) => [bn, await getBlockTimestamp(this.client, bn)]
+      ))
+    );
+    return logs.map((log) => ({
+      blockNumber: log.blockNumber,
+      blockHash: log.blockHash,
+      blockTimestamp: blockTimestamps.get(log.blockNumber),
+      transactionHash: log.transactionHash,
+      logIndex: log.logIndex,
+      type: Web3DocEvents.SignatureRevocation,
+      id: log.args.id,
+      emitter: log.args.emitter,
+      signatureHash: log.args.signatureHash,
+      signature: log.args.signature
+    }));
+  }
+  /**
+   * Retrieves Timestamp events by document hash.
+   * @param dochash The keccak256 hash of the document.
+   * @returns An array of TimestampLog entries associated with the document hash.
+   */
+  async getTimestampLogsByHash(dochash) {
+    let ids = await this.fetchAllPaginated(
+      (start, limit) => this.listDocumentIdsByHash(dochash, start, limit)
+    );
+    if (ids.length === 0) {
+      return [];
+    }
+    let blockNumbers = await this.getDocumentBlockNumberByIDBatch(ids);
+    if (blockNumbers.length !== ids.length) {
+      throw new Web3DocCriticalError("Mismatch between document IDs and block numbers length");
+    }
+    const timestampLogs = await Promise.all(
+      blockNumbers.map(async (blockNumber) => {
+        return this.searchTimestampLogs(ids, void 0, [dochash], blockNumber, blockNumber);
+      })
+    );
+    return timestampLogs.flat();
+  }
+  extractSignatureRevocationLog(receipt, timestamp) {
+    const parsedLogs = parseEventLogs({
+      strict: true,
+      abi: Web3Doc,
+      eventName: "SignatureRevocation",
+      logs: receipt.logs
+    });
+    if (timestamp) {
+      return Promise.resolve(parsedLogs.map((log) => ({
+        blockNumber: log.blockNumber,
+        blockHash: log.blockHash,
+        blockTimestamp: timestamp,
+        transactionHash: log.transactionHash,
+        logIndex: log.logIndex,
+        type: Web3DocEvents.SignatureRevocation,
+        id: log.args.id,
+        emitter: log.args.emitter,
+        signatureHash: log.args.signatureHash,
+        signature: log.args.signature
+      })));
+    }
+    const uniqueBlocks = [...new Set(parsedLogs.map((l) => l.blockNumber))];
+    return Promise.all(uniqueBlocks.map(
+      async (bn) => [bn, await getBlockTimestamp(this.client, bn)]
+    )).then((blockTimestampArray) => {
+      const blockTimestamps = new Map(blockTimestampArray);
+      return parsedLogs.map((log) => ({
+        blockNumber: log.blockNumber,
+        blockHash: log.blockHash,
+        blockTimestamp: blockTimestamps.get(log.blockNumber),
+        transactionHash: log.transactionHash,
+        logIndex: log.logIndex,
+        type: Web3DocEvents.SignatureRevocation,
+        id: log.args.id,
+        emitter: log.args.emitter,
+        signatureHash: log.args.signatureHash,
+        signature: log.args.signature
+      }));
+    });
+  }
+  /*****************************************************************************************************************/
+  /* UTILITY METHODS                                                                                              */
+  /*****************************************************************************************************************/
+  /**
+   * Helper method to fetch all items from a paginated contract method.
+   * @param fetchFn The paginated fetch function to call
+   * @param limit The number of items to fetch per page
+   * @param maxItems The maximum number of items to fetch in total (safety limit)
+   * @returns An array containing all fetched items
+   */
+  async fetchAllPaginated(fetchFn, limit = 1000n, maxItems = 100000n) {
+    const results = [];
+    let start = 0n;
+    do {
+      const batch = await fetchFn(start, limit);
+      results.push(...batch);
+      if (batch.length < Number(limit) || results.length >= Number(maxItems)) {
+        break;
+      }
+      start += limit;
+    } while (true);
+    return results;
+  }
+};
+_Web3Doc.abi = Web3Doc;
+// Pre-computed event definitions for efficient log queries
+_Web3Doc.DOCUMENT_EVENT = Web3Doc.find((item) => item.type === "event" && item.name === "Document");
+_Web3Doc.COPY_EVENT = Web3Doc.find((item) => item.type === "event" && item.name === "Copy");
+_Web3Doc.NOTIFICATION_EVENT = Web3Doc.find((item) => item.type === "event" && item.name === "Notification");
+_Web3Doc.SIGNATURE_EVENT = Web3Doc.find((item) => item.type === "event" && item.name === "Signature");
+_Web3Doc.SIGNATURE_REVOCATION_EVENT = Web3Doc.find((item) => item.type === "event" && item.name === "SignatureRevocation");
+_Web3Doc.TIMESTAMP_EVENT = Web3Doc.find((item) => item.type === "event" && item.name === "Timestamp");
+var Web3Doc2 = _Web3Doc;
+var Web3DocServiceError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Web3DocServiceError";
+  }
+};
+var Web3DocServiceCriticalError = class extends Web3DocServiceError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "Web3DocServiceCriticalError";
+  }
+};
+var Web3DocServiceValidationError = class extends Web3DocServiceError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "Web3DocServiceValidationError";
+  }
+};
+var Web3DocService = class {
+  /**
+   * Creates a new Web3DocService instance.
+   * 
+   * @param web3doc An instance implementing the IWeb3Doc interface.
+   * @param options Optional configuration options for the service.
+   */
+  constructor(web3doc, web3pgpService, options) {
+    this._web3doc = web3doc;
+    this._web3pgpService = web3pgpService;
+    this._options = {
+      concurrencyLimit: options?.concurrencyLimit ?? 10
+    };
+  }
+  /**
+   * Gets the Web3Doc instance.
+   */
+  get web3doc() {
+    return this._web3doc;
+  }
+  /**
+   * Sets the Web3Doc instance.
+   */
+  set web3doc(value) {
+    this._web3doc = value;
+  }
+  /**
+   * Gets the Web3PGP service instance.
+   */
+  get web3pgpService() {
+    return this._web3pgpService;
+  }
+  /**
+   * Sets the Web3PGP service instance.
+   */
+  set web3pgpService(value) {
+    this._web3pgpService = value;
+  }
+  /**
+   * Gets the service configuration options.
+   */
+  get options() {
+    return this._options;
+  }
+  /**
+   * Sets the service configuration options.
+   */
+  set options(value) {
+    this._options = value;
+  }
+  /*****************************************************************************************************************/
+  /* TIMESTAMPING                                                                                                  */
+  /*****************************************************************************************************************/
+  /**
+   * This function allows submitting the data needed to timestamp a document to the Web3Doc smart contract.
+   * 
+   * The function will download and verify the emitter's public key using the Web3PGP contract and then it will verify
+   * the provided detached signature over the keccak256 hash of the document. If the signature is valid, it will submit
+   * the hash and the signature to the smart contract for timestamping.
+   * 
+   * The service is expected to be configured with a Web3PGP service instance to enable automatic public key retrieval based
+   * on their fingerprint.
+   * 
+   * @param hash The keccak256 hash of the document to be timestamped, provided as a Uint8Array.
+   * @param signature The detached OpenPGP signature over the document hash.
+   * @param emitter The fingerprint of the public key used to create the signature. Will be used to download the public key from Web3PGP.
+   * @return A promise that resolves to the ID assigned to the new timestamp and the transaction receipt.
+   */
+  async timestamp(hash, signature, emitter) {
+    try {
+      console.debug(`[Web3Doc Service] Retrieving public key for emitter fingerprint: ${emitter}`);
+      const pk = await this.web3pgpService.getPublicKey(emitter);
+      console.debug(`[Web3Doc Service] Verifying signature for timestamp with emitter fingerprint: ${emitter}`);
+      try {
+        await openpgp2.verify({
+          message: await openpgp2.createMessage({ binary: hash }),
+          signature,
+          verificationKeys: pk,
+          date: /* @__PURE__ */ new Date()
+          // Use current date for verification
+        });
+      } catch (error) {
+        throw new Web3DocServiceValidationError(`Signature verification failed for emitter fingerprint: ${emitter}`, error instanceof Error ? error : void 0);
+      }
+      console.debug(`[Web3Doc Service] Submitting timestamp to Web3Doc smart contract for emitter fingerprint: ${emitter}`);
+      const receipt = await this.web3doc.timestamp(toBytes32(to0x(pk.getFingerprint())), toHex(hash), toHex(signature.write()));
+      console.debug(`[Web3Doc Service] Timestamp transaction submitted successfully`);
+      const logs = await this.web3doc.extractTimestampLog(receipt, /* @__PURE__ */ new Date());
+      if (logs.length !== 1) {
+        throw new Web3DocServiceCriticalError(`Unexpected number of timestamp logs in transaction receipt: ${logs.length}`);
+      }
+      console.debug(`[Web3Doc Service] Timestamp submitted successfully with ID: ${logs[0].id.toString()}`);
+      return [logs[0].id, receipt];
+    } catch (error) {
+      if (error instanceof Web3PGPServiceValidationError) {
+        throw new Web3DocServiceValidationError(`Emitter public key not valid for fingerprint: ${emitter}`, error);
+      }
+      console.error(error);
+      throw new Web3DocServiceCriticalError("Failed to retrieve or verify emitter public key", error instanceof Error ? error : void 0);
+    }
+  }
+  /**
+   * Verifies a timestamp entry on the blockchain by its ID. The function retrieves the timestamp data from the
+   * Web3Doc smart contract and verifies the detached signature over the document hash using the emitter's public key.
+   * 
+   * The function returns the document hash, the signature, and the public key used for verification.
+   * 
+   * The user can then compare the hash received from this function with the keccak256 hash they compute from their 
+   * document to ensure integrity.
+   * 
+   * @param id The ID of the timestamp entry to verify.
+   * @returns A promise that resolves to an object containing the document hash, signature, the public key, the transaction hash and the date of the timestamp. 
+   */
+  async verifyTimestamp(id) {
+    try {
+      const blockNumber = await this.web3doc.getDocumentBlockNumberByID(id);
+      const timestamp = await this.web3doc.getTimestampLogByID(id, blockNumber);
+      if (!timestamp) {
+        throw new Web3DocServiceValidationError(`Timestamp with ID ${id.toString()} not found on the blockchain`);
+      }
+      console.debug(`[Web3Doc Service] Retrieving public key for emitter fingerprint: ${timestamp.emitter}`);
+      const pk = await this.web3pgpService.getPublicKey(timestamp.emitter);
+      console.debug(`[Web3Doc Service] Verifying signature for timestamp ID: ${id.toString()}`);
+      const signature = await openpgp2.readSignature({ binarySignature: hexToBytes(timestamp.signature) });
+      try {
+        await openpgp2.verify({
+          message: await openpgp2.createMessage({ binary: hexToBytes(timestamp.dochash) }),
+          signature,
+          verificationKeys: pk,
+          date: timestamp.blockTimestamp
+          // Use the block timestamp for verification
+        });
+      } catch (error) {
+        throw new Web3DocServiceValidationError(`Signature verification failed for timestamp ID: ${id.toString()}`, error instanceof Error ? error : void 0);
+      }
+      console.debug(`[Web3Doc Service] Timestamp ID: ${id.toString()} verified successfully`);
+      return {
+        documentHash: hexToBytes(timestamp.dochash),
+        signature,
+        publicKey: pk,
+        tx: timestamp.transactionHash,
+        date: timestamp.blockTimestamp
+      };
+    } catch (error) {
+      if (error instanceof Web3PGPServiceValidationError) {
+        throw new Web3DocServiceValidationError(`Emitter public key not valid`, error);
+      }
+      throw new Web3DocServiceCriticalError("Failed to retrieve or verify the timestamp", error instanceof Error ? error : void 0);
+    }
+  }
+  /**
+   * Finds all timestamp IDs associated with a given document hash. Timestamp IDs can be used to retrieve and verify
+   * timestamp entries on the blockchain.
+   * 
+   * @param hash The keccak256 hash of the document to search for.
+   * @returns A promise that resolves to an array of timestamp IDs associated with the provided document hash.
+   */
+  async findTimestampsByHash(hash) {
+    const timestamps = await this.web3doc.getTimestampLogsByHash(toHex(hash));
+    return timestamps.map((t) => t.id);
+  }
+  /*****************************************************************************************************************/
+  /* DOCUMENT EXCHANGE                                                                                             */
+  /*****************************************************************************************************************/
+  // TODO: Implement document exchange methods (sendDocument, sendCopy, signDocument, etc.)
+};
+
+export { BYTES32_ZERO, EventType, FlatFee2 as FlatFee, HexTooLongError, InvalidHexError, Web3Doc2 as Web3Doc, Web3DocEvents, Web3DocService, Web3DocServiceCriticalError, Web3DocServiceError, Web3DocServiceValidationError, Web3PGP2 as Web3PGP, Web3PGPEvents, Web3PGPService, Web3PGPServiceCriticalError, Web3PGPServiceError, Web3PGPServiceValidationError, to0x, toBytes32 };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map