init commit

Author: bitcodr

.DS_Store

@@ -0,0 +1,2 @@
+RPC_URL=https://mainnet.infura.io/v3/your_project_id
+PRIVATE_KEY=your_private_key_here

.env.example

@@ -0,0 +1,24 @@
+
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        profile: minimal
+        override: true
+    - name: Run fmt
+      run: cargo fmt --all -- --check
+    - name: Run tests
+      run: cargo test

.github/workflows/ci.yml

@@ -0,0 +1,84 @@
+
+# eth-rust-sdk
+
+A modular, async-ready Rust SDK for interacting with Ethereum smart contracts using [ethers-rs](https://github.com/gakonst/ethers-rs).  
+Includes support for:
+- **ERC-721 (NFTs)**
+- **DAOs**
+- **Staking contracts**
+- **ERC-20 tokens**
+- **Vault contracts**
+
+---
+
+## Features
+
+- Modular design: each contract type is a separate module
+- Uses `ethers-rs` for provider, signer, and contract bindings
+- Works with any Ethereum-compatible chain (Mainnet, Goerli, Polygon, etc.)
+- Includes usage examples and `.env` configuration
+
+---
+
+## Setup
+
+1. Clone this repo and enter the directory:
+```bash
+git clone https://github.com/bitcodr/eth-rust-sdk.git
+cd eth-rust-sdk
+```
+
+2. Copy the `.env.example` to `.env` and add your Infura/Alchemy RPC + private key:
+```env
+RPC_URL=https://mainnet.infura.io/v3/your_project_id
+PRIVATE_KEY=your_private_key_here
+```
+
+3. Build the project:
+```bash
+cargo build
+```
+
+---
+
+## Examples
+
+Each module includes a sample usage file inside `/examples`.
+
+Run them like this:
+
+```bash
+cargo run --example fetch_nft_metadata
+cargo run --example dao_info
+cargo run --example staking_balance
+```
+
+---
+
+## Modules
+
+- `nft`: Query token URI, owner, and transfer
+- `dao`: Read proposals and vote
+- `staking`: Stake/unstake and read earnings
+- `erc20`: Token transfers, approvals, balances
+- `vault`: Deposit, withdraw, and check balances
+
+---
+
+## Development
+
+- Format code:
+```bash
+cargo fmt
+```
+
+- Run unit tests:
+```bash
+cargo test
+```
+
+---
+
+## License
+
+MIT © [bitcodr](https://github.com/bitcodr)

README.md

@@ -0,0 +1,24 @@
+
+use ethers::prelude::*;
+use std::sync::Arc;
+use dotenv::dotenv;
+use std::env;
+use eth_rust_sdk::dao::DaoClient;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    dotenv().ok();
+    let rpc_url = env::var("RPC_URL")?;
+    let private_key = env::var("PRIVATE_KEY")?;
+    let provider = Provider::<Http>::try_from(rpc_url)?.interval(std::time::Duration::from_millis(10));
+    let wallet: LocalWallet = private_key.parse()?;
+    let client = Arc::new(SignerMiddleware::new(provider, wallet.with_chain_id(1u64)));
+
+    let dao_address: Address = "0xYourDaoContractAddressHere".parse()?;
+    let dao = DaoClient::new(dao_address, client);
+
+    let (id, description, votes) = dao.get_proposal(U256::from(0)).await?;
+    println!("Proposal {}: {} ({} votes)", id, description, votes);
+
+    Ok(())
+}

examples/dao_info.rs

@@ -0,0 +1,24 @@
+
+use ethers::prelude::*;
+use std::sync::Arc;
+use dotenv::dotenv;
+use std::env;
+use eth_rust_sdk::nft::NftClient;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    dotenv().ok();
+    let rpc_url = env::var("RPC_URL")?;
+    let private_key = env::var("PRIVATE_KEY")?;
+    let provider = Provider::<Http>::try_from(rpc_url)?.interval(std::time::Duration::from_millis(10));
+    let wallet: LocalWallet = private_key.parse()?;
+    let client = Arc::new(SignerMiddleware::new(provider, wallet.with_chain_id(1u64)));
+
+    let nft_address: Address = "0xYourNftContractAddressHere".parse()?;
+    let nft = NftClient::new(nft_address, client.clone());
+
+    let token_id = U256::from(1);
+    println!("Owner: {}", nft.owner_of(token_id).await?);
+    println!("Token URI: {}", nft.token_uri(token_id).await?);
+    Ok(())
+}

examples/fetch_nft_metadata.rs

@@ -0,0 +1,25 @@
+
+use ethers::prelude::*;
+use std::sync::Arc;
+use dotenv::dotenv;
+use std::env;
+use eth_rust_sdk::staking::StakingClient;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    dotenv().ok();
+    let rpc_url = env::var("RPC_URL")?;
+    let private_key = env::var("PRIVATE_KEY")?;
+    let provider = Provider::<Http>::try_from(rpc_url)?.interval(std::time::Duration::from_millis(10));
+    let wallet: LocalWallet = private_key.parse()?;
+    let client = Arc::new(SignerMiddleware::new(provider, wallet.with_chain_id(1u64)));
+
+    let staking_address: Address = "0xYourStakingContractAddressHere".parse()?;
+    let staking = StakingClient::new(staking_address, client.clone());
+
+    let address = client.address();
+    println!("Staked Balance: {}", staking.balance_of(address).await?);
+    println!("Earned: {}", staking.earned(address).await?);
+
+    Ok(())
+}

examples/staking_balance.rs

@@ -0,0 +1,30 @@
+
+use ethers::prelude::*;
+use std::sync::Arc;
+
+abigen!(
+    DAO,
+    r#"[function proposals(uint256) view returns (uint256 id, string description, uint256 votes)
+        function vote(uint256 proposalId, bool support)]"#
+);
+
+pub struct DaoClient<M> {
+    contract: DAO<M>,
+}
+
+impl<M: Middleware> DaoClient<M> {
+    pub fn new(address: Address, client: Arc<M>) -> Self {
+        let contract = DAO::new(address, client);
+        Self { contract }
+    }
+
+    pub async fn get_proposal(&self, proposal_id: U256) -> Result<(U256, String, U256), ContractError<M>> {
+        self.contract.proposals(proposal_id).call().await
+    }
+
+    pub async fn vote(&self, proposal_id: U256, support: bool) -> Result<TxHash, ContractError<M>> {
+        let tx = self.contract.vote(proposal_id, support);
+        let pending_tx = tx.send().await?;
+        Ok(*pending_tx)
+    }
+}

src/dao/mod.rs

@@ -0,0 +1,37 @@
+
+use ethers::prelude::*;
+use std::sync::Arc;
+
+abigen!(
+    ERC20,
+    r#"[function balanceOf(address account) view returns (uint256)
+        function transfer(address recipient, uint256 amount) returns (bool)
+        function approve(address spender, uint256 amount) returns (bool)]"#
+);
+
+pub struct Erc20Client<M> {
+    contract: ERC20<M>,
+}
+
+impl<M: Middleware> Erc20Client<M> {
+    pub fn new(address: Address, client: Arc<M>) -> Self {
+        let contract = ERC20::new(address, client);
+        Self { contract }
+    }
+
+    pub async fn balance_of(&self, account: Address) -> Result<U256, ContractError<M>> {
+        self.contract.balance_of(account).call().await
+    }
+
+    pub async fn transfer(&self, to: Address, amount: U256) -> Result<TxHash, ContractError<M>> {
+        let tx = self.contract.transfer(to, amount);
+        let pending_tx = tx.send().await?;
+        Ok(*pending_tx)
+    }
+
+    pub async fn approve(&self, spender: Address, amount: U256) -> Result<TxHash, ContractError<M>> {
+        let tx = self.contract.approve(spender, amount);
+        let pending_tx = tx.send().await?;
+        Ok(*pending_tx)
+    }
+}

src/erc20/mod.rs

@@ -0,0 +1,5 @@
+pub mod nft;
+pub mod dao;
+pub mod staking;
+pub mod erc20;
+pub mod vault;