add simple contract for testing purposes

Author: hpmaxi

core/src/artifacts.rs

@@ -1,11 +1,16 @@
 use anyhow::{Context, Result};
-use ethers::abi::Abi;
+use ethers::{abi::Abi, types::Bytes, utils::hex::decode};
 use std::fs;
 
 fn contract_path(contract_name: &str) -> String {
+    let artifacts_dir =
+        std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src/solidity/artifacts");
+
     format!(
-        "contracts/{}/out/{}.sol/{}.json",
-        contract_name, contract_name, contract_name
+        "{}/{}.sol/{}.json",
+        artifacts_dir.display(),
+        contract_name,
+        contract_name
     )
 }
 
@@ -19,14 +24,14 @@ pub fn load_abi(contract_name: &str) -> Result<Abi> {
     Ok(abi)
 }
 
-pub fn load_bytecode(contract_name: &str) -> Result<String> {
+pub fn load_bytecode(contract_name: &str) -> Result<Bytes> {
     let path = contract_path(contract_name);
     let json = fs::read_to_string(&path)
         .with_context(|| format!("Failed to read bytecode from {}", path))?;
     let v: serde_json::Value = serde_json::from_str(&json)?;
-    let bytecode = v["bytecode"]["object"]
+    let bytecode_str = v["bytecode"]["object"]
         .as_str()
-        .context("Missing bytecode object")?
-        .to_string();
-    Ok(bytecode)
+        .context("Missing bytecode object")?;
+    let bytecode = decode(bytecode_str.strip_prefix("0x").unwrap_or(bytecode_str))?;
+    Ok(Bytes::from(bytecode))
 }

core/src/client.rs

@@ -1,12 +1,17 @@
 use anyhow::Result;
-use ethers::signers::{LocalWallet, Wallet};
+use ethers::signers::{LocalWallet, Signer, Wallet};
 use std::path::Path;
 
 /// Load a wallet from a keystore file.
 /// `cast wallet new .`
 pub async fn wallet_from_keystore(path: &str, password: &str) -> Result<LocalWallet> {
     let path = Path::new(path);
-    let wallet = Wallet::decrypt_keystore(&path, password)?;
+    let mut wallet = Wallet::decrypt_keystore(&path, password)?;
+
+    // TODO Replace with chain id from provider
+    let chain_id: u64 = 84532;
+    wallet = wallet.with_chain_id(chain_id);
+
     println!("Wallet loaded successfully.");
     Ok(wallet)
 }

core/src/compiler.rs

@@ -1,8 +1,6 @@
-use std::{
-    path::{Path, PathBuf},
-    process::Output,
-};
+use std::path::{Path, PathBuf};
 
+use anyhow::Error;
 use foundry_compilers::{Project, ProjectPathsConfig};
 
 pub fn compile_contract() -> Result<(), anyhow::Error> {
@@ -14,10 +12,12 @@ pub fn compile_contract() -> Result<(), anyhow::Error> {
         .paths(ProjectPathsConfig::hardhat(&contracts_path).unwrap())
         .set_no_artifacts(false)
         .build(Default::default())
-        .unwrap();
+        .map_err(|e| Error::new(e).context("Failed to build project"))?;
 
     println!("Project:\n {:?}\n", project);
-    let output = project.compile().unwrap();
+    let output = project
+        .compile()
+        .map_err(|e| Error::new(e).context("Failed to compile contracts"))?;
 
     println!("Output:\n {:?}\n", output);
     Ok(())

core/src/deployer.rs

@@ -1,19 +1,29 @@
 use crate::artifacts;
 use anyhow::Result;
-use ethers::prelude::*;
+use ethers::{abi::Token, prelude::*};
 use std::sync::Arc;
 
 pub async fn deploy_contract(
     contract_name: &str,
     provider: Provider<Http>,
     wallet: LocalWallet,
 ) -> Result<Address> {
+    let endpoint_address = "0x0000000000000000000000000000000000000001".parse::<Address>()?;
+    let constructor_args = vec![
+        abi::Token::Address(endpoint_address),
+        abi::Token::Address(endpoint_address),
+    ];
+
     let abi = artifacts::load_abi(contract_name)?;
     let bytecode = artifacts::load_bytecode(contract_name)?;
+    println!("ABI {:?}\nBytecode {:?}", abi, bytecode);
     let client = Arc::new(SignerMiddleware::new(provider, wallet));
 
-    let factory = ContractFactory::new(abi, Bytes::from(bytecode.as_bytes().to_vec()), client);
-    let deployer = factory.deploy(())?.send().await?;
+    let factory = ContractFactory::new(abi, bytecode, Arc::new(client.clone()));
+
+    println!("Factory {:?}", factory);
+
+    let deployed = factory.deploy(constructor_args)?.send().await?;
 
-    Ok(deployer.address())
+    Ok(deployed.address())
 }

core/src/solidity/contracts/SimpleIncrement.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract SimpleIncrement {
+    uint256 private _value;
+
+    event ValueIncremented(address indexed by, uint256 newValue);
+
+    constructor() {
+        _value = 0;
+    }
+
+    function increment() public returns (uint256) {
+        _value += 1;
+        emit ValueIncremented(msg.sender, _value);
+        return _value;
+    }
+
+    function getValue() public view returns (uint256) {
+        return _value;
+    }
+}