Eth/ERC20 Bridge related contracts

Cargo.toml

@@ -2,7 +2,7 @@
 resolver = "2"
 members = [
   "crates/starknet-core-contract-client",
-  "crates/sandbox",
+  "crates/ethereum-instance", "crates/starknet-eth-bridge-client", "crates/starknet-token-bridge-client", "crates/starkgate-manager-client", "crates/utils", "crates/starknet-erc20-client", "crates/starkgate-registry-client", "crates/starknet-proxy-client",
 ]
 
 [workspace.package]

README.md

@@ -1,48 +1,52 @@
 # Zaun
-A development environment for Starknet Solidity contracts.
 
-### Setup:
+This repository contains interfaces and functions to interact with starknet solidity contracts.
+
+## Setup
 
 ```bash
 curl -L https://foundry.paradigm.xyz | bash
 foundryup
 ```
 
-### Testing:
+## Testing
 
 Unit
+
 ```bash
 forge test -vv
 ```
 
 ### Devnet
 
-Start Avnvil as background process w/ Core Contracts and STARK token:
+Start Anvil as background process w/ Core Contracts and STARK token:
+
 ```bash
 ./script/sn-base-dev.sh
 ```
 
 Kill Anvil deployment:
+
 ```bash
 ./script/sn-base-kill.sh
 ```
 
-### Artifacts
+## Artifacts
 
-Zaun sandbox crate can be used as dev dependency in external projects for integration testing.  
-If any changes made to the Solidity contracts, one has to re-generate Ethers bindings (this won't be done automatically).
+Zaun sandbox crate can be used as dev dependency in external projects. If any changes made to the Solidity contracts, one has to re-generate Ethers bindings (this won't be done automatically).
 
 ```bash
 make artifacts
 ```
 
-### StarkNet Consensus Protocol Contracts
+## StarkNet Consensus Protocol Contracts
 
 PoC solidity implementation of the following Starknet Decentralized Protocol proposal:
+
 - [I - Introduction](https://community.starknet.io/t/starknet-decentralized-protocol-i-introduction/2671/1)
 - [II - Candidate for Leader Elections](https://community.starknet.io/t/starknet-decentralized-protocol-ii-candidate-for-leader-elections/4751)
 - [III - Consensus](https://community.starknet.io/t/starknet-decentralized-protocol-iii-consensus/5386)
 - [IV - Proofs in the Protocol](https://community.starknet.io/t/starknet-decentralized-protocol-iv-proofs-in-the-protocol/6030)
 - [V - Checkpoints for Fast Finality](https://community.starknet.io/t/starknet-decentralized-protocol-v-checkpoints-for-fast-finality/6032)
 - [VI - The Buffer Problem](https://community.starknet.io/t/starknet-decentralized-protocol-vi-the-buffer-problem/7098)
-- [VII - Chained Proof Protocols & Braiding](https://community.starknet.io/t/starknet-decentralized-protocol-vii-chained-proof-protocols-braiding/18831)
+- [VII - Chained Proof Protocols & Braiding](https://community.starknet.io/t/starknet-decentralized-protocol-vii-chained-proof-protocols-braiding/18831)

crates/sandbox/Cargo.toml → crates/ethereum-instance/Cargo.toml

@@ -1,16 +1,16 @@
 [package]
-name = "sandbox"
+name = "ethereum-instance"
 edition.workspace = true
 version.workspace = true
 authors.workspace = true
 
 [dependencies]
-starknet-core-contract-client = { path = "../starknet-core-contract-client" }
 ethers = { workspace = true }
 dirs = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 hex = { workspace = true }
+utils = { path = "../utils" }
 
 [dev-dependencies]
 tokio = { version = "1.29.1", features = ["rt", "macros", "parking_lot"] }

crates/sandbox/src/lib.rs → crates/ethereum-instance/src/lib.rs

@@ -1,26 +1,20 @@
 use ethers::abi::Tokenize;
-use ethers::contract::ContractError;
+use ethers::contract::{ContractError, ContractFactory, ContractInstance};
 use ethers::prelude::SignerMiddleware;
-use ethers::prelude::{ContractFactory, ContractInstance};
 use ethers::providers::{Http, Provider, ProviderError};
 use ethers::signers::{LocalWallet, Signer};
-use ethers::types::Bytes;
-use ethers::utils::hex::FromHex;
 use ethers::utils::{Anvil, AnvilInstance};
+use ethers::types::Bytes;
+use hex::FromHex;
 use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Duration;
 
-/// Unsafe proxy is a straightforward implementation of the delegate proxy contract
-/// that is used to make Starknet core contract upgradeable.
-/// This implementation DOES NOT restrict who can invoke the core contract.
-/// For more information see https://l2beat.com/scaling/projects/starknet#contracts
-pub mod unsafe_proxy;
 
 /// Ethers library allows multiple signer backends and transports.
 /// For simplicity we use local wallet (basically private key) and
 /// HTTP transport in this crate.
-pub use starknet_core_contract_client::LocalWalletSignerMiddleware;
+pub use utils::LocalWalletSignerMiddleware;
 
 /// Sandbox is typically used for E2E scenarios so we need to speed things up
 const POLLING_INTERVAL_MS: u64 = 10;
@@ -47,15 +41,15 @@ pub enum Error {
     ContractBuildArtifacts(&'static str),
 }
 
-/// A convenient wrapper over an already running or spawned Anvil local devnet
-pub struct EthereumSandbox {
+/// A convenient wrapper over an already running or spawned Anvil local devnet or ethereum 
+pub struct EthereumClient {
     /// If initialized keeps an Anvil instance to properly shutdown it at the end
     _anvil: Option<AnvilInstance>,
     /// Pre-configured local signer
-    client: Arc<LocalWalletSignerMiddleware>,
+    signer: Arc<LocalWalletSignerMiddleware>,
 }
 
-impl EthereumSandbox {
+impl EthereumClient {
     /// Creates a new sandbox instance.
     /// Will try to attach to already running Anvil instance using one
     /// of the following endpoints:
@@ -85,7 +79,7 @@ impl EthereumSandbox {
 
         Ok(Self {
             _anvil: None,
-            client: Arc::new(client),
+            signer: Arc::new(client),
         })
     }
 
@@ -115,19 +109,39 @@ impl EthereumSandbox {
 
         Self {
             _anvil: Some(anvil),
-            client: Arc::new(client),
+            signer: Arc::new(client),
         }
     }
 
     /// Returns local client configured for the running Anvil instance
+    pub fn signer(&self) -> Arc<LocalWalletSignerMiddleware> {
+        self.signer.clone()
+    }
+}
+
+
+/// Wrapper For Spawning a ethereum instance using the provider
+/// Used for deploying on the main network purposes
+pub struct EthereumInstance {
+    client: Arc<LocalWalletSignerMiddleware>
+}
+
+impl EthereumInstance {
+    pub fn spawn(rpc_url: String, priv_key: String, chain_id: u64) -> Self {
+
+        let provider = Provider::<Http>::try_from(rpc_url).expect("Failed to connect to the given rpc url");
+        let wallet: LocalWallet = priv_key.parse::<LocalWallet>().expect("Error in initializing local wallet");
+
+        let client = SignerMiddleware::new(provider, wallet.with_chain_id(chain_id));
+
+        Self { client: Arc::new(client) }
+    }
+
     pub fn client(&self) -> Arc<LocalWalletSignerMiddleware> {
         self.client.clone()
     }
 }
 
-/// Deploys new smart contract using:
-///     - Forge build artifacts (JSON file contents)
-///     - Constructor args (use () if no args expected)
 pub async fn deploy_contract<T: Tokenize>(
     client: Arc<LocalWalletSignerMiddleware>,
     contract_build_artifacts: &str,
@@ -160,4 +174,4 @@ pub async fn deploy_contract<T: Tokenize>(
         .send()
         .await
         .map_err(Into::<ContractError<LocalWalletSignerMiddleware>>::into)?)
-}
+}