revive-runner 0.2.0

Execute revive contracts in a simulated blockchain runtime
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use std::path::PathBuf;

use clap::Parser;

use revive_runner::{Code, OptionalHex, Specs, SpecsAction::*, TestAddress};

/// Execute revive PolkaVM contracts locally.
#[derive(Parser)]
#[command(version, about, long_about = None)]
struct Arguments {
    /// The hex encoded calldata for the contract call.
    #[arg(short, long)]
    calldata: Option<String>,

    /// The hex encoded calldata for the contract deployment.
    #[arg(short, long)]
    deploy_calldata: Option<String>,

    /// The hex encoded contract code blob to instantiate and execute.
    #[arg(short, long)]
    blob: Option<String>,

    /// The contract code to instantiate and execute.
    #[arg(short, long)]
    file: Option<PathBuf>,

    /// The origin account used to initiate the deploy and call transactions.
    #[arg(short, long)]
    origin: Option<TestAddress>,

    /// The value the call transaction is endowed with.
    #[arg(short, long)]
    value: Option<u128>,

    /// The value the deploy transaction is endowed with.
    #[arg(long)]
    deploy_value: Option<u128>,
}

fn main() -> anyhow::Result<()> {
    env_logger::init();

    let arguments = Arguments::parse();

    let code = match (arguments.blob, arguments.file) {
        (Some(blob), None) => hex::decode(blob)
            .map_err(|error| anyhow::anyhow!("expected hex encoded PVM blob: {error}"))?,
        (None, Some(file)) => std::fs::read(&file).map_err(|error| {
            anyhow::anyhow!("unable to read PVM file {}: {error}", file.display())
        })?,
        _ => anyhow::bail!("should either provide a PVM blob or a PVM file"),
    };
    let calldata = match arguments.calldata {
        Some(calldata) => hex::decode(calldata)
            .map_err(|error| anyhow::anyhow!("expected hex encoded calldata: {error}"))?,
        None => vec![],
    };
    let deploy_calldata = match arguments.deploy_calldata {
        Some(calldata) => hex::decode(calldata)
            .map_err(|error| anyhow::anyhow!("expected hex encoded calldata: {error}"))?,
        None => vec![],
    };
    let origin = arguments.origin.unwrap_or(TestAddress::Alice);

    let actions = vec![
        Instantiate {
            origin: origin.clone(),
            value: arguments.deploy_value.unwrap_or(0),
            gas_limit: None,
            storage_deposit_limit: None,
            code: Code::Bytes(code),
            data: deploy_calldata,
            salt: OptionalHex::default(),
        },
        Call {
            origin,
            dest: TestAddress::Instantiated(0),
            value: arguments.value.unwrap_or(0),
            gas_limit: None,
            storage_deposit_limit: None,
            data: calldata,
        },
    ];

    Specs {
        actions,
        differential: false,
        ..Default::default()
    }
    .run();

    Ok(())
}