[fortuna] Fix config and CLI args (#1605)

* cleanup config

* merge configs

* more simplification

* move everything to config

* version bump

* nicer loading of secrets

* fix readme

* precommit

* fix

* precommit

* pr comments

apps/fortuna/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name    = "fortuna"
-version = "5.4.5"
+version = "6.0.0"
 edition = "2021"
 
 [dependencies]

apps/fortuna/README.md

@@ -3,8 +3,9 @@
 Fortuna is a webservice that serves random numbers according to the Entropy protocol.
 The webservice generates a hash chain of random numbers and reveals them to callers when permitted by the protocol.
 The hash chain is generated from a secret key that is provided to the server on startup.
+The service also operates a keeper task that performs callback transactions for user requests.
 
-A single instance of this webservice can simultaneously serve random numbers for several different blockchains.
+A single instance of this service can simultaneously serve random numbers for several different blockchains.
 Each blockchain is configured in `config.yaml`.
 
 ## Build & Test
@@ -21,20 +22,16 @@ registering a new randomness provider, or drawing a random value. To see the ava
 
 To start an instance of the webserver for local testing, you first need to perform a few setup steps:
 
-1. Create `config.yaml` file to point to the desired blockchains and Entropy contracts. Copy the content in `config.sample.yaml` to start with.
-1. Generate a secret key. The secret key is a 32-byte random value used to construct the hash chains.
-   You can generate this value using the `openssl` command:
-   `openssl rand -hex 32`
-1. Generate an ethereum wallet for the provider. You can do this in foundry using `cast wallet new`.
-   Note both the private key and the address; you will need both for subsequent steps.
-1. Register a randomness provider for this service: `cargo run -- register-provider --chain-id <chain id> --secret <secret> --private-key <private-key>`.
-   The chain id is the key of the blockchain in `config.yaml`, the secret is from step (2), and the private key is from step (3).
-   Note that you need to run this command once per blockchain configured in `config.yaml`.
+1. Create a `config.yaml` file to point to the desired blockchains and Entropy contracts. Copy the content in `config.sample.yaml` and follow the directions inside to generate the necessary private keys and secrets.
+1. Make sure the wallets you have generated in step (1) contain some gas tokens for the configured networks.
+1. Run `cargo run -- setup-provider` to register a randomness provider for this service. This command
+   will update the on-chain contracts such that the configured provider key is a randomness provider,
+   and its on-chain configuration matches `config.yaml`.
 
-Once you've completed the setup, simply run the following command, using the secret from step (2) and the wallet address from step (3) as the provider:
+Once you've completed the setup, simply run the following command to start the service:
 
 ```bash
-cargo run -- run --secret <secret> --provider <provider>
+RUST_LOG=INFO cargo run -- run
 ```
 
 This command will start the webservice on `localhost:34000`.

apps/fortuna/config.sample.yaml

@@ -2,5 +2,44 @@ chains:
   lightlink_pegasus:
     geth_rpc_addr: https://replicator.pegasus.lightlink.io/rpc/v1
     contract_addr: 0x8250f4aF4B972684F7b336503E2D6dFeDeB1487a
+
+    # Keeper configuration for the chain
     reveal_delay_blocks: 0
     gas_limit: 500000
+
+    # Provider configuration
+    fee: 1500000000000000
+    # Historical commitments -- delete this block for local development purposes
+    commitments:
+      # prettier-ignore
+      - seed: [219,125,217,197,234,88,208,120,21,181,172,143,239,102,41,233,167,212,237,106,37,255,184,165,238,121,230,155,116,158,173,48]
+        chain_length: 10000
+        original_commitment_sequence_number: 104
+provider:
+  uri: http://localhost:8080/
+  chain_length: 100000
+
+  # An ethereum wallet address and private key. Generate with `cast wallet new`
+  address: 0xADDRESS
+  private_key:
+    # For local development, you can hardcode the private key here
+    value: 0xabcd
+    # For production, you can store the private key in a file.
+    # file: provider-key.txt
+  # A 32 byte random value in hexadecimal
+  # Generate with `openssl rand -hex 32`
+  secret:
+    # For local development, you can hardcode the value here
+    value: abcd
+    # For production, you can store the private key in a file.
+    # file: secret.txt
+keeper:
+  # An ethereum wallet address and private key for running the keeper service.
+  # This does not have to be the same key as the provider's key above.
+  # Generate with `cast wallet new`.
+  # The keeper private key can be omitted to run the webservice without the keeper.
+  private_key:
+    # For local development, you can hardcode the private key here
+    value: 0xabcd
+    # For production, you can store the private key in a file.
+    # file: keeper-key.txt

apps/fortuna/src/command/register_provider.rs

@@ -1,13 +1,22 @@
 use {
     crate::{
+        api::{
+            get_register_uri,
+            ChainId,
+        },
         chain::ethereum::SignablePythContract,
         config::{
             Config,
+            EthereumConfig,
+            ProviderConfig,
             RegisterProviderOptions,
         },
         state::PebbleHashChain,
     },
-    anyhow::Result,
+    anyhow::{
+        anyhow,
+        Result,
+    },
     ethers::{
         abi::Bytes,
         signers::{
@@ -28,42 +37,61 @@ pub struct CommitmentMetadata {
 /// Register as a randomness provider. This method will generate and commit to a new random
 /// hash chain from the configured secret & a newly generated random value.
 pub async fn register_provider(opts: &RegisterProviderOptions) -> Result<()> {
-    let chain_config = Config::load(&opts.config.config)?.get_chain_config(&opts.chain_id)?;
+    let config = Config::load(&opts.config.config)?;
+    let chain_config = config.get_chain_config(&opts.chain_id)?;
+
+    register_provider_from_config(&config.provider, &opts.chain_id, &chain_config).await?;
+
+    Ok(())
+}
+
+pub async fn register_provider_from_config(
+    provider_config: &ProviderConfig,
+    chain_id: &ChainId,
+    chain_config: &EthereumConfig,
+) -> Result<()> {
+    let private_key_string = provider_config.private_key.load()?.ok_or(anyhow!(
+        "Please specify a provider private key in the config"
+    ))?;
 
     // Initialize a Provider to interface with the EVM contract.
     let contract =
-        Arc::new(SignablePythContract::from_config(&chain_config, &opts.private_key).await?);
+        Arc::new(SignablePythContract::from_config(&chain_config, &private_key_string).await?);
     // Create a new random hash chain.
     let random = rand::random::<[u8; 32]>();
-    let secret = opts.randomness.load_secret()?;
+    let secret = provider_config
+        .secret
+        .load()?
+        .ok_or(anyhow!("Please specify a provider secret in the config"))?;
 
-    let commitment_length = opts.randomness.chain_length;
+    let commitment_length = provider_config.chain_length;
     let mut chain = PebbleHashChain::from_config(
         &secret,
-        &opts.chain_id,
-        &opts.private_key.clone().parse::<LocalWallet>()?.address(),
+        &chain_id,
+        &private_key_string.parse::<LocalWallet>()?.address(),
         &chain_config.contract_addr,
         &random,
         commitment_length,
     )?;
 
     // Arguments to the contract to register our new provider.
-    let fee_in_wei = opts.fee;
+    let fee_in_wei = chain_config.fee;
     let commitment = chain.reveal()?;
     // Store the random seed and chain length in the metadata field so that we can regenerate the hash
     // chain at-will. (This is secure because you can't generate the chain unless you also have the secret)
     let commitment_metadata = CommitmentMetadata {
         seed:         random,
         chain_length: commitment_length,
     };
+    let uri = get_register_uri(&provider_config.uri, &chain_id)?;
     let call = contract.register(
         fee_in_wei,
         commitment,
         bincode::serialize(&commitment_metadata)?.into(),
         commitment_length,
         // Use Bytes to serialize the uri. Most users will be using JS/TS to deserialize this uri.
         // Bincode is a different encoding mechanisms, and I didn't find any JS/TS library to parse bincode.
-        Bytes::from(opts.uri.as_str()).into(),
+        Bytes::from(uri.as_str()).into(),
     );
     let mut gas_estimate = call.estimate_gas().await?;
     let gas_multiplier = U256::from(2); //TODO: smarter gas estimation

apps/fortuna/src/command/run.rs

@@ -11,7 +11,6 @@ use {
             Commitment,
             Config,
             EthereumConfig,
-            ProviderConfig,
             RunOptions,
         },
         keeper,
@@ -32,7 +31,10 @@ use {
             Http,
             Provider,
         },
-        types::BlockNumber,
+        types::{
+            Address,
+            BlockNumber,
+        },
     },
     prometheus_client::{
         encoding::EncodeLabelSet,
@@ -150,12 +152,15 @@ pub async fn run_keeper(
 
 pub async fn run(opts: &RunOptions) -> Result<()> {
     let config = Config::load(&opts.config.config)?;
-    let secret = opts.randomness.load_secret()?;
+    let secret = config.provider.secret.load()?.ok_or(anyhow!(
+        "Please specify a provider secret in the config file."
+    ))?;
     let (tx_exit, rx_exit) = watch::channel(false);
 
     let mut chains: HashMap<ChainId, BlockchainState> = HashMap::new();
     for (chain_id, chain_config) in &config.chains {
-        let state = setup_chain_state(&opts, &secret, chain_id, chain_config).await;
+        let state =
+            setup_chain_state(&config.provider.address, &secret, chain_id, chain_config).await;
         match state {
             Ok(state) => {
                 chains.insert(chain_id.clone(), state);
@@ -184,13 +189,15 @@ pub async fn run(opts: &RunOptions) -> Result<()> {
 
     let metrics_registry = Arc::new(RwLock::new(Registry::default()));
 
-    if let Some(keeper_private_key) = opts.load_keeper_private_key()? {
+    if let Some(keeper_private_key) = config.keeper.private_key.load()? {
         spawn(run_keeper(
             chains.clone(),
             config.clone(),
             keeper_private_key,
             metrics_registry.clone(),
         ));
+    } else {
+        tracing::info!("Not starting keeper service: no keeper private key specified. Please add one to the config if you would like to run the keeper service.")
     }
 
     // Spawn a thread to track latest block lag. This helps us know if the rpc is up and updated with the latest block.
@@ -202,16 +209,19 @@ pub async fn run(opts: &RunOptions) -> Result<()> {
 }
 
 async fn setup_chain_state(
-    opts: &&RunOptions,
+    provider: &Address,
     secret: &String,
     chain_id: &ChainId,
     chain_config: &EthereumConfig,
 ) -> Result<BlockchainState> {
-    let provider_config = ProviderConfig::load(&opts.provider_config.provider_config)?;
     let contract = Arc::new(PythContract::from_config(&chain_config)?);
-    let provider_chain_config = provider_config.get_chain_config(chain_id)?;
-    let mut provider_commitments = provider_chain_config.get_sorted_commitments();
-    let provider_info = contract.get_provider_info(opts.provider).call().await?;
+    let mut provider_commitments = chain_config.commitments.clone().unwrap_or(Vec::new());
+    provider_commitments.sort_by(|c1, c2| {
+        c1.original_commitment_sequence_number
+            .cmp(&c2.original_commitment_sequence_number)
+    });
+
+    let provider_info = contract.get_provider_info(*provider).call().await?;
     let latest_metadata = bincode::deserialize::<CommitmentMetadata>(
         &provider_info.commitment_metadata,
     )
@@ -223,6 +233,16 @@ async fn setup_chain_state(
         )
     })?;
 
+    let last_prior_commitment = provider_commitments.last();
+    if last_prior_commitment.is_some()
+        && last_prior_commitment
+            .unwrap()
+            .original_commitment_sequence_number
+            >= provider_info.original_commitment_sequence_number
+    {
+        return Err(anyhow!("The current hash chain for chain id {} has configured commitments for sequence numbers greater than the current on-chain sequence number. Are the commitments configured correctly?", &chain_id));
+    }
+
     provider_commitments.push(Commitment {
         seed:                                latest_metadata.seed,
         chain_length:                        latest_metadata.chain_length,
@@ -243,7 +263,7 @@ async fn setup_chain_state(
         let pebble_hash_chain = PebbleHashChain::from_config(
             &secret,
             &chain_id,
-            &opts.provider,
+            &provider,
             &chain_config.contract_addr,
             &commitment.seed,
             commitment.chain_length,
@@ -268,7 +288,7 @@ async fn setup_chain_state(
         id: chain_id.clone(),
         state: Arc::new(chain_state),
         contract,
-        provider_address: opts.provider,
+        provider_address: provider.clone(),
         reveal_delay_blocks: chain_config.reveal_delay_blocks,
         confirmed_block_status: chain_config.confirmed_block_status,
     };