@appliedblockchain/silentdatarollup-hardhat-plugin-fireblocks 1.0.0

package/README.md

@@ -0,0 +1,106 @@
+# Silent Data [Rollup] Providers - Hardhat Plugin Fireblocks Package
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Prerequisites](#prerequisites)
+- [Integration](#integration)
+  - [Hardhat Integration](#hardhat-integration)
+    - [Installing Hardhat Integration Dependencies](#installing-hardhat-integration-dependencies)
+    - [Hardhat Integration Example](#hardhat-integration-example)
+- [Troubleshooting](#troubleshooting)
+- [License](#license)
+- [Additional Resources](#additional-resources)
+
+## Introduction
+
+Custom providers for integrating Silent Data [Rollup] with Hardhat and Fireblocks.
+
+## Prerequisites
+
+- Node.js (version 18 or higher)
+- Hardhat v2
+- npm
+- Basic knowledge of Ethereum and smart contracts
+
+## Integration
+
+### Hardhat Integration
+
+#### Installing Hardhat Integration Dependencies
+
+```bash
+npm install @appliedblockchain/silentdatarollup-core @appliedblockchain/silentdatarollup-hardhat-plugin-fireblocks @nomicfoundation/hardhat-ignition-ethers@0.15.7
+```
+
+#### Hardhat Integration Example
+
+To integrate the Silent Data [Rollup] Provider with Hardhat, you need to configure your Silent Data network in the `hardhat.config.ts` file. Below is an example of how to set it up, and note that a `silentdata` property is needed on the network config to enable it. This property can be an empty object to apply defaults, or you can specify the configurations.
+
+```typescript
+import {
+  ApiBaseUrl,
+  ASSETS,
+  ChainId,
+} from '@fireblocks/fireblocks-web3-provider'
+import '@nomicfoundation/hardhat-ignition-ethers'
+import '@appliedblockchain/silentdatarollup-hardhat-plugin-fireblocks'
+import { SilentDataSignatureTypeRollupProvider } from '@appliedblockchain/silentdatarollup-core'
+
+const RPC_URL = 'SILENT_DATA_ROLLUP_RPC_URL'
+const FIREBLOCKS_API_KEY = 'FIREBLOCKS_API_KEY'
+
+const fireblocksConfig = {
+  privateKey: 'FIREBLOCKS_PATH_TO_PRIVATE_KEY',
+  apiKey: FIREBLOCKS_API_KEY,
+  assetId: ASSETS[ChainId.SEPOLIA].assetId,
+  vaultAccountIds: 'FIREBLOCKS_VAULT_ACCOUNT_ID', // Note: Currently, only one vault account can be passed to the configuration.
+  chainId: ChainId.SEPOLIA,
+  apiBaseUrl: ApiBaseUrl.Sandbox, // If using a sandbox workspace
+  rpcUrl: RPC_URL,
+}
+
+export default {
+  solidity: '0.8.21',
+  defaultNetwork: 'sdr',
+  networks: {
+    hardhat: {},
+    sdr: {
+      url: RPC_URL,
+      fireblocks: fireblocksConfig,
+      silentdata: {
+        authSignatureType: SignatureType.EIP712, // Optional, defaults to RAW
+      },
+    },
+  },
+}
+```
+
+Note: With the above configuration, you can deploy a contract using Hardhat Ignition. For a detailed example, including a sample contract and an Ignition module, please refer to the [Hardhat Ignition Getting Started Guide](https://hardhat.org/ignition/docs/getting-started).
+
+To deploy your contract using Hardhat Ignition, run the following command:
+
+```bash
+npx hardhat ignition deploy ignition/modules/Apollo.ts --network sdr
+```
+
+## Troubleshooting
+
+If you encounter any issues, please check the following:
+
+1. Ensure you're using the correct RPC URL for your desired network.
+2. Verify that your private key is correctly set and has sufficient funds.
+3. Ensure that your token is still active on the SilentData AppChains dashboard.
+4. If using Fireblocks, validate your user and API keys.
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).
+
+## Additional Resources
+
+- [Silent Data [Rollup] Documentation](https://docs.silentdata.com)
+- [Fireblocks Hardhat Plugin](https://developers.fireblocks.com/reference/hardhat-plugin)
+- [Fireblocks Developer Documentation](https://developers.fireblocks.com/api)
+- [Fireblocks Web3 Provider](https://developers.fireblocks.com/reference/evm-web3-provider)
+- [Hardhat Ignition](https://hardhat.org/hardhat-runner/plugins/nomiclabs-hardhat-ignition)

package/dist/index.d.mts

@@ -0,0 +1,16 @@
+import { SignatureType } from '@appliedblockchain/silentdatarollup-core';
+
+interface SilentdataNetworkConfig {
+    authSignatureType: SignatureType;
+    maxRetries?: number;
+    pollingInterval?: number;
+}
+
+declare module 'hardhat/types/config' {
+    interface HttpNetworkUserConfig {
+        silentdata?: SilentdataNetworkConfig;
+    }
+    interface HttpNetworkConfig {
+        silentdata?: SilentdataNetworkConfig;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { SignatureType } from '@appliedblockchain/silentdatarollup-core';
+
+interface SilentdataNetworkConfig {
+    authSignatureType: SignatureType;
+    maxRetries?: number;
+    pollingInterval?: number;
+}
+
+declare module 'hardhat/types/config' {
+    interface HttpNetworkUserConfig {
+        silentdata?: SilentdataNetworkConfig;
+    }
+    interface HttpNetworkConfig {
+        silentdata?: SilentdataNetworkConfig;
+    }
+}

package/dist/index.js

@@ -0,0 +1,384 @@
+"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 __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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
+));
+
+// src/type-extensions.ts
+var import_config = require("hardhat/types/config");
+
+// src/index.ts
+var import_hardhat_fireblocks = require("@fireblocks/hardhat-fireblocks");
+var import_debug2 = __toESM(require("debug"));
+var import_config2 = require("hardhat/config");
+
+// src/constants.ts
+var import_silentdatarollup_core = require("@appliedblockchain/silentdatarollup-core");
+var SIGN_RPC_METHODS = [...import_silentdatarollup_core.SIGN_RPC_METHODS, "eth_call"];
+var DEBUG_NAMESPACE = "silentdata:fireblocks";
+var DEFAULT_MAX_RETRIES = 25;
+var DEFAULT_POLLING_INTERVAL = 2e3;
+
+// src/provider.ts
+var import_silentdatarollup_core2 = require("@appliedblockchain/silentdatarollup-core");
+var import_fireblocks_web3_provider = require("@fireblocks/fireblocks-web3-provider");
+var import_debug = __toESM(require("debug"));
+var import_ethers = require("ethers");
+var import_fireblocks_sdk = require("fireblocks-sdk");
+var import_plugins = require("hardhat/plugins");
+var log = (0, import_debug.default)(DEBUG_NAMESPACE);
+var SilentDataFireblocksSigner = class extends import_plugins.ProviderWrapper {
+  constructor(provider, config) {
+    super(provider);
+    this.lastNonce = {};
+    log("SilentDataFireblocksSigner initialized");
+    const fireblocksWeb3Provider = provider._provider._wrappedProvider._wrappedProvider._fireblocksWeb3Provider;
+    this.setupInterceptor(fireblocksWeb3Provider);
+    this._fireblocksWeb3Provider = fireblocksWeb3Provider;
+    this.config = {
+      ...config,
+      authSignatureType: config?.authSignatureType ?? import_silentdatarollup_core2.SignatureType.Raw
+    };
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.pollingInterval = config.pollingInterval ?? DEFAULT_POLLING_INTERVAL;
+    this.baseProvider = new import_silentdatarollup_core2.SilentDataRollupBase(config);
+  }
+  async request(args) {
+    log(".request()", JSON.stringify(args, null, 2));
+    const payload = {
+      jsonrpc: "2.0",
+      ...args,
+      id: Math.floor(Math.random() * 1e10)
+    };
+    if (args.method === "eth_sendTransaction") {
+      return this.sendTransaction(payload);
+    }
+    const result = await new Promise((resolve, reject) => {
+      ;
+      this._fireblocksWeb3Provider.send(
+        payload,
+        (error, response) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(response.result);
+          }
+        }
+      );
+    });
+    return result;
+  }
+  send(method, params) {
+    log("Provider .send() method called:", method);
+    return this.request({ method, params });
+  }
+  sendAsync(payload, callback) {
+    log("Provider .sendAsync() method called:", payload.method);
+    this.request(payload).then(callback).catch(callback);
+  }
+  setupInterceptor(provider) {
+    log("Setting up silent data interceptor for Fireblocks");
+    const originalSend = provider.send;
+    provider.send = async (payload, callback) => {
+      ;
+      (async () => {
+        const requiresAuthHeaders = SIGN_RPC_METHODS.includes(payload.method);
+        if (payload.method === "eth_sendTransaction") {
+          try {
+            const result2 = await this.sendTransaction(payload);
+            callback(null, result2);
+          } catch (error) {
+            callback(error, null);
+          }
+          return;
+        }
+        log("Intercepted send method:", JSON.stringify(payload, null, 2));
+        if (requiresAuthHeaders) {
+          log("Request requires auth headers");
+          const clonedEthereum = new import_fireblocks_web3_provider.FireblocksWeb3Provider(
+            provider.config
+          );
+          const authHeaders = await this.getAuthHeaders(payload);
+          const allHeaders = [];
+          for (const [key, value] of Object.entries(authHeaders)) {
+            allHeaders.push({ name: key, value });
+          }
+          ;
+          clonedEthereum.headers = allHeaders;
+          log("Auth headers set for cloned FireblocksWeb3Provider provider");
+          return originalSend.call(clonedEthereum, payload, callback);
+        }
+        const result = await originalSend.call(provider, payload, callback);
+        return result;
+      })();
+    };
+  }
+  async signMessage(content, operation, type) {
+    const vaultAccountId = this._fireblocksWeb3Provider.vaultAccountIds[0]?.toString();
+    const transactionArguments = {
+      operation,
+      assetId: this._fireblocksWeb3Provider.assetId,
+      source: {
+        type: import_fireblocks_sdk.PeerType.VAULT_ACCOUNT,
+        id: vaultAccountId
+      },
+      extraParameters: {
+        rawMessageData: {
+          messages: [
+            {
+              content,
+              ...type ? { type } : {}
+            }
+          ]
+        }
+      }
+    };
+    log("Creating transaction", JSON.stringify(transactionArguments, null, 2));
+    const txInfo = await this._fireblocksWeb3Provider.createTransaction(transactionArguments);
+    const sig = txInfo.signedMessages[0].signature;
+    const v = 27 + sig.v;
+    return "0x" + sig.r + sig.s + v.toString(16);
+  }
+  async getAuthHeaders(payload) {
+    log("Getting auth headers for method:", JSON.stringify(payload, null, 2));
+    const requestId = this._wrappedProvider._provider._wrappedProvider._wrappedProvider._wrappedProvider._nextRequestId;
+    const rpcRequest = {
+      jsonrpc: "2.0",
+      ...payload,
+      id: requestId
+    };
+    const xTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const headers = {
+      [import_silentdatarollup_core2.HEADER_TIMESTAMP]: xTimestamp
+    };
+    const signatureType = this.config?.authSignatureType ?? import_silentdatarollup_core2.SignatureType.Raw;
+    let content;
+    switch (signatureType) {
+      case import_silentdatarollup_core2.SignatureType.Raw:
+        const preparedMessage = this.baseProvider.prepareSignatureMessage(
+          rpcRequest,
+          xTimestamp
+        );
+        content = (0, import_ethers.hashMessage)(preparedMessage).slice(2);
+        break;
+      case import_silentdatarollup_core2.SignatureType.EIP712:
+        const types = (0, import_silentdatarollup_core2.getAuthEIP721Types)(payload);
+        const message = this.baseProvider.prepareSignatureTypedData(
+          payload,
+          xTimestamp
+        );
+        content = {
+          types: {
+            EIP712Domain: [
+              { name: "name", type: "string" },
+              { name: "version", type: "string" }
+            ],
+            ...types
+          },
+          primaryType: "Call",
+          domain: import_silentdatarollup_core2.eip721Domain,
+          message
+        };
+        break;
+      default:
+        throw new Error(`Unsupported signature type: ${signatureType}`);
+    }
+    const signature = await this.signMessage(
+      content,
+      signatureType === import_silentdatarollup_core2.SignatureType.Raw ? import_fireblocks_sdk.TransactionOperation.RAW : import_fireblocks_sdk.TransactionOperation.TYPED_MESSAGE,
+      signatureType
+    );
+    headers[signatureType === import_silentdatarollup_core2.SignatureType.Raw ? import_silentdatarollup_core2.HEADER_SIGNATURE : import_silentdatarollup_core2.HEADER_EIP712_SIGNATURE] = signature;
+    log("Auth headers generated successfully");
+    return headers;
+  }
+  /**
+   * Manages and returns the next available nonce for a given address.
+   *
+   * This method implements a local nonce management system to handle concurrent
+   * transactions and potential network delays. It's necessary because:
+   * 1. Multiple transactions can be initiated before earlier ones are confirmed.
+   * 2. We need to ensure each transaction uses a unique, incrementing nonce.
+   *
+   * The method works by:
+   * - Tracking the last used nonce for each address.
+   * - Comparing it with the current network nonce.
+   * - Always returning a nonce higher than both the network nonce and the last used nonce.
+   *
+   * This approach helps prevent nonce conflicts and ensures transactions can be
+   * sent in rapid succession without waiting for network confirmation.
+   *
+   * @param address - The Ethereum address for which to get the next nonce.
+   * @returns A Promise that resolves to the next available nonce as a number.
+   */
+  async getNextNonce(address) {
+    try {
+      log("Getting next nonce for address:", address);
+      const currentNonce = await this._wrappedProvider.request({
+        method: "eth_getTransactionCount",
+        params: [address, "latest"]
+      });
+      const currentNonceNumber = parseInt(currentNonce, 16);
+      log("Current nonce from provider:", currentNonceNumber);
+      this.lastNonce[address] = Math.max(
+        this.lastNonce[address] || 0,
+        currentNonceNumber
+      );
+      this.lastNonce[address]++;
+      const nextNonce = this.lastNonce[address] - 1;
+      log("Next nonce to be used:", nextNonce);
+      return nextNonce;
+    } catch (error) {
+      log("Error fetching nonce:", error);
+      throw new Error("Failed to get next nonce");
+    }
+  }
+  async getTransactionParams(payload) {
+    const from = payload.params[0].from;
+    const nonce = await this.getNextNonce(from);
+    log("Using nonce:", nonce);
+    const chainId = await this.getChainId();
+    log("Chain ID:", chainId);
+    const [maxPriorityFeePerGas, maxFeePerGas] = await this.getFeeData();
+    log("Max Priority Fee Per Gas:", maxPriorityFeePerGas.toString());
+    log("Max Fee Per Gas:", maxFeePerGas.toString());
+    const gasLimit = await this.estimateGasLimit(payload.params[0]);
+    log("Estimated gas limit:", gasLimit);
+    return {
+      type: 2,
+      chainId,
+      nonce,
+      to: payload.params[0].to,
+      maxFeePerGas: maxFeePerGas.toString(),
+      maxPriorityFeePerGas: maxPriorityFeePerGas.toString(),
+      gasLimit,
+      data: payload.params[0].data,
+      value: payload.params[0].value
+    };
+  }
+  async getChainId() {
+    const networkResult = await this._wrappedProvider.request({
+      method: "eth_chainId",
+      params: []
+    });
+    return parseInt(networkResult, 16);
+  }
+  async getFeeData() {
+    const [maxPriorityFeePerGasHex, baseFeePerGasHex] = await Promise.all([
+      this._wrappedProvider.request({
+        method: "eth_maxPriorityFeePerGas",
+        params: []
+      }),
+      this._wrappedProvider.request({
+        method: "eth_getBlockByNumber",
+        params: ["latest", false]
+      }).then((block) => block.baseFeePerGas)
+    ]);
+    const maxPriorityFeePerGas = BigInt(maxPriorityFeePerGasHex);
+    const baseFeePerGas = BigInt(baseFeePerGasHex);
+    const maxFeePerGas = maxPriorityFeePerGas + baseFeePerGas * BigInt(2);
+    return [maxPriorityFeePerGas, maxFeePerGas];
+  }
+  async estimateGasLimit(txParams) {
+    const gasLimitHex = await this._wrappedProvider.request({
+      method: "eth_estimateGas",
+      params: [txParams]
+    });
+    return parseInt(gasLimitHex, 16);
+  }
+  async waitForTransaction(txHash) {
+    for (let i = 0; i < this.maxRetries; i++) {
+      const receipt = await this._wrappedProvider.request({
+        method: "eth_getTransactionReceipt",
+        params: [txHash]
+      });
+      if (receipt) {
+        log("Transaction mined, receipt:", JSON.stringify(receipt, null, 2));
+        if (receipt.status !== "0x1") {
+          log("Transaction failed", receipt);
+          throw new Error("Transaction failed");
+        }
+        return receipt;
+      }
+      await new Promise((resolve) => setTimeout(resolve, this.pollingInterval));
+    }
+    throw new Error("Transaction was not mined within the expected timeframe");
+  }
+  async sendTransaction(payload) {
+    log("Starting sendTransaction");
+    if (payload.method !== "eth_sendTransaction") {
+      log("Not an eth_sendTransaction method, skipping");
+      throw new Error("Not an eth_sendTransaction method.");
+    }
+    const txParams = await this.getTransactionParams(payload);
+    log("Transaction params:", txParams);
+    const tx = import_ethers.Transaction.from(txParams);
+    const txHash = (0, import_ethers.keccak256)(tx.unsignedSerialized);
+    const txHashHex = (0, import_ethers.hexlify)(txHash).slice(2);
+    log("Transaction hash to sign:", txHashHex);
+    log("Creating signature");
+    const signature = await this.createPersonalSignature(
+      txHashHex,
+      import_fireblocks_sdk.TransactionOperation.RAW
+    );
+    log("Signature created:", signature);
+    tx.signature = signature;
+    log("Signature added to transaction");
+    log("Broadcasting transaction");
+    const signedTx = tx.serialized;
+    try {
+      const txHash2 = await this._wrappedProvider.request({
+        method: "eth_sendRawTransaction",
+        params: [signedTx]
+      });
+      log("Transaction broadcasted, hash:", txHash2);
+      await this.waitForTransaction(txHash2);
+      return txHash2;
+    } catch (error) {
+      log("Transaction broadcast failed:", error);
+      throw error;
+    }
+  }
+  async createPersonalSignature(content, operation, type) {
+    return this.signMessage(content, operation, type);
+  }
+};
+
+// src/index.ts
+var log2 = (0, import_debug2.default)(DEBUG_NAMESPACE);
+(0, import_config2.extendEnvironment)((hre) => {
+  const networkConfig = hre.network.config;
+  if (!networkConfig.silentdata) {
+    log2("SilentData configuration not found. Returning the original provider.");
+    return;
+  }
+  if (!networkConfig.fireblocks) {
+    log2("Fireblocks configuration not found. Returning the original provider.");
+    return;
+  }
+  log2("SilentData and Fireblocks configuration found. Extending provider...");
+  const wrappedProvider = new SilentDataFireblocksSigner(
+    hre.network.provider,
+    networkConfig.silentdata
+  );
+  log2("Wrapped provider created");
+  hre.network.provider = wrappedProvider;
+});

package/dist/index.mjs

@@ -0,0 +1,371 @@
+// src/type-extensions.ts
+import "hardhat/types/config";
+
+// src/index.ts
+import "@fireblocks/hardhat-fireblocks";
+import debug2 from "debug";
+import { extendEnvironment } from "hardhat/config";
+
+// src/constants.ts
+import { SIGN_RPC_METHODS as CORE_SIGN_RPC_METHODS } from "@appliedblockchain/silentdatarollup-core";
+var SIGN_RPC_METHODS = [...CORE_SIGN_RPC_METHODS, "eth_call"];
+var DEBUG_NAMESPACE = "silentdata:fireblocks";
+var DEFAULT_MAX_RETRIES = 25;
+var DEFAULT_POLLING_INTERVAL = 2e3;
+
+// src/provider.ts
+import {
+  eip721Domain,
+  getAuthEIP721Types,
+  HEADER_EIP712_SIGNATURE,
+  HEADER_SIGNATURE,
+  HEADER_TIMESTAMP,
+  SignatureType,
+  SilentDataRollupBase
+} from "@appliedblockchain/silentdatarollup-core";
+import { FireblocksWeb3Provider } from "@fireblocks/fireblocks-web3-provider";
+import debug from "debug";
+import { hashMessage, hexlify, keccak256, Transaction } from "ethers";
+import {
+  PeerType,
+  TransactionOperation
+} from "fireblocks-sdk";
+import { ProviderWrapper } from "hardhat/plugins";
+var log = debug(DEBUG_NAMESPACE);
+var SilentDataFireblocksSigner = class extends ProviderWrapper {
+  constructor(provider, config) {
+    super(provider);
+    this.lastNonce = {};
+    log("SilentDataFireblocksSigner initialized");
+    const fireblocksWeb3Provider = provider._provider._wrappedProvider._wrappedProvider._fireblocksWeb3Provider;
+    this.setupInterceptor(fireblocksWeb3Provider);
+    this._fireblocksWeb3Provider = fireblocksWeb3Provider;
+    this.config = {
+      ...config,
+      authSignatureType: config?.authSignatureType ?? SignatureType.Raw
+    };
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.pollingInterval = config.pollingInterval ?? DEFAULT_POLLING_INTERVAL;
+    this.baseProvider = new SilentDataRollupBase(config);
+  }
+  async request(args) {
+    log(".request()", JSON.stringify(args, null, 2));
+    const payload = {
+      jsonrpc: "2.0",
+      ...args,
+      id: Math.floor(Math.random() * 1e10)
+    };
+    if (args.method === "eth_sendTransaction") {
+      return this.sendTransaction(payload);
+    }
+    const result = await new Promise((resolve, reject) => {
+      ;
+      this._fireblocksWeb3Provider.send(
+        payload,
+        (error, response) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(response.result);
+          }
+        }
+      );
+    });
+    return result;
+  }
+  send(method, params) {
+    log("Provider .send() method called:", method);
+    return this.request({ method, params });
+  }
+  sendAsync(payload, callback) {
+    log("Provider .sendAsync() method called:", payload.method);
+    this.request(payload).then(callback).catch(callback);
+  }
+  setupInterceptor(provider) {
+    log("Setting up silent data interceptor for Fireblocks");
+    const originalSend = provider.send;
+    provider.send = async (payload, callback) => {
+      ;
+      (async () => {
+        const requiresAuthHeaders = SIGN_RPC_METHODS.includes(payload.method);
+        if (payload.method === "eth_sendTransaction") {
+          try {
+            const result2 = await this.sendTransaction(payload);
+            callback(null, result2);
+          } catch (error) {
+            callback(error, null);
+          }
+          return;
+        }
+        log("Intercepted send method:", JSON.stringify(payload, null, 2));
+        if (requiresAuthHeaders) {
+          log("Request requires auth headers");
+          const clonedEthereum = new FireblocksWeb3Provider(
+            provider.config
+          );
+          const authHeaders = await this.getAuthHeaders(payload);
+          const allHeaders = [];
+          for (const [key, value] of Object.entries(authHeaders)) {
+            allHeaders.push({ name: key, value });
+          }
+          ;
+          clonedEthereum.headers = allHeaders;
+          log("Auth headers set for cloned FireblocksWeb3Provider provider");
+          return originalSend.call(clonedEthereum, payload, callback);
+        }
+        const result = await originalSend.call(provider, payload, callback);
+        return result;
+      })();
+    };
+  }
+  async signMessage(content, operation, type) {
+    const vaultAccountId = this._fireblocksWeb3Provider.vaultAccountIds[0]?.toString();
+    const transactionArguments = {
+      operation,
+      assetId: this._fireblocksWeb3Provider.assetId,
+      source: {
+        type: PeerType.VAULT_ACCOUNT,
+        id: vaultAccountId
+      },
+      extraParameters: {
+        rawMessageData: {
+          messages: [
+            {
+              content,
+              ...type ? { type } : {}
+            }
+          ]
+        }
+      }
+    };
+    log("Creating transaction", JSON.stringify(transactionArguments, null, 2));
+    const txInfo = await this._fireblocksWeb3Provider.createTransaction(transactionArguments);
+    const sig = txInfo.signedMessages[0].signature;
+    const v = 27 + sig.v;
+    return "0x" + sig.r + sig.s + v.toString(16);
+  }
+  async getAuthHeaders(payload) {
+    log("Getting auth headers for method:", JSON.stringify(payload, null, 2));
+    const requestId = this._wrappedProvider._provider._wrappedProvider._wrappedProvider._wrappedProvider._nextRequestId;
+    const rpcRequest = {
+      jsonrpc: "2.0",
+      ...payload,
+      id: requestId
+    };
+    const xTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const headers = {
+      [HEADER_TIMESTAMP]: xTimestamp
+    };
+    const signatureType = this.config?.authSignatureType ?? SignatureType.Raw;
+    let content;
+    switch (signatureType) {
+      case SignatureType.Raw:
+        const preparedMessage = this.baseProvider.prepareSignatureMessage(
+          rpcRequest,
+          xTimestamp
+        );
+        content = hashMessage(preparedMessage).slice(2);
+        break;
+      case SignatureType.EIP712:
+        const types = getAuthEIP721Types(payload);
+        const message = this.baseProvider.prepareSignatureTypedData(
+          payload,
+          xTimestamp
+        );
+        content = {
+          types: {
+            EIP712Domain: [
+              { name: "name", type: "string" },
+              { name: "version", type: "string" }
+            ],
+            ...types
+          },
+          primaryType: "Call",
+          domain: eip721Domain,
+          message
+        };
+        break;
+      default:
+        throw new Error(`Unsupported signature type: ${signatureType}`);
+    }
+    const signature = await this.signMessage(
+      content,
+      signatureType === SignatureType.Raw ? TransactionOperation.RAW : TransactionOperation.TYPED_MESSAGE,
+      signatureType
+    );
+    headers[signatureType === SignatureType.Raw ? HEADER_SIGNATURE : HEADER_EIP712_SIGNATURE] = signature;
+    log("Auth headers generated successfully");
+    return headers;
+  }
+  /**
+   * Manages and returns the next available nonce for a given address.
+   *
+   * This method implements a local nonce management system to handle concurrent
+   * transactions and potential network delays. It's necessary because:
+   * 1. Multiple transactions can be initiated before earlier ones are confirmed.
+   * 2. We need to ensure each transaction uses a unique, incrementing nonce.
+   *
+   * The method works by:
+   * - Tracking the last used nonce for each address.
+   * - Comparing it with the current network nonce.
+   * - Always returning a nonce higher than both the network nonce and the last used nonce.
+   *
+   * This approach helps prevent nonce conflicts and ensures transactions can be
+   * sent in rapid succession without waiting for network confirmation.
+   *
+   * @param address - The Ethereum address for which to get the next nonce.
+   * @returns A Promise that resolves to the next available nonce as a number.
+   */
+  async getNextNonce(address) {
+    try {
+      log("Getting next nonce for address:", address);
+      const currentNonce = await this._wrappedProvider.request({
+        method: "eth_getTransactionCount",
+        params: [address, "latest"]
+      });
+      const currentNonceNumber = parseInt(currentNonce, 16);
+      log("Current nonce from provider:", currentNonceNumber);
+      this.lastNonce[address] = Math.max(
+        this.lastNonce[address] || 0,
+        currentNonceNumber
+      );
+      this.lastNonce[address]++;
+      const nextNonce = this.lastNonce[address] - 1;
+      log("Next nonce to be used:", nextNonce);
+      return nextNonce;
+    } catch (error) {
+      log("Error fetching nonce:", error);
+      throw new Error("Failed to get next nonce");
+    }
+  }
+  async getTransactionParams(payload) {
+    const from = payload.params[0].from;
+    const nonce = await this.getNextNonce(from);
+    log("Using nonce:", nonce);
+    const chainId = await this.getChainId();
+    log("Chain ID:", chainId);
+    const [maxPriorityFeePerGas, maxFeePerGas] = await this.getFeeData();
+    log("Max Priority Fee Per Gas:", maxPriorityFeePerGas.toString());
+    log("Max Fee Per Gas:", maxFeePerGas.toString());
+    const gasLimit = await this.estimateGasLimit(payload.params[0]);
+    log("Estimated gas limit:", gasLimit);
+    return {
+      type: 2,
+      chainId,
+      nonce,
+      to: payload.params[0].to,
+      maxFeePerGas: maxFeePerGas.toString(),
+      maxPriorityFeePerGas: maxPriorityFeePerGas.toString(),
+      gasLimit,
+      data: payload.params[0].data,
+      value: payload.params[0].value
+    };
+  }
+  async getChainId() {
+    const networkResult = await this._wrappedProvider.request({
+      method: "eth_chainId",
+      params: []
+    });
+    return parseInt(networkResult, 16);
+  }
+  async getFeeData() {
+    const [maxPriorityFeePerGasHex, baseFeePerGasHex] = await Promise.all([
+      this._wrappedProvider.request({
+        method: "eth_maxPriorityFeePerGas",
+        params: []
+      }),
+      this._wrappedProvider.request({
+        method: "eth_getBlockByNumber",
+        params: ["latest", false]
+      }).then((block) => block.baseFeePerGas)
+    ]);
+    const maxPriorityFeePerGas = BigInt(maxPriorityFeePerGasHex);
+    const baseFeePerGas = BigInt(baseFeePerGasHex);
+    const maxFeePerGas = maxPriorityFeePerGas + baseFeePerGas * BigInt(2);
+    return [maxPriorityFeePerGas, maxFeePerGas];
+  }
+  async estimateGasLimit(txParams) {
+    const gasLimitHex = await this._wrappedProvider.request({
+      method: "eth_estimateGas",
+      params: [txParams]
+    });
+    return parseInt(gasLimitHex, 16);
+  }
+  async waitForTransaction(txHash) {
+    for (let i = 0; i < this.maxRetries; i++) {
+      const receipt = await this._wrappedProvider.request({
+        method: "eth_getTransactionReceipt",
+        params: [txHash]
+      });
+      if (receipt) {
+        log("Transaction mined, receipt:", JSON.stringify(receipt, null, 2));
+        if (receipt.status !== "0x1") {
+          log("Transaction failed", receipt);
+          throw new Error("Transaction failed");
+        }
+        return receipt;
+      }
+      await new Promise((resolve) => setTimeout(resolve, this.pollingInterval));
+    }
+    throw new Error("Transaction was not mined within the expected timeframe");
+  }
+  async sendTransaction(payload) {
+    log("Starting sendTransaction");
+    if (payload.method !== "eth_sendTransaction") {
+      log("Not an eth_sendTransaction method, skipping");
+      throw new Error("Not an eth_sendTransaction method.");
+    }
+    const txParams = await this.getTransactionParams(payload);
+    log("Transaction params:", txParams);
+    const tx = Transaction.from(txParams);
+    const txHash = keccak256(tx.unsignedSerialized);
+    const txHashHex = hexlify(txHash).slice(2);
+    log("Transaction hash to sign:", txHashHex);
+    log("Creating signature");
+    const signature = await this.createPersonalSignature(
+      txHashHex,
+      TransactionOperation.RAW
+    );
+    log("Signature created:", signature);
+    tx.signature = signature;
+    log("Signature added to transaction");
+    log("Broadcasting transaction");
+    const signedTx = tx.serialized;
+    try {
+      const txHash2 = await this._wrappedProvider.request({
+        method: "eth_sendRawTransaction",
+        params: [signedTx]
+      });
+      log("Transaction broadcasted, hash:", txHash2);
+      await this.waitForTransaction(txHash2);
+      return txHash2;
+    } catch (error) {
+      log("Transaction broadcast failed:", error);
+      throw error;
+    }
+  }
+  async createPersonalSignature(content, operation, type) {
+    return this.signMessage(content, operation, type);
+  }
+};
+
+// src/index.ts
+var log2 = debug2(DEBUG_NAMESPACE);
+extendEnvironment((hre) => {
+  const networkConfig = hre.network.config;
+  if (!networkConfig.silentdata) {
+    log2("SilentData configuration not found. Returning the original provider.");
+    return;
+  }
+  if (!networkConfig.fireblocks) {
+    log2("Fireblocks configuration not found. Returning the original provider.");
+    return;
+  }
+  log2("SilentData and Fireblocks configuration found. Extending provider...");
+  const wrappedProvider = new SilentDataFireblocksSigner(
+    hre.network.provider,
+    networkConfig.silentdata
+  );
+  log2("Wrapped provider created");
+  hre.network.provider = wrappedProvider;
+});

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@appliedblockchain/silentdatarollup-hardhat-plugin-fireblocks",
+  "version": "1.0.0",
+  "description": "Hardhat plugin for Silent Data [Rollup] with Fireblocks integration",
+  "author": "Applied Blockchain",
+  "homepage": "https://github.com/appliedblockchain/silent-data-rollup-providers#readme",
+  "keywords": [
+    "ethereum",
+    "provider",
+    "silentdata",
+    "rollup",
+    "hardhat",
+    "fireblocks"
+  ],
+  "license": "MIT",
+  "repository": "https://github.com/appliedblockchain/silent-data-rollup-providers",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "check-exports": "attw --pack . --profile node16",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@appliedblockchain/silentdatarollup-core": "1.0.0",
+    "@fireblocks/fireblocks-web3-provider": "1.3.8",
+    "@fireblocks/hardhat-fireblocks": "1.3.5",
+    "debug": "4.3.7",
+    "ethers": "6.13.2",
+    "fireblocks-sdk": "5.31.2"
+  },
+  "devDependencies": {
+    "@types/debug": "4.1.12",
+    "@types/node": "22.5.4",
+    "hardhat": "2.22.10",
+    "ts-node": "10.9.2",
+    "typescript": "5.6.2"
+  },
+  "peerDependencies": {
+    "@fireblocks/hardhat-fireblocks": "1.3.5",
+    "hardhat": "2.22.10"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}