@appliedblockchain/silentdatarollup-core 1.0.9 → 1.0.10

package/dist/chunk-53A5RGL2.mjs

@@ -1,771 +0,0 @@
-// src/Base.ts
-import debug2 from "debug";
-import {
-  getBytes,
-  keccak256 as keccak2563,
-  toUtf8Bytes as toUtf8Bytes3,
-  TypedDataEncoder
-} from "ethers";
-
-// src/constants.ts
-import { keccak256, toUtf8Bytes } from "ethers";
-var SIGN_RPC_METHODS = [
-  "eth_estimateGas",
-  "eth_getProof",
-  "eth_getTransactionByHash",
-  "eth_getTransactionReceipt",
-  "eth_getUserOperationReceipt",
-  "eth_getUserOperationByHash"
-];
-var eip721Domain = {
-  name: "Silent Data [Rollup]",
-  version: "1"
-};
-var delegateEIP721Types = {
-  Ticket: [
-    { name: "expires", type: "string" },
-    { name: "ephemeralAddress", type: "string" }
-  ]
-};
-var DEBUG_NAMESPACE = "silentdata:core";
-var DEBUG_NAMESPACE_SILENTDATA_INTERCEPTOR = "silentdata:interceptor";
-var HEADER_SIGNATURE = "x-signature";
-var HEADER_TIMESTAMP = "x-timestamp";
-var HEADER_SIGNATURE_TYPE = "x-signature-type";
-var HEADER_EIP712_SIGNATURE = "x-eip712-signature";
-var HEADER_DELEGATE = "x-delegate";
-var HEADER_DELEGATE_SIGNATURE = "x-delegate-signature";
-var HEADER_EIP712_DELEGATE_SIGNATURE = "x-eip712-delegate-signature";
-var HEADER_SIGNER_SWC = "x-signer-swc";
-var HEADER_FROM_BLOCK = "x-from-block";
-var ENTRYPOINT_ADDRESS = "0x34F5Bda45f2Ce00B646BD6B19D0F9817b5D8D398";
-var DEFAULT_USER_OPERATION_RECEIPT_LOOKUP_RANGE = 1024;
-var USER_OPERATION_EVENT_SIGNATURE = "UserOperationEvent(bytes32,address,address,uint256,bool,uint256,uint256)";
-var USER_OPERATION_EVENT_HASH = keccak256(
-  toUtf8Bytes(USER_OPERATION_EVENT_SIGNATURE)
-);
-var DEFAULT_DELEGATE_EXPIRES = 10 * 60 * 60;
-var DELEGATE_EXPIRATION_THRESHOLD_BUFFER = 5;
-var WHITELISTED_METHODS = [
-  "eth_blockNumber",
-  "eth_call",
-  "eth_chainId",
-  "eth_estimateGas",
-  "eth_feeHistory",
-  "eth_gasPrice",
-  "eth_getBalance",
-  "eth_getBlockByHash",
-  "eth_getBlockByNumber",
-  "eth_getCode",
-  "eth_getFilterChanges",
-  "eth_getFilterLogs",
-  "eth_getHeaderByHash",
-  "eth_getLogs",
-  "eth_getProof",
-  "eth_getTransactionByHash",
-  "eth_getTransactionCount",
-  "eth_getTransactionReceipt",
-  "eth_maxPriorityFeePerGas",
-  "eth_newBlockFilter",
-  "eth_sendRawTransaction",
-  "eth_syncing",
-  "eth_newFilter",
-  "eth_newPendingTransactionFilter",
-  "net_listening",
-  "net_version",
-  "net_peerCount",
-  "web3_clientVersion",
-  "web3_sha3"
-];
-
-// src/privateEvents.ts
-import { keccak256 as keccak2562, toUtf8Bytes as toUtf8Bytes2 } from "ethers";
-var PRIVATE_EVENT_SIGNATURE = "PrivateEvent(address[],bytes32,bytes)";
-var PRIVATE_EVENT_SIGNATURE_HASH = keccak2562(
-  toUtf8Bytes2(PRIVATE_EVENT_SIGNATURE)
-);
-function calculateEventTypeHash(eventSignature) {
-  return keccak2562(toUtf8Bytes2(eventSignature));
-}
-
-// src/types.ts
-var ChainId = /* @__PURE__ */ ((ChainId2) => {
-  ChainId2[ChainId2["MAINNET"] = 380929] = "MAINNET";
-  ChainId2[ChainId2["TESTNET"] = 381185] = "TESTNET";
-  return ChainId2;
-})(ChainId || {});
-var NetworkName = /* @__PURE__ */ ((NetworkName2) => {
-  NetworkName2["MAINNET"] = "sdr";
-  NetworkName2["TESTNET"] = "sdr-testnet";
-  return NetworkName2;
-})(NetworkName || {});
-var SignatureType = /* @__PURE__ */ ((SignatureType2) => {
-  SignatureType2["Raw"] = "RAW";
-  SignatureType2["EIP191"] = "EIP191";
-  SignatureType2["EIP712"] = "EIP712";
-  return SignatureType2;
-})(SignatureType || {});
-
-// src/utils.ts
-import debug from "debug";
-import { Wallet } from "ethers";
-var log = debug(DEBUG_NAMESPACE);
-function getAuthEIP721Types(payload) {
-  return {
-    Call: [
-      {
-        name: "request",
-        type: Array.isArray(payload) ? "JsonRPCRequest[]" : "JsonRPCRequest"
-      },
-      { name: "timestamp", type: "string" }
-    ],
-    JsonRPCRequest: [
-      { name: "jsonrpc", type: "string" },
-      { name: "method", type: "string" },
-      { name: "params", type: "string" },
-      { name: "id", type: "uint256" }
-    ]
-  };
-}
-async function signAuthHeaderTypedData(signer, payload, timestamp, chainId) {
-  log("Preparing payload for signTypedData");
-  const preparePayload = (p) => ({
-    ...p,
-    params: JSON.stringify(p.params)
-  });
-  const preparedPayload = Array.isArray(payload) ? payload.map(preparePayload) : preparePayload(payload);
-  const message = {
-    request: preparedPayload,
-    timestamp
-  };
-  const types = getAuthEIP721Types(payload);
-  const domain = { ...eip721Domain, chainId };
-  log("Signing typed data", JSON.stringify({ domain, types, message }, null, 2));
-  const signature = await signer.signTypedData(domain, types, message);
-  log("Signature generated:", signature);
-  return signature;
-}
-async function signAuthHeaderRawMessage(signer, payload, timestamp, chainId) {
-  log("Preparing raw message for signing");
-  const serialRequest = JSON.stringify(payload);
-  const xMessage = chainId + serialRequest + timestamp;
-  log("Raw message:", xMessage);
-  const signature = await signer.signMessage(xMessage);
-  log("Raw signature generated:", signature);
-  return signature;
-}
-async function getAuthHeaders(signer, payload, chainId, signatureType) {
-  const xTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const headers = {
-    [HEADER_TIMESTAMP]: xTimestamp
-  };
-  switch (signatureType) {
-    case "RAW" /* Raw */:
-      log("Generating raw signature");
-      headers[HEADER_SIGNATURE] = await signAuthHeaderRawMessage(
-        signer,
-        payload,
-        xTimestamp,
-        chainId
-      );
-      break;
-    case "EIP712" /* EIP712 */:
-      log("Generating EIP712 signature");
-      headers[HEADER_EIP712_SIGNATURE] = await signAuthHeaderTypedData(
-        signer,
-        payload,
-        xTimestamp,
-        chainId
-      );
-      break;
-    default:
-      throw new Error(`Unsupported signature type: ${signatureType}`);
-  }
-  return headers;
-}
-function isSignableContractCall(payload, contracts) {
-  if (!contracts || contracts.length === 0) {
-    return false;
-  }
-  log("Checking if contract call is signable");
-  if (payload.method !== "eth_call") {
-    log("Payload method is not eth_call, returning false");
-    return false;
-  }
-  const params = payload.params;
-  if (!params || params.length === 0 || typeof params[0] !== "object") {
-    log("Invalid params, returning false");
-    return false;
-  }
-  const callTarget = params[0].to;
-  if (!callTarget) {
-    log("Missing call target, returning false");
-    return false;
-  }
-  log(`Call target: ${callTarget}`);
-  const contractIndex = contracts.findIndex(
-    (c) => c.contract.target.toString().toLowerCase() === callTarget.toLowerCase()
-  );
-  if (contractIndex < 0) {
-    log("Contract not found, returning false");
-    return false;
-  }
-  const callData = params[0].data;
-  if (!callData) {
-    log("Missing call data, returning false");
-    return false;
-  }
-  const methodSignature = callData.slice(2, 10);
-  if (!methodSignature) {
-    log("Missing method signature, returning false");
-    return false;
-  }
-  log(`Method signature: ${methodSignature}`);
-  const { contract, contractMethodsToSign } = contracts[contractIndex];
-  const isSignable = contractMethodsToSign.some((methodName) => {
-    const fragment = contract.interface.getFunction(methodName);
-    return !!fragment && methodSignature.startsWith(fragment.selector.slice(2));
-  });
-  log("Is signable contract call:", isSignable);
-  return isSignable;
-}
-var defaultGetDelegate = async (provider) => {
-  return Wallet.createRandom();
-};
-var prepareTypedDataPayload = (p) => ({
-  ...p,
-  params: JSON.stringify(p.params)
-});
-
-// src/Base.ts
-var log2 = debug2(DEBUG_NAMESPACE);
-var SilentDataRollupBase = class {
-  constructor(config) {
-    this.currentDelegateSigner = null;
-    this.delegateSignerExpires = 0;
-    this.cachedDelegateHeaders = null;
-    this.cachedHeadersExpiry = 0;
-    this.delegateHeadersPromise = null;
-    this.contracts = [];
-    this._cachedNetwork = null;
-    this.config = {
-      ...config,
-      authSignatureType: config.authSignatureType ?? "EIP191" /* EIP191 */
-    };
-    this.delegateConfig = this.resolveDelegateConfig(config);
-    log2(
-      "SilentDataRollupBase initialized with config:",
-      JSON.stringify(config, null, 2)
-    );
-  }
-  resolveDelegateConfig(config) {
-    if (config.delegate === true) {
-      return {
-        getDelegate: defaultGetDelegate,
-        expires: DEFAULT_DELEGATE_EXPIRES
-      };
-    } else if (typeof config.delegate === "object") {
-      return {
-        getDelegate: config.delegate.getDelegate ?? defaultGetDelegate,
-        expires: config.delegate.expires ?? DEFAULT_DELEGATE_EXPIRES
-      };
-    }
-    return null;
-  }
-  /**
-   * Get cached network with simple caching
-   * @param provider - The provider to get the network from
-   * @returns Promise<Network> - The cached or freshly fetched network
-   */
-  async getCachedNetwork(provider) {
-    if (!this._cachedNetwork) {
-      this._cachedNetwork = await provider.getNetwork();
-      log2("Network cached:", this._cachedNetwork);
-    }
-    return this._cachedNetwork;
-  }
-  async getDelegateSigner(provider) {
-    if (!this.delegateConfig) {
-      log2("getDelegateSigner: No delegate config, returning null");
-      return null;
-    }
-    const now = Math.floor(Date.now() / 1e3);
-    log2("getDelegateSigner: Current time:", now);
-    const isDelegateSignerValid = this.currentDelegateSigner && this.delegateSignerExpires - DELEGATE_EXPIRATION_THRESHOLD_BUFFER > now;
-    if (isDelegateSignerValid) {
-      log2(
-        "getDelegateSigner: Returning existing delegate signer, expires in:",
-        this.delegateSignerExpires - now,
-        "seconds"
-      );
-      return this.currentDelegateSigner;
-    } else {
-      log2("getDelegateSigner: Getting new delegate signer");
-      try {
-        const newSigner = await this.delegateConfig.getDelegate(provider);
-        this.currentDelegateSigner = newSigner;
-        this.delegateSignerExpires = now + this.delegateConfig.expires;
-        log2(
-          "getDelegateSigner: New delegate signer set, expires in:",
-          this.delegateConfig.expires,
-          "seconds"
-        );
-        return newSigner;
-      } catch (error) {
-        log2("getDelegateSigner: Error getting delegate signer:", error);
-        throw new Error("Failed to get delegate signer");
-      }
-    }
-  }
-  async getDelegateSignerMessage(provider) {
-    if (!this.delegateConfig) {
-      log2("No delegate config, returning null");
-      return null;
-    }
-    const delegateSigner = await this.getDelegateSigner(provider);
-    if (!delegateSigner) {
-      log2("Failed to get delegate signer, returning null");
-      return null;
-    }
-    return {
-      expires: new Date(this.delegateSignerExpires * 1e3).toISOString(),
-      ephemeralAddress: await delegateSigner.getAddress()
-    };
-  }
-  /**
-   * Signs a raw delegate header message.
-   * This method can be overridden by extending classes to customize the signing process.
-   * The signer implementation decides whether to add EIP-191 prefix or not.
-   * @param provider - The provider used for signing
-   * @param message - The delegate signer message to be signed
-   * @param isSWC - Whether signing for smart wallet contract (EIP-1271)
-   * @returns A promise that resolves to the signature string
-   */
-  async signDelegateHeader(provider, message, isSWC) {
-    log2("signDelegateHeader: Signing delegate header", message);
-    let bytesToSign;
-    if (isSWC) {
-      const messageHash = keccak2563(toUtf8Bytes3(message));
-      bytesToSign = getBytes(messageHash);
-      log2("Signing hash bytes for SWC", messageHash);
-    } else {
-      bytesToSign = toUtf8Bytes3(message);
-      log2("Signing message bytes for EOA", message);
-    }
-    const signature = await provider.signer.signMessage(bytesToSign);
-    log2("signDelegateHeader: Signature generated:", signature);
-    return signature;
-  }
-  /**
-   * Signs a typed delegate header message.
-   * This method can be overridden by extending classes to customize the signing process.
-   * @param provider - The provider used for signing
-   * @param chainId - The chain ID
-   * @param message - The delegate signer message to be signed
-   * @param isSWC - Whether signing for smart wallet contract (EIP-1271)
-   * @returns A promise that resolves to the signature string
-   */
-  async signTypedDelegateHeader(provider, chainId, message, isSWC) {
-    log2("signTypedDelegateHeader: Signing typed delegate header");
-    log2(
-      "signTypedDelegateHeader: Typed message:",
-      JSON.stringify(message, null, 2)
-    );
-    const domain = { ...eip721Domain, chainId };
-    if (isSWC) {
-      const messageHash = TypedDataEncoder.hash(
-        domain,
-        delegateEIP721Types,
-        message
-      );
-      const hashBytes = getBytes(messageHash);
-      const signature2 = await provider.signer.signMessage(hashBytes);
-      log2("signTypedDelegateHeader: Typed SWC signature generated:", signature2);
-      return signature2;
-    }
-    const signature = await provider.signer.signTypedData(
-      domain,
-      delegateEIP721Types,
-      message
-    );
-    log2("signTypedDelegateHeader: Signature generated:", signature);
-    return signature;
-  }
-  /**
-   * IMPORTANT: Return the cached promise (currentPromise), not the resolved value.
-   * This ensures multiple concurrent callers share the same in-flight request,
-   * preventing redundant API calls.
-   */
-  async getDelegateHeaders(provider) {
-    log2("Getting delegate headers");
-    if (!this.delegateHeadersPromise) {
-      this.delegateHeadersPromise = this.generateDelegateHeaders(provider);
-    }
-    const currentPromise = this.delegateHeadersPromise;
-    try {
-      const delegateHeaders = await currentPromise;
-      log2("Delegate headers:", JSON.stringify(delegateHeaders, null, 2));
-      return currentPromise;
-    } catch (error) {
-      log2("Error getting delegate headers:", error);
-      throw new Error("Failed to get delegate headers");
-    } finally {
-      if (this.delegateHeadersPromise === currentPromise) {
-        this.delegateHeadersPromise = null;
-      }
-    }
-  }
-  async generateDelegateHeaders(provider) {
-    const now = Math.floor(Date.now() / 1e3);
-    const signatureType = this.config.authSignatureType;
-    const isCachedHeadersValid = this.cachedDelegateHeaders && this.cachedHeadersExpiry - DELEGATE_EXPIRATION_THRESHOLD_BUFFER > now;
-    if (isCachedHeadersValid) {
-      log2("Returning cached delegate headers");
-      return this.cachedDelegateHeaders;
-    }
-    try {
-      const delegateSignerMessage = await this.getDelegateSignerMessage(provider);
-      if (!delegateSignerMessage) {
-        throw new Error("Failed to get delegate signer message");
-      }
-      const delegateSigner = await this.getDelegateSigner(provider);
-      if (!delegateSigner) {
-        throw new Error("Failed to get delegate signer");
-      }
-      const headers = {
-        [HEADER_DELEGATE]: JSON.stringify(delegateSignerMessage)
-      };
-      const chainId = (await this.getCachedNetwork(provider)).chainId.toString();
-      const isSWC = !!this.config.smartWalletAddress;
-      switch (signatureType) {
-        case "EIP191" /* EIP191 */:
-        case "RAW" /* Raw */: {
-          log2("Generating delegate signature");
-          const delegateMessageToSign = chainId + JSON.stringify(delegateSignerMessage);
-          headers[HEADER_DELEGATE_SIGNATURE] = await this.signDelegateHeader(
-            provider,
-            delegateMessageToSign,
-            isSWC
-          );
-          break;
-        }
-        case "EIP712" /* EIP712 */:
-          log2("Generating delegate EIP712 signature");
-          headers[HEADER_EIP712_DELEGATE_SIGNATURE] = await this.signTypedDelegateHeader(
-            provider,
-            chainId,
-            delegateSignerMessage,
-            isSWC
-          );
-          break;
-        default:
-          throw new Error(`Unsupported signature type: ${signatureType}`);
-      }
-      this.cachedDelegateHeaders = headers;
-      this.cachedHeadersExpiry = new Date(delegateSignerMessage.expires).getTime() / 1e3;
-      return this.cachedDelegateHeaders;
-    } catch (error) {
-      log2("Error getting delegate headers:", error);
-      throw new Error("Failed to get delegate headers");
-    }
-  }
-  async getAuthHeaders(provider, payload) {
-    log2("Getting auth headers", JSON.stringify(payload, null, 2));
-    const xTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const headers = {
-      [HEADER_TIMESTAMP]: xTimestamp
-    };
-    const chainId = (await this.getCachedNetwork(provider)).chainId.toString();
-    const signatureType = this.config.authSignatureType ?? "EIP191" /* EIP191 */;
-    const isSWC = !!this.config.smartWalletAddress;
-    let payloadToSign = payload;
-    const isGetUserOperationReceipt = !Array.isArray(payload) && payload.method === "eth_getUserOperationReceipt";
-    if (isGetUserOperationReceipt) {
-      log2(
-        "Detected eth_getUserOperationReceipt, building custom eth_getLogs payload for signing"
-      );
-      let fromBlock;
-      try {
-        fromBlock = await this.getFromBlockForUserOperationReceipt(provider);
-        headers[HEADER_FROM_BLOCK] = fromBlock.toString();
-        log2(`Added ${HEADER_FROM_BLOCK} header:`, fromBlock.toString());
-      } catch (error) {
-        log2(
-          "Error calculating fromBlock for eth_getUserOperationReceipt:",
-          error
-        );
-        throw new Error(
-          "Failed to calculate fromBlock for eth_getUserOperationReceipt"
-        );
-      }
-      payloadToSign = this.buildGetUserOperationReceiptSigningPayload(
-        payload,
-        fromBlock
-      );
-      log2(
-        "Using custom eth_getLogs payload for signing:",
-        JSON.stringify(payloadToSign, null, 2)
-      );
-    }
-    switch (signatureType) {
-      case "EIP191" /* EIP191 */:
-      case "RAW" /* Raw */:
-        log2("Generating auth header signature");
-        headers[HEADER_SIGNATURE] = await this.signAuthHeader(
-          provider,
-          payloadToSign,
-          xTimestamp,
-          chainId,
-          isSWC
-        );
-        break;
-      case "EIP712" /* EIP712 */:
-        log2("Generating auth header typed signature");
-        headers[HEADER_EIP712_SIGNATURE] = await this.signTypedAuthHeader(
-          provider,
-          payloadToSign,
-          xTimestamp,
-          chainId,
-          isSWC
-        );
-        break;
-      default:
-        throw new Error(`Unsupported signature type: ${signatureType}`);
-    }
-    log2("Auth headers:", JSON.stringify(headers, null, 2));
-    return headers;
-  }
-  /**
-   * Signs auth header.
-   */
-  async signAuthHeader(provider, payload, timestamp, chainId, isSWC) {
-    const xMessage = this.prepareMessage(chainId, payload, timestamp);
-    const delegateSigner = await this.getDelegateSigner(this);
-    const signer = delegateSigner ?? provider.signer;
-    const usingDelegate = !!delegateSigner;
-    let bytesToSign;
-    if (isSWC && !usingDelegate) {
-      const messageHash = keccak2563(toUtf8Bytes3(xMessage));
-      bytesToSign = getBytes(messageHash);
-      log2("Signing hash bytes for SWC");
-    } else {
-      bytesToSign = toUtf8Bytes3(xMessage);
-      log2("Signing message bytes for EOA");
-    }
-    const signature = await signer.signMessage(bytesToSign);
-    log2("Message signed raw. Signature:", signature);
-    return signature;
-  }
-  /**
-   * Signs auth header using typed data signature.
-   */
-  async signTypedAuthHeader(provider, payload, timestamp, chainId, isSWC) {
-    const message = this.prepareTypedData(payload, timestamp);
-    const types = getAuthEIP721Types(payload);
-    const delegateSigner = await this.getDelegateSigner(this);
-    const signer = delegateSigner ?? provider.signer;
-    const usingDelegate = !!delegateSigner;
-    const domain = { ...eip721Domain, chainId };
-    if (isSWC && !usingDelegate) {
-      const messageHash2 = TypedDataEncoder.hash(domain, types, message);
-      log2("EIP-712 hash (SWC without delegate):", messageHash2);
-      const hashBytes = getBytes(messageHash2);
-      const signature2 = await signer.signMessage(hashBytes);
-      log2("Message signed with EIP-712 for SWC. Signature:", signature2);
-      return signature2;
-    }
-    log2(
-      "Signing typed data",
-      JSON.stringify({ message, types, domain }, null, 2)
-    );
-    const messageHash = TypedDataEncoder.hash(domain, types, message);
-    log2("EIP-712 hash (EOA):", messageHash);
-    const signature = await this.signTypedData(signer, domain, types, message);
-    log2("Message signed with EIP-712. Signature:", signature);
-    return signature;
-  }
-  /**
-   * Signs a message using the provided signer.
-   * This method can be overridden to customize the signing process.
-   * @param signer - The signer to use
-   * @param message - The message to sign
-   * @returns A promise that resolves to the signature string
-   */
-  async signMessage(signer, message) {
-    return signer.signMessage(message);
-  }
-  /**
-   * Signs typed data using the provided signer.
-   * This method can be overridden to customize the signing process.
-   * @param signer - The signer to use
-   * @param domain - The EIP-712 domain
-   * @param types - The EIP-712 types
-   * @param message - The message to sign
-   * @returns A promise that resolves to the signature string
-   */
-  async signTypedData(signer, domain, types, message) {
-    return signer.signTypedData(domain, types, message);
-  }
-  setContract(contract, contractMethodsToSign) {
-    log2("Setting contract and methods to sign: ", contractMethodsToSign);
-    this.contracts.push({
-      contract,
-      contractMethodsToSign
-    });
-  }
-  /**
-   * Calculates the fromBlock value for eth_getUserOperationReceipt requests.
-   * Gets the current block number and subtracts the configured userOperationReceiptLookupRange.
-   *
-   * IMPORTANT: The bundler strictly validates this value and will reject the request if:
-   * - The header is missing
-   * - The value is < 0
-   * - The value is > current block number
-   * - The value is too far back (< currentBlock - userOperationReceiptLookupRange)
-   *
-   * This method ensures the returned value is always within the valid range:
-   * max(0, currentBlock - userOperationReceiptLookupRange) <= fromBlock <= currentBlock
-   *
-   * @param provider - The provider to use for fetching the current block number
-   * @returns A promise that resolves to the fromBlock value as a bigint
-   * @throws Error if unable to fetch the current block number
-   */
-  async getFromBlockForUserOperationReceipt(provider) {
-    const lookupRange = BigInt(
-      this.config.userOperationReceiptLookupRange ?? DEFAULT_USER_OPERATION_RECEIPT_LOOKUP_RANGE
-    );
-    log2("User operation receipt lookup range:", lookupRange.toString());
-    let currentBlockNumber;
-    if (typeof provider.getBlockNumber === "function") {
-      currentBlockNumber = BigInt(await provider.getBlockNumber());
-    } else if (typeof provider.request === "function") {
-      const blockNumberHex = await provider.request({
-        method: "eth_blockNumber",
-        params: []
-      });
-      currentBlockNumber = BigInt(blockNumberHex);
-    } else {
-      throw new Error(
-        "Provider does not support getBlockNumber or request method"
-      );
-    }
-    log2("Current block number:", currentBlockNumber.toString());
-    const fromBlock = currentBlockNumber > lookupRange ? currentBlockNumber - lookupRange : 0n;
-    log2("Calculated fromBlock:", fromBlock.toString());
-    return fromBlock;
-  }
-  /**
-   * Builds a custom eth_getLogs payload for signing when the original request is eth_getUserOperationReceipt.
-   * This method can be overridden to customize the payload construction.
-   *
-   * IMPORTANT: The bundler must reconstruct this exact payload to verify the signature.
-   * The bundler should use the same `id` from the original eth_getUserOperationReceipt request
-   * when constructing the eth_getLogs request to send to the RPC node.
-   *
-   * @param payload - The original eth_getUserOperationReceipt payload
-   * @param fromBlock - The fromBlock value to use in the eth_getLogs filter
-   * @returns A JsonRpcPayload with method 'eth_getLogs' to be used for signing
-   */
-  buildGetUserOperationReceiptSigningPayload(payload, fromBlock) {
-    return {
-      jsonrpc: payload.jsonrpc,
-      method: "eth_getLogs",
-      params: [
-        {
-          address: ENTRYPOINT_ADDRESS,
-          fromBlock: `0x${fromBlock.toString(16)}`,
-          topics: [
-            PRIVATE_EVENT_SIGNATURE_HASH,
-            USER_OPERATION_EVENT_HASH
-            // eventType
-          ]
-        }
-      ],
-      id: payload.id ?? 1
-    };
-  }
-  /**
-   * Prepares the message to be signed for the x-signature header.
-   */
-  prepareMessage(chainId, payload, timestamp) {
-    log2("Preparing raw message for signing", {
-      payload: JSON.stringify(payload, null, 2),
-      timestamp
-    });
-    const serialRequest = JSON.stringify(payload);
-    const xMessage = chainId + serialRequest + timestamp;
-    log2("Raw message to be signed:", xMessage);
-    return xMessage;
-  }
-  /**
-   * Prepares the message to be signed for the x-eip712-signature header.
-   */
-  prepareTypedData(payload, timestamp) {
-    log2("Preparing payload for signTypedData");
-    const preparedPayload = Array.isArray(payload) ? payload.map(prepareTypedDataPayload) : prepareTypedDataPayload(payload);
-    const message = {
-      request: preparedPayload,
-      timestamp
-    };
-    log2("Prepared payload for signTypedData", JSON.stringify(message, null, 2));
-    return message;
-  }
-};
-
-// src/contract.ts
-import { Contract as Contract2, Interface } from "ethers";
-var SilentDataRollupContract = class extends Contract2 {
-  constructor(config) {
-    const { address, abi, runner, contractMethodsToSign } = config;
-    const contractInterface = new Interface(abi);
-    contractMethodsToSign.forEach((method) => {
-      if (!contractInterface.hasFunction(method)) {
-        throw new Error(
-          `Method to sign '${method}' not found in the contract ABI`
-        );
-      }
-    });
-    super(address, abi, runner);
-    const baseProvider = runner.baseProvider || runner.provider?.baseProvider;
-    if (typeof baseProvider?.setContract === "function") {
-      baseProvider.setContract(this, contractMethodsToSign);
-    }
-  }
-};
-
-export {
-  SIGN_RPC_METHODS,
-  eip721Domain,
-  delegateEIP721Types,
-  DEBUG_NAMESPACE,
-  DEBUG_NAMESPACE_SILENTDATA_INTERCEPTOR,
-  HEADER_SIGNATURE,
-  HEADER_TIMESTAMP,
-  HEADER_SIGNATURE_TYPE,
-  HEADER_EIP712_SIGNATURE,
-  HEADER_DELEGATE,
-  HEADER_DELEGATE_SIGNATURE,
-  HEADER_EIP712_DELEGATE_SIGNATURE,
-  HEADER_SIGNER_SWC,
-  HEADER_FROM_BLOCK,
-  ENTRYPOINT_ADDRESS,
-  DEFAULT_USER_OPERATION_RECEIPT_LOOKUP_RANGE,
-  USER_OPERATION_EVENT_SIGNATURE,
-  USER_OPERATION_EVENT_HASH,
-  DEFAULT_DELEGATE_EXPIRES,
-  DELEGATE_EXPIRATION_THRESHOLD_BUFFER,
-  WHITELISTED_METHODS,
-  PRIVATE_EVENT_SIGNATURE,
-  PRIVATE_EVENT_SIGNATURE_HASH,
-  calculateEventTypeHash,
-  ChainId,
-  NetworkName,
-  SignatureType,
-  getAuthEIP721Types,
-  getAuthHeaders,
-  isSignableContractCall,
-  defaultGetDelegate,
-  prepareTypedDataPayload,
-  SilentDataRollupBase,
-  SilentDataRollupContract
-};