Merge branch 'master' of github.com:golemfactory/yagna

Author: nieznanysprawiciel

.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

.github/workflows/rust.yml

@@ -104,12 +104,13 @@ jobs:
     name: Run integration tests
     runs-on: goth
     needs: build
+    defaults:
+      run:
+        working-directory: './goth_tests'
+
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-        with:
-          repository: 'golemfactory/goth'
-          token: ${{ secrets.YAGNA_WORKFLOW_TOKEN }}
 
       - name: Configure python
         uses: actions/setup-python@v2
@@ -120,6 +121,7 @@ jobs:
         uses: Gr1N/setup-poetry@v4
         with:
           poetry-version: 1.1.4
+          working-directory: './goth_tests'
 
       - name: Install dependencies
         run: poetry install --no-root
@@ -140,7 +142,9 @@ jobs:
       - name: Run test suite
         env:
           GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: poetry run poe ci_test_self_hosted --yagna-binary-path=/tmp/yagna-build
+        run: |
+          poetry run poe goth-assets
+          poetry run poe goth-tests --config-override docker-compose.build-environment.binary-path=/tmp/yagna-build
 
       - name: Upload test logs
         uses: actions/upload-artifact@v2

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)
+}