how to use pallet_revive to execute solidity

[Subway2023]

I want to fuzz the revive compiler, but I don't know how to efficiently execute the bytecode generated by revive. Could you please let me know if there's a demo I can learn from?

[Subway2023]

    fn instantiate_works() {
        use specs::SpecsAction::*;
        let specs = Specs {
            differential: false,
            balances: vec![(ALICE, 1_000_000_000)],
            actions: vec![Instantiate {
                origin: TestAddress::Alice,
                value: 0,
                gas_limit: Some(GAS_LIMIT),
                storage_deposit_limit: Some(DEPOSIT_LIMIT),
                code: Code::Bytes(include_bytes!("../fixtures/Baseline.pvm").to_vec()),
                data: vec![],
                salt: OptionalHex::default(),
            }],
        };
        specs.run();
    }

The demo provides a test program for the PVM file, but I don't know how to specify the function and parameters to call. I assume it should be set in the data, but I'm not sure how to implement it.

[xermicus]

Hi @Subway2023, the data field is indeed what gets passed to the contract as input ("call data" in Solidity terms). The function being called is implied by the first 4 bytes in the call data (so called function selector). For call data encoding I suggest using the alloy crate, it has even some convenience macros.

Edit for completeness: Instantiate will always run the constructor code.

[Subway2023]

Thank you for your reply. Could you please provide specific code examples for reference? The approach used in alloy-sol is quite challenging for me.

[athei]

You can use the the compilers integration test as an example: https://github.com/paritytech/revive/tree/main/crates/integration

[Subway2023]

thanks

[Subway2023]

main.rs, which is modified from demo

fn main() {
    let args: Vec<String> = env::args().collect();

    if args.len() < 3 {
        eprintln!("Usage: <program> <contract_path> <data_string>");
        std::process::exit(1);
    }

    let contract_path = &args[1]; 
    let data_string = &args[2];

    let mut contract_code = Vec::new();
    let mut contract_file = File::open(contract_path).expect("Failed to open contract file");
    contract_file
        .read_to_end(&mut contract_code)
        .expect("Failed to read contract file");

    let data = data_string.as_bytes().to_vec();

    let specs = Specs {
        differential: false,
        balances: vec![(ALICE, 1_000_000_000)],
        actions: vec![Instantiate {
            origin: TestAddress::Alice,
            value: 0,
            gas_limit: Some(GAS_LIMIT),
            storage_deposit_limit: Some(DEPOSIT_LIMIT),
            code: Code::Bytes(contract_code),
            data: data,
            salt: OptionalHex::default(),
        }],
    };

    // 运行 specs
    let results = specs.run();

    // 打印返回的 CallResult 向量
    for result in results {
        println!("{:?}", result);
    }
}

test.sol

contract C {
    int a=0;
    constructor() {
        h();
    }
    function h() public returns(int){
        a=1123456789;
        return a;
    }
  }

resolc test.sol --bin -o ./tempDir --overwrite

cargo run /mnt/sdd1/sbw/crossCompilerFuzz/tempDir/2.sol:C.pvm b8c9d365

b8c9d365 is the selector of function h. The following output indicates that the function's output is empty. However, the function's output should be 1123456789. I don't know why.

Instantiate { result: ContractResult { gas_consumed: Weight { ref_time: 173570891, proof_size: 10257 }, gas_required: Weight { ref_time: 173570891, proof_size: 10705 }, storage_deposit: StorageDeposit::Charge(2282), result: Ok(InstantiateReturnValue { result: ExecReturnValue { flags: (empty), data: [] }, addr: 0x1c81a61a407017c58397a47d2ab28191b9b8ec9b }) }, wall_time: 8.30566ms, code_hash: 0x3ad16e22428c506bcc5291a01d9fc04dc441785c9a3abbdb6012fe331f0eef22 }

[xermicus]

FIY, you first need to upload the code or instantiate it (which implies an upload). Then you use the Call SpecActions to call external functions like h(). Instantiations will always run the constructor code.

[xermicus]

You can use the the compilers integration test as an example: https://github.com/paritytech/revive/tree/main/crates/integration

PTAL at those, for example here it does exactly that: Frist instantiate ("deploy") the fixture and then call it.

The Call then should return data. Does it work like this?

[Subway2023]

There is still error.

fn main() {
    let args: Vec<String> = env::args().collect();

    if args.len() < 3 {
        eprintln!("Usage: <program> <contract_path> <data_string>");
        std::process::exit(1);
    }

    let contract_path = &args[1]; 
    let data_string = &args[2];

    let mut contract_code = Vec::new();
    let mut contract_file = File::open(contract_path).expect("Failed to open contract file");
    contract_file
        .read_to_end(&mut contract_code)
        .expect("Failed to read contract file");

    let calldata = data_string.as_bytes().to_vec();

    let results=Specs {
        actions: vec![
            Instantiate {
                origin: TestAddress::Alice,
                value: 0,
                gas_limit: Some(GAS_LIMIT),
                storage_deposit_limit: Some(DEPOSIT_LIMIT),
                code: Code::Bytes(contract_code),
                data: vec![],
                salt: OptionalHex::default(),
            },
            Call {
                origin: TestAddress::Alice,
                dest: TestAddress::Instantiated(0),
                value: 0,
                gas_limit: None,
                storage_deposit_limit: None,
                data: calldata,
            }
        ],
        ..Default::default()
    }
    .run();

    for result in results {
        println!("{:?}", result);
    }
}

thread 'main' panicked at crates/runner/src/main.rs:167:9:
assertion `left == right` failed: contract execution result mismatch: Exec { result: ContractResult { gas_consumed: Weight { ref_time: 2563298, proof_size: 0 }, gas_required: Weight { ref_time: 2563298, proof_size: 0 }, storage_deposit: StorageDeposit::Charge(0), result: Ok(ExecReturnValue { flags: REVERT, data: [] }) }, wall_time: 1.011125ms }
  left: true
 right: false

[xermicus]

By default an assertion is inserted which expects the call to succeed. The call likely reverts due to no function selector matched.

let calldata = data_string.as_bytes().to_vec();

Assuming your call data is hex encoded and correct first hand: This looks wrong.

[Subway2023]

Thank you very much, it works after the modification.

let data_string = &args[2];
let calldata = hex::decode(data_string).expect("Invalid hex string");

[Subway2023]

code

    pub fn run(self) -> Vec<CallResult> {
        if self.differential {
            #[cfg(not(feature = "solidity"))]
            panic!("{NO_SOLIDITY_FRONTEND}");
            #[cfg(feature = "solidity")]
            self.run_on_evm()
        } else {
            self
        }
        .run_on_pallet()
    }

May I ask what the difference is between run_on_evm and run_on_pallet? It seems that both are executed within PolkaVM, is that correct?

[xermicus]

The difference is that, as the name suggest, run_on_evm will run your code on the EVM (using geth). run_on_pallet will run your code in the revive pallet.

[Subway2023]

thanks

[Subway2023]

Thank you very much for your reply. I have the same issue with Solang. If you're interested, could you kindly help me with it?

[xermicus]

This is the wrong place for Solana related questions.

[Subway2023]

ok，sry