@appliedblockchain/silentdatarollup-core 1.0.8 → 1.0.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Applied Blockchain Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/{chunk-5JD3GAHS.mjs → chunk-53A5RGL2.mjs}

@@ -1,12 +1,21 @@
 // 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_getTransactionReceipt",
+  "eth_getUserOperationReceipt",
+  "eth_getUserOperationByHash"
 ];
 var eip721Domain = {
   name: "Silent Data [Rollup]",
@@ -22,11 +31,19 @@ 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 = [
@@ -42,19 +59,15 @@ var WHITELISTED_METHODS = [
   "eth_getCode",
   "eth_getFilterChanges",
   "eth_getFilterLogs",
-  "eth_getHashrate",
   "eth_getHeaderByHash",
   "eth_getLogs",
   "eth_getProof",
   "eth_getTransactionByHash",
   "eth_getTransactionCount",
   "eth_getTransactionReceipt",
-  "eth_hashrate",
   "eth_maxPriorityFeePerGas",
-  "eth_mining",
   "eth_newBlockFilter",
   "eth_sendRawTransaction",
-  "eth_submitTransaction",
   "eth_syncing",
   "eth_newFilter",
   "eth_newPendingTransactionFilter",
@@ -62,21 +75,19 @@ var WHITELISTED_METHODS = [
   "net_version",
   "net_peerCount",
   "web3_clientVersion",
-  "web3_sha3",
-  "zkevm_batchNumber",
-  "zkevm_batchNumberByBlockNumber",
-  "zkevm_consolidatedBlockNumber",
-  "zkevm_estimateGasPrice",
-  "zkevm_getBatchByNumber",
-  "zkevm_getFullBlockByHash",
-  "zkevm_getFullBlockByNumber",
-  "zkevm_getLatestGlobalExitRoot",
-  "zkevm_isBlockConsolidated",
-  "zkevm_isBlockVirtualized",
-  "zkevm_verifiedBatchNumber",
-  "zkevm_virtualBatchNumber"
+  "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";
@@ -239,7 +250,7 @@ var SilentDataRollupBase = class {
     this._cachedNetwork = null;
     this.config = {
       ...config,
-      authSignatureType: config.authSignatureType ?? "RAW" /* Raw */
+      authSignatureType: config.authSignatureType ?? "EIP191" /* EIP191 */
     };
     this.delegateConfig = this.resolveDelegateConfig(config);
     log2(
@@ -324,37 +335,67 @@ var SilentDataRollupBase = class {
   /**
    * 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 signRawDelegateHeader(provider, message) {
-    log2("signRawDelegateHeader: Signing raw delegate header", message);
-    const signature = await provider.signer.signMessage(message);
-    log2("signRawDelegateHeader: Raw signature generated:", signature);
+  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) {
+  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(
-      { ...eip721Domain, chainId },
+      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) {
@@ -362,7 +403,9 @@ var SilentDataRollupBase = class {
     }
     const currentPromise = this.delegateHeadersPromise;
     try {
-      return await currentPromise;
+      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");
@@ -393,13 +436,16 @@ var SilentDataRollupBase = class {
         [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 raw signature");
+          log2("Generating delegate signature");
           const delegateMessageToSign = chainId + JSON.stringify(delegateSignerMessage);
-          headers[HEADER_DELEGATE_SIGNATURE] = await this.signRawDelegateHeader(
+          headers[HEADER_DELEGATE_SIGNATURE] = await this.signDelegateHeader(
             provider,
-            delegateMessageToSign
+            delegateMessageToSign,
+            isSWC
           );
           break;
         }
@@ -408,7 +454,8 @@ var SilentDataRollupBase = class {
           headers[HEADER_EIP712_DELEGATE_SIGNATURE] = await this.signTypedDelegateHeader(
             provider,
             chainId,
-            delegateSignerMessage
+            delegateSignerMessage,
+            isSWC
           );
           break;
         default:
@@ -429,24 +476,57 @@ var SilentDataRollupBase = class {
       [HEADER_TIMESTAMP]: xTimestamp
     };
     const chainId = (await this.getCachedNetwork(provider)).chainId.toString();
-    const signatureType = this.config.authSignatureType;
+    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 raw signature");
-        headers[HEADER_SIGNATURE] = await this.signAuthHeaderRawMessage(
+        log2("Generating auth header signature");
+        headers[HEADER_SIGNATURE] = await this.signAuthHeader(
           provider,
-          payload,
+          payloadToSign,
           xTimestamp,
-          chainId
+          chainId,
+          isSWC
         );
         break;
       case "EIP712" /* EIP712 */:
-        log2("Generating auth headerEIP712 signature");
-        headers[HEADER_EIP712_SIGNATURE] = await this.signAuthHeaderTypedData(
+        log2("Generating auth header typed signature");
+        headers[HEADER_EIP712_SIGNATURE] = await this.signTypedAuthHeader(
           provider,
-          payload,
+          payloadToSign,
           xTimestamp,
-          chainId
+          chainId,
+          isSWC
         );
         break;
       default:
@@ -455,26 +535,53 @@ var SilentDataRollupBase = class {
     log2("Auth headers:", JSON.stringify(headers, null, 2));
     return headers;
   }
-  async signAuthHeaderRawMessage(provider, payload, timestamp, chainId) {
-    const xMessage = this.prepareSignatureMessage(chainId, payload, timestamp);
+  /**
+   * 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 signature = await this.signMessage(signer, xMessage);
-    log2("Message signed. Signature:", signature);
+    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;
   }
-  async signAuthHeaderTypedData(provider, payload, timestamp, chainId) {
-    const message = this.prepareSignatureTypedData(payload, timestamp);
+  /**
+   * 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. Signature:", signature);
+    log2("Message signed with EIP-712. Signature:", signature);
     return signature;
   }
   /**
@@ -506,10 +613,81 @@ var SilentDataRollupBase = class {
       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.
    */
-  prepareSignatureMessage(chainId, payload, timestamp) {
+  prepareMessage(chainId, payload, timestamp) {
     log2("Preparing raw message for signing", {
       payload: JSON.stringify(payload, null, 2),
       timestamp
@@ -522,7 +700,7 @@ var SilentDataRollupBase = class {
   /**
    * Prepares the message to be signed for the x-eip712-signature header.
    */
-  prepareSignatureTypedData(payload, timestamp) {
+  prepareTypedData(payload, timestamp) {
     log2("Preparing payload for signTypedData");
     const preparedPayload = Array.isArray(payload) ? payload.map(prepareTypedDataPayload) : prepareTypedDataPayload(payload);
     const message = {
@@ -535,8 +713,8 @@ var SilentDataRollupBase = class {
 };
 
 // src/contract.ts
-import { Contract, Interface } from "ethers";
-var SilentDataRollupContract = class extends Contract {
+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);
@@ -555,16 +733,6 @@ var SilentDataRollupContract = class extends Contract {
   }
 };
 
-// src/privateEvents.ts
-import { keccak256, toUtf8Bytes } from "ethers";
-var PRIVATE_EVENT_SIGNATURE = "PrivateEvent(address[],bytes32,bytes)";
-var PRIVATE_EVENT_SIGNATURE_HASH = keccak256(
-  toUtf8Bytes(PRIVATE_EVENT_SIGNATURE)
-);
-function calculateEventTypeHash(eventSignature) {
-  return keccak256(toUtf8Bytes(eventSignature));
-}
-
 export {
   SIGN_RPC_METHODS,
   eip721Domain,
@@ -573,14 +741,23 @@ export {
   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,
@@ -590,8 +767,5 @@ export {
   defaultGetDelegate,
   prepareTypedDataPayload,
   SilentDataRollupBase,
-  SilentDataRollupContract,
-  PRIVATE_EVENT_SIGNATURE,
-  PRIVATE_EVENT_SIGNATURE_HASH,
-  calculateEventTypeHash
+  SilentDataRollupContract
 };

package/dist/index.d.mts

@@ -15,11 +15,39 @@ declare const DEBUG_NAMESPACE = "silentdata:core";
 declare const DEBUG_NAMESPACE_SILENTDATA_INTERCEPTOR = "silentdata:interceptor";
 declare const HEADER_SIGNATURE = "x-signature";
 declare const HEADER_TIMESTAMP = "x-timestamp";
+declare const HEADER_SIGNATURE_TYPE = "x-signature-type";
 declare const HEADER_EIP712_SIGNATURE = "x-eip712-signature";
 declare const HEADER_DELEGATE = "x-delegate";
 declare const HEADER_DELEGATE_SIGNATURE = "x-delegate-signature";
 declare const HEADER_EIP712_DELEGATE_SIGNATURE = "x-eip712-delegate-signature";
 declare const HEADER_SIGNER_SWC = "x-signer-swc";
+/**
+ * Header used when signing a user operation receipt call to the bundler (eth_getUserOperationReceipt)
+ */
+declare const HEADER_FROM_BLOCK = "x-from-block";
+/**
+ * Entrypoint address used when building eth_getLogs payload for signing eth_getUserOperationReceipt calls.
+ * This is hardcoded for now as we are just starting and will have support for only one version anyway.
+ * We are not worrying about different versions for now.
+ * In the future, if we do support other versions, this should be made a config while initializing the provider.
+ */
+declare const ENTRYPOINT_ADDRESS = "0x34F5Bda45f2Ce00B646BD6B19D0F9817b5D8D398";
+/**
+ * Default number of blocks to look back when fetching user operation receipts.
+ * This is used to calculate the fromBlock parameter in eth_getUserOperationReceipt requests.
+ */
+declare const DEFAULT_USER_OPERATION_RECEIPT_LOOKUP_RANGE = 1024;
+/**
+ * The signature for the UserOperationEvent from ERC-4337
+ * This is the event emitted by the EntryPoint contract and wrapped in PrivateEvent
+ */
+declare const USER_OPERATION_EVENT_SIGNATURE = "UserOperationEvent(bytes32,address,address,uint256,bool,uint256,uint256)";
+/**
+ * The keccak256 hash of the UserOperationEvent signature
+ * Used as the eventType filter when querying for user operation receipts via eth_getLogs
+ * Value: 0x49628fd1471006c1482da88028e9ce4dbb080b815c9b0344d39e5a8e6ec1419f
+ */
+declare const USER_OPERATION_EVENT_HASH: string;
 declare const DEFAULT_DELEGATE_EXPIRES: number;
 /**
  * A buffer time (in seconds) added to the current time when verifying the validity of a delegate.
@@ -73,6 +101,17 @@ type BaseConfig = {
         expires?: number;
     };
     authSignatureType?: SignatureType;
+    /**
+     * Smart wallet contract address.
+     * When provided, signing will be done on the hashed message for EIP-1271 verification.
+     */
+    smartWalletAddress?: string;
+    /**
+     * The block range to look back when fetching user operation receipts.
+     * This value is used to calculate the fromBlock parameter when querying for receipts.
+     * If not provided, defaults to DEFAULT_USER_OPERATION_RECEIPT_LOOKUP_RANGE (1024 blocks).
+     */
+    userOperationReceiptLookupRange?: number;
 };
 type DelegateSignerMessage = {
     expires: string;
@@ -89,6 +128,8 @@ type AuthHeaders = {
     [HEADER_TIMESTAMP]: string;
     [HEADER_SIGNATURE]?: string;
     [HEADER_EIP712_SIGNATURE]?: string;
+    [HEADER_SIGNATURE_TYPE]?: string;
+    [HEADER_FROM_BLOCK]?: string;
 };
 type DelegateHeaders = {
     [HEADER_DELEGATE]: string;
@@ -129,24 +170,39 @@ declare class SilentDataRollupBase {
     /**
      * 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
      */
-    protected signRawDelegateHeader(provider: any, message: string): Promise<string>;
+    protected signDelegateHeader(provider: any, message: string, isSWC?: boolean): Promise<string>;
     /**
      * 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
      */
-    protected signTypedDelegateHeader(provider: any, chainId: string, message: DelegateSignerMessage): Promise<string>;
+    protected signTypedDelegateHeader(provider: any, chainId: string, message: DelegateSignerMessage, isSWC?: boolean): Promise<string>;
+    /**
+     * 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.
+     */
     getDelegateHeaders(provider: any): Promise<DelegateHeaders>;
     generateDelegateHeaders(provider: any): Promise<DelegateHeaders>;
     getAuthHeaders(provider: any, payload: JsonRpcPayload | JsonRpcPayload[]): Promise<AuthHeaders>;
-    signAuthHeaderRawMessage(provider: any, payload: JsonRpcPayload | JsonRpcPayload[], timestamp: string, chainId: string): Promise<string>;
-    signAuthHeaderTypedData(provider: any, payload: JsonRpcPayload | JsonRpcPayload[], timestamp: string, chainId: string): Promise<string>;
+    /**
+     * Signs auth header.
+     */
+    signAuthHeader(provider: any, payload: JsonRpcPayload | JsonRpcPayload[], timestamp: string, chainId: string, isSWC?: boolean): Promise<string>;
+    /**
+     * Signs auth header using typed data signature.
+     */
+    signTypedAuthHeader(provider: any, payload: JsonRpcPayload | JsonRpcPayload[], timestamp: string, chainId: string, isSWC?: boolean): Promise<string>;
     /**
      * Signs a message using the provided signer.
      * This method can be overridden to customize the signing process.
@@ -166,14 +222,45 @@ declare class SilentDataRollupBase {
      */
     protected signTypedData(signer: any, domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>): Promise<string>;
     setContract(contract: Contract, contractMethodsToSign: string[]): void;
+    /**
+     * 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
+     */
+    protected getFromBlockForUserOperationReceipt(provider: any): Promise<bigint>;
+    /**
+     * 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
+     */
+    protected buildGetUserOperationReceiptSigningPayload(payload: JsonRpcPayload, fromBlock: bigint): JsonRpcPayload;
     /**
      * Prepares the message to be signed for the x-signature header.
      */
-    prepareSignatureMessage(chainId: string, payload: JsonRpcPayload | JsonRpcPayload[], timestamp: string): string;
+    prepareMessage(chainId: string, payload: JsonRpcPayload | JsonRpcPayload[], timestamp: string): string;
     /**
      * Prepares the message to be signed for the x-eip712-signature header.
      */
-    prepareSignatureTypedData(payload: JsonRpcPayload | JsonRpcPayload[], timestamp: string): AuthSignatureMessage;
+    prepareTypedData(payload: JsonRpcPayload | JsonRpcPayload[], timestamp: string): AuthSignatureMessage;
 }
 
 declare class SilentDataRollupContract extends Contract {
@@ -241,4 +328,4 @@ interface PrivateEvent {
  */
 declare function calculateEventTypeHash(eventSignature: string): string;
 
-export { type AuthHeaders, type AuthSignatureMessage, type AuthSignatureMessageRequest, type BaseConfig, ChainId, type ContractInfo, DEBUG_NAMESPACE, DEBUG_NAMESPACE_SILENTDATA_INTERCEPTOR, DEFAULT_DELEGATE_EXPIRES, DELEGATE_EXPIRATION_THRESHOLD_BUFFER, type DelegateConfig, type DelegateHeaders, type DelegateSignerMessage, HEADER_DELEGATE, HEADER_DELEGATE_SIGNATURE, HEADER_EIP712_DELEGATE_SIGNATURE, HEADER_EIP712_SIGNATURE, HEADER_SIGNATURE, HEADER_SIGNER_SWC, HEADER_TIMESTAMP, NetworkName, PRIVATE_EVENT_SIGNATURE, PRIVATE_EVENT_SIGNATURE_HASH, type PrivateEvent, SIGN_RPC_METHODS, SignatureType, type SilentDataProviderOptions, SilentDataRollupBase, SilentDataRollupContract, type SilentDataRollupContractConfig, type SilentdataNetworkConfig, WHITELISTED_METHODS, calculateEventTypeHash, defaultGetDelegate, delegateEIP721Types, eip721Domain, getAuthEIP721Types, getAuthHeaders, isSignableContractCall, prepareTypedDataPayload };
+export { type AuthHeaders, type AuthSignatureMessage, type AuthSignatureMessageRequest, type BaseConfig, ChainId, type ContractInfo, DEBUG_NAMESPACE, DEBUG_NAMESPACE_SILENTDATA_INTERCEPTOR, DEFAULT_DELEGATE_EXPIRES, DEFAULT_USER_OPERATION_RECEIPT_LOOKUP_RANGE, DELEGATE_EXPIRATION_THRESHOLD_BUFFER, type DelegateConfig, type DelegateHeaders, type DelegateSignerMessage, ENTRYPOINT_ADDRESS, HEADER_DELEGATE, HEADER_DELEGATE_SIGNATURE, HEADER_EIP712_DELEGATE_SIGNATURE, HEADER_EIP712_SIGNATURE, HEADER_FROM_BLOCK, HEADER_SIGNATURE, HEADER_SIGNATURE_TYPE, HEADER_SIGNER_SWC, HEADER_TIMESTAMP, NetworkName, PRIVATE_EVENT_SIGNATURE, PRIVATE_EVENT_SIGNATURE_HASH, type PrivateEvent, SIGN_RPC_METHODS, SignatureType, type SilentDataProviderOptions, SilentDataRollupBase, SilentDataRollupContract, type SilentDataRollupContractConfig, type SilentdataNetworkConfig, USER_OPERATION_EVENT_HASH, USER_OPERATION_EVENT_SIGNATURE, WHITELISTED_METHODS, calculateEventTypeHash, defaultGetDelegate, delegateEIP721Types, eip721Domain, getAuthEIP721Types, getAuthHeaders, isSignableContractCall, prepareTypedDataPayload };