25f2ae6fa9
Some checks failed
Rhai Tests / Run Rhai Tests (push) Has been cancelled
- Moved `prepare_function_arguments` and `convert_token_to_rhai` to the `ethereum` module for better organization. - Updated `keypair` module to use the new `session_manager` structure improving code clarity. - Changed `KeyPair` type usage to new `vault::keyspace::keypair_types::KeyPair` for consistency. - Improved error handling and clarity in `EthereumWallet` methods.
944 lines
30 KiB
Rust
944 lines
30 KiB
Rust
//! Rhai bindings for SAL crypto functionality
|
|
|
|
use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _};
|
|
use ethers::types::{Address, U256};
|
|
use once_cell::sync::Lazy;
|
|
use rhai::{Dynamic, Engine, EvalAltResult};
|
|
use std::collections::HashMap;
|
|
use std::fs;
|
|
use std::path::PathBuf;
|
|
use std::str::FromStr;
|
|
use std::sync::Mutex;
|
|
use tokio::runtime::Runtime;
|
|
|
|
use crate::vault::ethereum;
|
|
use crate::vault::keyspace::session_manager as keypair;
|
|
|
|
use crate::vault::symmetric::implementation as symmetric_impl;
|
|
// Global Tokio runtime for blocking async operations
|
|
static RUNTIME: Lazy<Mutex<Runtime>> =
|
|
Lazy::new(|| Mutex::new(Runtime::new().expect("Failed to create Tokio runtime")));
|
|
|
|
// Global provider registry
|
|
static PROVIDERS: Lazy<
|
|
Mutex<HashMap<String, ethers::providers::Provider<ethers::providers::Http>>>,
|
|
> = Lazy::new(|| Mutex::new(HashMap::new()));
|
|
|
|
// Key space management functions
|
|
fn load_key_space(name: &str, password: &str) -> bool {
|
|
// Get the key spaces directory from config
|
|
let home_dir = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
|
|
let key_spaces_dir = home_dir.join(".hero-vault").join("key-spaces");
|
|
|
|
// Check if directory exists
|
|
if !key_spaces_dir.exists() {
|
|
log::error!("Key spaces directory does not exist");
|
|
return false;
|
|
}
|
|
|
|
// Get the key space file path
|
|
let space_path = key_spaces_dir.join(format!("{}.json", name));
|
|
|
|
// Check if file exists
|
|
if !space_path.exists() {
|
|
log::error!("Key space file not found: {}", space_path.display());
|
|
return false;
|
|
}
|
|
|
|
// Read the file
|
|
let serialized = match fs::read_to_string(&space_path) {
|
|
Ok(data) => data,
|
|
Err(e) => {
|
|
log::error!("Error reading key space file: {}", e);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Deserialize the encrypted space
|
|
let encrypted_space = match symmetric_impl::deserialize_encrypted_space(&serialized) {
|
|
Ok(space) => space,
|
|
Err(e) => {
|
|
log::error!("Error deserializing key space: {}", e);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Decrypt the space
|
|
let space = match symmetric_impl::decrypt_key_space(&encrypted_space, password) {
|
|
Ok(space) => space,
|
|
Err(e) => {
|
|
log::error!("Error decrypting key space: {}", e);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Set as current space
|
|
match keypair::set_current_space(space) {
|
|
Ok(_) => true,
|
|
Err(e) => {
|
|
log::error!("Error setting current space: {}", e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
fn create_key_space(name: &str, password: &str) -> bool {
|
|
match keypair::create_space(name) {
|
|
Ok(_) => {
|
|
// Get the current space
|
|
match keypair::get_current_space() {
|
|
Ok(space) => {
|
|
// Encrypt the key space
|
|
let encrypted_space = match symmetric_impl::encrypt_key_space(&space, password)
|
|
{
|
|
Ok(encrypted) => encrypted,
|
|
Err(e) => {
|
|
log::error!("Error encrypting key space: {}", e);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Serialize the encrypted space
|
|
let serialized =
|
|
match symmetric_impl::serialize_encrypted_space(&encrypted_space) {
|
|
Ok(json) => json,
|
|
Err(e) => {
|
|
log::error!("Error serializing encrypted space: {}", e);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Get the key spaces directory
|
|
let home_dir = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
|
|
let key_spaces_dir = home_dir.join(".hero-vault").join("key-spaces");
|
|
|
|
// Create directory if it doesn't exist
|
|
if !key_spaces_dir.exists() {
|
|
match fs::create_dir_all(&key_spaces_dir) {
|
|
Ok(_) => {}
|
|
Err(e) => {
|
|
log::error!("Error creating key spaces directory: {}", e);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Write to file
|
|
let space_path = key_spaces_dir.join(format!("{}.json", name));
|
|
match fs::write(&space_path, serialized) {
|
|
Ok(_) => {
|
|
log::info!("Key space created and saved to {}", space_path.display());
|
|
true
|
|
}
|
|
Err(e) => {
|
|
log::error!("Error writing key space file: {}", e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
Err(e) => {
|
|
log::error!("Error getting current space: {}", e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
Err(e) => {
|
|
log::error!("Error creating key space: {}", e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
// Auto-save function for internal use
|
|
fn auto_save_key_space(password: &str) -> bool {
|
|
match keypair::get_current_space() {
|
|
Ok(space) => {
|
|
// Encrypt the key space
|
|
let encrypted_space = match symmetric_impl::encrypt_key_space(&space, password) {
|
|
Ok(encrypted) => encrypted,
|
|
Err(e) => {
|
|
log::error!("Error encrypting key space: {}", e);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Serialize the encrypted space
|
|
let serialized = match symmetric_impl::serialize_encrypted_space(&encrypted_space) {
|
|
Ok(json) => json,
|
|
Err(e) => {
|
|
log::error!("Error serializing encrypted space: {}", e);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Get the key spaces directory
|
|
let home_dir = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
|
|
let key_spaces_dir = home_dir.join(".hero-vault").join("key-spaces");
|
|
|
|
// Create directory if it doesn't exist
|
|
if !key_spaces_dir.exists() {
|
|
match fs::create_dir_all(&key_spaces_dir) {
|
|
Ok(_) => {}
|
|
Err(e) => {
|
|
log::error!("Error creating key spaces directory: {}", e);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Write to file
|
|
let space_path = key_spaces_dir.join(format!("{}.json", space.name));
|
|
match fs::write(&space_path, serialized) {
|
|
Ok(_) => {
|
|
log::info!("Key space saved to {}", space_path.display());
|
|
true
|
|
}
|
|
Err(e) => {
|
|
log::error!("Error writing key space file: {}", e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
Err(e) => {
|
|
log::error!("Error getting current space: {}", e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
fn encrypt_key_space(password: &str) -> String {
|
|
match keypair::get_current_space() {
|
|
Ok(space) => match symmetric_impl::encrypt_key_space(&space, password) {
|
|
Ok(encrypted_space) => match serde_json::to_string(&encrypted_space) {
|
|
Ok(json) => json,
|
|
Err(e) => {
|
|
log::error!("Error serializing encrypted space: {}", e);
|
|
String::new()
|
|
}
|
|
},
|
|
Err(e) => {
|
|
log::error!("Error encrypting key space: {}", e);
|
|
String::new()
|
|
}
|
|
},
|
|
Err(e) => {
|
|
log::error!("Error getting current space: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
fn decrypt_key_space(encrypted: &str, password: &str) -> bool {
|
|
match serde_json::from_str(encrypted) {
|
|
Ok(encrypted_space) => {
|
|
match symmetric_impl::decrypt_key_space(&encrypted_space, password) {
|
|
Ok(space) => match keypair::set_current_space(space) {
|
|
Ok(_) => true,
|
|
Err(e) => {
|
|
log::error!("Error setting current space: {}", e);
|
|
false
|
|
}
|
|
},
|
|
Err(e) => {
|
|
log::error!("Error decrypting key space: {}", e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
Err(e) => {
|
|
log::error!("Error parsing encrypted space: {}", e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
// Keypair management functions
|
|
fn create_keypair(name: &str, password: &str) -> bool {
|
|
match keypair::create_keypair(name) {
|
|
Ok(_) => {
|
|
// Auto-save the key space after creating a keypair
|
|
auto_save_key_space(password)
|
|
}
|
|
Err(e) => {
|
|
log::error!("Error creating keypair: {}", e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
fn select_keypair(name: &str) -> bool {
|
|
match keypair::select_keypair(name) {
|
|
Ok(_) => true,
|
|
Err(e) => {
|
|
log::error!("Error selecting keypair: {}", e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
fn list_keypairs() -> Vec<String> {
|
|
match keypair::list_keypairs() {
|
|
Ok(keypairs) => keypairs,
|
|
Err(e) => {
|
|
log::error!("Error listing keypairs: {}", e);
|
|
Vec::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Cryptographic operations
|
|
fn sign(message: &str) -> String {
|
|
let message_bytes = message.as_bytes();
|
|
match keypair::keypair_sign(message_bytes) {
|
|
Ok(signature) => BASE64.encode(signature),
|
|
Err(e) => {
|
|
log::error!("Error signing message: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
fn verify(message: &str, signature: &str) -> bool {
|
|
let message_bytes = message.as_bytes();
|
|
match BASE64.decode(signature) {
|
|
Ok(signature_bytes) => match keypair::keypair_verify(message_bytes, &signature_bytes) {
|
|
Ok(is_valid) => is_valid,
|
|
Err(e) => {
|
|
log::error!("Error verifying signature: {}", e);
|
|
false
|
|
}
|
|
},
|
|
Err(e) => {
|
|
log::error!("Error decoding signature: {}", e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
// Symmetric encryption
|
|
fn generate_key() -> String {
|
|
let key = symmetric_impl::generate_symmetric_key();
|
|
BASE64.encode(key)
|
|
}
|
|
|
|
fn encrypt(key: &str, message: &str) -> String {
|
|
match BASE64.decode(key) {
|
|
Ok(key_bytes) => {
|
|
let message_bytes = message.as_bytes();
|
|
match symmetric_impl::encrypt_symmetric(&key_bytes, message_bytes) {
|
|
Ok(ciphertext) => BASE64.encode(ciphertext),
|
|
Err(e) => {
|
|
log::error!("Error encrypting message: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
Err(e) => {
|
|
log::error!("Error decoding key: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
fn decrypt(key: &str, ciphertext: &str) -> String {
|
|
match BASE64.decode(key) {
|
|
Ok(key_bytes) => match BASE64.decode(ciphertext) {
|
|
Ok(ciphertext_bytes) => {
|
|
match symmetric_impl::decrypt_symmetric(&key_bytes, &ciphertext_bytes) {
|
|
Ok(plaintext) => match String::from_utf8(plaintext) {
|
|
Ok(text) => text,
|
|
Err(e) => {
|
|
log::error!("Error converting plaintext to string: {}", e);
|
|
String::new()
|
|
}
|
|
},
|
|
Err(e) => {
|
|
log::error!("Error decrypting ciphertext: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
Err(e) => {
|
|
log::error!("Error decoding ciphertext: {}", e);
|
|
String::new()
|
|
}
|
|
},
|
|
Err(e) => {
|
|
log::error!("Error decoding key: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Ethereum operations
|
|
|
|
// Gnosis Chain operations
|
|
fn create_ethereum_wallet() -> bool {
|
|
match ethereum::create_ethereum_wallet_for_network(ethereum::networks::gnosis()) {
|
|
Ok(_) => true,
|
|
Err(e) => {
|
|
log::error!("Error creating Ethereum wallet: {}", e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
fn get_ethereum_address() -> String {
|
|
match ethereum::get_current_ethereum_wallet_for_network("Gnosis") {
|
|
Ok(wallet) => wallet.address_string(),
|
|
Err(e) => {
|
|
log::error!("Error getting Ethereum address: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Peaq network operations
|
|
fn create_peaq_wallet() -> bool {
|
|
match ethereum::create_peaq_wallet() {
|
|
Ok(_) => true,
|
|
Err(e) => {
|
|
log::error!("Error creating Peaq wallet: {}", e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
fn get_peaq_address() -> String {
|
|
match ethereum::get_current_peaq_wallet() {
|
|
Ok(wallet) => wallet.address_string(),
|
|
Err(e) => {
|
|
log::error!("Error getting Peaq address: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Agung testnet operations
|
|
fn create_agung_wallet() -> bool {
|
|
match ethereum::create_agung_wallet() {
|
|
Ok(_) => true,
|
|
Err(e) => {
|
|
log::error!("Error creating Agung wallet: {}", e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
fn get_agung_address() -> String {
|
|
match ethereum::get_current_agung_wallet() {
|
|
Ok(wallet) => wallet.address_string(),
|
|
Err(e) => {
|
|
log::error!("Error getting Agung address: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generic network operations
|
|
fn create_wallet_for_network(network_name: &str) -> bool {
|
|
let network = match ethereum::networks::get_network_by_name(network_name) {
|
|
Some(network) => network,
|
|
None => {
|
|
log::error!("Unknown network: {}", network_name);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
match ethereum::create_ethereum_wallet_for_network(network) {
|
|
Ok(_) => true,
|
|
Err(e) => {
|
|
log::error!("Error creating wallet for network {}: {}", network_name, e);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get wallet address for a specific network
|
|
fn get_wallet_address_for_network(network_name: &str) -> String {
|
|
let network_name_proper = match ethereum::networks::get_proper_network_name(network_name) {
|
|
Some(name) => name,
|
|
None => {
|
|
log::error!("Unknown network: {}", network_name);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
match ethereum::get_current_ethereum_wallet_for_network(network_name_proper) {
|
|
Ok(wallet) => wallet.address_string(),
|
|
Err(e) => {
|
|
log::error!(
|
|
"Error getting wallet address for network {}: {}",
|
|
network_name,
|
|
e
|
|
);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Clear wallets for a specific network
|
|
fn clear_wallets_for_network(network_name: &str) -> bool {
|
|
let network_name_proper = match ethereum::networks::get_proper_network_name(network_name) {
|
|
Some(name) => name,
|
|
None => {
|
|
log::error!("Unknown network: {}", network_name);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
ethereum::clear_ethereum_wallets_for_network(network_name_proper);
|
|
true
|
|
}
|
|
|
|
// List supported networks
|
|
fn list_supported_networks() -> rhai::Array {
|
|
let mut arr = rhai::Array::new();
|
|
for name in ethereum::networks::list_network_names() {
|
|
arr.push(Dynamic::from(name.to_lowercase()));
|
|
}
|
|
arr
|
|
}
|
|
|
|
// Get network token symbol
|
|
fn get_network_token_symbol(network_name: &str) -> String {
|
|
match ethereum::networks::get_network_by_name(network_name) {
|
|
Some(network) => network.token_symbol,
|
|
None => {
|
|
log::error!("Unknown network: {}", network_name);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get network explorer URL
|
|
fn get_network_explorer_url(network_name: &str) -> String {
|
|
match ethereum::networks::get_network_by_name(network_name) {
|
|
Some(network) => network.explorer_url,
|
|
None => {
|
|
log::error!("Unknown network: {}", network_name);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create a wallet from a private key for a specific network
|
|
fn create_wallet_from_private_key_for_network(private_key: &str, network_name: &str) -> bool {
|
|
let network = match ethereum::networks::get_network_by_name(network_name) {
|
|
Some(network) => network,
|
|
None => {
|
|
log::error!("Unknown network: {}", network_name);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
match ethereum::create_ethereum_wallet_from_private_key_for_network(private_key, network) {
|
|
Ok(_) => true,
|
|
Err(e) => {
|
|
log::error!(
|
|
"Error creating wallet from private key for network {}: {}",
|
|
network_name,
|
|
e
|
|
);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create a provider for the Agung network
|
|
fn create_agung_provider() -> String {
|
|
match ethereum::create_agung_provider() {
|
|
Ok(provider) => {
|
|
// Generate a unique ID for the provider
|
|
let id = format!("provider_{}", uuid::Uuid::new_v4());
|
|
|
|
// Store the provider in the registry
|
|
if let Ok(mut providers) = PROVIDERS.lock() {
|
|
providers.insert(id.clone(), provider);
|
|
return id;
|
|
}
|
|
|
|
log::error!("Failed to acquire provider registry lock");
|
|
String::new()
|
|
}
|
|
Err(e) => {
|
|
log::error!("Error creating Agung provider: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get the balance of an address on a specific network
|
|
fn get_balance(network_name: &str, address: &str) -> String {
|
|
// Get the runtime
|
|
let rt = match RUNTIME.lock() {
|
|
Ok(rt) => rt,
|
|
Err(e) => {
|
|
log::error!("Failed to acquire runtime lock: {}", e);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Parse the address
|
|
let addr = match Address::from_str(address) {
|
|
Ok(addr) => addr,
|
|
Err(e) => {
|
|
log::error!("Invalid address format: {}", e);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Get the proper network name
|
|
let network_name_proper = match ethereum::networks::get_proper_network_name(network_name) {
|
|
Some(name) => name,
|
|
None => {
|
|
log::error!("Unknown network: {}", network_name);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Get the network config
|
|
let network = match ethereum::networks::get_network_by_name(network_name_proper) {
|
|
Some(n) => n,
|
|
None => {
|
|
log::error!("Failed to get network config for: {}", network_name_proper);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Create a provider
|
|
let provider = match ethereum::create_provider(&network) {
|
|
Ok(p) => p,
|
|
Err(e) => {
|
|
log::error!("Failed to create provider: {}", e);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Execute the balance query in a blocking manner
|
|
match rt.block_on(async { ethereum::get_balance(&provider, addr).await }) {
|
|
Ok(balance) => balance.to_string(),
|
|
Err(e) => {
|
|
log::error!("Failed to get balance: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Send ETH from one address to another using the blocking approach
|
|
fn send_eth(wallet_network: &str, to_address: &str, amount_str: &str) -> String {
|
|
// Get the runtime
|
|
let rt = match RUNTIME.lock() {
|
|
Ok(rt) => rt,
|
|
Err(e) => {
|
|
log::error!("Failed to acquire runtime lock: {}", e);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Parse the address
|
|
let to_addr = match Address::from_str(to_address) {
|
|
Ok(addr) => addr,
|
|
Err(e) => {
|
|
log::error!("Invalid address format: {}", e);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Parse the amount (using string to handle large numbers)
|
|
let amount = match U256::from_dec_str(amount_str) {
|
|
Ok(amt) => amt,
|
|
Err(e) => {
|
|
log::error!("Invalid amount format: {}", e);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Get the proper network name
|
|
let network_name_proper = match ethereum::networks::get_proper_network_name(wallet_network) {
|
|
Some(name) => name,
|
|
None => {
|
|
log::error!("Unknown network: {}", wallet_network);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Get the wallet
|
|
let wallet = match ethereum::get_current_ethereum_wallet_for_network(network_name_proper) {
|
|
Ok(w) => w,
|
|
Err(e) => {
|
|
log::error!("Failed to get wallet: {}", e);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Create a provider
|
|
let provider = match ethereum::create_provider(&wallet.network) {
|
|
Ok(p) => p,
|
|
Err(e) => {
|
|
log::error!("Failed to create provider: {}", e);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Execute the transaction in a blocking manner
|
|
match rt.block_on(async { ethereum::send_eth(&wallet, &provider, to_addr, amount).await }) {
|
|
Ok(tx_hash) => format!("{:?}", tx_hash),
|
|
Err(e) => {
|
|
log::error!("Transaction failed: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Smart contract operations
|
|
|
|
// Load a contract ABI from a JSON string and create a contract instance
|
|
fn load_contract_abi(network_name: &str, address: &str, abi_json: &str) -> String {
|
|
// Get the network
|
|
let network = match ethereum::networks::get_network_by_name(network_name) {
|
|
Some(network) => network,
|
|
None => {
|
|
log::error!("Unknown network: {}", network_name);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Parse the ABI
|
|
let abi = match ethereum::load_abi_from_json(abi_json) {
|
|
Ok(abi) => abi,
|
|
Err(e) => {
|
|
log::error!("Error parsing ABI: {}", e);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Create the contract
|
|
match ethereum::Contract::from_address_string(address, abi, network) {
|
|
Ok(contract) => {
|
|
// Serialize the contract to JSON for storage
|
|
match serde_json::to_string(&contract) {
|
|
Ok(json) => json,
|
|
Err(e) => {
|
|
log::error!("Error serializing contract: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
Err(e) => {
|
|
log::error!("Error creating contract: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Load a contract ABI from a file
|
|
fn load_contract_abi_from_file(network_name: &str, address: &str, file_path: &str) -> String {
|
|
// Read the ABI file
|
|
match fs::read_to_string(file_path) {
|
|
Ok(abi_json) => load_contract_abi(network_name, address, &abi_json),
|
|
Err(e) => {
|
|
log::error!("Error reading ABI file: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Use the utility functions from the ethereum module
|
|
|
|
// Call a read-only function on a contract (no arguments version)
|
|
fn call_contract_read_no_args(contract_json: &str, function_name: &str) -> Dynamic {
|
|
call_contract_read(contract_json, function_name, rhai::Array::new())
|
|
}
|
|
|
|
// Call a read-only function on a contract with arguments
|
|
fn call_contract_read(contract_json: &str, function_name: &str, args: rhai::Array) -> Dynamic {
|
|
// Deserialize the contract
|
|
let contract: ethereum::Contract = match serde_json::from_str(contract_json) {
|
|
Ok(contract) => contract,
|
|
Err(e) => {
|
|
log::error!("Error deserializing contract: {}", e);
|
|
return Dynamic::UNIT;
|
|
}
|
|
};
|
|
|
|
// Prepare the arguments
|
|
let tokens = match ethereum::prepare_function_arguments(&contract.abi, function_name, &args) {
|
|
Ok(tokens) => tokens,
|
|
Err(e) => {
|
|
log::error!("Error preparing arguments: {}", e);
|
|
return Dynamic::UNIT;
|
|
}
|
|
};
|
|
|
|
// Get the runtime
|
|
let rt = match RUNTIME.lock() {
|
|
Ok(rt) => rt,
|
|
Err(e) => {
|
|
log::error!("Failed to acquire runtime lock: {}", e);
|
|
return Dynamic::UNIT;
|
|
}
|
|
};
|
|
|
|
// Create a provider
|
|
let provider = match ethereum::create_provider(&contract.network) {
|
|
Ok(p) => p,
|
|
Err(e) => {
|
|
log::error!("Failed to create provider: {}", e);
|
|
return Dynamic::UNIT;
|
|
}
|
|
};
|
|
|
|
// Execute the call in a blocking manner
|
|
match rt.block_on(async {
|
|
ethereum::call_read_function(&contract, &provider, function_name, tokens).await
|
|
}) {
|
|
Ok(result) => ethereum::convert_token_to_rhai(&result),
|
|
Err(e) => {
|
|
log::error!("Failed to call contract function: {}", e);
|
|
Dynamic::UNIT
|
|
}
|
|
}
|
|
}
|
|
|
|
// Call a state-changing function on a contract (no arguments version)
|
|
fn call_contract_write_no_args(contract_json: &str, function_name: &str) -> String {
|
|
call_contract_write(contract_json, function_name, rhai::Array::new())
|
|
}
|
|
|
|
// Call a state-changing function on a contract with arguments
|
|
fn call_contract_write(contract_json: &str, function_name: &str, args: rhai::Array) -> String {
|
|
// Deserialize the contract
|
|
let contract: ethereum::Contract = match serde_json::from_str(contract_json) {
|
|
Ok(contract) => contract,
|
|
Err(e) => {
|
|
log::error!("Error deserializing contract: {}", e);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Prepare the arguments
|
|
let tokens = match ethereum::prepare_function_arguments(&contract.abi, function_name, &args) {
|
|
Ok(tokens) => tokens,
|
|
Err(e) => {
|
|
log::error!("Error preparing arguments: {}", e);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Get the runtime
|
|
let rt = match RUNTIME.lock() {
|
|
Ok(rt) => rt,
|
|
Err(e) => {
|
|
log::error!("Failed to acquire runtime lock: {}", e);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Get the wallet
|
|
let network_name_proper = contract.network.name.as_str();
|
|
let wallet = match ethereum::get_current_ethereum_wallet_for_network(network_name_proper) {
|
|
Ok(w) => w,
|
|
Err(e) => {
|
|
log::error!("Failed to get wallet: {}", e);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Create a provider
|
|
let provider = match ethereum::create_provider(&contract.network) {
|
|
Ok(p) => p,
|
|
Err(e) => {
|
|
log::error!("Failed to create provider: {}", e);
|
|
return String::new();
|
|
}
|
|
};
|
|
|
|
// Execute the transaction in a blocking manner
|
|
match rt.block_on(async {
|
|
ethereum::call_write_function(&contract, &wallet, &provider, function_name, tokens).await
|
|
}) {
|
|
Ok(tx_hash) => format!("{:?}", tx_hash),
|
|
Err(e) => {
|
|
// Log the error details for debugging
|
|
log::debug!("\nERROR DETAILS: Transaction failed: {}", e);
|
|
log::debug!("Contract address: {}", contract.address);
|
|
log::debug!("Function: {}", function_name);
|
|
log::debug!("Arguments: {:?}", args);
|
|
log::debug!("Wallet address: {}", wallet.address);
|
|
log::debug!("Network: {}", contract.network.name);
|
|
log::error!("Transaction failed: {}", e);
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Register crypto functions with the Rhai engine
|
|
pub fn register_crypto_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>> {
|
|
// Register key space functions
|
|
engine.register_fn("load_key_space", load_key_space);
|
|
engine.register_fn("create_key_space", create_key_space);
|
|
engine.register_fn("encrypt_key_space", encrypt_key_space);
|
|
engine.register_fn("decrypt_key_space", decrypt_key_space);
|
|
|
|
// Register keypair functions
|
|
engine.register_fn("create_keypair", create_keypair);
|
|
engine.register_fn("select_keypair", select_keypair);
|
|
engine.register_fn("list_keypairs", list_keypairs);
|
|
|
|
// Register signing/verification functions
|
|
engine.register_fn("sign", sign);
|
|
engine.register_fn("verify", verify);
|
|
|
|
// Register symmetric encryption functions
|
|
engine.register_fn("generate_key", generate_key);
|
|
engine.register_fn("encrypt", encrypt);
|
|
engine.register_fn("decrypt", decrypt);
|
|
|
|
// Register Ethereum functions (Gnosis Chain)
|
|
engine.register_fn("create_ethereum_wallet", create_ethereum_wallet);
|
|
engine.register_fn("get_ethereum_address", get_ethereum_address);
|
|
|
|
// Register Peaq network functions
|
|
engine.register_fn("create_peaq_wallet", create_peaq_wallet);
|
|
engine.register_fn("get_peaq_address", get_peaq_address);
|
|
|
|
// Register Agung testnet functions
|
|
engine.register_fn("create_agung_wallet", create_agung_wallet);
|
|
engine.register_fn("get_agung_address", get_agung_address);
|
|
|
|
// Register generic network functions
|
|
engine.register_fn("create_wallet_for_network", create_wallet_for_network);
|
|
engine.register_fn(
|
|
"get_wallet_address_for_network",
|
|
get_wallet_address_for_network,
|
|
);
|
|
engine.register_fn("clear_wallets_for_network", clear_wallets_for_network);
|
|
engine.register_fn("list_supported_networks", list_supported_networks);
|
|
engine.register_fn("get_network_token_symbol", get_network_token_symbol);
|
|
engine.register_fn("get_network_explorer_url", get_network_explorer_url);
|
|
|
|
// Register new Ethereum functions for wallet creation from private key and transactions
|
|
engine.register_fn(
|
|
"create_wallet_from_private_key_for_network",
|
|
create_wallet_from_private_key_for_network,
|
|
);
|
|
engine.register_fn("create_agung_provider", create_agung_provider);
|
|
engine.register_fn("send_eth", send_eth);
|
|
engine.register_fn("get_balance", get_balance);
|
|
|
|
// Register smart contract functions
|
|
engine.register_fn("load_contract_abi", load_contract_abi);
|
|
engine.register_fn("load_contract_abi_from_file", load_contract_abi_from_file);
|
|
|
|
// Register the read function with different arities
|
|
engine.register_fn("call_contract_read", call_contract_read_no_args);
|
|
engine.register_fn("call_contract_read", call_contract_read);
|
|
|
|
// Register the write function with different arities
|
|
engine.register_fn("call_contract_write", call_contract_write_no_args);
|
|
engine.register_fn("call_contract_write", call_contract_write);
|
|
|
|
Ok(())
|
|
}
|