Phat Contract 2.0 Compliance

ink/contracts/test_oracle/lib.rs

@@ -222,7 +222,7 @@ pub mod test_oracle {
  .get(message.trading_pair_id)
  .unwrap_or_default();
  trading_pair.value = message.price.unwrap_or_default();
- trading_pair.nb_updates += 1;
+ trading_pair.nb_updates = trading_pair.nb_updates.checked_add(1).unwrap_or(0);
  trading_pair.last_update = self.env().block_timestamp();
  self.trading_pairs
  .insert(message.trading_pair_id, &trading_pair);

ink/crates/phat_rollup_anchor_ink/src/traits/js_rollup_anchor.rs

@@ -0,0 +1,145 @@
+use crate::traits::rollup_anchor::RollupAnchorError;
+use ink::prelude::vec::Vec;
+use ink::storage::Lazy;
+use openbrush::contracts::access_control::{self, AccessControlError, RoleType};
+use openbrush::traits::Storage;
+use scale::{Decode, Encode};
+
+
+pub const JS_RA_MANAGER_ROLE: RoleType = ink::selector_id!("JS_RA_MANAGER_ROLE");
+
+#[derive(Debug, Eq, PartialEq, scale::Encode, scale::Decode)]
+#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
+pub enum JsRollupAnchorError {
+ AccessControlError(AccessControlError),
+}
+
+/// convertor from AccessControlError to JsRollupAnchorError
+impl From<AccessControlError> for JsRollupAnchorError {
+ fn from(error: AccessControlError) -> Self {
+ JsRollupAnchorError::AccessControlError(error)
+ }
+}
+
+type CodeHash = [u8; 32];
+
+/// Message sent to provide the data
+/// response pushed in the queue by the offchain rollup and read by the Ink! smart contract
+#[derive(Encode, Decode)]
+#[cfg_attr(
+ feature = "std",
+ derive(scale_info::TypeInfo, ink::storage::traits::StorageLayout)
+)]
+pub enum ResponseMessage {
+ JsResponse {
+ /// hash of js script executed to get the data
+ js_script_hash: CodeHash,
+ /// hash of data in input of js
+ input_hash: CodeHash,
+ /// hash of settings of js
+ settings_hash: CodeHash,
+ /// response value
+ output_value: Vec<u8>,
+ },
+ Error {
+ /// hash of js script
+ js_script_hash: CodeHash,
+ /// input in js
+ input_value: Vec<u8>,
+ /// hash of settings of js
+ settings_hash: CodeHash,
+ /// when an error occurs
+ error: Vec<u8>,
+ },
+}
+
+/// Enum used in the function on_message_received to return the result
+/// Input is the request type sent from the smart contract to phat offchain rollup
+/// Output is the response type receive by the smart contract
+pub enum MessageReceived<Input, Output> {
+ Ok { output: Output },
+ Error { input: Input, error: Vec<u8> },
+}
+
+#[derive(Default, Debug)]
+#[openbrush::storage_item]
+pub struct Data {
+ /// hash of js script executed to query the data
+ js_script_hash: Lazy<CodeHash>,
+ /// hash of settings given in parameter to js runner
+ settings_hash: Lazy<CodeHash>,
+}
+
+#[openbrush::trait_definition]
+pub trait JsRollupAnchor:
+ Storage<Data> + access_control::Internal
+{
+ #[ink(message)]
+ #[openbrush::modifiers(access_control::only_role(JS_RA_MANAGER_ROLE))]
+ fn set_js_script_hash(&mut self, js_script_hash: CodeHash) -> Result<(), JsRollupAnchorError> {
+ self.data::<Data>().js_script_hash.set(&js_script_hash);
+ Ok(())
+ }
+
+ #[ink(message)]
+ fn get_js_script_hash(&self) -> Option<CodeHash> {
+ self.data::<Data>().js_script_hash.get()
+ }
+
+ #[ink(message)]
+ #[openbrush::modifiers(access_control::only_role(JS_RA_MANAGER_ROLE))]
+ fn set_settings_hash(&mut self, settings_hash: CodeHash) -> Result<(), JsRollupAnchorError> {
+ self.data::<Data>().settings_hash.set(&settings_hash);
+ Ok(())
+ }
+
+ #[ink(message)]
+ fn get_settings_hash(&self) -> Option<CodeHash> {
+ self.data::<Data>().settings_hash.get()
+ }
+
+ fn on_message_received<I: Decode, O: Decode>(
+ &mut self,
+ action: Vec<u8>,
+ ) -> Result<MessageReceived<I, O>, RollupAnchorError> {
+ // parse the response
+ let response: ResponseMessage =
+ Decode::decode(&mut &action[..]).or(Err(RollupAnchorError::FailedToDecode))?;
+
+ match response {
+ ResponseMessage::JsResponse {
+ js_script_hash,
+ settings_hash,
+ output_value,
+ ..
+ } => {
+ // check the js code hash
+ if let Some(expected_js_hash) = self.data::<Data>().js_script_hash.get() {
+ if js_script_hash != expected_js_hash {
+ return Err(RollupAnchorError::ConditionNotMet);
+ }
+ }
+
+ // check the settings hash
+ if let Some(expected_settings_hash) = self.data::<Data>().settings_hash.get() {
+ if settings_hash != expected_settings_hash {
+ return Err(RollupAnchorError::ConditionNotMet);
+ }
+ }
+
+ // we received the data
+ let output = O::decode(&mut output_value.as_slice())
+ .map_err(|_| RollupAnchorError::FailedToDecode)?;
+ Ok(MessageReceived::<I,O>::Ok { output })
+ }
+ ResponseMessage::Error {
+ error, input_value, ..
+ } => {
+ // we received an error
+ let input = I::decode(&mut input_value.as_slice())
+ .map_err(|_| RollupAnchorError::FailedToDecode)?;
+ Ok(MessageReceived::<I,O>::Error { input, error })
+ }
+ }
+ }
+}

ink/crates/phat_rollup_anchor_ink/src/traits/meta_transaction.rs

@@ -17,6 +17,7 @@ pub enum MetaTransactionError {
  PublicKeyNotMatch,
  PublicKeyIncorrect,
  RollupAnchorError(RollupAnchorError),
+ NonceOverflow,
 }
 
 /// convertor from RollupAnchorError to MetaTxError
@@ -105,7 +106,10 @@ pub trait MetaTransaction: Storage<Data> + EventBroadcaster + RollupAnchor {
  // verify the signature
  self.verify(request, signature)?;
  // update the nonce
- let nonce = request.nonce + 1;
+ let nonce = request
+ .nonce
+ .checked_add(1)
+ .ok_or(MetaTransactionError::NonceOverflow)?;
  self.data::<Data>().nonces.insert(&request.from, &nonce);
  Ok(())
  }

ink/crates/phat_rollup_anchor_ink/src/traits/mod.rs

@@ -1,2 +1,3 @@
 pub mod meta_transaction;
 pub mod rollup_anchor;
+pub mod js_rollup_anchor;

ink/crates/phat_rollup_anchor_ink/src/traits/rollup_anchor.rs

@@ -44,6 +44,7 @@ pub enum RollupAnchorError {
  FailedToDecode,
  UnsupportedAction,
  AccessControlError(AccessControlError),
+ QueueIndexOverflow,
 }
 
 /// convertor from AccessControlError to RollupAnchorError
@@ -120,7 +121,10 @@ pub trait RollupAnchor:
  let encoded_value = data.encode();
  self.set_value(&key, Some(&encoded_value));
 
- self.set_queue_tail(id + 1);
+ self.set_queue_tail(
+ id.checked_add(1)
+ .ok_or(RollupAnchorError::QueueIndexOverflow)?,
+ );
  self.emit_event_message_queued(id, encoded_value);
 
  Ok(id)

ink/rust-toolchain.toml

@@ -1,5 +1,5 @@
 [toolchain]
-channel = "1.72"
+channel = "1.80"
 components = [
  "rustc",
  "cargo",