refactor: Fix ethereum deploy script

Cargo.toml

@@ -118,7 +118,7 @@ primitive-types = { version = "0.12.2", default-features = false }
 binary-merkle-tree = { version = "4.0.0-dev", git = "https://github.com/gear-tech/polkadot-sdk.git", branch = "gear-v1.3.0", default-features = false }
 
 # Alloy deps
-alloy = { git = "https://github.com/alloy-rs/alloy.git", package = "alloy", rev = "899b8b9", features = [
+alloy = { version = "0.2.0", package = "alloy", features = [
     "sol-types",
     "contract",
     "pubsub",

ethereum/client/src/tests.rs

@@ -1,8 +1,8 @@
 use alloy::{
     hex::FromHex,
-    network::Ethereum,
+    network::{Ethereum, EthereumWallet, NetworkWallet},
     primitives::{Address, Bytes, B256, U256},
-    providers::{Provider, ProviderBuilder},
+    providers::{Provider, ProviderBuilder, WalletProvider},
     sol,
     transports::Transport,
 };
@@ -90,45 +90,43 @@ where
     Ok(contracts)
 }
 
-async fn deploy<P, T>(provider: P) -> Result<DeploymentEnv, Error>
+async fn deploy<P, T>(provider: P, signer_address: Address) -> Result<DeploymentEnv, Error>
 where
     T: Transport + Clone,
     P: Provider<T, Ethereum> + Send + Sync + Clone + 'static,
 {
-    let vwara_erc20_mock = ERC20Mock::deploy(provider.clone(), "wVARA".to_string())
+    let relayer_proxy = ProxyContract::deploy(provider.clone())
         .await
         .map_err(Error::ErrorDuringContractExecution)?;
-    let verifier_mock = VerifierMock::deploy(provider.clone())
+
+    let message_queue_proxy = ProxyContract::deploy(provider.clone())
         .await
         .map_err(Error::ErrorDuringContractExecution)?;
 
-    let relayer = Relayer::deploy(provider.clone())
+    let erc20_treasury_proxy = ProxyContract::deploy(provider.clone())
         .await
         .map_err(Error::ErrorDuringContractExecution)?;
 
-    let erc20_treasury = ERC20Treasury::deploy(provider.clone())
+    let vwara_erc20_mock = ERC20Mock::deploy(provider.clone(), "wVARA".to_string())
         .await
         .map_err(Error::ErrorDuringContractExecution)?;
-
-    let message_queue = MessageQueue::deploy(provider.clone())
+    let verifier_mock = VerifierMock::deploy(provider.clone())
         .await
         .map_err(Error::ErrorDuringContractExecution)?;
 
-    let relayer_proxy = ProxyContract::deploy(provider.clone(), *relayer.address(), Bytes::new())
+    let relayer = Relayer::deploy(provider.clone(), *verifier_mock.address())
         .await
         .map_err(Error::ErrorDuringContractExecution)?;
 
-    let message_queue_proxy =
-        ProxyContract::deploy(provider.clone(), *message_queue.address(), Bytes::new())
-            .await
-            .map_err(Error::ErrorDuringContractExecution)?;
+    let erc20_treasury = ERC20Treasury::deploy(provider.clone(), *message_queue_proxy.address())
+        .await
+        .map_err(Error::ErrorDuringContractExecution)?;
 
-    let erc20_treasury_proxy =
-        ProxyContract::deploy(provider.clone(), *message_queue.address(), Bytes::new())
-            .await
-            .map_err(Error::ErrorDuringContractExecution)?;
+    let message_queue = MessageQueue::deploy(provider.clone(), *relayer_proxy.address())
+        .await
+        .map_err(Error::ErrorDuringContractExecution)?;
 
-    Ok(DeploymentEnv {
+    let deployment = DeploymentEnv {
         wvara_erc20: *vwara_erc20_mock.address(),
         verifier: *verifier_mock.address(),
         message_queue: *message_queue.address(),
@@ -137,7 +135,68 @@ where
         message_queue_proxy: *message_queue_proxy.address(),
         relayer_proxy: *relayer_proxy.address(),
         erc20_treasury_proxy: *erc20_treasury_proxy.address(),
-    })
+    };
+
+    let nonce = provider
+        .get_transaction_count(signer_address)
+        .await
+        .map_err(|_| Error::ErrorInHTTPTransport)?;
+
+    let relayer_proxy = ProxyContract::new(deployment.relayer_proxy, provider.clone());
+
+    let pending_tx = relayer_proxy
+        .upgradeToAndCall(deployment.relayer, Bytes::new())
+        .nonce(nonce);
+
+    let pending_tx = pending_tx
+        .send()
+        .await
+        .map_err(Error::ErrorDuringContractExecution)?;
+
+    pending_tx
+        .get_receipt()
+        .await
+        .map_err(|_| Error::ErrorWaitingTransactionReceipt)?;
+
+    let nonce = provider
+        .get_transaction_count(signer_address)
+        .await
+        .map_err(|_| Error::ErrorInHTTPTransport)?;
+
+    let pending_tx = message_queue_proxy
+        .upgradeToAndCall(deployment.message_queue, Bytes::new())
+        .nonce(nonce);
+
+    let pending_tx = pending_tx
+        .send()
+        .await
+        .map_err(Error::ErrorDuringContractExecution)?;
+
+    pending_tx
+        .get_receipt()
+        .await
+        .map_err(|_| Error::ErrorWaitingTransactionReceipt)?;
+
+    let nonce = provider
+        .get_transaction_count(signer_address)
+        .await
+        .map_err(|_| Error::ErrorInHTTPTransport)?;
+
+    let pending_tx = erc20_treasury_proxy
+        .upgradeToAndCall(deployment.erc20_treasury, Bytes::new())
+        .nonce(nonce);
+
+    let pending_tx = pending_tx
+        .send()
+        .await
+        .map_err(Error::ErrorDuringContractExecution)?;
+
+    pending_tx
+        .get_receipt()
+        .await
+        .map_err(|_| Error::ErrorWaitingTransactionReceipt)?;
+
+    Ok(deployment.clone())
 }
 
 fn get_test_block_merkle_proof() -> BlockMerkleRootProof {
@@ -158,7 +217,12 @@ async fn verify_block() {
     let provider = ProviderBuilder::new()
         .with_recommended_fillers()
         .on_anvil_with_wallet();
-    let deployment_env = deploy(provider.clone()).await.unwrap();
+
+    let signer_address = provider.wallet();
+    let signer_address =
+        <EthereumWallet as NetworkWallet<Ethereum>>::default_signer_address(signer_address);
+
+    let deployment_env = deploy(provider.clone(), signer_address).await.unwrap();
 
     let contracts = build_contracts(provider, &deployment_env).unwrap();
 
@@ -204,7 +268,12 @@ async fn verify_block_with_events() {
     let provider = ProviderBuilder::new()
         .with_recommended_fillers()
         .on_anvil_with_wallet();
-    let deployment_env = deploy(provider.clone()).await.unwrap();
+
+    let signer_address = provider.wallet();
+    let signer_address =
+        <EthereumWallet as NetworkWallet<Ethereum>>::default_signer_address(signer_address);
+
+    let deployment_env = deploy(provider.clone(), signer_address).await.unwrap();
 
     let contracts = build_contracts(provider, &deployment_env).unwrap();
 

ethereum/script/Deploy.s.sol

@@ -6,6 +6,7 @@ import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 
 import {Test, console} from "forge-std/Test.sol";
 import {Verifier} from "../src/Verifier.sol";
+import {Verifier as VerifierMock} from "../src/mocks/VerifierMock.sol";
 import {Relayer} from "../src/Relayer.sol";
 
 import {ERC20Treasury} from "../src/ERC20Treasury.sol";
@@ -14,6 +15,9 @@ import {IERC20Treasury} from "../src/interfaces/IERC20Treasury.sol";
 import {MessageQueue} from "../src/MessageQueue.sol";
 import {ProxyContract} from "../src/ProxyContract.sol";
 
+import {IVerifier} from "../src/interfaces/IVerifier.sol";
+
+
 import {ERC20Mock} from "../src/mocks/ERC20Mock.sol";
 
 
@@ -29,23 +33,46 @@ contract DeployScript is Script {
 
     function run() public {
         vm.broadcast();
-        Verifier _verifier = new Verifier();
-        vm.broadcast();
-        Relayer _relayer = new Relayer();
+        ProxyContract _relayer_proxy = new ProxyContract();
+
         vm.broadcast();
-        ERC20Treasury _treasury = new ERC20Treasury();
+        ProxyContract _message_queue_proxy = new ProxyContract();
 
         vm.broadcast();
-        MessageQueue _message_queue = new MessageQueue();
+        ProxyContract _treasury_proxy = new ProxyContract();
+
+        IVerifier _verifier;
 
         vm.broadcast();
-        ProxyContract _relayer_proxy = new ProxyContract(address(_relayer), bytes(""));
+        try vm.envBool("MOCK") {
+            if (vm.envBool("MOCK")) {
+                console.log("Deploying MockVerifier");
+                _verifier = IVerifier(address(new VerifierMock()));
+            }else{
+                console.log("Deploying Verifier");
+                _verifier = IVerifier(address(new Verifier()));
+            }
+
+        } catch {
+                console.log("Deploying Verifier");
+                _verifier = IVerifier(address(new Verifier()));
+        }
+
+        vm.broadcast();
+        Relayer _relayer = new Relayer(address(_verifier));
+        vm.broadcast();
+        ERC20Treasury _treasury = new ERC20Treasury(address(_message_queue_proxy));
 
         vm.broadcast();
-        ProxyContract _message_queue_proxy = new ProxyContract(address(_message_queue), bytes(""));
+        MessageQueue _message_queue = new MessageQueue(address(_relayer_proxy));
 
         vm.broadcast();
-        ProxyContract _treasury_proxy = new ProxyContract(address(_treasury), bytes(""));
+        _relayer_proxy.upgradeToAndCall(address(_relayer), "");
+        vm.broadcast();
+        _treasury_proxy.upgradeToAndCall(address(_treasury), "");
+        vm.broadcast();
+        _message_queue_proxy.upgradeToAndCall(address(_message_queue), "");
+
 
         relayer = Relayer(address(_relayer_proxy));
         treasury = ERC20Treasury(address(_treasury_proxy));

ethereum/src/ERC20Treasury.sol

@@ -7,12 +7,18 @@ import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 
 import {IERC20Treasury, WithdrawMessage} from "./interfaces/IERC20Treasury.sol";
-import {GRC_20_GATEWAY_ADDRESS, MESSAGE_QUEUE_ADDRESS} from "./libraries/Environment.sol";
+import {GRC_20_GATEWAY_ADDRESS} from "./libraries/Environment.sol";
 import {IMessageQueue, IMessageQueueReceiver, VaraMessage} from "./interfaces/IMessageQueue.sol";
 
 contract ERC20Treasury is IERC20Treasury, Context, IMessageQueueReceiver {
     using SafeERC20 for IERC20;
 
+    address immutable MESSAGE_QUEUE_ADDRESS;
+
+    constructor(address message_queue) {
+        MESSAGE_QUEUE_ADDRESS = message_queue; 
+    }
+
     /** @dev Deposit token to `Treasury` using `safeTransferFrom`. Allowance needs to allow treasury
      * contract transferring `amount` of tokens. Emits `Deposit` event.
      *

ethereum/src/MessageQueue.sol

@@ -8,14 +8,18 @@ import {IRelayer} from "./interfaces/IRelayer.sol";
 
 import {VaraMessage, VaraMessage, IMessageQueue, IMessageQueueReceiver, Hasher} from "./interfaces/IMessageQueue.sol";
 import {MerkleProof} from "openzeppelin-contracts/contracts/utils/cryptography/MerkleProof.sol";
-import {RELAYER_ADDRESS} from "./libraries/Environment.sol";
-
 
 
 contract MessageQueue is IMessageQueue {
     using Address for address;
     using Hasher for VaraMessage;
 
+    address immutable RELAYER_ADDRESS;
+
+    constructor (address relayer_address){
+        RELAYER_ADDRESS = relayer_address;
+    }
+
     function hash_vara_msg(
         VaraMessage calldata message
     ) internal pure returns (bytes32) {

ethereum/src/ProxyContract.sol

@@ -1,20 +1,17 @@
 pragma solidity ^0.8.24;
 
-import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import {Proxy} from "@openzeppelin/contracts/proxy/Proxy.sol";
 import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
 
-contract ProxyContract is ERC1967Proxy {
+contract ProxyContract is Proxy {
     error ProxyDeniedAdminAccess();
 
     /**
      * @dev Initializes an upgradeable proxy managed by an instance of a {ProxyAdmin} with an
      * `initialOwner`,backed by the implementation at `_logic`, and optionally initialized with
      * `_data` as explained in {ERC1967Proxy-constructor}.
      */
-    constructor(
-        address _logic,
-        bytes memory _data
-    ) payable ERC1967Proxy(_logic, _data) {
+    constructor() payable {
         ERC1967Utils.changeAdmin(msg.sender);
     }
 
@@ -55,6 +52,17 @@ contract ProxyContract is ERC1967Proxy {
         }
     }
 
+    /**
+     * @dev Returns the current implementation address.
+     *
+     * TIP: To get this value clients can read directly from the storage slot shown below (specified by ERC-1967) using
+     * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
+     * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
+     */
+    function _implementation() internal view virtual override returns (address) {
+        return ERC1967Utils.getImplementation();
+    }
+
     function implementation() public view returns (address) {
         return _implementation();
     }

ethereum/src/Relayer.sol

@@ -3,7 +3,6 @@ pragma solidity ^0.8.24;
 import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
 import {IVerifier} from "./interfaces/IVerifier.sol";
 import {IRelayer} from "./interfaces/IRelayer.sol";
-import  "./libraries/Environment.sol";
 
 contract Relayer is IRelayer {
     IVerifier private _verifier;
@@ -14,6 +13,12 @@ contract Relayer is IRelayer {
     uint256 private constant MASK_64BITS = (2 ** 64) - 1;
     uint256 private constant MASK_192BITS = (2 ** 192) - 1;
 
+    address immutable VERIFIER_ADDRESS;
+
+    constructor(address verifier) {
+        VERIFIER_ADDRESS = verifier;
+    }
+
 
     /**  @dev Verifies and stores a `merkle_root` for specified `block_number`. Calls `verifyProof`
      * in `PlonkVerifier` and reverts if the proof or the public inputs are malformed.

ethereum/src/libraries/Environment.sol

@@ -1,17 +1,5 @@
 pragma solidity ^0.8.24;
 
-address constant TREASURY_ADDRESS = address(
-    0x0165878A594ca255338adfa4d48449f69242Eb8F
-);
-address constant MESSAGE_QUEUE_ADDRESS = address(
-    0x5FC8d32690cc91D4c39d9d3abcBD16989F875707
-);
-address constant RELAYER_ADDRESS = address(
-    0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9
-);
-address constant VERIFIER_ADDRESS = address(
-    0x5FbDB2315678afecb367f032d93F642f64180aa3
-);
 
 // ALICE
 bytes32 constant GRC_20_GATEWAY_ADDRESS = bytes32(

ethereum/src/mocks/VerifierMock.sol

@@ -4,8 +4,8 @@ import {IVerifier} from "../interfaces/IVerifier.sol";
 
 contract Verifier is IVerifier {
     function verifyProof(
-        bytes calldata proof,
-        uint256[] calldata public_inputs
+        bytes calldata,
+        uint256[] calldata
     ) external pure returns (bool) {
         return true;
     }