ckb-testtool 1.1.1

CKB contract testing tools
Documentation 
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

#[cfg(feature = "native-simulator")]
mod native_simulator_cases {

    use ckb_testtool::{
        ckb_types::{
            bytes::Bytes,
            core::{ScriptHashType, TransactionBuilder},
            packed::{CellInput, CellOutput},
            prelude::*,
        },
        context::Context,
    };

    const MAX_CYCLES: u64 = 500_000_000_000;

    #[test]
    fn test_spawn() {
        let mut context = Context::default();

        context.add_contract_dir("test-contracts/target/debug/");
        context.add_contract_dir("tests/test-contracts/target/debug/");
        context.add_contract_dir("test-contracts/build/release/");
        context.add_contract_dir("tests/test-contracts/build/release/");

        let out_point_parent = context.deploy_cell_by_name("simple-spawn");

        let args: Vec<u8> = vec![];

        let lock_script = context
            .build_script_with_hash_type(
                &out_point_parent,
                ScriptHashType::Data2,
                Default::default(),
            )
            .expect("script")
            .as_builder()
            .args(args.pack())
            .build();
        let input: CellInput = CellInput::new_builder()
            .previous_output(
                context.create_cell(
                    CellOutput::new_builder()
                        .capacity(1000)
                        .lock(lock_script.clone())
                        .build(),
                    Bytes::new(),
                ),
            )
            .build();

        let outputs = vec![
            CellOutput::new_builder()
                .capacity(500)
                .lock(lock_script.clone())
                .build(),
            CellOutput::new_builder()
                .capacity(500)
                .lock(lock_script)
                .build(),
        ];

        let outputs_data = vec![Bytes::new(); 2];

        // build transaction
        let tx = TransactionBuilder::default()
            // .set_inputs(vec![input, input3, input2])
            .set_inputs(vec![input])
            .outputs(outputs)
            .outputs_data(outputs_data.pack())
            .build();

        let tx = context.complete_tx(tx);

        // run
        let result = context.verify_tx(&tx, MAX_CYCLES);
        let cycles = result.unwrap();

        println!("Cycles: {}", cycles);
    }
}