@appliedblockchain/silentdatarollup-ethers-provider 1.0.1 → 1.0.3

package/README.md

@@ -11,6 +11,10 @@
   - [Usage with a Contract](#usage-with-a-contract)
     - [Installing Usage with a Contract Dependencies](#installing-usage-with-a-contract-dependencies)
     - [Usage with a Contract Example](#usage-with-a-contract-example)
+  - [Private Events](#private-events)
+    - [Overview](#overview)
+    - [Using the SDInterface](#using-the-sdinterface)
+    - [Private Events Example](#private-events-example)
 - [Troubleshooting](#troubleshooting)
 - [License](#license)
 - [Additional Resources](#additional-resources)
@@ -106,6 +110,112 @@ const publicMethodResult = await contract.method3('param1', 'param2')
 console.log('Public method result:', publicMethodResult)
 ```
 
+### Private Events
+
+#### Overview
+
+Silent Data Rollup supports Private Events, which are blockchain events that are only visible to authorized users. The `SilentDataRollupProvider` includes specialized methods for working with these private events:
+
+- `getAllLogs()` - Returns both regular and private events
+- `getPrivateLogs()` - Returns only private events
+
+Private events are wrapped in a `PrivateEvent` event with the following structure:
+
+```solidity
+event PrivateEvent(
+  address[] allowedViewers,
+  bytes32 indexed eventType,
+  bytes payload
+);
+```
+
+#### Using the SDInterface
+
+To easily decode private events, use the `SDInterface` class which extends ethers' `Interface`:
+
+1. Create an `SDInterface` instance with your contract ABI plus **the private additional event signatures**
+2. Use it to parse logs from `getAllLogs()` or `getPrivateLogs()`
+3. Access the decoded inner event via the `innerLog` property of the parsed log
+
+#### Private Events Example
+
+```typescript
+import {
+  SDInterface,
+  SilentDataRollupProvider,
+} from '@appliedblockchain/silentdatarollup-ethers-provider'
+
+// Initialize provider
+const provider = new SilentDataRollupProvider({
+  rpcUrl: 'SILENT_DATA_ROLLUP_RPC_URL',
+  network: NetworkName.TESTNET,
+  privateKey: 'YOUR_PRIVATE_KEY',
+})
+
+// Contract ABI with PrivateEvent definition
+const contractAbi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: 'address[]',
+        name: 'allowedViewers',
+        type: 'address[]',
+      },
+      {
+        indexed: true,
+        internalType: 'bytes32',
+        name: 'eventType',
+        type: 'bytes32',
+      },
+      {
+        indexed: false,
+        internalType: 'bytes',
+        name: 'payload',
+        type: 'bytes',
+      },
+    ],
+    name: 'PrivateEvent',
+    type: 'event',
+  },
+  // Your other contract events and functions...
+]
+
+// Create SDInterface with contract ABI and any additional event signatures
+const sdInterface = new SDInterface([
+  ...contractAbi,
+  // Note: The private event doesn't have indexed params.
+  // Add any other event signatures that might be emitted privately
+  'event TransferPrivate(address from, address to, uint256 value)',
+])
+
+// Get private events
+const privateEvents = await provider.getPrivateLogs({
+  address: 'YOUR_CONTRACT_ADDRESS',
+  // Optional: Filter by specific event type
+  eventSignature: 'TransferPrivate(address,address,uint256)',
+})
+
+// Parse and access private events
+for (const log of privateEvents) {
+  const parsedLog = sdInterface.parseLog(log)
+
+  console.log('Private Event:', parsedLog.name) // Will be 'PrivateEvent'
+  console.log('Private Args:', parsedLog.args) // Raw PrivateEvent args
+
+  // Access the decoded inner event
+  if (parsedLog.innerLog) {
+    console.log('Decoded Private Event:', parsedLog.innerLog.name) // e.g., 'TransferPrivate'
+    console.log('Decoded Private Args:', parsedLog.innerLog.args) // Decoded inner event args
+
+    // Access args by name
+    const { from, to, value } = parsedLog.innerLog.args
+    console.log(`Transfer from ${from} to ${to}: ${value}`)
+  }
+}
+```
+
 ## License
 
 This project is licensed under the [MIT License](LICENSE).

package/dist/index.d.mts

@@ -1,7 +1,8 @@
-import { Signer, JsonRpcApiProviderOptions, JsonRpcProvider, JsonRpcPayload, JsonRpcResult, FetchRequest } from 'ethers';
+import { Signer, JsonRpcApiProviderOptions, Filter, JsonRpcProvider, JsonRpcPayload, JsonRpcResult, FetchRequest, Log, FilterByBlockHash, LogDescription, Interface } from 'ethers';
 import { BaseConfig, NetworkName } from '@appliedblockchain/silentdatarollup-core';
 
 declare const SIGN_RPC_METHODS: string[];
+declare const DEBUG_NAMESPACE = "silentdata:ethers-provider";
 
 interface SilentDataRollupProviderConfig extends BaseConfig {
     rpcUrl: string;
@@ -11,6 +12,24 @@ interface SilentDataRollupProviderConfig extends BaseConfig {
     signer?: Signer;
     options?: JsonRpcApiProviderOptions;
 }
+/**
+ * Extended filter type that includes a special flag for private events
+ * This flag is used to identify when a call to eth_getLogs originated from
+ * the getAllLogs method, so we can add authentication headers
+ */
+interface PrivateEventsFilter extends Filter {
+    /**
+     * Internal flag to identify requests that should include auth headers
+     * Set automatically by getAllLogs method
+     */
+    _isPrivateEvent?: boolean;
+    /**
+     * Optional event signature for filtering private events by type
+     * Example: "Transfer(address,address,uint256)"
+     * Will be converted to a hash and used for topic filtering
+     */
+    eventSignature?: string;
+}
 
 declare class SilentDataRollupProvider extends JsonRpcProvider {
     private config;
@@ -22,6 +41,66 @@ declare class SilentDataRollupProvider extends JsonRpcProvider {
         rpcUrl: string;
     }): FetchRequest;
     clone(): SilentDataRollupProvider;
+    /**
+     * Helper method to configure a filter for private events
+     * @param filter - The original filter
+     * @param forcePrivateOnly - Whether to force filtering for only PrivateEvents
+     * @returns The configured filter with proper topics
+     */
+    private configurePrivateEventsFilter;
+    /**
+     * Gets logs for private events, including authentication headers
+     * @param filter - The filter parameters for logs
+     * @returns Array of logs matching the filter
+     */
+    getAllLogs(filter?: PrivateEventsFilter): Promise<Array<Log>>;
+    /**
+     * Gets only private events (PrivateEvent logs), including authentication headers
+     * @param filter - The filter parameters for logs
+     * @returns Array of logs matching the filter, containing only PrivateEvent logs
+     */
+    getPrivateLogs(filter?: PrivateEventsFilter): Promise<Log[]>;
+    /**
+     * Override of ethers' getLogs method that preserves our custom _isPrivateEvent property
+     *
+     * IMPORTANT: This method mimics the behavior of ethers' original getLogs implementation
+     * but adds a crucial step to preserve the _isPrivateEvent flag. We need this because:
+     *
+     * 1. Ethers' _getFilter method sanitizes filter objects, removing any non-standard properties
+     * 2. Our _isPrivateEvent flag would be stripped by this sanitization
+     * 3. We need the flag to reach the _send method to trigger the addition of auth headers
+     *
+     * The approach here is to run the normal filter processing, then re-attach our flag as a
+     * non-enumerable property to avoid JSON serialization issues. This allows the flag to
+     * survive until _send where we check for it to determine if auth headers are needed.
+     *
+     * @param _filter - The filter with our potential _isPrivateEvent property
+     * @returns Array of logs matching the filter
+     */
+    getLogs(_filter: PrivateEventsFilter | FilterByBlockHash): Promise<Log[]>;
+}
+
+/**
+ * Extended LogDescription type that includes private event details
+ */
+interface SDLogDescription extends LogDescription {
+    /**
+     * Only present for PrivateEvents - contains the decoded inner log
+     * If decoding failed, this will be null
+     */
+    innerLog?: LogDescription | null;
+}
+/**
+ * Extends ethers Interface to provide support for decoding PrivateEvent logs
+ * Make sure to include the PrivateEvent signature in your ABI when using this class
+ */
+declare class SDInterface extends Interface {
+    /**
+     * Extends the parseLog method to handle PrivateEvent logs
+     * @param log - The log to parse
+     * @returns The parsed log description with additional private event details if applicable
+     */
+    parseLog(log: Parameters<Interface['parseLog']>[0]): SDLogDescription | null;
 }
 
-export { SIGN_RPC_METHODS, SilentDataRollupProvider, type SilentDataRollupProviderConfig };
+export { DEBUG_NAMESPACE, type PrivateEventsFilter, SDInterface, type SDLogDescription, SIGN_RPC_METHODS, SilentDataRollupProvider, type SilentDataRollupProviderConfig };

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import { Signer, JsonRpcApiProviderOptions, JsonRpcProvider, JsonRpcPayload, JsonRpcResult, FetchRequest } from 'ethers';
+import { Signer, JsonRpcApiProviderOptions, Filter, JsonRpcProvider, JsonRpcPayload, JsonRpcResult, FetchRequest, Log, FilterByBlockHash, LogDescription, Interface } from 'ethers';
 import { BaseConfig, NetworkName } from '@appliedblockchain/silentdatarollup-core';
 
 declare const SIGN_RPC_METHODS: string[];
+declare const DEBUG_NAMESPACE = "silentdata:ethers-provider";
 
 interface SilentDataRollupProviderConfig extends BaseConfig {
     rpcUrl: string;
@@ -11,6 +12,24 @@ interface SilentDataRollupProviderConfig extends BaseConfig {
     signer?: Signer;
     options?: JsonRpcApiProviderOptions;
 }
+/**
+ * Extended filter type that includes a special flag for private events
+ * This flag is used to identify when a call to eth_getLogs originated from
+ * the getAllLogs method, so we can add authentication headers
+ */
+interface PrivateEventsFilter extends Filter {
+    /**
+     * Internal flag to identify requests that should include auth headers
+     * Set automatically by getAllLogs method
+     */
+    _isPrivateEvent?: boolean;
+    /**
+     * Optional event signature for filtering private events by type
+     * Example: "Transfer(address,address,uint256)"
+     * Will be converted to a hash and used for topic filtering
+     */
+    eventSignature?: string;
+}
 
 declare class SilentDataRollupProvider extends JsonRpcProvider {
     private config;
@@ -22,6 +41,66 @@ declare class SilentDataRollupProvider extends JsonRpcProvider {
         rpcUrl: string;
     }): FetchRequest;
     clone(): SilentDataRollupProvider;
+    /**
+     * Helper method to configure a filter for private events
+     * @param filter - The original filter
+     * @param forcePrivateOnly - Whether to force filtering for only PrivateEvents
+     * @returns The configured filter with proper topics
+     */
+    private configurePrivateEventsFilter;
+    /**
+     * Gets logs for private events, including authentication headers
+     * @param filter - The filter parameters for logs
+     * @returns Array of logs matching the filter
+     */
+    getAllLogs(filter?: PrivateEventsFilter): Promise<Array<Log>>;
+    /**
+     * Gets only private events (PrivateEvent logs), including authentication headers
+     * @param filter - The filter parameters for logs
+     * @returns Array of logs matching the filter, containing only PrivateEvent logs
+     */
+    getPrivateLogs(filter?: PrivateEventsFilter): Promise<Log[]>;
+    /**
+     * Override of ethers' getLogs method that preserves our custom _isPrivateEvent property
+     *
+     * IMPORTANT: This method mimics the behavior of ethers' original getLogs implementation
+     * but adds a crucial step to preserve the _isPrivateEvent flag. We need this because:
+     *
+     * 1. Ethers' _getFilter method sanitizes filter objects, removing any non-standard properties
+     * 2. Our _isPrivateEvent flag would be stripped by this sanitization
+     * 3. We need the flag to reach the _send method to trigger the addition of auth headers
+     *
+     * The approach here is to run the normal filter processing, then re-attach our flag as a
+     * non-enumerable property to avoid JSON serialization issues. This allows the flag to
+     * survive until _send where we check for it to determine if auth headers are needed.
+     *
+     * @param _filter - The filter with our potential _isPrivateEvent property
+     * @returns Array of logs matching the filter
+     */
+    getLogs(_filter: PrivateEventsFilter | FilterByBlockHash): Promise<Log[]>;
+}
+
+/**
+ * Extended LogDescription type that includes private event details
+ */
+interface SDLogDescription extends LogDescription {
+    /**
+     * Only present for PrivateEvents - contains the decoded inner log
+     * If decoding failed, this will be null
+     */
+    innerLog?: LogDescription | null;
+}
+/**
+ * Extends ethers Interface to provide support for decoding PrivateEvent logs
+ * Make sure to include the PrivateEvent signature in your ABI when using this class
+ */
+declare class SDInterface extends Interface {
+    /**
+     * Extends the parseLog method to handle PrivateEvent logs
+     * @param log - The log to parse
+     * @returns The parsed log description with additional private event details if applicable
+     */
+    parseLog(log: Parameters<Interface['parseLog']>[0]): SDLogDescription | null;
 }
 
-export { SIGN_RPC_METHODS, SilentDataRollupProvider, type SilentDataRollupProviderConfig };
+export { DEBUG_NAMESPACE, type PrivateEventsFilter, SDInterface, type SDLogDescription, SIGN_RPC_METHODS, SilentDataRollupProvider, type SilentDataRollupProviderConfig };

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,11 +17,21 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  DEBUG_NAMESPACE: () => DEBUG_NAMESPACE,
+  SDInterface: () => SDInterface,
   SIGN_RPC_METHODS: () => SIGN_RPC_METHODS,
   SilentDataRollupProvider: () => SilentDataRollupProvider
 });
@@ -33,10 +45,14 @@ var SIGN_RPC_METHODS = [
   "eth_getProof",
   "eth_getTransactionReceipt"
 ];
+var DEBUG_NAMESPACE = "silentdata:ethers-provider";
 
 // src/provider.ts
 var import_silentdatarollup_core = require("@appliedblockchain/silentdatarollup-core");
 var import_ethers = require("ethers");
+function isPromise(value) {
+  return value && typeof value.then === "function";
+}
 function getNetwork(name, chainId) {
   switch (name) {
     case import_silentdatarollup_core.NetworkName.MAINNET:
@@ -89,16 +105,28 @@ var SilentDataRollupProvider = class _SilentDataRollupProvider extends import_et
     if (Array.isArray(payload)) {
       throw new Error("Batch requests are not currently supported");
     }
-    if (payload.method === "eth_call" && Array.isArray(payload.params)) {
+    const isEthCallOrEstimateGas = payload.method === "eth_call" || payload.method === "eth_estimateGas";
+    if (isEthCallOrEstimateGas && Array.isArray(payload.params)) {
       const txParams = payload.params[0];
       if (typeof txParams === "object" && txParams !== null) {
         txParams.from = await this.signer.getAddress();
       }
     }
+    let isPrivateLogsRequest = false;
+    if (payload.method === "eth_getLogs" && Array.isArray(payload.params) && payload.params.length > 0) {
+      const filter = payload.params[0];
+      if (filter && typeof filter === "object" && "_isPrivateEvent" in filter) {
+        isPrivateLogsRequest = !!filter._isPrivateEvent;
+        if (isPrivateLogsRequest) {
+          const { _isPrivateEvent, ...filterCopy } = filter;
+          payload.params[0] = filterCopy;
+        }
+      }
+    }
     const request = this._getConnection();
     request.body = JSON.stringify(payload);
     request.setHeader("content-type", "application/json");
-    const requiresAuthHeaders = import_silentdatarollup_core.SIGN_RPC_METHODS.includes(payload.method) || (0, import_silentdatarollup_core.isSignableContractCall)(
+    const requiresAuthHeaders = isPrivateLogsRequest || import_silentdatarollup_core.SIGN_RPC_METHODS.includes(payload.method) || (0, import_silentdatarollup_core.isSignableContractCall)(
       payload,
       this.baseProvider.contractMethodsToSign,
       this.baseProvider.contract
@@ -151,9 +179,172 @@ var SilentDataRollupProvider = class _SilentDataRollupProvider extends import_et
     const clonedProvider = new _SilentDataRollupProvider(this.config);
     return clonedProvider;
   }
+  /**
+   * Helper method to configure a filter for private events
+   * @param filter - The original filter
+   * @param forcePrivateOnly - Whether to force filtering for only PrivateEvents
+   * @returns The configured filter with proper topics
+   */
+  configurePrivateEventsFilter(filter, forcePrivateOnly = false) {
+    const privateFilter = {
+      ...filter,
+      _isPrivateEvent: true
+    };
+    privateFilter.topics = privateFilter.topics || [];
+    if (forcePrivateOnly || privateFilter.eventSignature) {
+      if (forcePrivateOnly) {
+        privateFilter.topics = [
+          import_silentdatarollup_core.PRIVATE_EVENT_SIGNATURE_HASH,
+          // Only match PrivateEvent
+          ...privateFilter.topics.slice(1)
+          // Preserve any other topic filters
+        ];
+      }
+      if (privateFilter.eventSignature) {
+        const eventTypeHash = (0, import_silentdatarollup_core.calculateEventTypeHash)(
+          privateFilter.eventSignature
+        );
+        if (forcePrivateOnly) {
+          privateFilter.topics[1] = eventTypeHash;
+        } else {
+          privateFilter.topics = [
+            import_silentdatarollup_core.PRIVATE_EVENT_SIGNATURE_HASH,
+            // Only match PrivateEvent
+            eventTypeHash,
+            // Only match the specific event type
+            ...(privateFilter.topics || []).slice(2)
+            // Preserve any other topics
+          ];
+        }
+        delete privateFilter.eventSignature;
+      }
+    }
+    return privateFilter;
+  }
+  /**
+   * Gets logs for private events, including authentication headers
+   * @param filter - The filter parameters for logs
+   * @returns Array of logs matching the filter
+   */
+  async getAllLogs(filter = {}) {
+    const privateFilter = this.configurePrivateEventsFilter(filter, false);
+    return await this.getLogs(privateFilter);
+  }
+  /**
+   * Gets only private events (PrivateEvent logs), including authentication headers
+   * @param filter - The filter parameters for logs
+   * @returns Array of logs matching the filter, containing only PrivateEvent logs
+   */
+  async getPrivateLogs(filter = {}) {
+    const privateFilter = this.configurePrivateEventsFilter(filter, true);
+    return await this.getLogs(privateFilter);
+  }
+  /**
+   * Override of ethers' getLogs method that preserves our custom _isPrivateEvent property
+   *
+   * IMPORTANT: This method mimics the behavior of ethers' original getLogs implementation
+   * but adds a crucial step to preserve the _isPrivateEvent flag. We need this because:
+   *
+   * 1. Ethers' _getFilter method sanitizes filter objects, removing any non-standard properties
+   * 2. Our _isPrivateEvent flag would be stripped by this sanitization
+   * 3. We need the flag to reach the _send method to trigger the addition of auth headers
+   *
+   * The approach here is to run the normal filter processing, then re-attach our flag as a
+   * non-enumerable property to avoid JSON serialization issues. This allows the flag to
+   * survive until _send where we check for it to determine if auth headers are needed.
+   *
+   * @param _filter - The filter with our potential _isPrivateEvent property
+   * @returns Array of logs matching the filter
+   */
+  async getLogs(_filter) {
+    let filter = this._getFilter(_filter);
+    if (isPromise(filter)) {
+      filter = await filter;
+    }
+    if (typeof _filter === "object" && "_isPrivateEvent" in _filter && _filter._isPrivateEvent) {
+      Object.defineProperty(filter, "_isPrivateEvent", {
+        value: true,
+        enumerable: false
+      });
+    }
+    const { network, params } = await (0, import_ethers.resolveProperties)({
+      network: this.getNetwork(),
+      params: this._perform({ method: "getLogs", filter })
+    });
+    return params.map((p) => this._wrapLog(p, network));
+  }
+};
+
+// src/sdInterface.ts
+var import_debug = __toESM(require("debug"));
+var import_ethers2 = require("ethers");
+var debugLog = (0, import_debug.default)(DEBUG_NAMESPACE);
+var SDInterface = class extends import_ethers2.Interface {
+  /**
+   * Extends the parseLog method to handle PrivateEvent logs
+   * @param log - The log to parse
+   * @returns The parsed log description with additional private event details if applicable
+   */
+  parseLog(log) {
+    const parsedLog = super.parseLog(log);
+    if (!parsedLog) {
+      debugLog(
+        "Failed to parse log - no matching event found or event is anonymous"
+      );
+      return null;
+    }
+    if (parsedLog.name === "PrivateEvent") {
+      debugLog("Processing PrivateEvent log");
+      const eventType = parsedLog.args.eventType;
+      const payload = parsedLog.args.payload;
+      debugLog(
+        `PrivateEvent - eventType: ${eventType}, payload length: ${payload?.length || 0}`
+      );
+      parsedLog.innerLog = null;
+      try {
+        if (!payload || payload === "0x") {
+          debugLog("Empty payload for PrivateEvent, cannot decode inner log");
+          return parsedLog;
+        }
+        const syntheticLog = {
+          topics: [eventType],
+          data: payload
+        };
+        debugLog(`Created synthetic log with topic: ${eventType}`);
+        const eventFragment = this.getEvent(eventType);
+        if (!eventFragment) {
+          debugLog(`No matching event found for topic ${eventType}`);
+          return parsedLog;
+        }
+        debugLog(`Found matching event fragment: ${eventFragment.name}`);
+        try {
+          const innerLogDescription = super.parseLog(syntheticLog);
+          if (innerLogDescription) {
+            debugLog(
+              `Successfully decoded inner log: ${innerLogDescription.name}`
+            );
+            parsedLog.innerLog = innerLogDescription;
+          } else {
+            debugLog(
+              "Failed to parse inner log - no matching inner event found"
+            );
+          }
+        } catch (innerError) {
+          debugLog(`Failed to parse synthetic log for inner log:`, innerError);
+        }
+      } catch (error) {
+        debugLog(`Failed to decode private event payload:`, error);
+      }
+    } else {
+      debugLog(`Processing regular event: ${parsedLog.name}`);
+    }
+    return parsedLog;
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEBUG_NAMESPACE,
+  SDInterface,
   SIGN_RPC_METHODS,
   SilentDataRollupProvider
 });

package/dist/index.mjs

@@ -6,9 +6,11 @@ var SIGN_RPC_METHODS = [
   "eth_getProof",
   "eth_getTransactionReceipt"
 ];
+var DEBUG_NAMESPACE = "silentdata:ethers-provider";
 
 // src/provider.ts
 import {
+  calculateEventTypeHash,
   ChainId,
   HEADER_DELEGATE,
   HEADER_DELEGATE_SIGNATURE,
@@ -18,6 +20,7 @@ import {
   HEADER_TIMESTAMP,
   isSignableContractCall,
   NetworkName,
+  PRIVATE_EVENT_SIGNATURE_HASH,
   SIGN_RPC_METHODS as SIGN_RPC_METHODS2,
   SignatureType,
   SilentDataRollupBase
@@ -27,8 +30,12 @@ import {
   FetchRequest,
   JsonRpcProvider,
   Network,
+  resolveProperties,
   Wallet
 } from "ethers";
+function isPromise(value) {
+  return value && typeof value.then === "function";
+}
 function getNetwork(name, chainId) {
   switch (name) {
     case NetworkName.MAINNET:
@@ -81,16 +88,28 @@ var SilentDataRollupProvider = class _SilentDataRollupProvider extends JsonRpcPr
     if (Array.isArray(payload)) {
       throw new Error("Batch requests are not currently supported");
     }
-    if (payload.method === "eth_call" && Array.isArray(payload.params)) {
+    const isEthCallOrEstimateGas = payload.method === "eth_call" || payload.method === "eth_estimateGas";
+    if (isEthCallOrEstimateGas && Array.isArray(payload.params)) {
       const txParams = payload.params[0];
       if (typeof txParams === "object" && txParams !== null) {
         txParams.from = await this.signer.getAddress();
       }
     }
+    let isPrivateLogsRequest = false;
+    if (payload.method === "eth_getLogs" && Array.isArray(payload.params) && payload.params.length > 0) {
+      const filter = payload.params[0];
+      if (filter && typeof filter === "object" && "_isPrivateEvent" in filter) {
+        isPrivateLogsRequest = !!filter._isPrivateEvent;
+        if (isPrivateLogsRequest) {
+          const { _isPrivateEvent, ...filterCopy } = filter;
+          payload.params[0] = filterCopy;
+        }
+      }
+    }
     const request = this._getConnection();
     request.body = JSON.stringify(payload);
     request.setHeader("content-type", "application/json");
-    const requiresAuthHeaders = SIGN_RPC_METHODS2.includes(payload.method) || isSignableContractCall(
+    const requiresAuthHeaders = isPrivateLogsRequest || SIGN_RPC_METHODS2.includes(payload.method) || isSignableContractCall(
       payload,
       this.baseProvider.contractMethodsToSign,
       this.baseProvider.contract
@@ -143,8 +162,171 @@ var SilentDataRollupProvider = class _SilentDataRollupProvider extends JsonRpcPr
     const clonedProvider = new _SilentDataRollupProvider(this.config);
     return clonedProvider;
   }
+  /**
+   * Helper method to configure a filter for private events
+   * @param filter - The original filter
+   * @param forcePrivateOnly - Whether to force filtering for only PrivateEvents
+   * @returns The configured filter with proper topics
+   */
+  configurePrivateEventsFilter(filter, forcePrivateOnly = false) {
+    const privateFilter = {
+      ...filter,
+      _isPrivateEvent: true
+    };
+    privateFilter.topics = privateFilter.topics || [];
+    if (forcePrivateOnly || privateFilter.eventSignature) {
+      if (forcePrivateOnly) {
+        privateFilter.topics = [
+          PRIVATE_EVENT_SIGNATURE_HASH,
+          // Only match PrivateEvent
+          ...privateFilter.topics.slice(1)
+          // Preserve any other topic filters
+        ];
+      }
+      if (privateFilter.eventSignature) {
+        const eventTypeHash = calculateEventTypeHash(
+          privateFilter.eventSignature
+        );
+        if (forcePrivateOnly) {
+          privateFilter.topics[1] = eventTypeHash;
+        } else {
+          privateFilter.topics = [
+            PRIVATE_EVENT_SIGNATURE_HASH,
+            // Only match PrivateEvent
+            eventTypeHash,
+            // Only match the specific event type
+            ...(privateFilter.topics || []).slice(2)
+            // Preserve any other topics
+          ];
+        }
+        delete privateFilter.eventSignature;
+      }
+    }
+    return privateFilter;
+  }
+  /**
+   * Gets logs for private events, including authentication headers
+   * @param filter - The filter parameters for logs
+   * @returns Array of logs matching the filter
+   */
+  async getAllLogs(filter = {}) {
+    const privateFilter = this.configurePrivateEventsFilter(filter, false);
+    return await this.getLogs(privateFilter);
+  }
+  /**
+   * Gets only private events (PrivateEvent logs), including authentication headers
+   * @param filter - The filter parameters for logs
+   * @returns Array of logs matching the filter, containing only PrivateEvent logs
+   */
+  async getPrivateLogs(filter = {}) {
+    const privateFilter = this.configurePrivateEventsFilter(filter, true);
+    return await this.getLogs(privateFilter);
+  }
+  /**
+   * Override of ethers' getLogs method that preserves our custom _isPrivateEvent property
+   *
+   * IMPORTANT: This method mimics the behavior of ethers' original getLogs implementation
+   * but adds a crucial step to preserve the _isPrivateEvent flag. We need this because:
+   *
+   * 1. Ethers' _getFilter method sanitizes filter objects, removing any non-standard properties
+   * 2. Our _isPrivateEvent flag would be stripped by this sanitization
+   * 3. We need the flag to reach the _send method to trigger the addition of auth headers
+   *
+   * The approach here is to run the normal filter processing, then re-attach our flag as a
+   * non-enumerable property to avoid JSON serialization issues. This allows the flag to
+   * survive until _send where we check for it to determine if auth headers are needed.
+   *
+   * @param _filter - The filter with our potential _isPrivateEvent property
+   * @returns Array of logs matching the filter
+   */
+  async getLogs(_filter) {
+    let filter = this._getFilter(_filter);
+    if (isPromise(filter)) {
+      filter = await filter;
+    }
+    if (typeof _filter === "object" && "_isPrivateEvent" in _filter && _filter._isPrivateEvent) {
+      Object.defineProperty(filter, "_isPrivateEvent", {
+        value: true,
+        enumerable: false
+      });
+    }
+    const { network, params } = await resolveProperties({
+      network: this.getNetwork(),
+      params: this._perform({ method: "getLogs", filter })
+    });
+    return params.map((p) => this._wrapLog(p, network));
+  }
+};
+
+// src/sdInterface.ts
+import debug from "debug";
+import { Interface } from "ethers";
+var debugLog = debug(DEBUG_NAMESPACE);
+var SDInterface = class extends Interface {
+  /**
+   * Extends the parseLog method to handle PrivateEvent logs
+   * @param log - The log to parse
+   * @returns The parsed log description with additional private event details if applicable
+   */
+  parseLog(log) {
+    const parsedLog = super.parseLog(log);
+    if (!parsedLog) {
+      debugLog(
+        "Failed to parse log - no matching event found or event is anonymous"
+      );
+      return null;
+    }
+    if (parsedLog.name === "PrivateEvent") {
+      debugLog("Processing PrivateEvent log");
+      const eventType = parsedLog.args.eventType;
+      const payload = parsedLog.args.payload;
+      debugLog(
+        `PrivateEvent - eventType: ${eventType}, payload length: ${payload?.length || 0}`
+      );
+      parsedLog.innerLog = null;
+      try {
+        if (!payload || payload === "0x") {
+          debugLog("Empty payload for PrivateEvent, cannot decode inner log");
+          return parsedLog;
+        }
+        const syntheticLog = {
+          topics: [eventType],
+          data: payload
+        };
+        debugLog(`Created synthetic log with topic: ${eventType}`);
+        const eventFragment = this.getEvent(eventType);
+        if (!eventFragment) {
+          debugLog(`No matching event found for topic ${eventType}`);
+          return parsedLog;
+        }
+        debugLog(`Found matching event fragment: ${eventFragment.name}`);
+        try {
+          const innerLogDescription = super.parseLog(syntheticLog);
+          if (innerLogDescription) {
+            debugLog(
+              `Successfully decoded inner log: ${innerLogDescription.name}`
+            );
+            parsedLog.innerLog = innerLogDescription;
+          } else {
+            debugLog(
+              "Failed to parse inner log - no matching inner event found"
+            );
+          }
+        } catch (innerError) {
+          debugLog(`Failed to parse synthetic log for inner log:`, innerError);
+        }
+      } catch (error) {
+        debugLog(`Failed to decode private event payload:`, error);
+      }
+    } else {
+      debugLog(`Processing regular event: ${parsedLog.name}`);
+    }
+    return parsedLog;
+  }
 };
 export {
+  DEBUG_NAMESPACE,
+  SDInterface,
   SIGN_RPC_METHODS,
   SilentDataRollupProvider
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appliedblockchain/silentdatarollup-ethers-provider",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Ethers.js provider for Silent Data [Rollup]",
   "author": "Applied Blockchain",
   "homepage": "https://github.com/appliedblockchain/silent-data-rollup-providers#readme",
@@ -32,7 +32,8 @@
     "test": "jest"
   },
   "dependencies": {
-    "@appliedblockchain/silentdatarollup-core": "1.0.1",
+    "@appliedblockchain/silentdatarollup-core": "1.0.3",
+    "debug": "4.3.7",
     "ethers": "6.13.2"
   },
   "devDependencies": {