Fireblocks support (#53)

* wip fireblocks filler logic

* add fireblocks feature through an alloy provider

* license

Author: austinabell

.gitignore

@@ -1,3 +1,6 @@
 .DS_Store
 target/
-.env
+.env
+
+fireblocks*.csr
+fireblocks*.key

Cargo.lock

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-alloy = { version = "0.3.1", features = ["node-bindings", "network", "providers", "transports", "signer-local"] }
+alloy = { version = "0.3.1", features = ["node-bindings", "network", "providers", "transports", "signer-local", "rpc-types"] }
 alloy-contract = "0.3.1"
 alloy-sol-types = { version = "0.8.2", features = ["json"] }
 anyhow = "1.0"
@@ -27,3 +27,4 @@ serde_with = { version = "3.8", features = ["base64"] }
 
 [features]
 prebuilt-docker = ["blobstream0-core/prebuilt-docker"]
+fireblocks = []

cli/Cargo.toml

@@ -0,0 +1,67 @@
+// Copyright 2024 RISC Zero, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use alloy::{
+    network::{Network, TransactionBuilder},
+    primitives::Address,
+    providers::{
+        fillers::{FillerControlFlow, TxFiller},
+        Provider, SendableTx,
+    },
+    transports::{Transport, TransportResult},
+};
+
+#[derive(Clone, Copy, Debug, Default)]
+pub(crate) struct FireblocksFiller {
+    pub sender: Address,
+}
+
+impl<N: Network> TxFiller<N> for FireblocksFiller {
+    type Fillable = ();
+
+    fn status(&self, _tx: &<N as Network>::TransactionRequest) -> FillerControlFlow {
+        FillerControlFlow::Finished
+    }
+
+    fn fill_sync(&self, tx: &mut SendableTx<N>) {
+        if let Some(builder) = tx.as_mut_builder() {
+            // 1 Ether max tx fee
+            if let Some(fee) = builder.max_fee_per_gas() {
+                builder.set_max_fee_per_gas(core::cmp::min(0x0de0b6b3a7640000, fee));
+            }
+
+            builder.set_from(self.sender.clone());
+        }
+    }
+
+    async fn prepare<P, T>(
+        &self,
+        _provider: &P,
+        _tx: &<N as Network>::TransactionRequest,
+    ) -> TransportResult<Self::Fillable>
+    where
+        P: Provider<T, N>,
+        T: Transport + Clone,
+    {
+        Ok(())
+    }
+
+    async fn fill(
+        &self,
+        _fillable: Self::Fillable,
+        tx: SendableTx<N>,
+    ) -> TransportResult<SendableTx<N>> {
+        Ok(tx)
+    }
+}

cli/src/fireblocks.rs

@@ -14,10 +14,8 @@
 
 use alloy::{
     hex::FromHex,
-    network::EthereumWallet,
     primitives::{hex, Address, FixedBytes},
     providers::ProviderBuilder,
-    signers::local::PrivateKeySigner,
 };
 use alloy_sol_types::{sol, SolCall};
 use blobstream0_core::prove_block_range;
@@ -30,6 +28,8 @@ use tokio::fs;
 use tracing_subscriber::fmt::format;
 use tracing_subscriber::{fmt::format::FmtSpan, EnvFilter};
 
+#[cfg(feature = "fireblocks")]
+pub(crate) mod fireblocks;
 mod service;
 
 sol!(
@@ -54,6 +54,35 @@ const CONTROL_ID: [u8; 32] =
 const BN254_CONTROL_ID: [u8; 32] =
     hex!("05a022e1db38457fb510bc347b30eb8f8cf3eda95587653d0eac19e1f10d164e");
 
+#[cfg(feature = "fireblocks")]
+macro_rules! setup_provider {
+    ($cli:ident) => {{
+        let fireblocks_address: Address = $cli.fireblocks_address.parse()?;
+        let provider = ProviderBuilder::new()
+            .fetch_chain_id()
+            .filler(crate::fireblocks::FireblocksFiller {
+                sender: fireblocks_address,
+            })
+            .on_http($cli.eth_rpc.parse()?);
+        (provider, fireblocks_address)
+    }};
+}
+
+#[cfg(not(feature = "fireblocks"))]
+macro_rules! setup_provider {
+    ($cli:ident) => {{
+        let signer: alloy::signers::local::PrivateKeySigner = $cli.private_key_hex.parse()?;
+        let signer_address = signer.address();
+        let provider = ProviderBuilder::new()
+            .with_recommended_fillers()
+            .wallet(alloy::network::EthereumWallet::from(signer))
+            .on_http($cli.eth_rpc.parse()?);
+        (provider, signer_address)
+    }};
+}
+
+pub(crate) use setup_provider;
+
 #[derive(Parser, Debug)]
 #[command(name = "blobstream0-cli")]
 #[command(bin_name = "blobstream0-cli")]
@@ -91,6 +120,12 @@ struct DeployArgs {
     #[clap(long, env)]
     eth_rpc: String,
 
+    #[cfg(feature = "fireblocks")]
+    /// Fireblocks signer address.
+    #[clap(long, env)]
+    fireblocks_address: String,
+
+    #[cfg(not(feature = "fireblocks"))]
     /// Hex encoded private key to use for deploying.
     #[clap(long, env)]
     private_key_hex: String,
@@ -127,7 +162,13 @@ struct UpgradeArgs {
     #[clap(long, env)]
     eth_rpc: String,
 
-    /// Hex encoded private key to use for upgrading the contract. Must be the owner.
+    #[cfg(feature = "fireblocks")]
+    /// Fireblocks signer address.
+    #[clap(long, env)]
+    fireblocks_address: String,
+
+    #[cfg(not(feature = "fireblocks"))]
+    /// Hex encoded private key to use for deploying.
     #[clap(long, env)]
     private_key_hex: String,
 
@@ -162,19 +203,13 @@ async fn main() -> anyhow::Result<()> {
             fs::write(out, bincode::serialize(&receipt)?).await?;
         }
         BlobstreamCli::Deploy(deploy) => {
-            let signer: PrivateKeySigner = deploy.private_key_hex.parse()?;
-
+            let (provider, signer_address) = setup_provider!(deploy);
             let admin_address: Address = if let Some(address) = deploy.admin_address {
                 address.parse()?
             } else {
-                signer.address()
+                signer_address
             };
 
-            let wallet = EthereumWallet::from(signer);
-            let provider = ProviderBuilder::new()
-                .with_recommended_fillers()
-                .wallet(wallet)
-                .on_http(deploy.eth_rpc.parse()?);
             let verifier_address: Address = if let Some(address) = deploy.verifier_address {
                 address.parse()?
             } else {
@@ -222,13 +257,7 @@ async fn main() -> anyhow::Result<()> {
             println!("deployed contract to address: {}", proxy.address());
         }
         BlobstreamCli::Upgrade(upgrade) => {
-            let signer: PrivateKeySigner = upgrade.private_key_hex.parse()?;
-
-            let wallet = EthereumWallet::from(signer);
-            let provider = ProviderBuilder::new()
-                .with_recommended_fillers()
-                .wallet(wallet)
-                .on_http(upgrade.eth_rpc.parse()?);
+            let (provider, _) = setup_provider!(upgrade);
 
             let proxy_address: Address = upgrade.proxy_address.parse()?;
             println!("proxy address: {}", proxy_address);

cli/src/main.rs

@@ -13,10 +13,8 @@
 // limitations under the License.
 
 use self::blobstream::BlobstreamService;
-use alloy::{
-    network::EthereumWallet, primitives::Address, providers::ProviderBuilder,
-    signers::local::PrivateKeySigner,
-};
+use super::setup_provider;
+use alloy::{primitives::Address, providers::ProviderBuilder};
 use blobstream0_primitives::IBlobstream;
 use clap::Parser;
 use tendermint_rpc::HttpClient;
@@ -38,7 +36,13 @@ pub(crate) struct ServiceArgs {
     #[clap(long, env)]
     eth_address: Address,
 
-    /// Hex encoded private key to use for submitting proofs to Ethereum
+    #[cfg(feature = "fireblocks")]
+    /// Fireblocks signer address.
+    #[clap(long, env)]
+    fireblocks_address: String,
+
+    #[cfg(not(feature = "fireblocks"))]
+    /// Hex encoded private key to use for deploying.
     #[clap(long, env)]
     private_key_hex: String,
 
@@ -49,29 +53,14 @@ pub(crate) struct ServiceArgs {
 
 impl ServiceArgs {
     pub(crate) async fn start(self) -> anyhow::Result<()> {
-        let ServiceArgs {
-            tendermint_rpc,
-            eth_rpc,
-            eth_address,
-            private_key_hex,
-            batch_size,
-        } = self;
-
-        let tm_client = HttpClient::new(tendermint_rpc.as_str())?;
-
-        let signer: PrivateKeySigner = private_key_hex.parse().expect("should parse private key");
-        let wallet = EthereumWallet::from(signer);
+        let tm_client = HttpClient::new(self.tendermint_rpc.as_str())?;
 
-        // Create a provider with the wallet.
-        let provider = ProviderBuilder::new()
-            .with_recommended_fillers()
-            .wallet(wallet)
-            .on_http(eth_rpc.parse()?);
+        let (provider, _) = setup_provider!(self);
 
-        let contract = IBlobstream::new(eth_address, provider);
+        let contract = IBlobstream::new(self.eth_address, provider);
 
         tracing::info!(target: "blobstream0::service", "Starting service");
-        BlobstreamService::new(contract, tm_client, batch_size)
+        BlobstreamService::new(contract, tm_client, self.batch_size)
             .spawn()
             .await?;