281 lines
8.6 KiB
Rust
281 lines
8.6 KiB
Rust
//! 以太坊桥插件实现（独立版本）
|
||
|
||
use ethers::prelude::*;
|
||
use serde::{Deserialize, Serialize};
|
||
use std::sync::Arc;
|
||
|
||
/// 桥插件错误
|
||
#[derive(Debug, thiserror::Error)]
|
||
pub enum BridgeError {
|
||
#[error("Network error: {0}")]
|
||
Network(String),
|
||
|
||
#[error("Invalid proof: {0}")]
|
||
InvalidProof(String),
|
||
|
||
#[error("Plugin error: {0}")]
|
||
PluginError(String),
|
||
}
|
||
|
||
/// Token信息
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct TokenInfo {
|
||
pub contract_address: Option<String>,
|
||
pub symbol: String,
|
||
pub decimals: u8,
|
||
}
|
||
|
||
/// 以太坊桥插件
|
||
pub struct EthereumBridgePlugin {
|
||
/// 链ID（1=主网，5=Goerli，11155111=Sepolia）
|
||
chain_id: u64,
|
||
/// RPC提供商
|
||
provider: Arc<Provider<Http>>,
|
||
/// 桥合约地址
|
||
bridge_contract_address: String,
|
||
/// 链名称
|
||
chain_name: String,
|
||
/// Logo URL
|
||
_logo_url: String,
|
||
}
|
||
|
||
impl EthereumBridgePlugin {
|
||
/// 创建新的以太坊桥插件
|
||
///
|
||
/// # 参数
|
||
/// - `rpc_url`: 以太坊RPC节点URL
|
||
/// - `chain_id`: 链ID（1=主网）
|
||
/// - `bridge_contract_address`: 桥合约地址
|
||
pub async fn new(
|
||
rpc_url: &str,
|
||
chain_id: u64,
|
||
bridge_contract_address: String,
|
||
) -> Result<Self, BridgeError> {
|
||
let provider = Provider::<Http>::try_from(rpc_url)
|
||
.map_err(|e| BridgeError::Network(format!("Failed to connect to RPC: {}", e)))?;
|
||
|
||
let provider = Arc::new(provider);
|
||
|
||
let chain_name = match chain_id {
|
||
1 => "Ethereum Mainnet".to_string(),
|
||
5 => "Goerli Testnet".to_string(),
|
||
11155111 => "Sepolia Testnet".to_string(),
|
||
_ => format!("Ethereum Chain {}", chain_id),
|
||
};
|
||
|
||
let _logo_url = "https://ethereum.org/static/eth-diamond-black.png".to_string();
|
||
|
||
Ok(Self {
|
||
chain_id,
|
||
provider,
|
||
bridge_contract_address,
|
||
chain_name,
|
||
_logo_url,
|
||
})
|
||
}
|
||
|
||
/// 获取链ID
|
||
pub fn chain_id(&self) -> u64 {
|
||
self.chain_id
|
||
}
|
||
|
||
/// 获取链名称
|
||
pub fn chain_name(&self) -> &str {
|
||
&self.chain_name
|
||
}
|
||
|
||
/// 获取ETH余额
|
||
pub async fn get_eth_balance(&self, address: &str) -> Result<u128, BridgeError> {
|
||
let address: Address = address
|
||
.parse()
|
||
.map_err(|e| BridgeError::PluginError(format!("Invalid address: {}", e)))?;
|
||
|
||
let balance = self.provider
|
||
.get_balance(address, None)
|
||
.await
|
||
.map_err(|e| BridgeError::Network(format!("Failed to get balance: {}", e)))?;
|
||
|
||
Ok(balance.as_u128())
|
||
}
|
||
|
||
/// 获取ERC-20余额
|
||
pub async fn get_erc20_balance(
|
||
&self,
|
||
user_address: &str,
|
||
token_address: &str,
|
||
) -> Result<u128, BridgeError> {
|
||
let user_addr: Address = user_address
|
||
.parse()
|
||
.map_err(|e| BridgeError::PluginError(format!("Invalid user address: {}", e)))?;
|
||
|
||
let token_addr: Address = token_address
|
||
.parse()
|
||
.map_err(|e| BridgeError::PluginError(format!("Invalid token address: {}", e)))?;
|
||
|
||
// ERC-20 balanceOf函数选择器: 0x70a08231
|
||
let mut data = vec![0x70, 0xa0, 0x82, 0x31]; // balanceOf(address)
|
||
data.extend_from_slice(&[0u8; 12]); // 填充12字节
|
||
data.extend_from_slice(user_addr.as_bytes());
|
||
|
||
let tx = Eip1559TransactionRequest::new()
|
||
.to(token_addr)
|
||
.data(data);
|
||
|
||
let result = self.provider
|
||
.call(&tx.into(), None)
|
||
.await
|
||
.map_err(|e| BridgeError::Network(format!("Failed to call balanceOf: {}", e)))?;
|
||
|
||
// 解析返回值（32字节uint256）
|
||
if result.len() != 32 {
|
||
return Err(BridgeError::PluginError(
|
||
"Invalid balanceOf response".to_string()
|
||
));
|
||
}
|
||
|
||
let balance = U256::from_big_endian(&result);
|
||
Ok(balance.as_u128())
|
||
}
|
||
|
||
/// 获取余额（自动判断ETH或ERC-20）
|
||
pub async fn get_balance(
|
||
&self,
|
||
address: &str,
|
||
token: &TokenInfo,
|
||
) -> Result<u128, BridgeError> {
|
||
if let Some(contract_address) = &token.contract_address {
|
||
self.get_erc20_balance(address, contract_address).await
|
||
} else {
|
||
self.get_eth_balance(address).await
|
||
}
|
||
}
|
||
|
||
/// 构造锁定ETH交易数据
|
||
///
|
||
/// # 参数
|
||
/// - `amount`: ETH数量（wei）
|
||
/// - `nac_target_address`: NAC目标地址（32字节）
|
||
///
|
||
/// # 返回
|
||
/// 交易数据（可用于签名和广播）
|
||
pub fn build_lock_eth_tx_data(
|
||
&self,
|
||
_amount: u128,
|
||
nac_target_address: &[u8; 32],
|
||
) -> Vec<u8> {
|
||
// lockETH(bytes32 nacTargetAddress)
|
||
let mut data = vec![0x12, 0x34, 0x56, 0x78]; // 函数选择器（占位符）
|
||
data.extend_from_slice(nac_target_address);
|
||
data
|
||
}
|
||
|
||
/// 构造锁定ERC-20交易数据
|
||
///
|
||
/// # 参数
|
||
/// - `token_address`: ERC-20合约地址
|
||
/// - `amount`: Token数量
|
||
/// - `nac_target_address`: NAC目标地址（32字节）
|
||
///
|
||
/// # 返回
|
||
/// 交易数据
|
||
pub fn build_lock_erc20_tx_data(
|
||
&self,
|
||
token_address: &str,
|
||
amount: u128,
|
||
nac_target_address: &[u8; 32],
|
||
) -> Result<Vec<u8>, BridgeError> {
|
||
let token_addr: Address = token_address
|
||
.parse()
|
||
.map_err(|e| BridgeError::PluginError(format!("Invalid token address: {}", e)))?;
|
||
|
||
// lockERC20(address token, uint256 amount, bytes32 nacTargetAddress)
|
||
let mut data = vec![0xab, 0xcd, 0xef, 0x12]; // 函数选择器（占位符）
|
||
|
||
// token地址
|
||
data.extend_from_slice(&[0u8; 12]);
|
||
data.extend_from_slice(token_addr.as_bytes());
|
||
|
||
// amount
|
||
let mut amount_bytes = [0u8; 32];
|
||
U256::from(amount).to_big_endian(&mut amount_bytes);
|
||
data.extend_from_slice(&amount_bytes);
|
||
|
||
// NAC目标地址
|
||
data.extend_from_slice(nac_target_address);
|
||
|
||
Ok(data)
|
||
}
|
||
|
||
/// 获取交易收据
|
||
pub async fn get_transaction_receipt(
|
||
&self,
|
||
tx_hash: &str,
|
||
) -> Result<TransactionReceipt, BridgeError> {
|
||
let tx_hash_bytes = hex::decode(tx_hash.trim_start_matches("0x"))
|
||
.map_err(|e| BridgeError::PluginError(format!("Invalid tx hash: {}", e)))?;
|
||
|
||
let tx_hash_h256 = H256::from_slice(&tx_hash_bytes);
|
||
|
||
let receipt = self.provider
|
||
.get_transaction_receipt(tx_hash_h256)
|
||
.await
|
||
.map_err(|e| BridgeError::Network(format!("Failed to get receipt: {}", e)))?
|
||
.ok_or_else(|| BridgeError::InvalidProof("Transaction not found".to_string()))?;
|
||
|
||
Ok(receipt)
|
||
}
|
||
|
||
/// 获取区块信息
|
||
pub async fn get_block(&self, block_number: u64) -> Result<Block<H256>, BridgeError> {
|
||
let block = self.provider
|
||
.get_block(block_number)
|
||
.await
|
||
.map_err(|e| BridgeError::Network(format!("Failed to get block: {}", e)))?
|
||
.ok_or_else(|| BridgeError::Network("Block not found".to_string()))?;
|
||
|
||
Ok(block)
|
||
}
|
||
|
||
/// 获取桥合约地址
|
||
pub fn bridge_contract_address(&self) -> &str {
|
||
&self.bridge_contract_address
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[tokio::test]
|
||
#[ignore] // 需要实际的RPC节点
|
||
async fn test_ethereum_bridge_creation() {
|
||
let bridge = EthereumBridgePlugin::new(
|
||
"https://eth-mainnet.g.alchemy.com/v2/demo",
|
||
1,
|
||
"0x1234567890123456789012345678901234567890".to_string(),
|
||
).await;
|
||
|
||
assert!(bridge.is_ok());
|
||
let bridge = bridge.expect("mainnet: handle error");
|
||
assert_eq!(bridge.chain_id(), 1);
|
||
assert_eq!(bridge.chain_name(), "Ethereum Mainnet");
|
||
}
|
||
|
||
#[test]
|
||
fn test_build_lock_eth_tx_data() {
|
||
let bridge = EthereumBridgePlugin {
|
||
chain_id: 1,
|
||
provider: Arc::new(Provider::<Http>::try_from("http://localhost:8545").expect("mainnet: handle error")),
|
||
bridge_contract_address: "0x1234...".to_string(),
|
||
chain_name: "Test".to_string(),
|
||
_logo_url: "".to_string(),
|
||
};
|
||
|
||
let nac_address = [1u8; 32];
|
||
let data = bridge.build_lock_eth_tx_data(1000000, &nac_address);
|
||
|
||
// 函数选择器(4字节) + NAC地址(32字节) = 36字节
|
||
assert_eq!(data.len(), 36);
|
||
}
|
||
}
|