Update Pool Box

core/src/box_kind.rs

@@ -2,8 +2,10 @@ mod ballot_box;
 mod oracle_box;
 mod pool_box;
 mod refresh_box;
+mod update_box;
 
 pub use ballot_box::*;
 pub use oracle_box::*;
 pub use pool_box::*;
 pub use refresh_box::*;
+pub use update_box::*;

core/src/box_kind/ballot_box.rs

@@ -1,5 +1,3 @@
-use std::convert::TryInto;
-
 use crate::{
     contracts::ballot::{BallotContract, BallotContractError},
     oracle_config::{BallotBoxWrapperParameters, CastBallotBoxVoteParameters},
@@ -59,23 +57,14 @@ pub trait BallotBox {
     fn get_box(&self) -> &ErgoBox;
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct BallotBoxWrapper {
     ergo_box: ErgoBox,
     contract: BallotContract,
 }
 
 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()
-            .ok_or(BallotBoxError::ExpectedVoteCast)?;
         let ballot_token_id = &ergo_box
             .tokens
             .as_ref()
@@ -98,42 +87,54 @@ impl BallotBoxWrapper {
             return Err(BallotBoxError::UnexpectedGroupElementInR4);
         }
 
-        if ergo_box
-            .get_register(NonMandatoryRegisterId::R5.into())
-            .ok_or(BallotBoxError::NoUpdateBoxCreationHeightInR5)?
-            .try_extract_into::<i32>()
-            .is_err()
+        if let Some(CastBallotBoxVoteParameters {
+            reward_token_id,
+            reward_token_quantity,
+            pool_box_address_hash,
+            update_box_creation_height,
+        }) = inputs.parameters.vote_parameters.as_ref()
         {
-            return Err(BallotBoxError::NoUpdateBoxCreationHeightInR5);
-        }
+            let register_update_box_creation_height = ergo_box
+                .get_register(NonMandatoryRegisterId::R5.into())
+                .ok_or(BallotBoxError::NoUpdateBoxCreationHeightInR5)?
+                .try_extract_into::<i32>()?;
 
-        let register_pool_box_address_hash = ergo_box
-            .get_register(NonMandatoryRegisterId::R6.into())
-            .ok_or(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 register_update_box_creation_height != *update_box_creation_height {
+                warn!("Update box creation height in R5 register differs to config. Could be due to vote.");
+            }
 
-        let register_reward_token_id = ergo_box
-            .get_register(NonMandatoryRegisterId::R7.into())
-            .ok_or(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.");
-        }
+            let register_pool_box_address_hash = ergo_box
+                .get_register(NonMandatoryRegisterId::R6.into())
+                .ok_or(BallotBoxError::NoPoolBoxAddressInR6)?
+                .try_extract_into::<Digest32>()?;
 
-        let register_reward_token_quantity = ergo_box
-            .get_register(NonMandatoryRegisterId::R8.into())
-            .ok_or(BallotBoxError::NoRewardTokenQuantityInR8)?
-            .try_extract_into::<i32>()? as u32;
+            if *pool_box_address_hash != register_pool_box_address_hash {
+                warn!("Pool box address in R6 register differs to config. Could be due to vote.");
+            }
+
+            let register_reward_token_id = ergo_box
+                .get_register(NonMandatoryRegisterId::R7.into())
+                .ok_or(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 register_reward_token_quantity != *reward_token_quantity {
-            warn!("Reward token quantity in R8 register differs to config. Could be due to vote.");
+            let register_reward_token_quantity: u64 = ergo_box
+                .get_register(NonMandatoryRegisterId::R8.into())
+                .ok_or(BallotBoxError::NoRewardTokenQuantityInR8)?
+                .try_extract_into::<i64>()?
+                as u64;
+
+            if register_reward_token_quantity != *reward_token_quantity {
+                warn!(
+                    "Reward token quantity in R8 register differs to config. Could be due to vote."
+                );
+            }
+        } else if ergo_box.additional_registers.len() > 1 {
+            // If no vote parameter is provided, then the box must only have R4 (owner public key) defined
+            return Err(BallotBoxError::ExpectedVoteCast);
         }
 
         let contract = BallotContract::from_ergo_tree(ergo_box.ergo_tree.clone(), inputs.into())?;
@@ -150,6 +151,73 @@ pub struct BallotBoxWrapperInputs<'a> {
     pub update_nft_token_id: &'a TokenId,
 }
 
+/// A Ballot Box with vote parameters guaranteed to be set
+#[derive(Clone, Debug)]
+pub struct VoteBallotBoxWrapper {
+    ergo_box: ErgoBox,
+    vote_parameters: CastBallotBoxVoteParameters,
+    contract: BallotContract,
+}
+
+impl VoteBallotBoxWrapper {
+    pub fn new(ergo_box: ErgoBox, inputs: BallotBoxWrapperInputs) -> Result<Self, BallotBoxError> {
+        let ballot_token_id = &ergo_box
+            .tokens
+            .as_ref()
+            .ok_or(BallotBoxError::NoBallotToken)?
+            .get(0)
+            .ok_or(BallotBoxError::NoBallotToken)?
+            .token_id;
+        if *ballot_token_id != *inputs.ballot_token_id {
+            return Err(BallotBoxError::UnknownBallotTokenId);
+        }
+
+        if ergo_box
+            .get_register(NonMandatoryRegisterId::R4.into())
+            .ok_or(BallotBoxError::NoGroupElementInR4)?
+            .try_extract_into::<EcPoint>()
+            .is_err()
+        {
+            return Err(BallotBoxError::NoGroupElementInR4);
+        }
+        let update_box_creation_height = ergo_box
+            .get_register(NonMandatoryRegisterId::R5.into())
+            .ok_or(BallotBoxError::NoUpdateBoxCreationHeightInR5)?
+            .try_extract_into::<i32>()?;
+
+        let pool_box_address_hash = ergo_box
+            .get_register(NonMandatoryRegisterId::R6.into())
+            .ok_or(BallotBoxError::NoPoolBoxAddressInR6)?
+            .try_extract_into::<Digest32>()?;
+
+        let reward_token_id = ergo_box
+            .get_register(NonMandatoryRegisterId::R7.into())
+            .ok_or(BallotBoxError::NoRewardTokenIdInR7)?
+            .try_extract_into::<TokenId>()?;
+        let reward_token_quantity = ergo_box
+            .get_register(NonMandatoryRegisterId::R8.into())
+            .ok_or(BallotBoxError::NoRewardTokenQuantityInR8)?
+            .try_extract_into::<i64>()? as u64;
+
+        let contract = BallotContract::from_ergo_tree(ergo_box.ergo_tree.clone(), inputs.into())?;
+        let vote_parameters = CastBallotBoxVoteParameters {
+            pool_box_address_hash,
+            reward_token_id,
+            reward_token_quantity,
+            update_box_creation_height,
+        };
+        Ok(Self {
+            ergo_box,
+            contract,
+            vote_parameters,
+        })
+    }
+
+    pub fn vote_parameters(&self) -> &CastBallotBoxVoteParameters {
+        &self.vote_parameters
+    }
+}
+
 impl BallotBox for BallotBoxWrapper {
     fn contract(&self) -> &BallotContract {
         &self.contract
@@ -183,6 +251,39 @@ impl BallotBox for BallotBoxWrapper {
     }
 }
 
+impl BallotBox for VoteBallotBoxWrapper {
+    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,
@@ -210,7 +311,7 @@ pub fn make_local_ballot_box_candidate(
     );
     builder.set_register_value(
         NonMandatoryRegisterId::R8,
-        (*reward_tokens.amount.as_u64() as i32).into(),
+        (*reward_tokens.amount.as_u64() as i64).into(),
     );
     builder.add_token(ballot_token);
     builder.build()

core/src/box_kind/update_box.rs

@@ -0,0 +1,70 @@
+use ergo_lib::ergotree_ir::chain::ergo_box::ErgoBox;
+use ergo_lib::ergotree_ir::chain::token::Token;
+use ergo_lib::ergotree_ir::chain::token::TokenId;
+use ergo_lib::ergotree_ir::ergo_tree::ErgoTree;
+use thiserror::Error;
+
+use crate::contracts::update::UpdateContract;
+use crate::contracts::update::UpdateContractError;
+use crate::contracts::update::UpdateContractParameters;
+
+#[derive(Debug, Error)]
+pub enum UpdateBoxError {
+    #[error("oracle box: no tokens found")]
+    NoTokens,
+    #[error("update contract: {0:?}")]
+    UpdateContractError(#[from] UpdateContractError),
+    #[error("update contract: {0:?}")]
+    IncorrectUpdateTokenId(TokenId),
+}
+
+#[derive(Clone)]
+pub struct UpdateBoxWrapper(ErgoBox, UpdateContract);
+
+impl UpdateBoxWrapper {
+    pub fn new(b: ErgoBox, inputs: UpdateBoxWrapperInputs) -> Result<Self, UpdateBoxError> {
+        let update_token_id = b
+            .tokens
+            .as_ref()
+            .ok_or(UpdateBoxError::NoTokens)?
+            .get(0)
+            .ok_or(UpdateBoxError::NoTokens)?
+            .token_id
+            .clone();
+        if update_token_id != *inputs.update_nft_token_id {
+            return Err(UpdateBoxError::IncorrectUpdateTokenId(update_token_id));
+        }
+        let contract = UpdateContract::from_ergo_tree(b.ergo_tree.clone(), inputs.into())?;
+
+        Ok(Self(b, contract))
+    }
+    pub fn ergo_tree(&self) -> ErgoTree {
+        self.1.ergo_tree()
+    }
+    pub fn update_nft(&self) -> Token {
+        self.0.tokens.as_ref().unwrap().get(0).unwrap().clone()
+    }
+    pub fn ballot_token_id(&self) -> TokenId {
+        self.1.ballot_token_id().clone()
+    }
+    pub fn get_box(&self) -> &ErgoBox {
+        &self.0
+    }
+    pub fn min_votes(&self) -> u32 {
+        self.1.min_votes() as u32
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct UpdateBoxWrapperInputs<'a> {
+    pub contract_parameters: &'a UpdateContractParameters,
+    pub update_nft_token_id: &'a TokenId,
+    pub ballot_token_id: &'a TokenId,
+    pub pool_nft_token_id: &'a TokenId,
+}
+
+impl From<UpdateBoxWrapper> for ErgoBox {
+    fn from(w: UpdateBoxWrapper) -> Self {
+        w.0.clone()
+    }
+}

core/src/cli_commands.rs

@@ -2,15 +2,18 @@ use ergo_lib::ergotree_ir::chain::address::NetworkPrefix;
 
 pub mod bootstrap;
 pub mod extract_reward_tokens;
+pub mod prepare_update;
 pub mod print_reward_tokens;
 pub mod transfer_oracle_token;
+pub mod update_pool;
 pub mod vote_update_pool;
 
 pub(crate) fn ergo_explorer_transaction_link(tx_id_str: String, prefix: NetworkPrefix) -> String {
     let prefix_str = match prefix {
         NetworkPrefix::Mainnet => "explorer",
         NetworkPrefix::Testnet => "testnet",
     };
+    let tx_id_str = tx_id_str.replace('"', ""); // Node interface returns Tx Id as a JSON string "TxId"
     format!(
         "https://{}.ergoplatform.com/en/transactions/{}",
         prefix_str, tx_id_str