Change token name from REV to ASI

Author: Timekiller7

src/args.rs

@@ -35,8 +35,8 @@ pub enum Commands {
     /// Generate a new secp256k1 private/public key pair
     GenerateKeyPair(GenerateKeyPairArgs),
 
-    /// Generate a REV address from a public key
-    GenerateRevAddress(GenerateRevAddressArgs),
+    /// Generate a ASI address from a public key
+    GenerateAsiAddress(GenerateAsiAddressArgs),
 
     /// Get node status and peer information
     Status(HttpArgs),
@@ -71,7 +71,7 @@ pub enum Commands {
     /// Get blocks in the main chain
     ShowMainChain(ShowMainChainArgs),
 
-    /// Transfer REV tokens between addresses
+    /// Transfer ASI tokens between addresses
     Transfer(TransferArgs),
 
     /// Get a specific deploy by ID
@@ -305,9 +305,9 @@ pub struct GenerateKeyPairArgs {
     pub output_dir: String,
 }
 
-/// Arguments for generate-rev-address command
+/// Arguments for generate-asi-address command
 #[derive(Parser)]
-pub struct GenerateRevAddressArgs {
+pub struct GenerateAsiAddressArgs {
     /// Public key in hex format (uncompressed format preferred)
     #[arg(short, long, conflicts_with = "private_key")]
     pub public_key: Option<String>,
@@ -510,11 +510,11 @@ pub struct WaitArgs {
 /// Arguments for transfer command
 #[derive(Parser)]
 pub struct TransferArgs {
-    /// Recipient REV address
+    /// Recipient ASI address
     #[arg(short, long)]
     pub to_address: String,
 
-    /// Amount in REV to transfer
+    /// Amount in ASI to transfer
     #[arg(short, long)]
     pub amount: u64,
 

src/commands/crypto.rs

@@ -80,7 +80,7 @@ pub fn generate_key_pair_command(args: &GenerateKeyPairArgs) -> Result<()> {
     Ok(())
 }
 
-pub fn generate_rev_address_command(args: &GenerateRevAddressArgs) -> Result<()> {
+pub fn generate_asi_address_command(args: &GenerateAsiAddressArgs) -> Result<()> {
     // Determine the public key to use
     let public_key_hex = if let Some(public_key_hex) = &args.public_key {
         // Use provided public key
@@ -89,7 +89,7 @@ pub fn generate_rev_address_command(args: &GenerateRevAddressArgs) -> Result<()>
         // Derive public key from private key
         let secret_key = CryptoUtils::decode_private_key(private_key_hex)?;
         let public_key = CryptoUtils::derive_public_key(&secret_key);
-        // Use uncompressed format for REV address generation
+        // Use uncompressed format for ASI address generation
         CryptoUtils::serialize_public_key(&public_key, false)
     } else {
         return Err(NodeCliError::config_missing_required(
@@ -104,12 +104,12 @@ pub fn generate_rev_address_command(args: &GenerateRevAddressArgs) -> Result<()>
         ));
     }
 
-    // Generate REV address
-    let rev_address = CryptoUtils::generate_rev_address(&public_key_hex)?;
+    // Generate ASI address
+    let asi_address = CryptoUtils::generate_asi_address(&public_key_hex)?;
 
     // Print the result using output utils
     print_key("Public key", &public_key_hex);
-    print_key("REV address", &rev_address);
+    print_key("ASI address", &asi_address);
 
     Ok(())
 }

src/commands/network.rs

@@ -231,7 +231,7 @@ pub async fn is_finalized_command(
 }
 
 pub async fn transfer_deploy(args: &TransferArgs) -> Result<String, Box<dyn std::error::Error>> {
-    println!("💸 Initiating REV transfer");
+    println!("💸 Initiating ASI transfer");
 
     println!(
         "🔌 Connecting to F1r3fly node at {}:{}",
@@ -245,18 +245,18 @@ pub async fn transfer_deploy(args: &TransferArgs) -> Result<String, Box<dyn std:
         let secret_key = CryptoUtils::decode_private_key(&args.private_key)?;
         let public_key = CryptoUtils::derive_public_key(&secret_key);
         let public_key_hex = CryptoUtils::serialize_public_key(&public_key, false);
-        CryptoUtils::generate_rev_address(&public_key_hex)?
+        CryptoUtils::generate_asi_address(&public_key_hex)?
     };
 
-    validate_rev_address(&from_address)?;
-    validate_rev_address(&args.to_address)?;
+    validate_asi_address(&from_address)?;
+    validate_asi_address(&args.to_address)?;
 
     let amount_dust = args.amount * 100_000_000;
 
     println!("📋 Transfer Details:");
     println!("   From: {}", from_address);
     println!("   To: {}", args.to_address);
-    println!("   Amount: {} REV ({} dust)", args.amount, amount_dust);
+    println!("   Amount: {} ASI ({} dust)", args.amount, amount_dust);
     println!(
         "   Phlo limit: {}",
         if args.bigger_phlo {
@@ -353,7 +353,7 @@ pub async fn bond_validator_command(
     args: &BondValidatorArgs,
 ) -> Result<(), Box<dyn std::error::Error>> {
     println!("🔗 Bonding new validator to the network");
-    println!("💰 Stake amount: {} REV", args.stake);
+    println!("💰 Stake amount: {} ASI", args.stake);
 
     // Initialize the F1r3fly API client for deploying
     let f1r3fly_api = F1r3flyApi::new(&args.private_key, &args.host, args.grpc_port);
@@ -748,13 +748,13 @@ pub async fn get_deploy_command(
     }
 }
 
-pub fn validate_rev_address(address: &str) -> Result<(), Box<dyn std::error::Error>> {
+pub fn validate_asi_address(address: &str) -> Result<(), Box<dyn std::error::Error>> {
     if !address.starts_with("1111") {
-        return Err("Invalid REV address format: must start with '1111'".into());
+        return Err("Invalid ASI address format: must start with '1111'".into());
     }
 
     if address.len() < 40 {
-        return Err("Invalid REV address format: too short".into());
+        return Err("Invalid ASI address format: too short".into());
     }
 
     Ok(())
@@ -782,7 +782,7 @@ in {{
       for (@result <- resultCh) {{
         match result {{
           (true, Nil) => {{
-            stdout!(("Transfer successful:", {}, "REV"))
+            stdout!(("Transfer successful:", {}, "ASI"))
           }}
           (false, reason) => {{
             stdout!(("Transfer failed:", reason))

src/commands/query.rs

@@ -347,7 +347,7 @@ pub async fn wallet_balance_command(
             let duration = start_time.elapsed();
             println!("✅ Wallet balance retrieved successfully!");
             println!("⏱️  Time taken: {:.2?}", duration);
-            println!("💰 Balance for {}: {} REV", args.address, balance);
+            println!("💰 Balance for {}: {} ASI", args.address, balance);
             println!("📊 {}", block_info);
 
             return Ok((balance, block_info));
@@ -848,7 +848,7 @@ pub async fn validator_status_command(
                                 if validator == args.public_key {
                                     if let Some(stake) = bond.get("stake").and_then(|s| s.as_i64())
                                     {
-                                        println!("   Stake Amount: {} REV", stake);
+                                        println!("   Stake Amount: {} ASI", stake);
                                     }
                                     break;
                                 }

src/dispatcher.rs

@@ -31,8 +31,8 @@ impl Dispatcher {
             Commands::GenerateKeyPair(args) => {
                 generate_key_pair_command(args).map_err(NodeCliError::from)
             }
-            Commands::GenerateRevAddress(args) => {
-                generate_rev_address_command(args).map_err(NodeCliError::from)
+            Commands::GenerateAsiAddress(args) => {
+                generate_asi_address_command(args).map_err(NodeCliError::from)
             }
             Commands::Status(args) => status_command(args).await.map_err(NodeCliError::from),
             Commands::Blocks(args) => blocks_command(args).await.map_err(NodeCliError::from),

src/utils/crypto.rs

@@ -47,16 +47,16 @@ impl CryptoUtils {
         hex::encode(private_key.secret_bytes())
     }
 
-    /// Generate REV address from public key
-    pub fn generate_rev_address(public_key_hex: &str) -> Result<String> {
+    /// Generate ASI address from public key
+    pub fn generate_asi_address(public_key_hex: &str) -> Result<String> {
         let public_key_bytes = hex::decode(public_key_hex)?;
 
         let public_key = PublicKey::from_bytes(&public_key_bytes);
 
         match RevAddress::from_public_key(&public_key) {
-            Some(rev_address) => Ok(rev_address.to_base58()),
+            Some(asi_address) => Ok(asi_address.to_base58()),
             None => Err(NodeCliError::crypto_invalid_public_key(
-                "Failed to generate REV address from public key",
+                "Failed to generate ASI address from public key",
             )),
         }
     }