wip

Cargo.toml

@@ -4,4 +4,5 @@ exclude = []
 
 members = [
 	"dapps/ink-rust/wasm-flipper/contract/flipper",
+	"dapps/xcm/unnamed",
 ]

dapps/ink-rust/wasm-flipper/contract/flipper/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2021"
 # https://github.com/paritytech/ink/releases
 ink = { version = "4.2.0", default-features = false }
 
-scale = { package = "parity-scale-codec", version = "3.4.0", default-features = false, features = ["derive"] }
+scale = { package = "parity-scale-codec", version = "3.5.0", default-features = false, features = ["derive"] }
 scale-info = { version = "2.7", default-features = false, features = ["derive"], optional = true }
 
 [dev-dependencies]

dapps/xcm/unnamed/Cargo.toml

@@ -7,8 +7,10 @@ edition = "2021"
 [dependencies]
 ink = { version = "4.2.0", default-features = false }
 
-scale = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive"] }
-scale-info = { version = "2.6", default-features = false, features = ["derive"], optional = true }
+scale = { package = "parity-scale-codec", version = "3.5.0", default-features = false, features = ["derive"] }
+scale-info = { version = "2.7", default-features = false, features = ["derive"], optional = true }
+
+oracle_contract = { path = "oracle_contract", default-features = false, features = ["ink-as-dependency"] }
 
 [dev-dependencies]
 ink_e2e = "4.2.0"

dapps/xcm/unnamed/README.md

@@ -0,0 +1,5 @@
+```
+rustup update
+rustup default stable
+rustup show
+```

dapps/xcm/unnamed/lib.rs

@@ -9,20 +9,15 @@ mod unnamed {
     /// to add new static storage fields to your contract.
     #[ink(storage)]
     pub struct Unnamed {
-        /// Stores a single `bool` value on the storage.
-        value: bool,
         /// Store a reference to the `OracleContract`.
         oracle_contract: OracleContractRef,
     }
 
     impl Unnamed {
-        /// Constructor that:
-        /// * Instantiates the OracleContract using its uploaded `code_hash`
-        /// * Initializes the `bool` value to the given `init_value`.
+        /// Constructor that instantiates the OracleContract using its uploaded `code_hash`
         #[ink(constructor)]
         pub fn new(
             oracle_contract_code_hash: Hash,
-            init_value: bool
         ) -> Self {
             let oracle_contract = OracleContractRef::new(true)
                 .code_hash(oracle_contract_code_hash)
@@ -32,18 +27,9 @@ mod unnamed {
 
             Self {
                 oracle_contract,
-                value: init_value,
             }
         }
 
-        /// Constructor that initializes the `bool` value to `false`.
-        ///
-        /// Constructors can delegate to other constructors.
-        #[ink(constructor)]
-        pub fn default() -> Self {
-            Self::new(Default::default())
-        }
-
         /// A message that can be called on instantiated contracts.
         /// This one flips the value of the stored `bool` from `true`
         /// to `false` and vice versa.

dapps/xcm/unnamed/oracle_contract/Cargo.toml

@@ -6,9 +6,10 @@ edition = "2021"
 
 [dependencies]
 ink = { version = "4.2.0", default-features = false }
+# hex = { version = "0.4.3", default-features = false }
 
-scale = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive"] }
-scale-info = { version = "2.6", default-features = false, features = ["derive"], optional = true }
+scale = { package = "parity-scale-codec", version = "3.5.0", default-features = false, features = ["derive"] }
+scale-info = { version = "2.7", default-features = false, features = ["derive"], optional = true }
 
 [dev-dependencies]
 ink_e2e = "4.2.0"

dapps/xcm/unnamed/oracle_contract/lib.rs

@@ -4,27 +4,66 @@ pub use self::oracle_contract::OracleContractRef;
 
 #[ink::contract]
 mod oracle_contract {
+    use ink::prelude::string::String;
     use ink::prelude::vec::Vec;
     use ink::storage::{
         Lazy,
         Mapping,
-        traits::ManualKey,
+        // traits::ManualKey,
     };
+    use ink::storage::traits::{
+        StorableHint,
+        StorageKey,
+        Storable,
+    };
+    // use core::str;
+    // use hex;
 
-    /// A block number.
-    pub type BlockNumber = u64;
-    pub type MarketGuessId = String;
+    pub type MarketGuessId = Vec<u8>;
     pub type OracleOwner = AccountId;
-    pub type BlockNumberEntropy = BlockNumber;
 
-    pub enum Status {
-        Pending,
-        Finalized,
+    /// Emitted when create new market guess for market id.
+    #[ink(event)]
+    pub struct NewOracleMarketGuessForMarketId {
+        #[ink(topic)]
+        id_market: MarketGuessId,
+        #[ink(topic)]
+        oracle_owner: OracleOwner,
+        #[ink(topic)]
+        block_number_guessed: BlockNumber,
+        #[ink(topic)]
+        block_number_entropy: BlockNumber,
+        // #[ink(topic)]
+        block_number_end: BlockNumber,
     }
 
+    /// Emitted when set block hash entropy for market id.
+    #[ink(event)]
+    pub struct SetBlockHashEntropyForMarketId {
+        #[ink(topic)]
+        id_market: MarketGuessId,
+        oracle_owner: OracleOwner,
+        #[ink(topic)]
+        block_number_entropy: BlockNumber,
+        #[ink(topic)]
+        block_hash_entropy: Hash,
+    }
+
+    // https://docs.rs/ink/latest/ink/attr.storage_item.html
+    // Non-packed types like `Mapping` require calculating the storage key during compilation
+    // and it is best to rely on automatic storage key calculation via `ink::storage_item`
+    // and must be called before `derive`
+    #[derive(scale::Decode, scale::Encode)]
+    #[cfg_attr(
+        feature = "std",
+        derive(scale_info::TypeInfo, ink::storage::traits::StorageLayout)
+    )]
+    #[derive(Default, Debug)]
     pub struct MarketGuess {
         /// Market guess id.
         id_market: MarketGuessId,
+        /// Oracle account owner
+        oracle_owner: OracleOwner,
         /// Block number when market guesses were made.
         block_number_guessed: BlockNumber,
         /// Block number in the future to use the block hash of for entropy.
@@ -34,22 +73,28 @@ mod oracle_contract {
         block_hash_entropy: Hash,
         /// Market guess period end block number
         block_number_end: BlockNumber,
-        /// Market guess finalization status.
-        status: Status,
     }
 
     #[derive(Default)]
     #[ink(storage)]
     pub struct OracleContract {
         /// Assign an owner and block number for entropy to every market guess id.
-        market_data: Mapping<MarketGuessId, (OracleOwner, BlockNumberEntropy), ManualKey<123>>,
-        /// Enforce non-`Packed` storage layout since vector may get large
-        /// and expensive to work with.
-        /// Lazy fields like `market_guesses` provide `get()` and `set()`
-        /// storage operators.
-        market_guesses: Lazy<Vec<MarketGuess>>,
+        market_data: Mapping<MarketGuessId, MarketGuess>, // , ManualKey<123>
+    }
+
+    /// Errors that can occur upon calling this contract.
+    #[derive(Debug, PartialEq, Eq, scale::Encode, scale::Decode)]
+    #[cfg_attr(feature = "std", derive(::scale_info::TypeInfo))]
+    pub enum Error {
+        /// Returned if the no data exists for given market guess id.
+        NoDataForMarketGuessId,
+        /// Returned if caller is not oracle owner of market guess id.
+        CallerIsNotOracleOwner,
     }
 
+    /// Type alias for the contract's result type.
+    pub type Result<T> = core::result::Result<T, Error>;
+
     impl OracleContract {
         #[ink(constructor)]
         pub fn new(
@@ -59,72 +104,107 @@ mod oracle_contract {
             block_number_end: BlockNumber,
         ) -> Self {
             let mut instance = Self::default();
-            let caller: OracleOwner = Self.env().caller();
+            let oracle_owner: OracleOwner = instance.env().caller();
             let market_data = Mapping::default();
-            assert!(self.exists_market_data_for_id, "unable to find market data for given id");
-            let block_number_current: Self::env().block_number();
+            assert!(instance.exists_market_data_for_id(id_market), "unable to find market data for given id");
+            let block_number_current = Self::env().block_number();
             // TODO - we need to verify that the block hash exists for the block number
             // when they say guessing occurred
             assert!(
                 block_number_current > block_number_guessed,
                 "block number when guessing occurred must be before the current block number"
             );
-            // TODO - 100 is a magic number
+            // TODO - 100 and 200 are magic numbers, need something more meaningful
             assert!(
                 block_number_entropy - block_number_current > 100,
                 "block used for entropy must allow sufficient block confirmations after the current \
                 block and block when guessing occurred for assurance that epoch gets finalized \
                 incase head susceptible to reorganization for safety"
             );
-            // TODO - 200 is a magic number
             assert!(
                 block_number_end - block_number_entropy > 200,
                 "block when market ends must be allow sufficient block confirmations after the \
                 block used for entropy"
             );
-
-            instance.market_data.insert(&id_market, (&caller, &block_number_entropy)));
             let new_market_guess = MarketGuess {
                 id_market,
+                oracle_owner,
                 block_number_guessed,
                 block_number_entropy,
                 block_hash_entropy: Default::default(),
                 block_number_end,
-                status: Status::Pending,
             };
-            let mut market_guesses = self.market_guesses.get_or_default();
-            market_guesses.push(new_market_guess);
-            self.market_guesses.set(&market_guesses);
+            instance.market_data.insert(&id_market, &new_market_guess);
+            self.env().emit_event(NewOracleMarketGuessForMarketId {
+                id_market,
+                oracle_owner,
+                block_number_guessed,
+                block_number_entropy,
+                block_number_end,
+            });
             instance
         }
 
-        // #[ink(message)]
-        // pub fn set_block_number_guessed(&mut self, block_number) {
-        //     self.block_number_guessed = block_number;
-        // }
-        // #[ink(message)]
-        // pub fn get_block_number_guessed(&self) -> BlockNumber {
-        //     self.block_number_guessed
-        // }
-        // assert!(caller == owner, "caller is not owner")
-
         #[ink(message)]
         pub fn set_block_hash_entropy_for_market_id(
             &mut self,
             id_market: MarketGuessId,
             block_hash_entropy: Hash,
-        ) {
-            self.block_number_guessed = block_number;
+        ) -> Result<()> {
+            let caller: AccountId = self.env().caller();
+            // assert!(self.exists_market_data_for_id(id_market), "unable to find market data for given id");
+            let market_guess = match self.market_data.get(id_market) {
+                Some(data) => data,
+                None => return Err(Error::NoDataForMarketGuessId),
+            };
+            // singleton change of block hash entropy from the default value set at instantiation of the contract
+            assert!(market_guess.block_hash_entropy == Default::default(), "unable to set block hash entropy for market id once");
+            if market_guess.oracle_owner != caller {
+                return Err(Error::CallerIsNotOracleOwner)
+            }
+            let new_market_guess = MarketGuess {
+                block_hash_entropy,
+                ..market_guess
+            };
+            self.market_data.insert(&id_market, &new_market_guess);
+            self.env().emit_event(SetBlockHashEntropyForMarketId {
+                id_market,
+                oracle_owner: caller,
+                block_number_entropy: market_guess.block_number_entropy,
+                block_hash_entropy,
+            });
+            Ok(())
         }
 
-        #[ink(message)]
-        pub fn get_block_hash_entropy_for_market_id(&self, id_market) -> BlockNumber {
-            self.block_number_guessed
-        }
+        // #[ink(message)]
+        // // pub fn get_entropy_for_market_id(&self, id_market: MarketGuessId) -> (BlockNumber, BlockNumber, ????) {
+        // pub fn get_entropy_for_market_id(&self, id_market: MarketGuessId) -> (BlockNumber, BlockNumber) {
+        //     let market_guess = match self.market_data.get(id_market) {
+        //         Some(data) => data,
+        //         None => return Err(Error::NoDataForMarketGuessId),
+        //     };
+        //     assert!(market_guess.block_hash_entropy != Default::default(), "block hash entropy must be set prior to obtaining entropy");
+        //     let block_number_entropy = market_guess.block_number_entropy;
+        //     let block_hash_entropy = market_guess.block_hash_entropy;
+
+        //     let entropy = block_hash_entropy.replace(&["0x"][..], "");
+            // let str = decode(entropy);
+            // let buffer = <[u8; 12]>::from_hex(entropy)?;
+            // let str = str::from_utf8(&buffer).expect("invalid buffer length");
+            // let sub = &str[..5];
+            // ink::env::debug_println!("sub: {}\n", sub);
+
+            // generate random number from block hash
+            // don't allow them to use the default value for the random number, they need to have set the
+            // block hash entropy to a block hash 
+
+            // (block_number_entropy, block_hash_entropy, ???)
+        //     (block_number_entropy, block_hash_entropy)
+        // }
 
         // helper methods
-        fn exists_market_data_for_id(id_market: MarketGuessId) -> bool {
-            self.market_data.get(id_market).is_some()
+        fn exists_market_data_for_id(&self, id_market: MarketGuessId) -> bool {
+            self.market_data.contains(id_market)
         }
     }
 }