Cob/account liquidity experiment (#279)

* account liqudity api experiment

* add gateway namespace, add portfolio endpoint

* playbook to update binary on full nodes ( update rpc )

* add exec trx request to repl

Author: coburncoburn

chains/repl.js

@@ -179,6 +179,19 @@ function defineCommands(r, { api, keyring, types }, saddle, network, contracts)
     })
   });
 
+  r.defineCommand('exec', {
+    help: 'Sign and send a trx request from saddle eth addr',
+    action: defineAction(r, async (request) => {
+      let user = saddle.account;// get saddle user and make chain account
+      const nonce = await api.query.cash.nonces({eth: user});
+      let req = `${nonce}:${request}`
+      let sig = await saddle.web3.eth.sign(req, user)
+      console.log("🎲", req)
+      let tx = api.tx.cash.execTrxRequest(request, {'Eth': [user, sig]}, nonce)
+      console.log("🏁", await tx.send())
+    })
+  });
+
   r.defineCommand('eth_network', {
     help: 'Show given Ethereum network',
     action: defineAction(r, async () => {

node/src/api.rs

@@ -11,9 +11,10 @@ use sp_runtime::{generic::BlockId, traits::Block as BlockT};
 
 use pallet_cash::{
     chains::{ChainAccount, ChainAsset},
+    portfolio::Portfolio,
     rates::APR,
     reason::Reason,
-    types::{AssetAmount, AssetBalance, AssetInfo},
+    types::{AssetAmount, AssetBalance, AssetInfo, InterestRateModel, Symbol},
 };
 use pallet_cash_runtime_api::CashApi as CashRuntimeApi;
 use pallet_oracle::types::AssetPrice;
@@ -43,13 +44,41 @@ pub struct ApiAssetData {
     price: String,
 }
 
+#[derive(Deserialize, Serialize, Types)]
+pub enum ApiInterestRateModel {
+    Kink {
+        zero_rate: String,
+        kink_rate: String,
+        kink_utilization: String,
+        full_rate: String,
+    },
+}
+
+#[derive(Deserialize, Serialize, Types)]
+pub struct ApiAssetInfo {
+    asset: ChainAsset,
+    decimals: u8,
+    liquidity_factor: String,
+    rate_model: ApiInterestRateModel,
+    miner_shares: String,
+    supply_cap: String,
+    symbol: Symbol,
+    ticker: String,
+}
+
 #[derive(Deserialize, Serialize, Types)]
 pub struct ApiCashData {
     balance: String,
     cash_yield: String,
     price: String,
 }
 
+#[derive(Deserialize, Serialize, Types)]
+pub struct ApiPortfolio {
+    cash: String,
+    positions: Vec<(ChainAsset, String)>,
+}
+
 /// Converts a runtime trap into an RPC error.
 fn runtime_err(err: impl std::fmt::Debug) -> RpcError {
     RpcError {
@@ -93,6 +122,25 @@ pub trait GatewayRpcApi<BlockHash> {
 
     #[rpc(name = "gateway_rates")]
     fn gateway_rates(&self, asset: ChainAsset, at: Option<BlockHash>) -> RpcResult<ApiRates>;
+
+    #[rpc(name = "gateway_assets")]
+    fn gateway_assets(&self, at: Option<BlockHash>) -> RpcResult<Vec<ApiAssetInfo>>;
+
+    #[rpc(name = "gateway_chain_accounts")]
+    fn chain_accounts(&self, at: Option<BlockHash>) -> RpcResult<Vec<ChainAccount>>;
+
+    #[rpc(name = "gateway_chain_account_liquidities")]
+    fn chain_account_liquidities(
+        &self,
+        at: Option<BlockHash>,
+    ) -> RpcResult<Vec<(ChainAccount, String)>>;
+
+    #[rpc(name = "gateway_chain_account_portfolio")]
+    fn chain_account_portfolio(
+        &self,
+        account: ChainAccount,
+        at: Option<BlockHash>,
+    ) -> RpcResult<ApiPortfolio>;
 }
 
 pub struct GatewayRpcHandler<C, B> {
@@ -226,4 +274,92 @@ where
             .map_err(chain_err)?;
         Ok((borrow_rate.0 as ApiAPR, supply_rate.0 as ApiAPR)) // XXX try_into?
     }
+
+    fn gateway_assets(&self, at: Option<<B as BlockT>::Hash>) -> RpcResult<Vec<ApiAssetInfo>> {
+        let api = self.client.runtime_api();
+        let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash));
+        let assets = api
+            .get_assets(&at)
+            .map_err(runtime_err)?
+            .map_err(chain_err)?;
+
+        fn api_rate_model(model: InterestRateModel) -> ApiInterestRateModel {
+            match model {
+                InterestRateModel::Kink {
+                    zero_rate,
+                    kink_rate,
+                    kink_utilization,
+                    full_rate,
+                } => ApiInterestRateModel::Kink {
+                    zero_rate: format!("{:?}", zero_rate.0),
+                    kink_rate: format!("{:?}", kink_rate.0),
+                    kink_utilization: format!("{:?}", kink_utilization.0),
+                    full_rate: format!("{:?}", full_rate.0),
+                },
+            }
+        }
+
+        let assets_lite = assets
+            .iter()
+            .map(|asset_info| ApiAssetInfo {
+                asset: asset_info.asset,
+                decimals: asset_info.decimals,
+                liquidity_factor: format!("{}", asset_info.liquidity_factor.0),
+                rate_model: api_rate_model(asset_info.rate_model),
+                miner_shares: format!("{}", asset_info.miner_shares.0),
+                supply_cap: format!("{}", asset_info.supply_cap),
+                symbol: asset_info.symbol,
+                ticker: String::from(asset_info.ticker),
+            })
+            .collect();
+
+        Ok(assets_lite) // XXX try_into?
+    }
+
+    fn chain_accounts(&self, at: Option<<B as BlockT>::Hash>) -> RpcResult<Vec<ChainAccount>> {
+        let api = self.client.runtime_api();
+        let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash));
+        let accounts = api
+            .get_accounts(&at)
+            .map_err(runtime_err)?
+            .map_err(chain_err)?;
+        Ok(accounts) // XXX try_into?
+    }
+
+    fn chain_account_liquidities(
+        &self,
+        at: Option<<B as BlockT>::Hash>,
+    ) -> RpcResult<Vec<(ChainAccount, String)>> {
+        let api = self.client.runtime_api();
+        let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash));
+        let accounts = api
+            .get_accounts_liquidity(&at)
+            .map_err(runtime_err)?
+            .map_err(chain_err)?;
+        Ok(accounts) // XXX try_into?
+    }
+
+    fn chain_account_portfolio(
+        &self,
+        account: ChainAccount,
+        at: Option<<B as BlockT>::Hash>,
+    ) -> RpcResult<ApiPortfolio> {
+        let api = self.client.runtime_api();
+        let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash));
+        let result: Portfolio = api
+            .get_portfolio(&at, account)
+            .map_err(runtime_err)?
+            .map_err(chain_err)?;
+
+        let positions_lite = result
+            .positions
+            .iter()
+            .map(|p| (p.0.asset, format!("{}", p.1.value)))
+            .collect();
+        print!("{:?}", positions_lite);
+        Ok(ApiPortfolio {
+            cash: format!("{}", result.cash.value),
+            positions: positions_lite,
+        })
+    }
 }

node/src/chain_spec.rs

@@ -241,7 +241,7 @@ pub(crate) mod tests {
     #[test]
     fn test_extract_configuration_from_properties_happy_path() {
         let expected_starport = "hello starport";
-        let expected_topic = "hello topic";
+        let _expected_topic = "hello topic";
         let properties = serde_json::json!({ "eth_starport_address": expected_starport });
         let properties = properties.as_object().unwrap();
 

node/src/rpc.rs

@@ -100,10 +100,9 @@ where
     let FullDeps {
         client,
         pool,
-        select_chain, // XXX delete?
-        chain_spec,   // XXX delete?
         deny_unsafe,
         grandpa,
+        ..
     } = deps;
 
     let GrandpaDeps {

ops/ansible/playbooks/update_rpc_node.yml

@@ -0,0 +1,19 @@
+- hosts:
+    - full_node
+  tasks:
+    - name: stop gateway service
+      become: true
+      systemd:
+        name: gateway.service
+        state: stopped
+
+    - include_role:
+        name: chain_node
+        tasks_from: build-chain.yml
+
+    - name: start gateway service
+      become: true
+      systemd:
+        name: gateway.service
+        state: started
+      

pallets/cash/runtime-api/src/lib.rs

@@ -1,5 +1,6 @@
 use pallet_cash::{
     chains::{ChainAccount, ChainAsset},
+    portfolio::Portfolio,
     rates::APR,
     reason::Reason,
     types::{AssetAmount, AssetBalance, AssetInfo},
@@ -17,5 +18,9 @@ sp_api::decl_runtime_apis! {
         fn get_price(ticker: String) -> Result<AssetPrice, Reason>;
         fn get_price_with_ticker(ticker: Ticker) -> Result<AssetPrice, Reason>;
         fn get_rates(asset: ChainAsset) -> Result<(APR, APR), Reason>;
+        fn get_assets() -> Result<Vec<AssetInfo>, Reason>;
+        fn get_accounts() -> Result<Vec<ChainAccount>, Reason>;
+        fn get_accounts_liquidity() -> Result<Vec<(ChainAccount, String)>, Reason>;
+        fn get_portfolio(account: ChainAccount) -> Result<Portfolio, Reason>;
     }
 }

pallets/cash/src/core.rs

@@ -108,6 +108,14 @@ pub fn get_rates<T: Config>(asset: ChainAsset) -> Result<(APR, APR), Reason> {
         .get_rates(utilization, APR::ZERO, info.miner_shares)?)
 }
 
+/// Return the current list of assets.
+pub fn get_assets<T: Config>() -> Result<Vec<AssetInfo>, Reason> {
+    let info = SupportedAssets::iter()
+        .map(|(_chain_asset, asset_info)| asset_info)
+        .collect::<Vec<AssetInfo>>();
+    Ok(info)
+}
+
 /// Return the current total borrow and total supply balances for the asset.
 pub fn get_market_totals<T: Config>(
     asset: ChainAsset,
@@ -132,6 +140,28 @@ pub fn get_cash_yield<T: Config>() -> Result<APR, Reason> {
     Ok(CashYield::get())
 }
 
+/// Return the current borrow and supply rates for the asset.
+pub fn get_accounts<T: Config>() -> Result<Vec<ChainAccount>, Reason> {
+    let info: Vec<ChainAccount> = CashPrincipals::iter()
+        .map(|p| p.0)
+        .collect::<Vec<ChainAccount>>();
+    Ok(info)
+}
+
+/// Return the current borrow and supply rates for the asset.
+pub fn get_accounts_liquidity<T: Config>() -> Result<Vec<(ChainAccount, AssetBalance)>, Reason> {
+    let mut info: Vec<(ChainAccount, AssetBalance)> = CashPrincipals::iter()
+        .map(|a| (a.0.clone(), get_liquidity::<T>(a.0).unwrap().value))
+        .collect::<Vec<(ChainAccount, AssetBalance)>>();
+    info.sort_by(|(_a_account, a_balance), (_b_account, b_balance)| a_balance.cmp(b_balance));
+    Ok(info)
+}
+
+/// Return the portfolio of the chain account
+pub fn get_portfolio<T: Config>(account: ChainAccount) -> Result<Portfolio, Reason> {
+    Ok(Portfolio::from_storage::<T>(account)?)
+}
+
 // Internal helpers
 
 pub fn passes_validation_threshold(
@@ -1492,6 +1522,38 @@ mod tests {
         })
     }
 
+    #[test]
+    fn test_get_assets() -> Result<(), Reason> {
+        new_test_ext().execute_with(|| {
+            initialize_storage();
+            let assets = vec![
+                AssetInfo {
+                    ticker: FromStr::from_str("USD").unwrap(),
+                    liquidity_factor: FromStr::from_str("7890").unwrap(),
+                    ..AssetInfo::minimal(
+                        FromStr::from_str("eth:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")
+                            .unwrap(),
+                        FromStr::from_str("USDC/6").unwrap(),
+                    )
+                },
+                AssetInfo {
+                    liquidity_factor: FromStr::from_str("7890").unwrap(),
+                    ..AssetInfo::minimal(
+                        FromStr::from_str("eth:0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE")
+                            .unwrap(),
+                        FromStr::from_str("ETH/18").unwrap(),
+                    )
+                },
+            ];
+
+            let found_assets = crate::core::get_assets::<Test>()?;
+
+            assert_eq!(assets, found_assets);
+
+            Ok(())
+        })
+    }
+
     #[test]
     fn test_has_liquidity_to_reduce_cash() -> Result<(), Reason> {
         const BAT: Units = Units::from_ticker_str("BAT", 18);

pallets/cash/src/lib.rs

@@ -17,6 +17,7 @@ use crate::{
     },
     events::{ChainLogEvent, ChainLogId, EventState},
     notices::{Notice, NoticeId, NoticeState},
+    portfolio::Portfolio,
     types::{
         AssetAmount, AssetBalance, AssetIndex, AssetInfo, Bips, CashIndex, CashPrincipal,
         CashPrincipalAmount, CodeHash, EncodedNotice, GovernanceResult, InterestRateModel,
@@ -28,7 +29,7 @@ use codec::alloc::string::String;
 use frame_support::{
     decl_event, decl_module, decl_storage, dispatch,
     sp_runtime::traits::Convert,
-    traits::{OnRuntimeUpgrade, StoredMap, UnfilteredDispatchable},
+    traits::{StoredMap, UnfilteredDispatchable},
     weights::{DispatchClass, GetDispatchInfo, Pays, Weight},
     Parameter,
 };
@@ -591,7 +592,7 @@ decl_module! {
 
         // Remove any notice holds if they have been executed
         #[weight = (1, DispatchClass::Normal, Pays::No)] // XXX
-        pub fn cull_notices(origin) -> dispatch::DispatchResult {
+        pub fn cull_notices(_origin) -> dispatch::DispatchResult {
             log!("Culling executed notices");
             NoticeHolds::iter().for_each(|(chain_id, notice_id)| {
                 match NoticeStates::get(chain_id, notice_id) {
@@ -677,6 +678,29 @@ impl<T: Config> Module<T> {
     pub fn get_rates(asset: ChainAsset) -> Result<(APR, APR), Reason> {
         Ok(core::get_rates::<T>(asset)?)
     }
+
+    /// Get the list of assets
+    pub fn get_assets() -> Result<Vec<AssetInfo>, Reason> {
+        Ok(core::get_assets::<T>()?)
+    }
+    /// Get the rates for the given asset.
+    pub fn get_accounts() -> Result<Vec<ChainAccount>, Reason> {
+        Ok(core::get_accounts::<T>()?)
+    }
+
+    /// Get the all liquidity
+    pub fn get_accounts_liquidity() -> Result<Vec<(ChainAccount, String)>, Reason> {
+        let accounts: Vec<(ChainAccount, String)> = core::get_accounts_liquidity::<T>()?
+            .iter()
+            .map(|(chain_account, bal)| (chain_account.clone(), format!("{}", bal)))
+            .collect();
+        Ok(accounts)
+    }
+
+    /// Get the portfolio for the given chain account.
+    pub fn get_portfolio(account: ChainAccount) -> Result<Portfolio, Reason> {
+        Ok(core::get_portfolio::<T>(account)?)
+    }
 }
 
 impl<T: Config> frame_support::unsigned::ValidateUnsigned for Module<T> {