Rust智能合约编译工具foundry-compilers-core使用指南

foundry-compilers-core 是一个 Rust 库，提供了对 Solidity 和 Vyper 智能合约编译器的核心功能集成，是 Foundry 工具链的一部分。

主要功能

• 支持 Solidity 和 Vyper 编译器
• 提供编译器版本管理
• 编译智能合约代码
• 生成合约 ABI
• 支持多文件编译
• 提供编译器输出标准化

安装

在 Cargo.toml 中添加依赖：

[dependencies]
foundry-compilers-core = "0.2"

基本使用方法

1. 编译 Solidity 合约

use foundry_compilers_core::{CompilerInput, Solc};

async fn compile_solidity() {
    // 初始化 Solc 实例
    let solc = Solc::default();
    
    // 准备编译器输入
    let input = CompilerInput::new()
        .source("contracts/MyContract.sol", r#"
            pragma solidity ^0.8.0;
            
            contract MyContract {
                uint256 public value;
                
                function setValue(uint256 _value) public {
                    value = _value;
                }
            }
        "#);
    
    // 执行编译
    let output = solc.compile(&input).await.unwrap();
    
    // 处理编译结果
    if output.has_compiler_errors() {
        eprintln!("Compilation errors: {:?}", output.errors);
    } else {
        println!("Compilation successful!");
        println!("ABI: {:?}", output.contracts["MyContract"].abi);
        println!("Bytecode: {:?}", output.contracts["MyContract"].evm.bytecode.object);
    }
}

2. 编译 Vyper 合约

use foundry_compilers_core::{CompilerInput, Vyper};

async fn compile_vyper() {
    // 初始化 Vyper 实例
    let vyper = Vyper::default();
    
    // 准备编译器输入
    let input = CompilerInput::new()
        .source("contracts/my_contract.vy", r#"
            # @version ^0.3.0
            
            value: uint256
            
            @external
            def set_value(_value: uint256):
                self.value = _value
        "#);
    
    // 执行编译
    let output = vyper.compile(&input).await.unwrap();
    
    // 处理编译结果
    if output.has_compiler_errors() {
        eprintln!("Compilation errors: {:?}", output.errors);
    else {
        println!("Compilation successful!");
        println!("ABI: {:?}", output.contracts["my_contract"].abi);
        println!("Bytecode: {:?}", output.contracts["my_contract"].evm.bytecode.object);
    }
}

3. 指定编译器版本

use foundry_compilers_core::{Solc, SolcVersion};

async fn compile_with_specific_version() {
    // 指定 Solidity 编译器版本
    let solc = Solc::find_or_install(&SolcVersion::new("0.8.19")).await.unwrap();
    
    // ... 其余编译代码与之前相同
}

高级功能

1. 多文件编译

use foundry_compilers_core::{CompilerInput, Solc};

async fn compile_multiple_files() {
    let solc = Solc::default();
    
    let input = CompilerInput::new()
        .source("contracts/MyContract.sol", r#"
            pragma solidity ^0.8.0;
            import "./MyLibrary.sol";
            
            contract MyContract {
                using MyLibrary for uint256;
                uint256 public value;
                
                function setValue(uint256 _value) public {
                    value = _value.double();
                }
            }
        "#)
        .source("contracts/MyLibrary.sol", r#"
            pragma solidity ^0.8.0;
            
            library MyLibrary {
                function double(uint256 self) internal pure returns (uint256) {
                    return self * 2;
                }
            }
        "#);
    
    let output = solc.compile(&input).await.unwrap();
    // 处理输出...
}

2. 使用编译器设置

use foundry_compilers_core::{CompilerInput, CompilerSettings, Solc};

async fn compile_with_settings() {
    let solc = Solc::default();
    
    let settings = CompilerSettings::default()
        .optimizer(true)
        .optimizer_runs(200)
        .evm_version("london");
    
    let input = CompilerInput::new()
        .settings(settings)
        .source("contracts/MyContract.sol", "...");
    
    let output = solc.compile(&input).await.unwrap();
    // 处理输出...
}

错误处理

use foundry_compilers_core::{CompilerInput, Solc};

async fn handle_compilation_errors() {
    let solc = Solc::default();
    
    let input = CompilerInput::new()
        .source("contracts/ErrorContract.sol", r#"
            pragma solidity ^0.8.0;
            
            contract ErrorContract {
                // 故意制造语法错误
                function badFunction() public {
                    uint x = 
                }
            }
        "#);
    
    match solc.compile(&input).await {
        Ok(output) if output.has_compiler_errors() => {
            for error in output.errors {
                eprintln!("Error: {} at {}:{}", error.message, error.source_location.file, error.source_location.line);
            }
        }
        Ok(output) => {
            println!("Compilation successful!");
        }
        Err(e) => {
            eprintln!("Failed to compile: {}", e);
        }
    }
}

完整示例

下面是一个完整的 Rust 项目示例，展示了如何使用 foundry-compilers-core 编译 Solidity 合约：

use foundry_compilers_core::{CompilerInput, Solc};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // 1. 初始化 Solc 编译器
    let solc = Solc::default();
    
    // 2. 准备合约源代码
    let contract_source = r#"
        pragma solidity ^0.8.0;
        
        contract SimpleStorage {
            uint256 storedData;
            
            function set(uint256 x) public {
                storedData = x;
            }
            
            function get() public view returns (uint256) {
                return storedData;
            }
        }
    "#;
    
    // 3. 创建编译器输入
    let input = CompilerInput::new()
        .source("SimpleStorage.sol", contract_source);
    
    // 4. 执行编译
    let output = solc.compile(&input).await?;
    
    // 5. 处理编译结果
    if output.has_compiler_errors() {
        for error in output.errors {
            eprintln!("编译错误: {}", error.message);
        }
        return Err("编译失败".into());
    }
    
    // 6. 获取编译结果
    if let Some(contract) = output.contracts.get("SimpleStorage") {
        println!("编译成功!");
        println!("ABI: {}", serde_json::to_string_pretty(&contract.abi)?);
        println!("字节码: {}", contract.evm.bytecode.object);
    } else {
        eprintln!("未找到合约 SimpleStorage");
        return Err("合约未编译".into());
    }
    
    Ok(())
}

总结

foundry-compilers-core 提供了强大的智能合约编译功能，支持 Solidity 和 Vyper 语言，可以方便地集成到 Rust 项目中。通过合理的错误处理和编译器设置，可以构建可靠的智能合约编译流程。