Added command to list known ERC 20 contracts for a chain

README.md

@@ -8,7 +8,7 @@ The project is work in progress and is being developed as a side project. As suc
 
 The code is written primarily in Rust. Cargo is Rust's build system and package manager. To install Rust and Cargo:
 
-* Rust: [https://doc.rust-lang.org/cargo/getting-started/installation.html](https://doc.rust-lang.org/cargo/getting-started/installation.html). To 
+* Rust: [https://doc.rust-lang.org/cargo/getting-started/installation.html](https://doc.rust-lang.org/cargo/getting-started/installation.html)
 * Cargo: [https://doc.rust-lang.org/cargo/getting-started/installation.html](https://doc.rust-lang.org/cargo/getting-started/installation.html)
 
 # Run

bin/rb/src/commands/erc20.rs

@@ -1,6 +1,7 @@
 use clap::{Args, Subcommand};
 use eyre::Result;
 
+use alloy::primitives::{Address, address};
 use tokens::erc20::Erc20;
 
 use lib::prelude::*;
@@ -15,6 +16,7 @@ pub struct Erc20Args {
 #[derive(Debug, Subcommand)]
 pub enum Erc20Commands {
     Symbol(Erc20SymbolArgs),
+    List(Erc20ListArgs),
 }
 
 #[derive(Debug, Args)]
@@ -23,6 +25,12 @@ pub struct Erc20SymbolArgs {
     pub address: Address,
 }
 
+#[derive(Debug, Args)]
+#[command(args_conflicts_with_subcommands = true)]
+pub struct Erc20ListArgs {
+}
+
+
 pub async fn erc20_symbol(args: Erc20SymbolArgs, provider: RootProvider) -> Result<()> {
     let tok0_address = args.address;
     let tok0_contract = Erc20::new(tok0_address, provider).await?;
@@ -32,3 +40,48 @@ pub async fn erc20_symbol(args: Erc20SymbolArgs, provider: RootProvider) -> Resu
 
     Ok(())
 }
+
+const ETHEREUM_WETH: Address = address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2");
+const ETHEREUM_USDC: Address = address!("A0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48");
+const ETHEREUM_IMX: Address = address!("f57e7e7c23978c3caec3c3548e3d615c346e79ff");
+const ETHEREUM_GOG: Address = address!("9ab7bb7fdc60f4357ecfef43986818a2a3569c62");
+
+const IMMUTABLE_USDC: Address = address!("6de8aCC0D406837030CE4dd28e7c08C5a96a30d2");
+const IMMUTABLE_WETH: Address = address!("52A6c53869Ce09a731CD772f245b97A4401d3348");
+const IMMUTABLE_WIMX: Address = address!("3A0C2Ba54D6CBd3121F01b96dFd20e99D1696C9D");
+const IMMUTABLE_GOG: Address = address!("b00ed913aAFf8280C17BfF33CcE82fE6D79e85e8");
+
+pub async fn erc20_list(_args: Erc20ListArgs, provider: RootProvider) -> Result<()> {
+    let id = provider.get_chain_id().await?;
+    println!("Known tokens for chain {}", id);
+    println!(" Symbol  Address                                     Decimals  Supply");
+
+    match id {
+        1 => {
+            print_erc20_info(ETHEREUM_WETH, provider.clone()).await?;
+            print_erc20_info(ETHEREUM_USDC, provider.clone()).await?;
+            print_erc20_info(ETHEREUM_IMX, provider.clone()).await?;
+            print_erc20_info(ETHEREUM_GOG, provider.clone()).await?;
+        }
+        13371 => {
+            print_erc20_info(IMMUTABLE_WETH, provider.clone()).await?;
+            print_erc20_info(IMMUTABLE_USDC, provider.clone()).await?;
+            print_erc20_info(IMMUTABLE_WIMX, provider.clone()).await?;
+            print_erc20_info(IMMUTABLE_GOG, provider.clone()).await?;
+        }
+        _ => {
+            println!(" No known tokens for this chain");
+        }
+    }
+
+    Ok(())
+}
+
+pub async fn print_erc20_info(erc20_address: Address, provider: RootProvider) -> Result<()> {
+    let contract = Erc20::new(erc20_address, provider).await?;
+    let symbol = contract.symbol().await?;
+    let decimals = contract.decimals().await?;
+    let total_supply = contract.total_supply().await?;
+    println!(" {:<7} {}  {:<3}       {}", symbol, erc20_address, decimals, total_supply);
+    Ok(())
+}

bin/rb/src/main.rs

@@ -2,14 +2,14 @@ use clap::{Parser, Subcommand};
 
 mod commands;
 use commands::{
-    chain_id, erc20_symbol, finalized, latest, pool_current_tick, pool_tick_dump, pool_tick_info,
+    chain_id, erc20_symbol, erc20_list, finalized, latest, pool_current_tick, pool_tick_dump, pool_tick_info,
     pool_tick_spacing, ChainArgs, Erc20Args, Erc20Commands, PoolArgs, PoolCommands,
 };
 use lib::prelude::*;
 
 #[derive(Debug, Parser)]
 #[command(name = "rb")]
-#[command(about = "R-bitrage Bot", long_about = None)]
+#[command(about = "CODAS", long_about = None)]
 struct Cli {
     #[command(subcommand)]
     command: Commands,
@@ -45,6 +45,7 @@ async fn main() -> eyre::Result<()> {
     match cli.into_command() {
         (Commands::Erc20(args), provider) => match args.command {
             Erc20Commands::Symbol(args) => erc20_symbol(args, provider).await,
+            Erc20Commands::List(args) => erc20_list(args, provider).await,
         },
         (Commands::Pool(args), provider) => match args.command {
             PoolCommands::TickSpacing(args) => pool_tick_spacing(args, provider).await,

crates/tokens/src/erc20.rs

@@ -23,6 +23,7 @@ sol! {
         event Approval(address indexed owner, address indexed spender, uint256 value);
 
         function symbol() external view returns (string sym);
+        function decimals() external view returns (uint256 value);
     }
 
 }
@@ -34,9 +35,6 @@ pub struct Erc20 {
 impl Erc20 {
     pub async fn new(token_address: Address, provider: RootProvider) -> Result<Self> {
         let token_contract = IERC20::new(token_address, provider);
-        let tok0_symbol = token_contract.symbol().call().await?.sym;
-        println!("Sym: {}", tok0_symbol);
-
         Ok(Self { token_contract })
     }
 
@@ -54,4 +52,9 @@ impl Erc20 {
         let res = self.token_contract.totalSupply().call().await?.supply;
         Ok(res)
     }
+
+    pub async fn decimals(&self) -> Result<U256> {
+        let res = self.token_contract.decimals().call().await?.value;
+        Ok(res)
+    }
 }