zksync driver deposit (enter CLI command) (#1208)

* Set up goth integration tests

Adds files necessary for running goth tests as part of yagna repository.
This also includes moving the VM E2E test from goth to yagna.

* Add dev-dependencies for goth tests

* Add --config-override option to goth tests

* Add VM test assets directory

* Include upload dir in VM assets

* add deposit as in the std example

* token needs to be approved before deposit

* feat: enter command

* feat: signing transactions works

* [after review] Gert-Jan comments

* [after review] Gert-Jan suggestions /2

* [after review] Adam comments

* Adam's comments /2

* Add e2e WASI integration test

* Add ya-provider multi-activity integration test

* Add payments integration tests

* Specify goth patch version explicitly

* Update poetry.lock

* Add integration tests readme

* Review: update integration tests readme

* Review: make config_overrides non-optional

* Review: move task packages to activity helpers module

Co-authored-by: Kuba Mazurek <[email protected]>

Author: pnowosie

.env-template

@@ -37,10 +37,12 @@ YAGNA_DATADIR="."
 #ACCOUNT_LIST="${YAGNA_DATADIR}/accounts.json"
 #PAYMENT_SHUTDOWN_TIMEOUT_SECS=10
 
+## All drivers
+#RINKEBY_GETH_ADDR=http://1.geth.testnet.golem.network:55555
+#MAINNET_GETH_ADDR=https://geth.golem.network:55555
+
 ## ERC20 driver.
 #ETH_FAUCET_ADDRESS=http://faucet.testnet.golem.network:4000/donate
-#ERC20_RINKEBY_GETH_ADDR=http://1.geth.testnet.golem.network:55555
-#ERC20_MAINNET_GETH_ADDR=https://geth.golem.network:55555
 #ERC20_RINKEBY_REQUIRED_CONFIRMATIONS=3
 #ERC20_MAINNET_REQUIRED_CONFIRMATIONS=5
 #RINKEBY_TGLM_CONTRACT_ADDRESS=0xd94e3DC39d4Cad1DAd634e7eb585A57A19dC7EFE
@@ -52,6 +54,7 @@ YAGNA_DATADIR="."
 ## ZkSync driver
 #ZKSYNC_RINKEBY_RPC_ADDRESS=https://rinkeby-api.zksync.io/jsrpc
 #ZKSYNC_MAINNET_RPC_ADDRESS=https://api.zksync.io/jsrpc
+#ZKSYNC_ETH_CONFIRMATION_TIMEOUT_SECONDS=60
 #ZKSYNC_FAUCET_ADDR=
 #ZKSYNC_SENDOUT_INTERVAL_SECS=10
 #ZKSYNC_CONFIRMATION_INTERVAL_SECS=5

Cargo.lock

@@ -332,10 +332,10 @@ impl RpcMessage for ValidateAllocation {
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Enter {
-    amount: BigDecimal,
-    address: String,
-    network: Option<String>,
-    token: Option<String>,
+    pub amount: BigDecimal,
+    pub address: String,
+    pub network: Option<String>,
+    pub token: Option<String>,
 }
 
 impl Enter {

core/model/src/driver.rs

@@ -195,9 +195,9 @@ pub async fn get_tx_receipt(
 
 fn get_rpc_addr_from_env(network: Network) -> String {
     match network {
-        Network::Mainnet => std::env::var("ERC20_MAINNET_GETH_ADDR")
+        Network::Mainnet => std::env::var("MAINNET_GETH_ADDR")
             .unwrap_or("https://geth.golem.network:55555".to_string()),
-        Network::Rinkeby => std::env::var("ERC20_RINKEBY_GETH_ADDR")
+        Network::Rinkeby => std::env::var("RINKEBY_GETH_ADDR")
             .unwrap_or("http://geth.testnet.golem.network:55555".to_string()),
     }
 }

core/payment-driver/erc20/src/erc20/ethereum.rs

@@ -20,6 +20,7 @@ log = "0.4.8"
 maplit = "1.0"
 metrics-macros = "=0.1.0-alpha.5"
 num-bigint = { version = "0.3", features = ["serde"] }
+rlp = "0.4"
 serde = "1.0"
 serde_json = "^1.0"
 tiny-keccak = "1.4.2"

core/payment-driver/zksync/Cargo.toml

@@ -0,0 +1,41 @@
+#[macro_use]
+extern crate log;
+
+use bigdecimal::BigDecimal;
+use std::str::FromStr;
+use ya_payment_driver::db::models::Network as DbNetwork;
+use ya_zksync_driver::zksync::wallet as driver_wallet;
+use zksync::zksync_types::H256;
+use zksync::{Network, RpcProvider, Wallet, WalletCredentials};
+use zksync_eth_signer::{EthereumSigner, PrivateKeySigner};
+
+const PRIVATE_KEY: &str = "e0c704b6e925c3be222337f9c94610c46b7fec95c14b8f5b9800d20ed4782670";
+
+#[actix_rt::main]
+async fn main() -> anyhow::Result<()> {
+    let log_level = std::env::var("RUST_LOG").unwrap_or("info".to_owned());
+    std::env::set_var("RUST_LOG", log_level);
+    env_logger::init();
+
+    dotenv::dotenv().expect("Failed to read .env file");
+
+    let private_key = H256::from_str(PRIVATE_KEY).expect("Cannot decode bytes from hex-encoded PK");
+    let signer = PrivateKeySigner::new(private_key);
+    let address = signer.get_address().await?;
+    info!("Account address {:#x}", address);
+
+    info!("Creating wallet");
+    let provider = RpcProvider::new(Network::Rinkeby);
+    let cred = WalletCredentials::from_eth_signer(address, signer, Network::Rinkeby).await?;
+    let wallet = Wallet::new(provider, cred).await?;
+
+    let one_tglm = BigDecimal::from(1);
+
+    let deposit_tx_hash = driver_wallet::deposit(wallet, DbNetwork::Rinkeby, one_tglm).await?;
+    info!(
+        "Check out deposit transaction at https://rinkeby.etherscan.io/tx/{:#x}",
+        deposit_tx_hash
+    );
+
+    Ok(())
+}

core/payment-driver/zksync/examples/deposit.rs

@@ -175,8 +175,14 @@ impl PaymentDriver for ZksyncDriver {
         _caller: String,
         msg: Enter,
     ) -> Result<String, GenericError> {
-        log::info!("ENTER = Not Implemented: {:?}", msg);
-        Ok("NOT_IMPLEMENTED".to_string())
+        let tx_hash = wallet::enter(msg).await?;
+
+        Ok(format!(
+            "Deposit transaction has been sent on Ethereum and soon funds should be available \
+        on ZkSync network. You can check transaction status in the block explorer. \
+        Tracking link: https://rinkeby.zkscan.io/explorer/transactions/{}",
+            tx_hash
+        ))
     }
 
     async fn exit(

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

@@ -9,6 +9,7 @@
 // External uses
 use async_trait::async_trait;
 use futures::{Future, FutureExt};
+use rlp::RlpStream;
 use std::pin::Pin;
 use tiny_keccak::keccak256;
 use tokio::task;
@@ -56,9 +57,16 @@ impl EthereumSigner for YagnaEthSigner {
         Ok(tx_eth_sig)
     }
 
-    async fn sign_transaction(&self, _raw_tx: RawTransaction) -> Result<Vec<u8>, SignerError> {
+    async fn sign_transaction(&self, raw_tx: RawTransaction) -> Result<Vec<u8>, SignerError> {
         log::debug!("YagnaEthSigner sign_transaction");
-        todo!();
+
+        let node_id = self.eth_address.as_bytes().into();
+        let payload: Vec<u8> = raw_tx.hash().into();
+        let chain_id = raw_tx.chain_id as u64;
+
+        let signature = sign_tx(node_id, payload.clone()).await?;
+
+        Ok(encode_signed_tx(&raw_tx, signature, chain_id))
     }
 }
 
@@ -105,3 +113,56 @@ fn sign_tx(
     });
     Box::pin(fut)
 }
+
+fn encode_signed_tx(raw_tx: &RawTransaction, signature: Vec<u8>, chain_id: u64) -> Vec<u8> {
+    let (sig_v, sig_r, sig_s) = prepare_signature(signature, chain_id);
+
+    let mut tx = RlpStream::new();
+
+    tx.begin_unbounded_list();
+
+    tx_encode(&raw_tx, &mut tx);
+    tx.append(&sig_v);
+    tx.append(&sig_r);
+    tx.append(&sig_s);
+
+    tx.finalize_unbounded_list();
+
+    tx.out()
+}
+
+fn prepare_signature(signature: Vec<u8>, chain_id: u64) -> (u64, Vec<u8>, Vec<u8>) {
+    // TODO ugly solution
+    assert_eq!(signature.len(), 65);
+
+    let sig_v = signature[0];
+    let sig_v = sig_v as u64 + chain_id * 2 + 35;
+
+    let mut sig_r = signature.to_owned().split_off(1);
+    let mut sig_s = sig_r.split_off(32);
+
+    prepare_signature_part(&mut sig_r);
+    prepare_signature_part(&mut sig_s);
+
+    (sig_v, sig_r, sig_s)
+}
+
+fn prepare_signature_part(part: &mut Vec<u8>) {
+    assert_eq!(part.len(), 32);
+    while part[0] == 0 {
+        part.remove(0);
+    }
+}
+
+fn tx_encode(tx: &RawTransaction, s: &mut RlpStream) {
+    s.append(&tx.nonce);
+    s.append(&tx.gas_price);
+    s.append(&tx.gas);
+    if let Some(ref t) = tx.to {
+        s.append(t);
+    } else {
+        s.append(&vec![]);
+    }
+    s.append(&tx.value);
+    s.append(&tx.data);
+}

core/payment-driver/zksync/src/zksync/signer.rs

@@ -12,7 +12,7 @@ use zksync::types::BlockStatus;
 use zksync::zksync_types::{
     tokens::{ChangePubKeyFeeType, ChangePubKeyFeeTypeArg},
     tx::TxHash,
-    Address, Nonce, TxFeeTypes,
+    Address, Nonce, TxFeeTypes, H256,
 };
 use zksync::{
     provider::{Provider, RpcProvider},
@@ -23,7 +23,8 @@ use zksync_eth_signer::EthereumSigner;
 // Workspace uses
 use ya_payment_driver::{
     db::models::Network,
-    model::{AccountMode, Exit, GenericError, Init, PaymentDetails},
+    model::{AccountMode, Enter, Exit, GenericError, Init, PaymentDetails},
+    utils as base_utils,
 };
 
 // Local uses
@@ -120,6 +121,16 @@ pub async fn exit(msg: &Exit) -> Result<String, GenericError> {
     }
 }
 
+pub async fn enter(msg: Enter) -> Result<String, GenericError> {
+    let network = msg.network.unwrap_or(DEFAULT_NETWORK.to_string());
+    let network = Network::from_str(&network).map_err(|e| GenericError::new(e))?;
+    let wallet = get_wallet(&msg.address, network).await?;
+
+    let tx_hash = deposit(wallet, network, msg.amount).await?;
+
+    Ok(hex::encode(tx_hash.as_fixed_bytes()))
+}
+
 pub async fn get_tx_fee(address: &str, network: Network) -> Result<BigDecimal, GenericError> {
     let token = get_network_token(network, None);
     let wallet = get_wallet(&address, network).await?;
@@ -276,6 +287,21 @@ fn get_rpc_addr(network: Network) -> String {
     }
 }
 
+fn get_ethereum_node_addr_from_env(network: Network) -> String {
+    match network {
+        Network::Mainnet => {
+            env::var("MAINNET_GETH_ADDR").unwrap_or("https://geth.golem.network:55555".to_string())
+        }
+        Network::Rinkeby => env::var("RINKEBY_GETH_ADDR")
+            .unwrap_or("http://geth.testnet.golem.network:55555".to_string()),
+    }
+}
+
+fn get_ethereum_confirmation_timeout() -> std::time::Duration {
+    let value = std::env::var("ZKSYNC_ETH_CONFIRMATION_TIMEOUT_SECONDS").unwrap_or("60".to_owned());
+    std::time::Duration::from_secs(value.parse::<u64>().unwrap())
+}
+
 async fn get_wallet(
     address: &str,
     network: Network,
@@ -448,3 +474,57 @@ async fn get_unlock_fee<S: EthereumSigner + Clone, P: Provider + Clone>(
         .total_fee;
     Ok(unlock_fee)
 }
+
+pub async fn deposit<S: EthereumSigner + Clone, P: Provider + Clone>(
+    wallet: Wallet<S, P>,
+    network: Network,
+    amount: BigDecimal,
+) -> Result<H256, GenericError> {
+    let token = get_network_token(network, None);
+    let amount = base_utils::big_dec_to_u256(amount);
+    let address = wallet.address();
+
+    log::info!(
+        "Starting deposit into ZkSync network. Address {:#x}, amount: {} of {}",
+        address,
+        amount,
+        token
+    );
+
+    let mut ethereum = wallet
+        .ethereum(get_ethereum_node_addr_from_env(network))
+        .await
+        .map_err(|err| GenericError::new(err))?;
+    ethereum.set_confirmation_timeout(get_ethereum_confirmation_timeout());
+
+    if !ethereum
+        .is_limited_erc20_deposit_approved(token.as_str(), amount)
+        .await
+        .unwrap()
+    {
+        let tx = ethereum
+            .limited_approve_erc20_token_deposits(token.as_str(), amount)
+            .await
+            .map_err(|err| GenericError::new(err))?;
+        info!(
+            "Approve erc20 token for ZkSync deposit. Tx: https://rinkeby.etherscan.io/tx/{:#x}",
+            tx
+        );
+
+        ethereum
+            .wait_for_tx(tx)
+            .await
+            .map_err(|err| GenericError::new(err))?;
+    }
+
+    let deposit_tx_hash = ethereum
+        .deposit(token.as_str(), amount, address)
+        .await
+        .map_err(|err| GenericError::new(err))?;
+    info!(
+        "Check out deposit transaction at https://rinkeby.etherscan.io/tx/{:#x}",
+        deposit_tx_hash
+    );
+
+    Ok(deposit_tx_hash)
+}

core/payment-driver/zksync/src/zksync/wallet.rs

@@ -41,13 +41,14 @@ pub enum PaymentCli {
         account: pay::AccountCli,
     },
 
-    // TODO: Uncomment when operation is supported by drivers
-    // Enter {
-    //     #[structopt(flatten)]
-    //     account: AccountCli,
-    //     #[structopt(long)]
-    //     amount: String,
-    // },
+    /// Enter layer 2 (deposit funds to layer 2 network)
+    Enter {
+        #[structopt(flatten)]
+        account: pay::AccountCli,
+        #[structopt(long)]
+        amount: String,
+    },
+
     /// Exit layer 2 (withdraw funds to Ethereum)
     Exit {
         #[structopt(flatten)]
@@ -215,17 +216,16 @@ impl PaymentCli {
                         .await??,
                 )
             }
-            // TODO: Uncomment when operation is supported by drivers
-            // PaymentCli::Enter {
-            //     account,
-            //     driver,
-            //     network,
-            //     amount
-            // } => {
-            //     let address = resolve_address(account).await?;
-            //     let amount = BigDecimal::from_str(&amount)?;
-            //     CommandOutput::object(wallet::enter(amount, address, driver, network, token).await?)
-            // }
+            PaymentCli::Enter { account, amount } => CommandOutput::object(
+                wallet::enter(
+                    BigDecimal::from_str(&amount)?,
+                    resolve_address(account.address()).await?,
+                    account.driver(),
+                    Some(account.network()),
+                    None,
+                )
+                .await?,
+            ),
             PaymentCli::Exit {
                 account,
                 to_address,