@appliedblockchain/silentdatarollup-core 1.0.0

package/README.md

@@ -0,0 +1,17 @@
+# Silent Data [Rollup] Providers - Core Package
+
+This package contains the core functionality for the other packages.
+
+## Overview
+
+The Core Package serves as the foundation for all other packages within the `packages` folder. It provides essential utilities, shared components, and common functionality that can be utilized across the entire project.
+
+## Features
+
+- Shared utilities and helper functions
+- Common interfaces and types
+- Configuration management
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).

package/dist/chunk-BIZ7KJDG.mjs

@@ -0,0 +1,561 @@
+// src/Base.ts
+import debug2 from "debug";
+
+// src/constants.ts
+var SIGN_RPC_METHODS = [
+  "eth_getTransactionByHash",
+  "eth_getTransactionCount",
+  "eth_getProof",
+  "eth_getTransactionReceipt"
+];
+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_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 DEFAULT_DELEGATE_EXPIRES = 24 * 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_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",
+  "net_listening",
+  "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"
+];
+
+// src/types.ts
+var ChainId = /* @__PURE__ */ ((ChainId2) => {
+  ChainId2[ChainId2["MAINNET"] = 51966] = "MAINNET";
+  ChainId2[ChainId2["TESTNET"] = 1001] = "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) {
+  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);
+  log(
+    "Signing typed data",
+    JSON.stringify({ eip721Domain, types, message }, null, 2)
+  );
+  const signature = await signer.signTypedData(eip721Domain, types, message);
+  log("Signature generated:", signature);
+  return signature;
+}
+async function signAuthHeaderRawMessage(signer, payload, timestamp) {
+  log("Preparing raw message for signing");
+  const serialRequest = JSON.stringify(payload);
+  const xMessage = serialRequest + timestamp;
+  log("Raw message:", xMessage);
+  const signature = await signer.signMessage(xMessage);
+  log("Raw signature generated:", signature);
+  return signature;
+}
+async function signTypedDelegateHeader(signer, message) {
+  log("Signing typed delegate header");
+  const signature = await signer.signTypedData(
+    eip721Domain,
+    delegateEIP721Types,
+    message
+  );
+  log("Signature generated:", signature);
+  return signature;
+}
+async function signRawDelegateHeader(signer, message) {
+  log("Signing raw delegate header");
+  log("Raw message:", message);
+  const signature = await signer.signMessage(JSON.stringify(message));
+  log("Raw signature generated:", signature);
+  return signature;
+}
+async function getAuthHeaders(signer, payload, 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
+      );
+      break;
+    case "EIP712" /* EIP712 */:
+      log("Generating EIP712 signature");
+      headers[HEADER_EIP712_SIGNATURE] = await signAuthHeaderTypedData(
+        signer,
+        payload,
+        xTimestamp
+      );
+      break;
+    default:
+      throw new Error(`Unsupported signature type: ${signatureType}`);
+  }
+  return headers;
+}
+function isSignableContractCall(payload, contractMethodsToSign, contract) {
+  if (!contractMethodsToSign || !contract) {
+    return false;
+  }
+  log("Checking if contract call is signable");
+  log("Contract methods to sign:", contractMethodsToSign);
+  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 methodSignature = params[0].data.slice(2, 10);
+  log("Method signature:", methodSignature);
+  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.contract = null;
+    this.contractMethodsToSign = [];
+    this.config = {
+      ...config,
+      authSignatureType: config.authSignatureType ?? "RAW" /* Raw */
+    };
+    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;
+  }
+  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.
+   * @param provider - The provider used for signing
+   * @param message - The delegate signer message to be signed
+   * @returns A promise that resolves to the signature string
+   */
+  async signRawDelegateHeader(provider, message) {
+    log2("signRawDelegateHeader: Signing raw delegate header");
+    log2("signRawDelegateHeader: Raw message:", JSON.stringify(message, null, 2));
+    const signature = await provider.signer.signMessage(JSON.stringify(message));
+    log2("signRawDelegateHeader: Raw 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 message - The delegate signer message to be signed
+   * @returns A promise that resolves to the signature string
+   */
+  async signTypedDelegateHeader(provider, message) {
+    log2("signTypedDelegateHeader: Signing typed delegate header");
+    log2(
+      "signTypedDelegateHeader: Typed message:",
+      JSON.stringify(message, null, 2)
+    );
+    const signature = await provider.signer.signTypedData(
+      eip721Domain,
+      delegateEIP721Types,
+      message
+    );
+    log2("signTypedDelegateHeader: Signature generated:", signature);
+    return signature;
+  }
+  async getDelegateHeaders(provider) {
+    log2("Getting delegate headers");
+    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)
+      };
+      switch (signatureType) {
+        case "RAW" /* Raw */:
+          log2("Generating delegate raw signature");
+          headers[HEADER_DELEGATE_SIGNATURE] = await this.signRawDelegateHeader(
+            provider,
+            delegateSignerMessage
+          );
+          break;
+        case "EIP712" /* EIP712 */:
+          log2("Generating delegate EIP712 signature");
+          headers[HEADER_EIP712_DELEGATE_SIGNATURE] = await this.signTypedDelegateHeader(provider, delegateSignerMessage);
+          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 signatureType = this.config.authSignatureType;
+    switch (signatureType) {
+      case "RAW" /* Raw */:
+        log2("Generating auth header raw signature");
+        headers[HEADER_SIGNATURE] = await this.signAuthHeaderRawMessage(
+          provider,
+          payload,
+          xTimestamp
+        );
+        break;
+      case "EIP712" /* EIP712 */:
+        log2("Generating auth headerEIP712 signature");
+        headers[HEADER_EIP712_SIGNATURE] = await this.signAuthHeaderTypedData(
+          provider,
+          payload,
+          xTimestamp
+        );
+        break;
+      default:
+        throw new Error(`Unsupported signature type: ${signatureType}`);
+    }
+    log2("Auth headers:", JSON.stringify(headers, null, 2));
+    return headers;
+  }
+  async signAuthHeaderRawMessage(provider, payload, timestamp) {
+    const xMessage = this.prepareSignatureMessage(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);
+    return signature;
+  }
+  async signAuthHeaderTypedData(provider, payload, timestamp) {
+    const message = this.prepareSignatureTypedData(payload, timestamp);
+    const types = getAuthEIP721Types(payload);
+    const delegateSigner = await this.getDelegateSigner(this);
+    const signer = delegateSigner ?? provider.signer;
+    log2(
+      "Signing typed data",
+      JSON.stringify({ message, types, eip721Domain }, null, 2)
+    );
+    const signature = await this.signTypedData(
+      signer,
+      eip721Domain,
+      types,
+      message
+    );
+    log2("Message signed. 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.contract = contract;
+    this.contractMethodsToSign = contractMethodsToSign;
+  }
+  /**
+   * Prepares the message to be signed for the x-signature header.
+   */
+  prepareSignatureMessage(payload, timestamp) {
+    log2("Preparing raw message for signing", {
+      payload: JSON.stringify(payload, null, 2),
+      timestamp
+    });
+    const serialRequest = JSON.stringify(payload);
+    const xMessage = serialRequest + timestamp;
+    log2("Raw message to be signed:", xMessage);
+    return xMessage;
+  }
+  /**
+   * Prepares the message to be signed for the x-eip712-signature header.
+   */
+  prepareSignatureTypedData(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 CustomContractRunner = class {
+  constructor(signer) {
+    this.provider = signer.provider;
+    this.signer = signer;
+  }
+  async sendTransaction(tx) {
+    tx.nonce = await this.signer.getNonce();
+    return this.signer.sendTransaction(tx);
+  }
+};
+var SilentDataRollupContract = class extends Contract2 {
+  constructor(address, abi, runner, contractMethodsToSign) {
+    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`
+        );
+      }
+    });
+    const baseProvider = runner.baseProvider || runner.provider?.baseProvider;
+    const runnerIsSigner = typeof runner.sendTransaction === "function";
+    if (runnerIsSigner) {
+      runner = new CustomContractRunner(runner);
+    }
+    super(address, abi, runner);
+    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_EIP712_SIGNATURE,
+  HEADER_DELEGATE,
+  HEADER_DELEGATE_SIGNATURE,
+  HEADER_EIP712_DELEGATE_SIGNATURE,
+  DEFAULT_DELEGATE_EXPIRES,
+  DELEGATE_EXPIRATION_THRESHOLD_BUFFER,
+  WHITELISTED_METHODS,
+  ChainId,
+  NetworkName,
+  SignatureType,
+  getAuthEIP721Types,
+  signAuthHeaderTypedData,
+  signAuthHeaderRawMessage,
+  signTypedDelegateHeader,
+  signRawDelegateHeader,
+  getAuthHeaders,
+  isSignableContractCall,
+  defaultGetDelegate,
+  prepareTypedDataPayload,
+  SilentDataRollupBase,
+  SilentDataRollupContract
+};