@appliedblockchain/silentdatarollup-core 1.0.7 → 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/README.md

@@ -1,4 +1,4 @@
-# Silent Data [Rollup] Providers - Core Package
+# Silent Data Providers - Core Package
 
 This package contains the core functionality for the other packages.
 

package/dist/{chunk-5VQIOQAW.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,10 +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 = [
@@ -41,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",
@@ -61,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";
@@ -238,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(
@@ -323,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) {
@@ -361,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");
@@ -392,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;
         }
@@ -407,7 +454,8 @@ var SilentDataRollupBase = class {
           headers[HEADER_EIP712_DELEGATE_SIGNATURE] = await this.signTypedDelegateHeader(
             provider,
             chainId,
-            delegateSignerMessage
+            delegateSignerMessage,
+            isSWC
           );
           break;
         default:
@@ -428,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:
@@ -454,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;
   }
   /**
@@ -505,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
@@ -521,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 = {
@@ -534,38 +713,10 @@ var SilentDataRollupBase = class {
 };
 
 // src/contract.ts
-import {
-  Contract,
-  Interface,
-  assertArgument
-} from "ethers";
-var CustomContractRunner = class {
-  constructor(provider, signer) {
-    this.provider = provider;
-    this.signer = signer;
-  }
-  async sendTransaction(tx) {
-    if (!tx.gasLimit) {
-      tx.gasLimit = await this.provider.estimateGas(tx);
-    }
-    return this.signer.sendTransaction(tx);
-  }
-};
-function getContractRunner(runner, provider) {
-  const runnerIsSigner = typeof runner.sendTransaction === "function";
-  if (!runnerIsSigner) {
-    return runner;
-  }
-  const runnerProviderConstructor = runner.provider?.constructor.name ?? "";
-  if (!runnerProviderConstructor.includes("SilentDataRollupProvider")) {
-    assertArgument(provider, "provider is mandatory", "provider", provider);
-    return new CustomContractRunner(provider, runner);
-  }
-  return new CustomContractRunner(runner.provider, runner);
-}
-var SilentDataRollupContract = class extends Contract {
+import { Contract as Contract2, Interface } from "ethers";
+var SilentDataRollupContract = class extends Contract2 {
   constructor(config) {
-    const { address, abi, runner, contractMethodsToSign, provider } = config;
+    const { address, abi, runner, contractMethodsToSign } = config;
     const contractInterface = new Interface(abi);
     contractMethodsToSign.forEach((method) => {
       if (!contractInterface.hasFunction(method)) {
@@ -574,8 +725,7 @@ var SilentDataRollupContract = class extends Contract {
         );
       }
     });
-    const contractRunner = getContractRunner(runner, provider);
-    super(address, abi, contractRunner);
+    super(address, abi, runner);
     const baseProvider = runner.baseProvider || runner.provider?.baseProvider;
     if (typeof baseProvider?.setContract === "function") {
       baseProvider.setContract(this, contractMethodsToSign);
@@ -583,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,
@@ -601,13 +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,
@@ -617,8 +767,5 @@ export {
   defaultGetDelegate,
   prepareTypedDataPayload,
   SilentDataRollupBase,
-  SilentDataRollupContract,
-  PRIVATE_EVENT_SIGNATURE,
-  PRIVATE_EVENT_SIGNATURE_HASH,
-  calculateEventTypeHash
+  SilentDataRollupContract
 };