fvm_integration_tests 4.8.1 

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

// Copyright 2021-2023 Protocol Labs
// SPDX-License-Identifier: Apache-2.0, MIT
use anyhow::{Context, Result};
use cid::Cid;
use fvm::machine::{BURNT_FUNDS_ACTOR_ID, Manifest};
use fvm::state_tree::{ActorState, StateTree};
use fvm::{init_actor, system_actor};
use fvm_ipld_blockstore::Blockstore;
use fvm_ipld_encoding::CborStore;
use fvm_shared::ActorID;
use fvm_shared::address::Address;
use multihash_codetable::Code;

use crate::error::Error::{FailedToLoadManifest, FailedToSetState};

// Retrieve system, init and accounts actors code CID
pub fn fetch_builtin_code_cid(
    blockstore: &impl Blockstore,
    builtin_actors: &Cid,
    ver: u32,
) -> Result<(Cid, Cid, Cid, Cid, Cid)> {
    let manifest = Manifest::load(blockstore, builtin_actors, ver).context(FailedToLoadManifest)?;
    Ok((
        *manifest.get_system_code(),
        *manifest.get_init_code(),
        *manifest.get_account_code(),
        *manifest.get_placeholder_code(),
        *manifest.get_eam_code(),
    ))
}

pub fn set_sys_actor(
    state_tree: &mut StateTree<impl Blockstore>,
    sys_state: system_actor::State,
    sys_code_cid: Cid,
) -> Result<()> {
    let sys_state_cid = state_tree
        .store()
        .put_cbor(&sys_state, Code::Blake2b256)
        .context(FailedToSetState("system actor".to_owned()))?;

    let sys_actor_state = ActorState {
        code: sys_code_cid,
        state: sys_state_cid,
        sequence: 0,
        balance: Default::default(),
        delegated_address: None,
    };
    state_tree.set_actor(system_actor::SYSTEM_ACTOR_ID, sys_actor_state);
    Ok(())
}

pub fn set_init_actor(
    state_tree: &mut StateTree<impl Blockstore>,
    init_code_cid: Cid,
    init_state: init_actor::State,
) -> Result<()> {
    let init_state_cid = state_tree
        .store()
        .put_cbor(&init_state, Code::Blake2b256)
        .context(FailedToSetState("init actor".to_owned()))?;

    let init_actor_state = ActorState {
        code: init_code_cid,
        state: init_state_cid,
        sequence: 0,
        balance: Default::default(),
        delegated_address: None,
    };

    state_tree.set_actor(init_actor::INIT_ACTOR_ID, init_actor_state);
    Ok(())
}

pub fn set_eam_actor(state_tree: &mut StateTree<impl Blockstore>, eam_code_cid: Cid) -> Result<()> {
    const EAM_ACTOR_ID: ActorID = 10;

    let eam_state_cid = state_tree
        .store()
        .put_cbor(&[(); 0], Code::Blake2b256)
        .context(FailedToSetState("eam actor".to_owned()))?;

    let eam_actor_state = ActorState {
        code: eam_code_cid,
        state: eam_state_cid,
        sequence: 0,
        balance: Default::default(),
        delegated_address: None,
    };

    state_tree.set_actor(EAM_ACTOR_ID, eam_actor_state);
    Ok(())
}

pub fn set_burnt_funds_account(
    state_tree: &mut StateTree<impl Blockstore>,
    account_code_cid: Cid,
) -> Result<()> {
    let state = fvm::account_actor::State {
        address: Address::new_id(BURNT_FUNDS_ACTOR_ID),
    };

    let account_state_cid = state_tree
        .store()
        .put_cbor(&state, Code::Blake2b256)
        .context(FailedToSetState("burnt funds account actor".to_owned()))?;

    let actor_state = ActorState {
        code: account_code_cid,
        state: account_state_cid,
        sequence: 0,
        balance: Default::default(),
        delegated_address: None,
    };

    state_tree.set_actor(BURNT_FUNDS_ACTOR_ID, actor_state);
    Ok(())
}