Rollup anchor for ink! smart contracts

ink/contracts/test_oracle/Cargo.toml

@@ -17,6 +17,7 @@ phat_rollup_anchor_ink = { path = "../../crates/phat_rollup_anchor_ink", default
 [dev-dependencies]
 ink_e2e = { version = "4.3.0" }
 hex-literal = { version = "0.4.1" }
+subxt-signer = { version = "0.31.0" }
 
 [lib]
 path = "lib.rs"

ink/contracts/test_oracle/lib.rs

@@ -13,12 +13,13 @@ pub mod test_oracle {
     use scale::{Decode, Encode};
 
     use phat_rollup_anchor_ink::traits::{
-        kv_store, kv_store::*, message_queue, message_queue::*, meta_transaction,
-        meta_transaction::*, rollup_anchor, rollup_anchor::*,
+        meta_transaction, meta_transaction::*, rollup_anchor, rollup_anchor::*,
     };
 
     pub type TradingPairId = u32;
 
+    pub const MANAGER_ROLE: RoleType = ink::selector_id!("MANAGER_ROLE");
+
     /// Events emitted when a price is received
     #[ink(event)]
     pub struct PriceReceived {
@@ -38,22 +39,22 @@ pub mod test_oracle {
     #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
     pub enum ContractError {
         AccessControlError(AccessControlError),
-        MessageQueueError(MessageQueueError),
+        RollupAnchorError(RollupAnchorError),
         MetaTransactionError(MetaTransactionError),
         MissingTradingPair,
     }
     /// convertor from MessageQueueError to ContractError
-    impl From<MessageQueueError> for ContractError {
-        fn from(error: MessageQueueError) -> Self {
-            ContractError::MessageQueueError(error)
-        }
-    }
-    /// convertor from MessageQueueError to ContractError
     impl From<AccessControlError> for ContractError {
         fn from(error: AccessControlError) -> Self {
             ContractError::AccessControlError(error)
         }
     }
+    /// convertor from RollupAnchorError to ContractError
+    impl From<RollupAnchorError> for ContractError {
+        fn from(error: RollupAnchorError) -> Self {
+            ContractError::RollupAnchorError(error)
+        }
+    }
     /// convertor from MetaTxError to ContractError
     impl From<MetaTransactionError> for ContractError {
         fn from(error: MetaTransactionError) -> Self {
@@ -118,7 +119,7 @@ pub mod test_oracle {
         #[storage_field]
         access: access_control::Data,
         #[storage_field]
-        kv_store: kv_store::Data,
+        rollup_anchor: rollup_anchor::Data,
         #[storage_field]
         meta_transaction: meta_transaction::Data,
         trading_pairs: Mapping<TradingPairId, TradingPair>,
@@ -187,13 +188,8 @@ pub mod test_oracle {
         }
 
         #[ink(message)]
-        pub fn register_attestor(
-            &mut self,
-            account_id: AccountId,
-            ecdsa_public_key: [u8; 33],
-        ) -> Result<(), ContractError> {
+        pub fn register_attestor(&mut self, account_id: AccountId) -> Result<(), ContractError> {
             AccessControl::grant_role(self, ATTESTOR_ROLE, Some(account_id))?;
-            self.register_ecdsa_public_key(account_id, ecdsa_public_key)?;
             Ok(())
         }
 
@@ -208,8 +204,6 @@ pub mod test_oracle {
         }
     }
 
-    impl KvStore for TestOracle {}
-    impl MessageQueue for TestOracle {}
     impl RollupAnchor for TestOracle {}
     impl MetaTransaction for TestOracle {}
 
@@ -266,7 +260,7 @@ pub mod test_oracle {
         pub id: u32,
     }
 
-    impl message_queue::EventBroadcaster for TestOracle {
+    impl rollup_anchor::EventBroadcaster for TestOracle {
         fn emit_event_message_queued(&self, id: u32, data: Vec<u8>) {
             self.env().emit_event(MessageQueued { id, data });
         }
@@ -794,22 +788,12 @@ pub mod test_oracle {
                 .expect("instantiate failed")
                 .account_id;
 
-            // register the ecda public key because I am not able to retrieve if from the account id
-            // Alice
+            // Alice is the attestor
+            // use the ecsda account because we are not able to verify the sr25519 signature
             let from = ink::primitives::AccountId::from(
-                Signer::<PolkadotConfig>::account_id(&ink_e2e::alice()).0,
-            );
-            let ecdsa_public_key: [u8; 33] = hex_literal::hex!(
-                "037051bed73458951b45ca6376f4096c85bf1a370da94d5336d04867cfaaad019e"
+                Signer::<PolkadotConfig>::account_id(&subxt_signer::ecdsa::dev::alice()).0,
             );
 
-            let register_ecdsa_public_key = build_message::<TestOracleRef>(contract_acc_id.clone())
-                .call(|oracle| oracle.register_ecdsa_public_key(from, ecdsa_public_key));
-            client
-                .call(&ink_e2e::bob(), register_ecdsa_public_key, 0, None)
-                .await
-                .expect("We should be able to register the ecdsa public key");
-
             // prepare the meta transaction
             let data = u8::encode(&5);
             let prepare_meta_tx = build_message::<TestOracleRef>(contract_acc_id.clone())
@@ -819,19 +803,15 @@ pub mod test_oracle {
                 .await
                 .expect("We should be able to prepare the meta tx");
 
-            let (request, hash) = result
+            let (request, _hash) = result
                 .return_value()
                 .expect("Expected value when preparing meta tx");
 
             assert_eq!(0, request.nonce);
             assert_eq!(from, request.from);
+            assert_eq!(contract_acc_id, request.to);
             assert_eq!(&data, &request.data);
 
-            let expected_hash = hex_literal::hex!(
-                "17cb4f6eae2f95ba0fbaee9e0e51dc790fe752e7386b72dcd93b9669450c2ccf"
-            );
-            assert_eq!(&expected_hash, &hash.as_ref());
-
             Ok(())
         }
 
@@ -850,22 +830,12 @@ pub mod test_oracle {
                 .expect("instantiate failed")
                 .account_id;
 
-            // register the ecda public key because I am not able to retrieve if from the account id
             // Alice is the attestor
+            // use the ecsda account because we are not able to verify the sr25519 signature
             let from = ink::primitives::AccountId::from(
-                Signer::<PolkadotConfig>::account_id(&ink_e2e::alice()).0,
-            );
-            let ecdsa_public_key: [u8; 33] = hex_literal::hex!(
-                "037051bed73458951b45ca6376f4096c85bf1a370da94d5336d04867cfaaad019e"
+                Signer::<PolkadotConfig>::account_id(&subxt_signer::ecdsa::dev::alice()).0,
             );
 
-            let register_ecdsa_public_key = build_message::<TestOracleRef>(contract_acc_id.clone())
-                .call(|oracle| oracle.register_ecdsa_public_key(from, ecdsa_public_key));
-            client
-                .call(&ink_e2e::charlie(), register_ecdsa_public_key, 0, None)
-                .await
-                .expect("We should be able to register the ecdsa public key");
-
             // add the role => it should be succeed
             let grant_role = build_message::<TestOracleRef>(contract_acc_id.clone())
                 .call(|oracle| oracle.grant_role(ATTESTOR_ROLE, Some(from)));
@@ -883,21 +853,18 @@ pub mod test_oracle {
                 .await
                 .expect("We should be able to prepare the meta tx");
 
-            let (request, hash) = result
+            let (request, _hash) = result
                 .return_value()
                 .expect("Expected value when preparing meta tx");
 
             assert_eq!(0, request.nonce);
             assert_eq!(from, request.from);
+            assert_eq!(contract_acc_id, request.to);
             assert_eq!(&data, &request.data);
 
-            let expected_hash = hex_literal::hex!(
-                "c91f57305dc05a66f1327352d55290a250eb61bba8e3cf8560a4b8e7d172bb54"
-            );
-            assert_eq!(&expected_hash, &hash.as_ref());
-
-            // signature by Alice of previous hash
-            let signature : [u8; 65] = hex_literal::hex!("c9a899bc8daa98fd1e819486c57f9ee889d035e8d0e55c04c475ca32bb59389b284d18d785a9db1bdd72ce74baefe6a54c0aa2418b14f7bc96232fa4bf42946600");
+            // Alice signs the message
+            let keypair = subxt_signer::ecdsa::dev::alice();
+            let signature = keypair.sign(&scale::Encode::encode(&request)).0;
 
             // do the meta tx
             let meta_tx_rollup_cond_eq = build_message::<TestOracleRef>(contract_acc_id.clone())

ink/crates/phat_rollup_anchor_ink/Cargo.toml

@@ -11,11 +11,12 @@ scale = { package = "parity-scale-codec", version = "3", default-features = fals
 scale-info = { version = "2.6", default-features = false, features = ["derive"], optional = true }
 kv-session = { package = "pink-kv-session", version = "0.2" }
 
-#openbrush = { git = "https://github.com/727-Ventures/openbrush-contracts", tag = "4.0.0-beta", features = ["ownable", "access_control"], default-features = false }
 openbrush = { git = "https://github.com/Brushfam/openbrush-contracts", version = "4.0.0-beta", features = ["ownable", "access_control"], default-features = false }
 
 [dev-dependencies]
 hex-literal = "0.4.1"
+ink_e2e = { version = "4.3.0" }
+subxt-signer = { version = "0.31.0" }
 
 [lib]
 path = "src/lib.rs"

ink/crates/phat_rollup_anchor_ink/README.md

@@ -3,7 +3,7 @@
 Library for Ink! smart contract to help you build [Phat Rollup Anchor ](https://github.com/Phala-Network/phat-offchain-rollup/
 )deployed on the Substrate pallet Contracts.
 This library uses the [OpenBrush](https://learn.brushfam.io/docs/OpenBrush) library with the features `ownable` and `access_control`
-It provides the following traits for:
+It provides the following features for:
  - `KvStore`: key-value store that allows offchain Phat Contracts to perform read/write operations.
  - `MessageQueue`: Message Queue, enabling a request-response programming model for the smart-contract while ensuring that each request received exactly one response. It uses the KV Store to save the messages. 
  - `RollupAnchor`: Use the kv-store and the message queue to allow offchain's rollup transactions.
@@ -58,7 +58,7 @@ std = [
 ### Add imports
 
 Use `openbrush::contract` macro instead of `ink::contract`. 
-Import everything from `openbrush::contracts::access_control`, `openbrush::contracts::ownable`, `phat_rollup_anchor_ink::traits::kv_store`, `phat_rollup_anchor_ink::traits::message_queue`, `phat_rollup_anchor_ink::traits::meta_transaction`, `phat_rollup_anchor_ink::traits::rollup_anchor`.
+Import everything from `openbrush::contracts::access_control`, `openbrush::contracts::ownable`, `phat_rollup_anchor_ink::traits::meta_transaction`, `phat_rollup_anchor_ink::traits::rollup_anchor`.
 
 ```rust
 #![cfg_attr(not(feature = "std"), no_std, no_main)]
@@ -73,8 +73,6 @@ pub mod test_oracle {
     use scale::{Decode, Encode};
 
     use phat_rollup_anchor_ink::traits::{
-        kv_store, kv_store::*,
-        message_queue, message_queue::*,
         meta_transaction, meta_transaction::*,
         rollup_anchor, rollup_anchor::*
     };
@@ -94,7 +92,7 @@ pub struct TestOracle {
     #[storage_field]
     access: access_control::Data,
     #[storage_field]
-    kv_store: kv_store::Data,
+    rollup_anchor: rollup_anchor::Data,
     #[storage_field]
     meta_transaction: meta_transaction::Data,
     ...
@@ -105,8 +103,6 @@ pub struct TestOracle {
 Inherit implementation of the traits. You can customize (override) methods in this `impl` block.
 
 ```rust
-impl KvStore for TestOracle {}
-impl MessageQueue for TestOracle {}
 impl RollupAnchor for TestOracle {}
 impl MetaTransaction for TestOracle {}
 ```
@@ -129,8 +125,8 @@ impl TestOracle {
 
 ### Traits to implement
 
-### Trait for the message queue
-Implement the `message_queue::EventBroadcaster` trait to emit the events when a message is pushed in the queue and when a message is proceeded. 
+### Trait for the rollup anchor
+Implement the `rollup_anchor::EventBroadcaster` trait to emit the events when a message is pushed in the queue and when a message is proceeded. 
 If you don't want to emit the events, you can put an empty block in the methods `emit_event_message_queued` and `emit_event_message_processed_to`.
 
 ```rust
@@ -147,7 +143,7 @@ pub struct MessageProcessedTo {
     pub id: u32,
 }
 
-impl message_queue::EventBroadcaster for TestOracle {
+impl rollup_anchor::EventBroadcaster for TestOracle {
 
     fn emit_event_message_queued(&self, id: u32, data: Vec<u8>){
         self.env().emit_event(MessageQueued { id, data });
@@ -159,7 +155,7 @@ impl message_queue::EventBroadcaster for TestOracle {
 
 }
 ```
-### Traits for the rollup anchor
+
 Implement the `rollup_anchor::MessageHandler` trait to put your business logic when a message is received.
 Here an example when the Oracle receives a message with the price feed. 
 
@@ -239,8 +235,7 @@ pub mod test_oracle {
     use scale::{Decode, Encode};
 
     use phat_rollup_anchor_ink::traits::{
-        kv_store, kv_store::*, message_queue, message_queue::*, meta_transaction,
-        meta_transaction::*, rollup_anchor, rollup_anchor::*,
+        meta_transaction, meta_transaction::*, rollup_anchor, rollup_anchor::*,
     };
 
     pub type TradingPairId = u32;
@@ -264,25 +259,25 @@ pub mod test_oracle {
     #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
     pub enum ContractError {
         AccessControlError(AccessControlError),
-        MessageQueueError(MessageQueueError),
+        RollupAnchorError(RollupAnchorError),
         MetaTransactionError(MetaTransactionError),
         MissingTradingPair,
     }
 
-    /// convertor from MessageQueueError to ContractError
-    impl From<MessageQueueError> for ContractError {
-        fn from(error: MessageQueueError) -> Self {
-            ContractError::MessageQueueError(error)
-        }
-    }
-
     /// convertor from MessageQueueError to ContractError
     impl From<AccessControlError> for ContractError {
         fn from(error: AccessControlError) -> Self {
             ContractError::AccessControlError(error)
         }
     }
 
+    /// convertor from RollupAnchorError to ContractError
+    impl From<RollupAnchorError> for ContractError {
+        fn from(error: RollupAnchorError) -> Self {
+            ContractError::RollupAnchorError(error)
+        }
+    }
+
     /// convertor from MetaTxError to ContractError
     impl From<MetaTransactionError> for ContractError {
         fn from(error: MetaTransactionError) -> Self {
@@ -312,7 +307,7 @@ pub mod test_oracle {
         trading_pair_id: TradingPairId,
         /// price of the trading pair
         price: Option<u128>,
-        /// when the price is read
+        /// error when the price is read
         err_no: Option<u128>,
     }
 
@@ -348,7 +343,7 @@ pub mod test_oracle {
         #[storage_field]
         access: access_control::Data,
         #[storage_field]
-        kv_store: kv_store::Data,
+        rollup_anchor: rollup_anchor::Data,
         #[storage_field]
         meta_transaction: meta_transaction::Data,
         trading_pairs: Mapping<TradingPairId, TradingPair>,
@@ -438,10 +433,6 @@ pub mod test_oracle {
         }
     }
 
-    impl KvStore for TestOracle {}
-
-    impl MessageQueue for TestOracle {}
-
     impl RollupAnchor for TestOracle {}
 
     impl MetaTransaction for TestOracle {}
@@ -499,7 +490,7 @@ pub mod test_oracle {
         pub id: u32,
     }
 
-    impl message_queue::EventBroadcaster for TestOracle {
+    impl rollup_anchor::EventBroadcaster for TestOracle {
         fn emit_event_message_queued(&self, id: u32, data: Vec<u8>) {
             self.env().emit_event(MessageQueued { id, data });
         }