securesecrets · DrPresident · Dec 14, 2021 · Nov 22, 2021 · Nov 26, 2021 · Dec 1, 2021
diff --git a/contractlib/oraclelib.py b/contractlib/oraclelib.py
@@ -23,13 +23,13 @@ def __init__(self, label, band_contract, sscrt, contract='oracle.wasm.gz', admin
         super().__init__(contract, init_msg, label, admin, uploader, backend,
                          instantiated_contract=instantiated_contract, code_id=code_id)
 
-    def get_price(self, symbol):
+    def price(self, symbol):
         """
         Get current coin price
         :param symbol: Coin ticker
         :return:
         """
-        msg = json.dumps({'get_price': {'symbol': symbol}})
+        msg = json.dumps({'price': {'symbol': symbol}})
 
         return self.query(msg)
 
@@ -40,3 +40,14 @@ def register_sswap_pair(self, pair):
         }})
 
         return self.execute(msg)
+
+    def register_index(self, symbol, basket: list):
+        msg = json.dumps({
+            'register_index': {
+                'symbol': symbol,
+                'basket': basket,
+            }
+        })
+        print(msg)
+
+        return self.execute(msg)
diff --git a/contractlib/secretlib/secretlib.py b/contractlib/secretlib/secretlib.py
@@ -3,7 +3,7 @@
 import time
 
 # Presetup some commands
-query_list_code = ['secretcli', 'query', 'compute', 'list-code']
+query_list_code = ['secretd', 'query', 'compute', 'list-code']
 MAX_TRIES = 30
 
 GAS_METRICS = []
@@ -18,6 +18,7 @@ def run_command(command):
     :param wait: Time to wait for command
     :return: Output string
     """
+    # print('CMD', command)
     p = Popen(command, stdout=PIPE, stderr=PIPE, text=True)
     output, err = p.communicate()
     status = p.wait()
@@ -36,7 +37,7 @@ def store_contract(contract, user='a', backend='test'):
     :return: Contract ID
     """
 
-    command = ['secretcli', 'tx', 'compute', 'store', f'./compiled/{contract}',
+    command = ['secretd', 'tx', 'compute', 'store', f'./compiled/{contract}',
                '--from', user, '--gas', STORE_GAS, '-y']
 
     if backend is not None:
@@ -63,7 +64,7 @@ def instantiate_contract(contract, msg, label, user='a', backend='test'):
     :return:
     """
 
-    command = ['secretcli', 'tx', 'compute', 'instantiate', contract, msg, '--from',
+    command = ['secretd', 'tx', 'compute', 'instantiate', contract, msg, '--from',
                user, '--label', label, '-y', '--gas', '500000']
 
     if backend is not None:
@@ -73,19 +74,19 @@ def instantiate_contract(contract, msg, label, user='a', backend='test'):
 
 
 def list_code():
-    command = ['secretcli', 'query', 'compute', 'list-code']
+    command = ['secretd', 'query', 'compute', 'list-code']
 
     return json.loads(run_command(command))
 
 
 def list_contract_by_code(code):
-    command = ['secretcli', 'query', 'compute', 'list-contract-by-code', code]
+    command = ['secretd', 'query', 'compute', 'list-contract-by-code', code]
 
     return json.loads(run_command(command))
 
 
 def execute_contract(contract, msg, user='a', backend='test', amount=None, compute=True):
-    command = ['secretcli', 'tx', 'compute', 'execute', contract, json.dumps(msg), '--from', user, '--gas', GAS, '-y']
+    command = ['secretd', 'tx', 'compute', 'execute', contract, json.dumps(msg), '--from', user, '--gas', GAS, '-y']
 
     if backend is not None:
         command += ['--keyring-backend', backend]
@@ -100,15 +101,15 @@ def execute_contract(contract, msg, user='a', backend='test', amount=None, compu
 
 
 def query_hash(hash):
-    return run_command(['secretcli', 'q', 'tx', hash])
+    return run_command(['secretd', 'q', 'tx', hash])
 
 
 def compute_hash(hash):
-    return run_command(['secretcli', 'q', 'compute', 'tx', hash])
+    return run_command(['secretd', 'q', 'compute', 'tx', hash])
 
 
 def query_contract(contract, msg):
-    command = ['secretcli', 'query', 'compute', 'query', contract, json.dumps(msg)]
+    command = ['secretd', 'query', 'compute', 'query', contract, json.dumps(msg)]
     out = run_command(command)
     try:
         return json.loads(out)

diff --git a/contracts/micro_mint/src/handle.rs b/contracts/micro_mint/src/handle.rs
@@ -17,7 +17,7 @@ use shade_protocol::{
     mint::MintMsgHook,
     snip20::{Snip20Asset, token_config_query, TokenConfig},
     oracle::{
-        QueryMsg::GetPrice,
+        QueryMsg::Price,
     },
     band::ReferenceData,
     asset::Contract,
@@ -491,7 +491,7 @@ fn oracle<S: Storage, A: Api, Q: Querier>(
 ) -> StdResult<Uint128> {
 
     let config: Config = config_r(&deps.storage).load()?;
-    let answer: ReferenceData = GetPrice { 
+    let answer: ReferenceData = Price { 
         symbol: symbol.to_string() 
     }.query(&deps.querier,
              config.oracle.code_hash,

diff --git a/contracts/mint/src/contract.rs b/contracts/mint/src/contract.rs
@@ -7,7 +7,7 @@ use secret_toolkit::{
 use shade_protocol::{
     mint::{InitMsg, HandleMsg, HandleAnswer, QueryMsg, QueryAnswer, MintConfig, SupportedAsset, SnipMsgHook},
     oracle::{
-        QueryMsg::GetPrice,
+        QueryMsg::Price,
     },
     band::ReferenceData,
     asset::{Contract},
@@ -387,7 +387,7 @@ fn call_oracle<S: Storage, A: Api, Q: Querier>(
     symbol: String,
 ) -> StdResult<Uint128> {
     let config = config_read(&deps.storage).load()?;
-    let query_msg = GetPrice { symbol };
+    let query_msg = Price { symbol };
     let answer: ReferenceData = query_msg.query(&deps.querier,
                                  config.oracle.code_hash,
                                  config.oracle.address)?;

diff --git a/contracts/mock_band/src/contract.rs b/contracts/mock_band/src/contract.rs
@@ -7,6 +7,21 @@ use serde::{Deserialize, Serialize};
 use schemars::JsonSchema;
 use shade_protocol::band::{ReferenceData, InitMsg};
 
+use cosmwasm_storage::{
+    bucket, bucket_read,
+    Bucket, ReadonlyBucket
+};
+
+pub static PRICE: &[u8] = b"prices";
+
+pub fn price_r<S: Storage>(storage: &S) -> ReadonlyBucket<S, Uint128> {
+    bucket_read(PRICE, storage)
+}
+
+pub fn price_w<S: Storage>(storage: &mut S) -> Bucket<S, Uint128> {
+    bucket(PRICE, storage)
+}
+
 pub fn init<S: Storage, A: Api, Q: Querier>(
     _deps: &mut Extern<S, A, Q>,
     _env: Env,
@@ -17,13 +32,24 @@ pub fn init<S: Storage, A: Api, Q: Querier>(
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
-pub enum HandleMsg { }
+pub enum HandleMsg {
+    MockPrice {
+        symbol: String,
+        price: Uint128,
+    }
+}
 
 pub fn handle<S: Storage, A: Api, Q: Querier>(
-    _deps: &mut Extern<S, A, Q>,
+    deps: &mut Extern<S, A, Q>,
     _env: Env,
-    _msg: HandleMsg,
+    msg: HandleMsg,
 ) -> StdResult<HandleResponse> { 
+    match msg {
+        HandleMsg::MockPrice { symbol, price } => {
+            price_w(&mut deps.storage).save(&symbol.as_bytes(), &price)?;
+            return Ok(HandleResponse::default())
+        }
+    }
 
     Err(StdError::GenericErr { msg: "Not Implemented".to_string(), backtrace: None})
 }
@@ -41,29 +67,40 @@ pub enum QueryMsg {
     },
 }
 pub fn query<S: Storage, A: Api, Q: Querier>(
-    _deps: &Extern<S, A, Q>,
+    deps: &Extern<S, A, Q>,
     msg: QueryMsg,
 ) -> StdResult<Binary> {
     match msg {
-        QueryMsg::GetReferenceData { base_symbol: _, quote_symbol: _ } => 
-            to_binary(&ReferenceData {
-              rate: Uint128(1_000_000_000_000_000_000),
-              last_updated_base: 1628544285u64,
-              last_updated_quote: 3377610u64
-            }),
+        QueryMsg::GetReferenceData { 
+            base_symbol,
+            quote_symbol: _ 
+        } => {
+            if let Some(price) = price_r(&deps.storage).may_load(&base_symbol.as_bytes())? {
+                return to_binary(&ReferenceData {
+                      rate: price,
+                      last_updated_base: 0,
+                      last_updated_quote: 0 
+                })
+            }
+            return Err(StdError::GenericErr { msg: "Missing Price Feed".to_string(), backtrace: None})
+        },
         QueryMsg::GetReferenceDataBulk {
             base_symbols,
             quote_symbols: _
         } => {
             let mut results = Vec::new();
-            let data = ReferenceData {
-                  rate: Uint128(1_000_000_000_000_000_000),
-                  last_updated_base: 1628544285u64,
-                  last_updated_quote: 3377610u64
-            };
 
-            for _ in base_symbols {
-                results.push(data.clone());
+            for sym in base_symbols {
+                if let Some(price) = price_r(&deps.storage).may_load(&sym.as_bytes())? {
+                    results.push(ReferenceData {
+                          rate: price,
+                          last_updated_base: 0,
+                     
10000
     last_updated_quote: 0 
+                    });
+                }
+                else {
+                    return Err(StdError::GenericErr { msg: "Missing Price Feed".to_string(), backtrace: None})
+                }
             }
             to_binary(&results)
         },

@@ -14,7 +14,8 @@ The oracle contract is used to query the price of different currencies
 ##### Request
 |Name      |Type      |Description                                                                                                        | optional |
 |----------|----------|-------------------------------------------------------------------------------------------------------------------|----------|
-|owner     | string   |  New contract owner; SHOULD be a valid bech32 address, but contracts may use a different naming scheme as well    |  yes     |
+|admin     | string   |  New contract admin; SHOULD be a valid bech32 address, but contracts may use a different naming scheme as well    |  yes     |
+|sscrt     | Contract |  sSCRT snip20 token contract |  no      |
 |band      | Contract |  Band protocol contract   |  no      |
 
 ##User
@@ -40,8 +41,8 @@ Updates the given values
 
 ### Queries
 
-#### GetPrice
-Get asset price according to band protocol.
+#### Price
+Get asset price
 ##### Request
 |Name        |Type    |Description                                                                                                            | optional |
 |------------|--------|-----------------------------------------------------------------------------------------------------------------------|----------|
@@ -56,20 +57,22 @@ Get asset price according to band protocol.
   }
 }
 ```
-#### GetReferenceData
-Get base asset price relative to quote asset according to band protocol.
+#### Prices
+Get prices of list of assets
 ##### Request
 |Name        |Type    |Description                                                                                                            | optional |
 |------------|--------|-----------------------------------------------------------------------------------------------------------------------|----------|
-|base_symbol | string |  asset abbreviation e.g. BTC/ETH/SCRT;   |  no      |
-|quote_symbol| string |  asset abbreviation e.g. BTC/ETH/SCRT;   |  no      |
+|symbols      | list |  list of asset symbols e.g. BTC/ETH/SCRT;   |  no      |
 ##### Response
 ```json
 {
-  {
-    "rate": "1470000000000000000",
-    "last_updated_base": 1628569146,
-    "last_updated_quote": 3377610
-  }
+  [
+    {
+      "rate": "1470000000000000000",
+      "last_updated_base": 1628569146,
+      "last_updated_quote": 3377610
+    },
+    ...
+  ]
 }
 ```
@@ -21,7 +21,7 @@ pub fn init<S: Storage, A: Api, Q: Querier>(
     msg: InitMsg,
 ) -> StdResult<InitResponse> {
     let state = OracleConfig {
-        owner: match msg.admin {
+        admin: match msg.admin {
             None => { env.message.sender.clone() }
             Some(admin) => { admin }
         },
@@ -53,12 +53,16 @@ pub fn handle<S: Storage, A: Api, Q: Querier>(
 
     match msg {
         HandleMsg::UpdateConfig {
-            owner,
+            admin,
             band,
-        } => handle::try_update_config(deps, env, owner, band),
+        } => handle::try_update_config(deps, env, admin, band),
         HandleMsg::RegisterSswapPair {
             pair,
         } => handle::register_sswap_pair(deps, env, pair),
+        HandleMsg::RegisterIndex {
+            symbol,
+            basket,
+        } => handle::register_index(deps, env, symbol, basket),
     }
 }
 
@@ -67,7 +71,8 @@ pub fn query<S: Storage, A: Api, Q: Querier>(
     msg: QueryMsg,
 ) -> StdResult<Binary> {
     match msg {
-        QueryMsg::GetConfig {} => to_binary(&query::config(deps)?),
-        QueryMsg::GetPrice { symbol } => to_binary(&query::get_price(deps, symbol)?),
+        QueryMsg::Config {} => to_binary(&query::config(deps)?),
+        QueryMsg::Price { symbol } => to_binary(&query::price(deps, symbol)?),
+        QueryMsg::Prices { symbols } => to_binary(&query::prices(deps, symbols)?),
     }
 }