provider: don't use providerAccounts

This relied on calling payment init, which is obsolete. The new solution
is to get the default identity and allow for specifying the complete
platform instead of just the network.

Author: kamirr

Cargo.toml

@@ -280,9 +280,9 @@ ya-service-api-interfaces = { path = "core/serv-api/interfaces" }
 ya-service-api-web = { path = "core/serv-api/web" }
 
 ## CLIENT
-ya-client = { git = "https://github.com/golemfactory/ya-client.git", rev = "b60640065835a1fc8eb33d2fb174ec6c0e4b30c4" }
+ya-client = { git = "https://github.com/golemfactory/ya-client.git", rev = "e3113709178fa31fc144e79a835c06afcc6f8a34" }
 #ya-client = { path = "../ya-client" }
-ya-client-model = { git = "https://github.com/golemfactory/ya-client.git", rev = "b60640065835a1fc8eb33d2fb174ec6c0e4b30c4" }
+ya-client-model = { git = "https://github.com/golemfactory/ya-client.git", rev = "e3113709178fa31fc144e79a835c06afcc6f8a34" }
 #ya-client-model = "0.7"
 golem-certificate = { git = "https://github.com/golemfactory/golem-certificate.git", rev = "f2d7514c18fc066e9cfb796090b90f5b27cfe1c6" }
 

agent/provider/src/provider_agent.rs

@@ -2,6 +2,7 @@ use actix::prelude::*;
 use anyhow::{anyhow, Error};
 use futures::{FutureExt, StreamExt, TryFutureExt};
 use ya_client::net::NetApi;
+use ya_core_model::NodeId;
 
 use std::convert::TryFrom;
 use std::path::{Path, PathBuf};
@@ -28,7 +29,9 @@ use crate::market::provider_market::{OfferKind, Shutdown as MarketShutdown, Unsu
 use crate::market::{CreateOffer, Preset, PresetManager, ProviderMarket};
 use crate::payments::{AccountView, LinearPricingOffer, Payments, PricingOffer};
 use crate::rules::RulesManager;
-use crate::startup_config::{FileMonitor, NodeConfig, ProviderConfig, RunConfig};
+use crate::startup_config::{
+    FileMonitor, PaymentPlatform, NodeConfig, ProviderConfig, RunConfig,
+};
 use crate::tasks::task_manager::{InitializeTaskManager, TaskManager};
 
 struct GlobalsManager {
@@ -77,9 +80,9 @@ pub struct ProviderAgent {
     task_manager: Addr<TaskManager>,
     presets: PresetManager,
     hardware: hardware::Manager,
-    accounts: Vec<AccountView>,
+    account: NodeId,
     log_handler: LoggerHandle,
-    networks: Vec<NetworkName>,
+    networks: Vec<PaymentPlatform>,
     rulestore_monitor: FileMonitor,
     keystore_monitor: FileMonitor,
     whitelist_monitor: FileMonitor,
@@ -116,14 +119,8 @@ impl ProviderAgent {
         let api = ProviderApi::try_from(&args.api)?;
 
         log::info!("Loading payment accounts...");
-        let accounts: Vec<AccountView> = api
-            .payment
-            .get_provider_accounts()
-            .await?
-            .into_iter()
-            .map(Into::into)
-            .collect();
-        log::info!("Payment accounts: {:#?}", accounts);
+        let account = api.identity.me().await?.identity;
+        log::info!("Payment account: {:#?}", account);
         let registry = config.registry()?;
         registry.validate()?;
         registry.test_runtimes(&data_dir).await?;
@@ -149,7 +146,7 @@ impl ProviderAgent {
 
         let networks = args.node.account.networks.clone();
         for n in networks.iter() {
-            let net_color = match n {
+            let net_color = match n.network {
                 NetworkName::Mainnet => yansi::Color::Magenta,
                 NetworkName::Polygon => yansi::Color::Magenta,
                 NetworkName::Rinkeby => yansi::Color::Cyan,
@@ -158,7 +155,7 @@ impl ProviderAgent {
                 NetworkName::Holesky => yansi::Color::Cyan,
                 _ => yansi::Color::Red,
             };
-            log::info!("Using payment network: {}", net_color.paint(&n));
+            log::info!("Using payment network: {}", net_color.paint(&n.network));
         }
 
         let mut globals = GlobalsManager::try_new(&config.globals_file, args.node)?;
@@ -186,7 +183,7 @@ impl ProviderAgent {
             task_manager,
             presets,
             hardware,
-            accounts,
+            account,
             log_handler,
             networks,
             rulestore_monitor,
@@ -317,56 +314,21 @@ impl ProviderAgent {
             .support_multi_activity(true))
     }
 
-    fn accounts(&self, networks: &Vec<NetworkName>) -> anyhow::Result<Vec<AccountView>> {
+    fn accounts(&self, networks: &Vec<PaymentPlatform>) -> anyhow::Result<Vec<AccountView>> {
         let globals = self.globals.get_state();
-        if let Some(address) = &globals.account {
-            log::info!(
-                "Filtering payment accounts by address={} and networks={:?}",
-                address,
-                networks,
-            );
-            let accounts: Vec<AccountView> = self
-                .accounts
-                .iter()
-                .filter(|acc| &acc.address == address && networks.contains(&acc.network))
-                .cloned()
-                .collect();
-
-            if accounts.is_empty() {
-                anyhow::bail!(
-                    "Payment account {} not initialized. Please run\n\
-                    \t`yagna payment init --receiver --network {} --account {}`\n\
-                    for all drivers you want to use.",
-                    address,
-                    networks[0],
-                    address,
-                )
-            }
 
-            Ok(accounts)
-        } else {
-            log::debug!("Filtering payment accounts by networks={:?}", networks);
-            let accounts: Vec<AccountView> = self
-                .accounts
-                .iter()
-                // FIXME: this is dirty fix -- we can get more that one address from this filter
-                // FIXME: use /me endpoint and filter out only accounts bound to given app-key
-                // FIXME: or introduce param to getProviderAccounts to filter out external account above
-                .filter(|acc| networks.contains(&acc.network))
-                .cloned()
-                .collect();
-
-            if accounts.is_empty() {
-                anyhow::bail!(
-                    "Default payment account not initialized. Please run\n\
-                    \t`yagna payment init --receiver --network {}`\n\
-                    for all drivers you want to use.",
-                    networks[0],
-                )
-            }
+        let account = globals.account.unwrap_or(self.account);
 
-            Ok(accounts)
-        }
+        let accounts: Vec<_> = networks
+            .iter()
+            .map(|network| AccountView {
+                address: account,
+                network: network.network.clone(),
+                platform: network.platform(),
+            })
+            .collect();
+
+        Ok(accounts)
     }
 }
 

agent/provider/src/startup_config.rs

@@ -1,18 +1,19 @@
+use std::convert::TryInto;
 use std::env;
 use std::error::Error;
 use std::path::{Path, PathBuf};
+use std::str::FromStr;
 use std::sync::mpsc;
 use std::time::Duration;
 
 use directories::UserDirs;
 use futures::channel::oneshot;
 use notify::*;
-use serde::{Deserialize, Serialize};
 use structopt::{clap, StructOpt};
 use strum::VariantNames;
 use ya_client::{cli::ApiOpts, model::node_id::NodeId};
 
-use ya_core_model::payment::local::NetworkName;
+use ya_core_model::payment::local::{DriverName, NetworkName, DEFAULT_PAYMENT_DRIVER};
 use ya_utils_path::data_dir::DataDir;
 
 use crate::cli::clean::CleanConfig;
@@ -142,7 +143,61 @@ impl ProviderConfig {
     }
 }
 
-#[derive(StructOpt, Clone, Debug, Serialize, Deserialize, derive_more::Display)]
+#[derive(Clone, Debug)]
+pub struct PaymentPlatform {
+    pub driver: String,
+    pub network: NetworkName,
+}
+
+impl PaymentPlatform {
+    pub fn platform(&self) -> String {
+        format!(
+            "{}-{}-{}",
+            self.driver,
+            self.network,
+            self.network.get_token()
+        )
+        .to_lowercase()
+    }
+}
+
+impl FromStr for PaymentPlatform {
+    type Err = String;
+
+    fn from_str(arg: &str) -> std::result::Result<Self, Self::Err> {
+        let value = if let Ok(network_name) = NetworkName::from_str(arg) {
+            PaymentPlatform {
+                driver: DEFAULT_PAYMENT_DRIVER.to_string(),
+                network: network_name,
+            }
+        } else {
+            let err = "Not a valid network or a platform";
+
+            let parts: [&str; 3] = arg
+                .split("-")
+                .collect::<Vec<_>>()
+                .try_into()
+                .map_err(|_| err.to_string())?;
+
+            if !DriverName::VARIANTS.contains(&parts[0]) {
+                return Err(err.to_string());
+            }
+            let network_name = NetworkName::from_str(&parts[1]).map_err(|_| err.to_string())?;
+            if parts[2] != network_name.get_token() {
+                return Err(err.to_string());
+            }
+
+            PaymentPlatform {
+                driver: parts[0].to_string(),
+                network: network_name,
+            }
+        };
+
+        Ok(value)
+    }
+}
+
+#[derive(StructOpt, Clone, Debug, derive_more::Display)]
 #[display(
     fmt = "{}Networks: {:?}",
     "account.map(|a| format!(\"Address: {}\n\", a)).unwrap_or_else(|| \"\".into())",
@@ -153,8 +208,13 @@ pub struct ReceiverAccount {
     #[structopt(long, env = "YA_ACCOUNT")]
     pub account: Option<NodeId>,
     /// Payment network.
-    #[structopt(long = "payment-network", env = "YA_PAYMENT_NETWORK", possible_values = NetworkName::VARIANTS, default_value = NetworkName::Mainnet.into())]
-    pub networks: Vec<NetworkName>,
+    #[structopt(
+        long = "payment-network",
+        env = "YA_PAYMENT_NETWORK",
+        default_value = NetworkName::Mainnet.into(),
+        help = "Specify platforms to collect funds, e.g. erc20-mainnet-glm. Network name can be passed as well, in which case the default driver will be used"
+    )]
+    pub networks: Vec<PaymentPlatform>,
 }
 
 #[derive(StructOpt, Clone, Debug)]

core/model/src/payment.rs

@@ -570,6 +570,12 @@ pub mod local {
         Mumbai,
     }
 
+    impl NetworkName {
+        pub fn get_token(&self) -> &'static str {
+            get_token_from_network_name(self)
+        }
+    }
+
     pub fn get_token_from_network_name(network_name: &NetworkName) -> &'static str {
         network_name
             .get_str("token")

core/serv-api/web/src/middleware/auth/mod.rs

@@ -87,7 +87,6 @@ where
         // TODO: remove this hack; possibly by enabling creation of arbitrary appkey from CLI
         if req.uri().to_string().starts_with("/metrics-api")
             || req.uri().to_string().starts_with("/version")
-            || req.uri().to_string().starts_with("/default-identity")
         {
             log::debug!("skipping authorization for uri={}", req.uri());
             return Box::pin(service.borrow_mut().call(req));

core/serv/src/main.rs

@@ -4,7 +4,6 @@ use actix_web::{middleware, web, App, HttpServer, Responder};
 use anyhow::{Context, Result};
 use futures::prelude::*;
 use metrics::{counter, gauge};
-use ya_core_model::identity;
 #[cfg(feature = "static-openssl")]
 extern crate openssl_probe;
 
@@ -569,7 +568,6 @@ impl ServiceCommand {
                         .wrap(auth::Auth::new(cors.cache()))
                         .wrap(cors.cors())
                         .route("/me", web::get().to(me))
-                        .route("/default-identity", web::get().to(default_identity))
                         .service(forward_gsb);
                     let rest = Services::rest(app, &context);
                     if count_started.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
@@ -684,17 +682,6 @@ async fn me(id: Identity) -> impl Responder {
     web::Json(id)
 }
 
-async fn default_identity() -> impl Responder {
-    let id = ya_service_bus::typed::service(identity::BUS_ID)
-        .call(identity::Get::ByDefault)
-        .await
-        .map_err(actix_web::error::ErrorInternalServerError)?
-        .map_err(actix_web::error::ErrorInternalServerError)?
-        .unwrap();
-
-    Ok::<_, actix_web::Error>(web::Json(id.node_id))
-}
-
 #[actix_web::post("/_gsb/{service:.*}")]
 async fn forward_gsb(
     id: Identity,