call via main but no Builder not support tuple return Decode(Error)

dapps/xcm/unnamed/lib.rs

@@ -2,6 +2,16 @@
 
 #[ink::contract]
 mod unnamed {
+    use ink::env::{
+        call::{
+            build_create,
+            build_call,
+            ExecutionInput,
+            Selector,
+        },
+        DefaultEnvironment,
+    };
+
     use oracle_contract::OracleContractRef;
 
     use ink::prelude::string::String;
@@ -10,6 +20,13 @@ mod unnamed {
     // refactor into types file
     pub type OracleOwner = AccountId;
 
+    #[derive(Clone, Debug, scale::Encode, scale::Decode)]
+    #[cfg_attr(
+        feature = "std",
+        derive(scale_info::TypeInfo, ink::storage::traits::StorageLayout)
+    )]
+    pub struct EntropyData(BlockNumber, String, i16, i16);
+
     /// Defines the storage of your contract.
     /// Add new fields to the below struct in order
     /// to add new static storage fields to your contract.
@@ -18,6 +35,7 @@ mod unnamed {
     pub struct Unnamed {
         /// Store a reference to the `OracleContract`.
         oracle_contract: Option<OracleContractRef>,
+        oracle_contract_address: Option<AccountId>,
         owner: Option<OracleOwner>,
     }
 
@@ -27,6 +45,7 @@ mod unnamed {
     pub enum Error {
         /// Returned if not oracle contract address exists.
         NoOracleContractAddress,
+        ResponseError,
     }
 
     /// Type alias for the contract's result type.
@@ -37,26 +56,32 @@ mod unnamed {
         #[ink(constructor)]
         pub fn new(
             oracle_contract_code_hash: Hash,
+            oracle_contract_address: AccountId,
             id_market: String,
             block_number_guessed: BlockNumber,
             block_number_entropy: BlockNumber,
             block_number_end: BlockNumber,
         ) -> Self {
             let instance = Self::default();
             let caller = instance.env().caller();
-            let oracle_contract = OracleContractRef::new(
-                    id_market,
-                    block_number_guessed,
-                    block_number_entropy,
-                    block_number_end,
-                )
+            let oracle_contract = build_create::<OracleContractRef>()
                 .code_hash(oracle_contract_code_hash)
+                .gas_limit(100000000000)
                 .endowment(0)
+                .exec_input(
+                    ExecutionInput::new(Selector::new(ink::selector_bytes!("new")))
+                        .push_arg(id_market)
+                        .push_arg(block_number_guessed)
+                        .push_arg(block_number_entropy)
+                        .push_arg(block_number_end)
+                )
                 .salt_bytes([0xDE, 0xAD, 0xBE, 0xEF])
+                .returns::<OracleContractRef>()
                 .instantiate();
 
             Self {
                 oracle_contract: Some(oracle_contract),
+                oracle_contract_address: Some(oracle_contract_address),
                 owner: Some(caller),
             }
         }
@@ -69,14 +94,23 @@ mod unnamed {
             block_number_entropy: BlockNumber, // always require this even though it may not have changed
             block_hash_entropy: String, // Hash
         ) -> Result<()> {
-            ink::env::debug_println!("&self.oracle_contract {:?}", &self.oracle_contract);
-            match &self.oracle_contract {
+            ink::env::debug_println!("&self.oracle_contract_address {:?}", &self.oracle_contract_address);
+            match &self.oracle_contract_address {
                 Some(c) => {
-                    let res = c.clone().set_block_for_entropy_for_market_id(
-                        id_market,
-                        block_number_entropy,
-                        block_hash_entropy.clone(),
-                    );
+                    // using CallBuilder
+                    // https://use.ink/basics/cross-contract-calling#callbuilder
+                    build_call::<DefaultEnvironment>()
+                        .call(c.clone())
+                        .gas_limit(100000000000)
+                        .transferred_value(0)
+                        .exec_input(
+                            ExecutionInput::new(Selector::new(ink::selector_bytes!("set_block_for_entropy_for_market_id")))
+                                .push_arg(id_market)
+                                .push_arg(block_number_entropy)
+                                .push_arg(block_hash_entropy.clone())
+                        )
+                        .returns::<()>()
+                        .invoke();
                     Ok(())
                 },
                 None => return Err(Error::NoOracleContractAddress),
@@ -85,14 +119,65 @@ mod unnamed {
 
         /// Using the `OracleContractRef` we can call all the messages of the `OracleContract`
         #[ink(message)]
-        pub fn get_entropy_for_market_id(&self, id_market: String) -> Result<(BlockNumber, String, i16, i16)> {
-            match &self.oracle_contract {
+        pub fn set_entropy_for_market_id(
+            &mut self,
+            id_market: String,
+            block_number_entropy: BlockNumber, // always require this even though it may not have changed
+            block_hash_entropy: String, // Hash
+            c1_entropy: i16,
+            c2_entropy: i16,
+        ) -> Result<()> {
+            ink::env::debug_println!("&self.oracle_contract_address {:?}", &self.oracle_contract_address);
+            match &self.oracle_contract_address {
                 Some(c) => {
-                    let res = match c.clone().get_entropy_for_market_id(id_market) {
-                        Ok(r) => r,
-                        Err(_e) => panic!("arr {:?}", _e),
+                    // using CallBuilder
+                    // https://use.ink/basics/cross-contract-calling#callbuilder
+                    build_call::<DefaultEnvironment>()
+                        .call(c.clone())
+                        .gas_limit(100000000000)
+                        .transferred_value(0)
+                        .exec_input(
+                            ExecutionInput::new(Selector::new(ink::selector_bytes!("set_entropy_for_market_id")))
+                                .push_arg(id_market)
+                                .push_arg(block_number_entropy)
+                                .push_arg(block_hash_entropy.clone())
+                                .push_arg(c1_entropy)
+                                .push_arg(c2_entropy)
+                        )
+                        .returns::<()>()
+                        .invoke();
+                    Ok(())
+                },
+                None => return Err(Error::NoOracleContractAddress),
+            }
+        }
+
+        /// Using the `OracleContractRef` we can call all the messages of the `OracleContract`
+        #[ink(message)]
+        pub fn get_entropy_for_market_id(&self, id_market: String) -> Result<EntropyData> {
+            match &self.oracle_contract_address {
+                Some(c) => {
+                    let res =
+                        build_call::<DefaultEnvironment>()
+                            .call(c.clone())
+                            .gas_limit(100000000000)
+                            .exec_input(
+                                ExecutionInput::new(Selector::new(ink::selector_bytes!("get_entropy_for_market_id")))
+                                    .push_arg(id_market)
+                            )
+                            .returns::<EntropyData>()
+                            .try_invoke()
+                            .expect("Error calling get_entropy_for_market_id.");
+                    match res {
+                        Ok(tuple) => {
+                            ink::env::debug_println!("tuple {:?}", tuple);
+                            return Ok(tuple);
+                        },
+                        Err(e) => {
+                            ink::env::debug_println!("error {:?}", e);
+                            return Err(Error::ResponseError);
+                        },
                     };
-                    Ok(res)
                 },
                 None => return Err(Error::NoOracleContractAddress),
             }
@@ -101,9 +186,28 @@ mod unnamed {
         /// Using the `OracleContractRef` we can call all the messages of the `OracleContract`
         #[ink(message)]
         pub fn get_oracle_contract_address(&self) -> Result<AccountId> {
-            match &self.oracle_contract {
+            match &self.oracle_contract_address {
                 Some(c) => {
-                    Ok(c.clone().get_oracle_contract_address())
+                    let res =
+                        build_call::<DefaultEnvironment>()
+                            .call(c.clone())
+                            .gas_limit(100000000000)
+                            .exec_input(
+                                ExecutionInput::new(Selector::new(ink::selector_bytes!("get_oracle_contract_address")))
+                            )
+                            .returns::<AccountId>()
+                            .try_invoke()
+                            .expect("Error calling get_oracle_contract_address.");
+                    match res {
+                        Ok(contract_address) => {
+                            ink::env::debug_println!("contract_address {:?}", contract_address);
+                            return Ok(contract_address);
+                        },
+                        Err(e) => {
+                            ink::env::debug_println!("error {:?}", e);
+                            return Err(Error::ResponseError);
+                        },
+                    };
                 },
                 None => return Err(Error::NoOracleContractAddress),
             }

dapps/xcm/unnamed/oracle_contract/lib.rs

@@ -23,6 +23,13 @@ mod oracle_contract {
     pub type MarketGuessId = Vec<u8>;
     pub type OracleOwner = AccountId;
 
+    #[derive(Clone, Debug, scale::Encode, scale::Decode)]
+    #[cfg_attr(
+        feature = "std",
+        derive(scale_info::TypeInfo, ink::storage::traits::StorageLayout)
+    )]
+    pub struct EntropyData(BlockNumber, String, i16, i16);
+
     /// Emitted when create new market guess for market id.
     #[ink(event)]
     pub struct NewOracleMarketGuessForMarketId {
@@ -216,17 +223,23 @@ mod oracle_contract {
             //     waiting sufficient blocks after previous so guarantee of waiting until \
             //     validators change after a certain amount of epochs"
             // );
+            ink::env::debug_println!("111");
             let block_hash_entropy_no_prefix = block_hash_entropy.replace("0x", "");
+            ink::env::debug_println!("222");
             assert!(block_hash_entropy_no_prefix.len() == 64, "block hash should be a 256 bit block hash");
-
+            ink::env::debug_println!("333 {:?}, {:?}", market_guess.oracle_owner, caller);
+            // FIXME - if called from the main contract then the caller won't be the oracle_owner,
+            // instead it'll be the main contract's address
             if market_guess.oracle_owner != Some(caller) {
-                return Err(Error::CallerIsNotOracleOwner)
+                return Err(Error::CallerIsNotOracleOwner);
             }
+            ink::env::debug_println!("444");
             let new_market_guess = MarketGuess {
                 block_number_entropy,
                 block_hash_entropy: Some(block_hash_entropy_no_prefix.clone()),
                 ..market_guess
             };
+            ink::env::debug_println!("new_market_guess: {:?}\n", new_market_guess);
             self.market_data.insert(id_market.clone().into_bytes(), &new_market_guess);
             self.env().emit_event(SetBlockHashEntropyForMarketId {
                 id_market: id_market.clone().into_bytes(),
@@ -246,13 +259,14 @@ mod oracle_contract {
             c1_entropy: i16,
             c2_entropy: i16,
         ) -> Result<()> {
+            ink::env::debug_println!("set_entropy_for_market_id");
             let caller: AccountId = self.env().caller();
             let market_guess = match self.market_data.get(id_market.clone().into_bytes()) {
                 Some(data) => data,
                 None => return Err(Error::NoDataForMarketGuessId),
             };
             if market_guess.oracle_owner != Some(caller) {
-                return Err(Error::CallerIsNotOracleOwner)
+                return Err(Error::CallerIsNotOracleOwner);
             }
             let block_hash_entropy_no_prefix = block_hash_entropy.replace("0x", "");
             assert!(block_hash_entropy_no_prefix.len() == 64, "block hash should be a 256 bit block hash");
@@ -271,6 +285,7 @@ mod oracle_contract {
                 c2_entropy: Some(c2_entropy),
                 ..market_guess
             };
+            ink::env::debug_println!("new_market_guess: {:?}\n", new_market_guess);
             self.market_data.insert(id_market.clone().into_bytes(), &new_market_guess);
             self.env().emit_event(SetEntropyForMarketId {
                 id_market: id_market.into_bytes(),
@@ -290,7 +305,7 @@ mod oracle_contract {
         }
 
         #[ink(message)]
-        pub fn get_entropy_for_market_id(&self, id_market: String) -> Result<(BlockNumber, String, i16, i16)> {
+        pub fn get_entropy_for_market_id(&self, id_market: String) -> Result<EntropyData> {
             let caller: AccountId = self.env().caller();
             let market_guess = match self.market_data.get(id_market.clone().into_bytes()) {
                 Some(data) => data,
@@ -349,7 +364,8 @@ mod oracle_contract {
                 c2_entropy: c2_rem,
             });
 
-            Ok((block_number_entropy, block_hash_entropy.clone(), c1_rem, c2_rem))
+            let entropy_data = EntropyData(block_number_entropy, block_hash_entropy.clone(), c1_rem, c2_rem);
+            Ok(entropy_data)
         }
 
         // get symbols 61-64 for coin1 and 57-60 for coin2 fro the block hash