Payments: Mainnet/testnet preparation

Introduced changes to the payment service and payment driver API
necessary for supporting both mainnet and testnet in a single Yagna
daemon process. This changes require drivers to be network-aware.

Signed-off-by: Adam Wierzbicki <awierzbicki@golem.network>

Cargo.toml

@@ -172,8 +172,8 @@ ya-sb-router = { path = "service-bus/router" }
 ya-sb-util = { path = "service-bus/util" }
 
 ## CLIENT
-ya-client = { git = "https://github.com/golemfactory/ya-client.git", branch = "event-api/master"}
-ya-client-model = { git = "https://github.com/golemfactory/ya-client.git", branch = "event-api/master"}
+ya-client = { git = "https://github.com/golemfactory/ya-client.git", rev = "94f4cc5844477374f97dacfa22a53a15f3a59ada"}
+ya-client-model = { git = "https://github.com/golemfactory/ya-client.git", rev = "94f4cc5844477374f97dacfa22a53a15f3a59ada"}
 
 #ya-client = { path = "../ya-client" }
 #ya-client-model = { path = "../ya-client/model" }

agent/provider/src/payments/mod.rs

@@ -6,4 +6,4 @@ mod pricing;
 
 pub use factory::PaymentModelFactory;
 pub use payments::Payments;
-pub use pricing::{LinearPricing, LinearPricingOffer, PricingOffer};
+pub use pricing::{AccountView, LinearPricing, LinearPricingOffer, PricingOffer};

agent/provider/src/payments/pricing.rs

@@ -8,11 +8,26 @@ use ya_client_model::payment::Account;
 use super::model::{PaymentDescription, PaymentModel};
 use crate::market::presets::{Coefficient, Preset};
 
+#[derive(Clone, Debug)]
+pub struct AccountView {
+    pub address: String,
+    pub platform: String,
+}
+
+impl From<Account> for AccountView {
+    fn from(account: Account) -> Self {
+        Self {
+            address: account.address,
+            platform: account.platform,
+        }
+    }
+}
+
 pub trait PricingOffer {
     fn prices(&self, preset: &Preset) -> Vec<(Coefficient, f64)>;
     fn build(
         &self,
-        accounts: &Vec<Account>,
+        accounts: &Vec<AccountView>,
         initial_price: f64,
         prices: Vec<(String, f64)>,
     ) -> Result<ComInfo>;
@@ -89,7 +104,7 @@ impl PricingOffer for LinearPricingOffer {
 
     fn build(
         &self,
-        accounts: &Vec<Account>,
+        accounts: &Vec<AccountView>,
         initial_price: f64,
         prices: Vec<(String, f64)>,
     ) -> Result<ComInfo> {

agent/provider/src/provider_agent.rs

@@ -5,7 +5,7 @@ use crate::execution::{
 use crate::hardware;
 use crate::market::provider_market::{OfferKind, Shutdown as MarketShutdown, Unsubscribe};
 use crate::market::{CreateOffer, Preset, PresetManager, ProviderMarket};
-use crate::payments::{LinearPricingOffer, Payments, PricingOffer};
+use crate::payments::{AccountView, LinearPricingOffer, Payments, PricingOffer};
 use crate::startup_config::{FileMonitor, NodeConfig, ProviderConfig, RecvAccount, RunConfig};
 use crate::tasks::task_manager::{InitializeTaskManager, TaskManager};
 
@@ -23,7 +23,6 @@ use std::{fs, io};
 use ya_agreement_utils::agreement::TypedArrayPointer;
 use ya_agreement_utils::*;
 use ya_client::cli::ProviderApi;
-use ya_client_model::payment::Account;
 use ya_utils_actix::actix_handler::send_message;
 use ya_utils_path::SwapSave;
 
@@ -34,7 +33,7 @@ pub struct ProviderAgent {
     task_manager: Addr<TaskManager>,
     presets: PresetManager,
     hardware: hardware::Manager,
-    accounts: Vec<Account>,
+    accounts: Vec<AccountView>,
 }
 
 struct GlobalsManager {
@@ -127,7 +126,13 @@ impl ProviderAgent {
         let api = ProviderApi::try_from(&args.api)?;
 
         log::info!("Loading payment accounts...");
-        let accounts: Vec<Account> = api.payment.get_provider_accounts().await?;
+        let accounts: Vec<AccountView> = api
+            .payment
+            .get_provider_accounts()
+            .await?
+            .into_iter()
+            .map(Into::into)
+            .collect();
         log::info!("Payment accounts: {:#?}", accounts);
         let registry = config.registry()?;
         registry.validate()?;
@@ -171,7 +176,7 @@ impl ProviderAgent {
         inf_node_info: InfNodeInfo,
         runner: Addr<TaskRunner>,
         market: Addr<ProviderMarket>,
-        accounts: Vec<Account>,
+        accounts: Vec<AccountView>,
     ) -> anyhow::Result<()> {
         if presets.is_empty() {
             return Err(anyhow!("No Presets were selected. Can't create offers."));
@@ -252,19 +257,19 @@ impl ProviderAgent {
         node_info
     }
 
-    fn accounts(&self) -> Vec<Account> {
+    fn accounts(&self) -> Vec<AccountView> {
         let globals = self.globals.get_state();
         if let Some(account) = &globals.account {
             let mut accounts = Vec::new();
             if account.platform.is_some() {
-                let zkaddr = Account {
+                let zkaddr = AccountView {
                     platform: account.platform.clone().unwrap(),
                     address: account.address.to_lowercase(),
                 };
                 accounts.push(zkaddr);
             } else {
-                for &platform in &["NGNT", "ZK-NGNT"] {
-                    accounts.push(Account {
+                for &platform in &["erc20-rinkeby-tglm", "zksync-rinkeby-tglm"] {
+                    accounts.push(AccountView {
                         platform: platform.to_string(),
                         address: account.address.to_lowercase(),
                     })

agent/provider/src/startup_config.rs

@@ -112,8 +112,8 @@ impl FromStr for RecvAccount {
             (Some(driver), Some(addr), None) => {
                 let platform = Some(
                     match driver {
-                        "zksync" | "zk" => "ZK-NGNT",
-                        "eth" | "l1" => "NGTN",
+                        "zksync" | "zk" => "zksync-rinkeby-tglm",
+                        "eth" | "l1" => "erc20-rinkeby-tglm",
                         _ => anyhow::bail!("unknown driver: {}", driver),
                     }
                     .to_string(),

core/model/src/driver.rs

@@ -116,12 +116,24 @@ impl RpcMessage for VerifyPayment {
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Init {
     address: String,
+    network: Option<String>,
+    token: Option<String>,
     mode: AccountMode,
 }
 
 impl Init {
-    pub fn new(address: String, mode: AccountMode) -> Init {
-        Init { address, mode }
+    pub fn new(
+        address: String,
+        network: Option<String>,
+        token: Option<String>,
+        mode: AccountMode,
+    ) -> Init {
+        Init {
+            address,
+            network,
+            token,
+            mode,
+        }
     }
     pub fn address(&self) -> String {
         self.address.clone()

core/model/src/payment.rs

@@ -21,6 +21,7 @@ pub mod local {
     use crate::driver::{AccountMode, PaymentConfirmation};
     use bigdecimal::{BigDecimal, Zero};
     use chrono::{DateTime, Utc};
+    use std::collections::HashMap;
     use std::fmt::Display;
     use ya_client_model::NodeId;
 
@@ -129,17 +130,37 @@ pub mod local {
     #[error("")]
     pub struct NoError {} // This is needed because () doesn't implement Display
 
+    #[derive(Clone, Debug, Serialize, Deserialize)]
+    pub struct Network {
+        pub default_token: String,
+        pub tokens: HashMap<String, String>, // token -> platform
+    }
+
+    #[derive(Clone, Debug, Serialize, Deserialize)]
+    pub struct DriverDetails {
+        pub default_network: String,
+        pub networks: HashMap<String, Network>,
+        pub recv_init_required: bool, // Is account initialization required for receiving payments
+    }
+
     #[derive(Clone, Debug, Serialize, Deserialize)]
     pub struct RegisterDriver {
         pub driver_name: String,
-        pub platform: String,
-        pub recv_init_required: bool, // Is account initialization required for receiving payments
+        pub details: DriverDetails,
+    }
+
+    #[derive(Clone, Debug, Serialize, Deserialize, thiserror::Error)]
+    pub enum RegisterDriverError {
+        #[error("Invalid default token specified: token={0}, network={1}")]
+        InvalidDefaultToken(String, String),
+        #[error("Invalid default network specified: {0}")]
+        InvalidDefaultNetwork(String),
     }
 
     impl RpcMessage for RegisterDriver {
         const ID: &'static str = "RegisterDriver";
         type Item = ();
-        type Error = NoError;
+        type Error = RegisterDriverError;
     }
 
     #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -153,9 +174,10 @@ pub mod local {
 
     #[derive(Clone, Debug, Serialize, Deserialize)]
     pub struct RegisterAccount {
-        pub platform: String,
         pub address: String,
         pub driver: String,
+        pub network: String,
+        pub token: String,
         pub mode: AccountMode,
     }
 
@@ -165,6 +187,10 @@ pub mod local {
         AlreadyRegistered(String, String),
         #[error("Driver not registered: {0}")]
         DriverNotRegistered(String),
+        #[error("Network not supported by driver: network={0}, driver={1}")]
+        UnsupportedNetwork(String, String),
+        #[error("Token not supported by driver: token={0}, network={1}, driver={2}")]
+        UnsupportedToken(String, String, String),
         #[error("Error while registering account: {0}")]
         Other(String),
     }
@@ -190,6 +216,7 @@ pub mod local {
     #[derive(Clone, Debug, Serialize, Deserialize)]
     pub struct NotifyPayment {
         pub driver: String,
+        pub platform: String,
         pub amount: BigDecimal,
         pub sender: String,
         pub recipient: String,
@@ -287,15 +314,6 @@ pub mod local {
     #[derive(Clone, Debug, Serialize, Deserialize)]
     pub struct GetAccounts {}
 
-    #[derive(Clone, Debug, Serialize, Deserialize)]
-    pub struct Account {
-        pub platform: String,
-        pub address: String,
-        pub driver: String,
-        pub send: bool,
-        pub receive: bool,
-    }
-
     impl RpcMessage for GetAccounts {
         const ID: &'static str = "GetAccounts";
         type Item = Vec<Account>;

core/payment-driver/base/src/bus.rs

@@ -70,8 +70,11 @@ pub async fn bind_service<Driver: PaymentDriver + 'static>(
     log::debug!("Registering driver in payment service...");
     let message = payment_srv::RegisterDriver {
         driver_name: driver.get_name(),
-        platform: driver.get_platform(),
-        recv_init_required: driver.recv_init_required(),
+        details: payment_srv::DriverDetails {
+            default_network: driver.get_default_network(),
+            networks: Default::default(),
+            recv_init_required: driver.recv_init_required(),
+        },
     };
     service(payment_srv::BUS_ID).send(message).await?.unwrap(); // Unwrap on purpose because it's NoError
     log::debug!("Successfully registered driver in payment service.");
@@ -102,13 +105,15 @@ pub async fn list_unlocked_identities() -> Result<Vec<NodeId>, GenericError> {
 pub async fn register_account(
     driver: &(dyn PaymentDriver),
     address: &str,
+    network: &str,
+    token: &str,
     mode: AccountMode,
 ) -> Result<(), GenericError> {
-    let address = address.to_string();
     let msg = payment_srv::RegisterAccount {
-        platform: driver.get_platform(),
-        address,
+        address: address.to_string(),
         driver: driver.get_name(),
+        network: network.to_string(),
+        token: token.to_string(),
         mode,
     };
     service(payment_srv::BUS_ID)
@@ -130,12 +135,14 @@ pub async fn sign(node_id: NodeId, payload: Vec<u8>) -> Result<Vec<u8>, GenericE
 
 pub async fn notify_payment(
     driver_name: &str,
+    platform: &str,
     order_ids: Vec<String>,
     details: &PaymentDetails,
     confirmation: Vec<u8>,
 ) -> Result<(), GenericError> {
     let msg = payment_srv::NotifyPayment {
         driver: driver_name.to_string(),
+        platform: platform.to_string(),
         amount: details.amount.clone(),
         sender: details.sender.clone(),
         recipient: details.recipient.clone(),

core/payment-driver/base/src/driver.rs

@@ -13,8 +13,10 @@ use crate::model::*;
 // Public revealed uses, required to implement this trait
 pub use async_trait::async_trait;
 pub use bigdecimal::BigDecimal;
+use std::collections::HashMap;
 pub use ya_client_model::NodeId;
 pub use ya_core_model::identity::{event::Event as IdentityEvent, Error as IdentityError};
+pub use ya_core_model::payment::local::Network;
 
 #[async_trait(?Send)]
 pub trait PaymentDriver {
@@ -34,7 +36,8 @@ pub trait PaymentDriver {
 
     // used by bus to bind service
     fn get_name(&self) -> String;
-    fn get_platform(&self) -> String;
+    fn get_default_network(&self) -> String;
+    fn get_networks(&self) -> HashMap<String, Network>;
     fn recv_init_required(&self) -> bool;
 
     async fn get_transaction_balance(