Merge branch 'develop' into updatepool

Author: sethdusek

README.md

@@ -1,71 +1,10 @@
-# Oracle Core
-
-![](images/oracle-core.png)
+# Oracle Core v2.0
 
 The oracle core is the off-chain component that oracles who are part of an oracle pool run. This oracle core provides a HTTP API interface for reading the current protocol state & another for submitting datapoints. Once a datapoint is submited, the oracle core will automatically generate the required tx and post it as well as any other actions required for the protocol to run. This thereby allows the oracle to participate in the oracle pool protocol without any extra effort for the oracle operator.
 
 The oracle core requires that the user has access to a full node wallet in order to create txs & perform UTXO-set scanning. Furthermore each oracle core is designed to work with only a single oracle pool. If an operator runs several oracles in several oracle pools then a single full node can be used, but several instances of oracle cores must be run (and set with different api ports).
 
-A `Connector` must also be used with the oracle core in order to acquire data to submit to the pool. Each connector sources data from the expected sources, potentially applies functions to said data, and then submits the data to the oracle core via HTTP API during the `Live Epoch` stage in the oracle pool protocol. All oracles for a given pool are expected to use the exact same connector, thereby making it simple to onboard and get started.
-
-The current oracle core is built to run the protocol specified in the [Deviation Checking Oracle Pool Spec](/docs/specs/v0.2/Deviation-Checking-Oracle-Pool-Spec.md).
-
-Other documents can also be found explaining how various parts of the oracle core work in the [docs folder](docs).
-
-
-
-# Building & Running An Oracle
-The majority of oracle operators will only need to focus on setting up their own oracle core to work with an [already bootstrapped oracle pool](#Bootstrapping-An-Oracle-Pool). This section will explain how to do so for oracles using the ERG-USD connector. The steps are exactly the same for other connectors, but simply require using that connector's prepare script.
-
-It is assumed that you are running this oracle on Linux, and have the following prerequisites:
-- Access to an [Ergo Node](https://github.com/ergoplatform/ergo) v3.3.0+ with an unlocked wallet.
-- A recent stable version of the [Rust Compiler](https://www.rust-lang.org/tools/install) installed.
-- The Linux CLI tool `screen` and the `libssl-dev` package on Ubuntu (aka `openssl-devel` on Fedora, and potentially slightly different on other distros) installed.
-
-1. Clone this repository via:
-```sh
-git clone [email protected]:ergoplatform/oracle-core.git
-```
-2. Enter into the connector's script folder:
-```sh
-cd oracle-core/scripts/erg-usd-oracle
-```
-3. Run the prepare script which will automatically compile the oracle core and the connector for you:
-```sh
-sh prepare-erg-usd-oracle.sh
-```
-4. Enter into the newly created `oracle-core-deployed` folder:
-```sh
-cd ../../erg-usd-oracle-deployed & ls
-```
-5. Edit your `oracle-config.yaml` with your Ergo Node information, your oracle address (address that was used for bootstrapping the pool & is inside of your Ergo Node wallet), and other relevant pool information. (Optionally acquire a pre-configured `oracle-config.yaml` from the user who bootstrapped the oracle pool and simply fill in your node info/oracle address)
-6. Ensure your Ergo Node is running (and matches the info you input in the config) and has it's wallet unlocked (with some Ergs in the wallet to pay for tx fees).
-7. Launch your oracle by running `run-oracle.sh`:
-```sh
-sh run-oracle.sh
-```
-8. A `screen` instance will be created which launches both the oracle core and the connector. (Press `Ctrl+a - n` to go between the core & the connector screens).
-9. If your node is running and properly configured, the oracle core will inform you that it has successfully registered the required UTXO-set scans:
-```sh
-UTXO-Set Scans Have Been Successfully Registered With The Ergo Node
-```
-10. Press enter to confirm that the scans have been registered. Your oracle core is now properly set up and waiting for the UTXO-set scans to be triggered in order to read the state of the oracle pool on-chain to then perform actions/txs.
-11. Rescan the blockchain history by either using the `/wallet/rescan` GET endpoint of your node, or by deleting `.ergo/wallet/registry` in your Ergo Node folder. Either option triggers a rescan after the blockchain progresses into the next block.
-12. Once the node has finished rescanning (which can be checked via the `/wallet/status` endpoint and comparing the `walletHeight` value to the current blockheight), the oracle core & connector will automatically issue transactions and move the protocol forward.
-13. Congrats, you can now detach from the screen instance if you wish via `Ctrl+a d`. (And reattach via `screen -r`) Your oracle core/connector will run automatically going forward.
-
-
-# Bootstrapping An Oracle Pool
-In order for an oracle pool to run, it must be first created/bootstrapped on-chain. This is the bootstrap process that is required before oracle operators can run their oracle core and have the pool function on-chain.
-
-Check out the [Oracle Pool Bootstrap folder](oracle-pool-bootstrap) for detailed instructions about how to bootstrap an oracle pool using the CLI tool or manually.
-
-
-# Writing A New Connector
-If you are looking to create a new Oracle Pool for a new datapoint, you need to write a new Connector. This process has been greatly simplified thanks to [`Connector Lib`](connectors/connector-lib).
+The current oracle core is built to run the protocol specified in the [EIP-0023 PR](https://github.com/ergoplatform/eips/pull/41).
 
-Now within 15-20 lines of Rust code, you can easily create your own Connector that plugs right in to the Oracle Core.
 
-If you would like to integrate your pool with the Ergo Explorer we have also created [`Frontend Connector Lib`](connectors/frontend-connector-lib). This library builds off of `Connector Lib` and automatically provides + runs an API server which produces all of the data required for the frontend.
 
-Building a Frontend Connector provides a single endpoint which summarizes the majority of relevant data about your Oracle Pool, and as such can also be useful if you intend to create your own custom website/frontend for showing off what is going on in your pool.

bootstrap_config_example.yaml

@@ -1,5 +1,6 @@
+# Example bootstrap config file corresponding to the non-advaced `bootstrap` command.
 ---
-refresh_contract_parameters:
+oracle_pool_parameter_values: # These values are the defaults described in EIP-0023
   epoch_length: 30
   buffer: 4
   total_oracles: 15

core/src/actions.rs

@@ -67,7 +67,7 @@ fn execute_publish_datapoint_action(action: PublishDataPointAction) -> Result<()
     Ok(())
 }
 
-impl OraclePool {
+impl<'a> OraclePool<'a> {
     // /// Generates and submits the "Collect Funds" action tx
     // pub fn action_collect_funds(&self) -> Result<String, StageError> {
     //     let mut req = json::parse(BASIC_TRANSACTION_SEND_REQUEST).unwrap();

core/src/api.rs

@@ -39,16 +39,16 @@ pub fn start_get_api(repost_receiver: Receiver<bool>) {
     // Basic information about the oracle pool
     app.get("/poolInfo", move |context| {
         let parameters = &ORACLE_CONFIG;
-        let num_of_oracles = datapoint_stage.number_of_boxes().unwrap_or(10);
+        let num_of_oracles = datapoint_stage.stage.number_of_boxes().unwrap_or(10);
 
         let response_json = json! ({
             "number_of_oracles": num_of_oracles,
-            "datapoint_address": datapoint_stage.contract_address,
-            "live_epoch_length": parameters.epoch_length,
-            "deviation_range": parameters.max_deviation_percent,
-            "consensus_num": parameters.min_data_points,
-            "oracle_pool_nft_id": parameters.oracle_pool_nft,
-            "oracle_pool_participant_token_id": parameters.oracle_pool_participant_token_id,
+            "datapoint_address": datapoint_stage.stage.contract_address,
+            "live_epoch_length": parameters.refresh_contract_parameters.epoch_length,
+            "deviation_range": parameters.refresh_contract_parameters.max_deviation_percent,
+            "consensus_num": parameters.refresh_contract_parameters.min_data_points,
+            "oracle_pool_nft_id": parameters.token_ids.pool_nft_token_id,
+            "oracle_pool_participant_token_id": parameters.token_ids.oracle_token_id,
 
         });
 

core/src/box_kind/ballot_box.rs

@@ -1,35 +1,54 @@
-use crate::contracts::ballot::{BallotContract, BallotContractError};
+use std::convert::TryInto;
+
+use crate::{
+    contracts::ballot::{BallotContract, BallotContractError},
+    oracle_config::{BallotBoxWrapperParameters, CastBallotBoxVoteParameters},
+};
 use ergo_lib::{
     chain::ergo_box::box_builder::{ErgoBoxCandidateBuilder, ErgoBoxCandidateBuilderError},
     ergo_chain_types::{Digest32, EcPoint},
     ergotree_ir::{
         chain::{
+            address::{Address, AddressEncoder, AddressEncoderError},
             ergo_box::{box_value::BoxValue, ErgoBox, ErgoBoxCandidate, NonMandatoryRegisterId},
             token::{Token, TokenId},
         },
-        mir::constant::TryExtractInto,
+        mir::constant::{TryExtractFromError, TryExtractInto},
+        serialization::SigmaSerializationError,
         sigma_protocol::sigma_boolean::ProveDlog,
     },
 };
-use std::convert::TryFrom;
+use log::warn;
 use thiserror::Error;
 
 #[derive(Debug, Error)]
 pub enum BallotBoxError {
     #[error("ballot box: no ballot token found")]
     NoBallotToken,
+    #[error("ballot box: unknown ballot token id in `TOKENS(0)`")]
+    UnknownBallotTokenId,
     #[error("ballot box: no reward token id in R7 register")]
     NoRewardTokenIdInR7,
     #[error("ballot box: no reward token quantity in R8 register")]
     NoRewardTokenQuantityInR8,
     #[error("ballot box: no group element in R4 register")]
     NoGroupElementInR4,
+    #[error("ballot box: unexpected group element in R4 register")]
+    UnexpectedGroupElementInR4,
     #[error("ballot box: no update box creation height in R5 register")]
     NoUpdateBoxCreationHeightInR5,
     #[error("ballot box: no pool box address hash in R6 register")]
     NoPoolBoxAddressInR6,
     #[error("ballot box: contract error {0:?}")]
     BallotContract(#[from] BallotContractError),
+    #[error("ballot box: AddressEncoder error {0}")]
+    AddressEncoder(#[from] AddressEncoderError),
+    #[error("ballot box: TryExtractFrom error {0:?}")]
+    TryExtractFrom(#[from] TryExtractFromError),
+    #[error("ballot box: SigmaSerializationError {0:?}")]
+    SigmaSerialization(#[from] SigmaSerializationError),
+    #[error("ballot box: vote expected to be already cast, but hasn't")]
+    ExpectedVoteCast,
 }
 
 pub trait BallotBox {
@@ -46,59 +65,37 @@ pub struct BallotBoxWrapper {
     contract: BallotContract,
 }
 
-impl BallotBox for BallotBoxWrapper {
-    fn contract(&self) -> &BallotContract {
-        &self.contract
-    }
-
-    fn ballot_token(&self) -> Token {
-        self.ergo_box
-            .tokens
+impl BallotBoxWrapper {
+    pub fn new(ergo_box: ErgoBox, inputs: BallotBoxWrapperInputs) -> Result<Self, BallotBoxError> {
+        let CastBallotBoxVoteParameters {
+            reward_token_id,
+            reward_token_quantity,
+            pool_box_address_hash,
+        } = inputs
+            .parameters
+            .vote_parameters
             .as_ref()
-            .unwrap()
-            .get(0)
-            .unwrap()
-            .clone()
-    }
-
-    fn min_storage_rent(&self) -> u64 {
-        self.contract.min_storage_rent()
-    }
-
-    fn ballot_token_owner(&self) -> ProveDlog {
-        self.ergo_box
-            .get_register(NonMandatoryRegisterId::R4.into())
-            .unwrap()
-            .try_extract_into::<EcPoint>()
-            .unwrap()
-            .into()
-    }
-
-    fn get_box(&self) -> &ErgoBox {
-        &self.ergo_box
-    }
-}
-
-impl TryFrom<ErgoBox> for BallotBoxWrapper {
-    type Error = BallotBoxError;
-
-    fn try_from(ergo_box: ErgoBox) -> Result<Self, Self::Error> {
-        let _ballot_token_id = ergo_box
+            .ok_or(BallotBoxError::ExpectedVoteCast)?;
+        let ballot_token_id = &ergo_box
             .tokens
             .as_ref()
             .ok_or(BallotBoxError::NoBallotToken)?
             .get(0)
             .ok_or(BallotBoxError::NoBallotToken)?
-            .token_id
-            .clone();
+            .token_id;
+        if *ballot_token_id != *inputs.ballot_token_id {
+            return Err(BallotBoxError::UnknownBallotTokenId);
+        }
 
-        if ergo_box
+        let ec = ergo_box
             .get_register(NonMandatoryRegisterId::R4.into())
             .ok_or(BallotBoxError::NoGroupElementInR4)?
-            .try_extract_into::<EcPoint>()
-            .is_err()
-        {
-            return Err(BallotBoxError::NoGroupElementInR4);
+            .try_extract_into::<EcPoint>()?;
+        let prefix = inputs.parameters.contract_parameters.p2s.network();
+        let config_from_address = AddressEncoder::new(prefix)
+            .parse_address_from_str(&inputs.parameters.ballot_token_owner_address)?;
+        if config_from_address != Address::P2Pk(ProveDlog::from(ec)) {
+            return Err(BallotBoxError::UnexpectedGroupElementInR4);
         }
 
         if ergo_box
@@ -110,38 +107,82 @@ impl TryFrom<ErgoBox> for BallotBoxWrapper {
             return Err(BallotBoxError::NoUpdateBoxCreationHeightInR5);
         }
 
-        if ergo_box
+        let register_pool_box_address_hash = ergo_box
             .get_register(NonMandatoryRegisterId::R6.into())
             .ok_or(BallotBoxError::NoPoolBoxAddressInR6)?
-            .try_extract_into::<Digest32>()
-            .is_err()
-        {
-            return Err(BallotBoxError::NoPoolBoxAddressInR6);
+            .try_extract_into::<Digest32>()?;
+        let pb: Digest32 = base16::decode(pool_box_address_hash)
+            .unwrap()
+            .try_into()
+            .unwrap();
+        if pb != register_pool_box_address_hash {
+            warn!("Pool box address in R6 register differs to config. Could be due to vote.");
         }
 
-        if ergo_box
+        let register_reward_token_id = ergo_box
             .get_register(NonMandatoryRegisterId::R7.into())
             .ok_or(BallotBoxError::NoRewardTokenIdInR7)?
-            .try_extract_into::<TokenId>()
-            .is_err()
-        {
-            return Err(BallotBoxError::NoRewardTokenIdInR7);
+            .try_extract_into::<TokenId>()?;
+        if register_reward_token_id != *reward_token_id {
+            warn!("Reward token id in R7 register differs to config. Could be due to vote.");
         }
 
-        if ergo_box
+        let register_reward_token_quantity = ergo_box
             .get_register(NonMandatoryRegisterId::R8.into())
             .ok_or(BallotBoxError::NoRewardTokenQuantityInR8)?
-            .try_extract_into::<i64>()
-            .is_err()
-        {
-            return Err(BallotBoxError::NoRewardTokenQuantityInR8);
+            .try_extract_into::<i32>()? as u32;
+
+        if register_reward_token_quantity != *reward_token_quantity {
+            warn!("Reward token quantity in R8 register differs to config. Could be due to vote.");
         }
 
-        let contract = BallotContract::from_ergo_tree(ergo_box.ergo_tree.clone())?;
+        let contract = BallotContract::from_ergo_tree(ergo_box.ergo_tree.clone(), inputs.into())?;
         Ok(Self { ergo_box, contract })
     }
 }
 
+#[derive(Clone, Copy, Debug)]
+pub struct BallotBoxWrapperInputs<'a> {
+    pub parameters: &'a BallotBoxWrapperParameters,
+    /// Ballot token is expected to reside in `tokens(0)` of the ballot box.
+    pub ballot_token_id: &'a TokenId,
+    /// This token id appears as a constant in the ballot contract.
+    pub update_nft_token_id: &'a TokenId,
+}
+
+impl BallotBox for BallotBoxWrapper {
+    fn contract(&self) -> &BallotContract {
+        &self.contract
+    }
+
+    fn ballot_token(&self) -> Token {
+        self.ergo_box
+            .tokens
+            .as_ref()
+            .unwrap()
+            .get(0)
+            .unwrap()
+            .clone()
+    }
+
+    fn min_storage_rent(&self) -> u64 {
+        self.contract.min_storage_rent()
+    }
+
+    fn ballot_token_owner(&self) -> ProveDlog {
+        self.ergo_box
+            .get_register(NonMandatoryRegisterId::R4.into())
+            .unwrap()
+            .try_extract_into::<EcPoint>()
+            .unwrap()
+            .into()
+    }
+
+    fn get_box(&self) -> &ErgoBox {
+        &self.ergo_box
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 pub fn make_local_ballot_box_candidate(
     contract: &BallotContract,