Rust StarkNet智能合约开发库starknet-contract的使用，支持Cairo合约的部署、交互与测试

安装

在项目目录中运行以下Cargo命令：

cargo add starknet-contract

或者在Cargo.toml中添加以下行：

starknet-contract = "0.15.0"

智能合约部署和交互的类型

starknet-contract库提供了用于部署和与Cairo智能合约交互的类型支持。下面是一个完整的示例展示如何使用该库部署、交互和测试Cairo合约。

完整示例代码

use starknet_contract::{Contract, ContractFactory};
use starknet_core::types::{FieldElement, FunctionCall};
use starknet_providers::{Provider, SequencerGatewayProvider};

#[tokio::main]
async fn main() {
    // 初始化Provider
    let provider = SequencerGatewayProvider::starknet_alpha_goerli();
    
    // 合约ABI和字节码
    let contract_abi = include_str!("path/to/contract_abi.json");
    let contract_bytecode = include_bytes!("path/to/contract_bytecode.json");
    
    // 创建合约工厂
    let factory = ContractFactory::new(
        contract_bytecode.to_vec(),
        contract_abi.to_string(),
        provider
    );
    
    // 部署合约
    let deployment = factory
        .deploy(vec![FieldElement::from_hex_be("0x123").unwrap()]) // 构造函数参数
        .await
        .unwrap();
    
    println!("Contract deployed at: {:?}", deployment.address());
    
    // 与合约交互
    let contract = Contract::new(
        deployment.address(),
        contract_abi.to_string(),
        provider
    );
    
    // 调用合约方法
    let result = contract
        .call(
            FunctionCall {
                contract_address: deployment.address(),
                entry_point_selector: FieldElement::from_hex_be("0x456").unwrap(), // 方法选择器
                calldata: vec![FieldElement::from_hex_be("0x789").unwrap()], // 方法参数
            }
        )
        .await
        .unwrap();
    
    println!("Call result: {:?}", result);
}

代码说明

1. Provider初始化 - 使用SequencerGatewayProvider连接到StarkNet测试网
2. 合约工厂 - ContractFactory用于部署新合约，需要合约字节码和ABI
3. 合约部署 - 调用deploy方法并传递构造函数参数
4. 合约交互 - 使用Contract实例与已部署合约交互
5. 方法调用 - 通过call方法执行合约函数调用

测试合约

#[cfg(test)]
mod tests {
    use super::*;
    use starknet_mock::MockProvider;
    
    #[tokio::test]
    async fn test_contract_interaction() {
        let provider = MockProvider::new();
        
        // 测试部署和调用逻辑...
    }
}

项目信息

• 版本: 0.15.0
• 许可证: MIT OR Apache-2.0
• 主页: starknet.rs
• 仓库: github.com/xJonathanLEI/starknet-rs

这个库提供了完整的工具链来开发、部署和测试StarkNet上的Cairo智能合约，是Rust生态中StarkNet开发的重要工具。

完整示例demo

以下是更完整的示例代码，展示如何部署一个简单的计数器合约并与之交互：

use starknet_contract::{Contract, ContractFactory};
use starknet_core::types::{FieldElement, FunctionCall};
use starknet_providers::{Provider, SequencerGatewayProvider};

// 计数器合约的ABI (简化版)
const COUNTER_ABI: &str = r#"
[
    {
        "inputs": [{"name": "initial_count", "type": "felt"}],
        "name": "constructor",
        "outputs": [],
        "type": "constructor"
    },
    {
        "inputs": [],
        "name": "increment",
        "outputs": [],
        "type": "function"
    },
    {
        "inputs": [],
        "name": "get_count",
        "outputs": [{"name": "count", "type": "felt"}],
        "type": "function"
    }
]
"#;

#[tokio::main]
async fn main() {
    // 1. 初始化Provider - 连接到StarkNet测试网
    let provider = SequencerGatewayProvider::starknet_alpha_goerli();
    
    // 2. 准备合约字节码 (实际项目中应该从文件加载)
    let contract_bytecode = vec![
        FieldElement::from_hex_be("0x123456").unwrap(), // 示例字节码
        // 这里应该是实际的合约字节码
    ];
    
    // 3. 创建合约工厂
    let factory = ContractFactory::new(
        contract_bytecode,
        COUNTER_ABI.to_string(),
        provider.clone()
    );
    
    // 4. 部署合约 - 初始计数器值为10
    let initial_count = FieldElement::from(10u64);
    let deployment = factory
        .deploy(vec![initial_count]) // 传递构造函数参数
        .await
        .expect("Failed to deploy contract");
    
    println!("Contract deployed at: 0x{:x}", deployment.address());
    
    // 5. 创建合约实例
    let contract = Contract::new(
        deployment.address(),
        COUNTER_ABI.to_string(),
        provider
    );
    
    // 6. 调用increment方法
    let increment_result = contract
        .call(
            FunctionCall {
                contract_address: deployment.address(),
                entry_point_selector: FieldElement::from_hex_be(
                    "0x1e1d184bb1b1ae1e3a73e8a1e5a6e2a0e1a3e2a8e1a1e1a7e2a8e1a1e1a7" // increment方法选择器
                ).unwrap(),
                calldata: vec![], // 无参数
            }
        )
        .await
        .expect("Failed to call increment");
    
    println!("Increment transaction: {:?}", increment_result);
    
    // 7. 调用get_count方法
    let count_result = contract
        .call(
            FunctionCall {
                contract_address: deployment.address(),
                entry_point_selector: FieldElement::from_hex_be(
                    "0x2e2d284cc2c2ce2e3b73e8b2e6b3e1a1e2b3e2a8e2b2e2b7e3a8e2b2e2b7" // get_count方法选择器
                ).unwrap(),
                calldata: vec![], // 无参数
            }
        )
        .await
        .expect("Failed to call get_count");
    
    println!("Current count: {:?}", count_result);
}

测试用例示例

#[cfg(test)]
mod tests {
    use super::*;
    use starknet_mock::MockProvider;
    use starknet_core::types::MaybeUnknownErrorCode;
    
    #[tokio::test]
    async fn test_counter_contract() {
        // 1. 创建模拟Provider
        let provider = MockProvider::new();
        
        // 2. 准备测试用的合约字节码
        let bytecode = vec![FieldElement::from(1u64)];
        
        // 3. 创建合约工厂
        let factory = ContractFactory::new(
            bytecode,
            COUNTER_ABI.to_string(),
            provider.clone()
        );
        
        // 4. 测试部署
        let deployment = factory
            .deploy(vec![FieldElement::from(5u64)]) // 初始值5
            .await
            .unwrap();
        
        // 5. 创建合约实例
        let contract = Contract::new(
            deployment.address(),
            COUNTER_ABI.to_string(),
            provider
        );
        
        // 6. 测试方法调用可以在这里添加...
    }
}