fil_actor_interface 18.0.0

Backward compatibility layer for all versions of builtin actor released v8 onwards.
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
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// Copyright 2019-2023 ChainSafe Systems
// SPDX-License-Identifier: Apache-2.0, MIT

use crate::convert::{
    from_address_v3_to_v2, from_address_v4_to_v2, from_token_v3_to_v2, from_token_v4_to_v2,
};
use fvm_ipld_blockstore::Blockstore;
use fvm_ipld_encoding::RawBytes;
use fvm_shared::{address::Address, clock::ChainEpoch, econ::TokenAmount, MethodNum};
use serde::{Deserialize, Serialize};

/// Multisig actor method.
pub type Method = fil_actor_multisig_state::v8::Method;

/// Multisig actor state.
#[derive(Serialize, Debug)]
#[serde(untagged)]
pub enum State {
    V8(fil_actor_multisig_state::v8::State),
    V9(fil_actor_multisig_state::v9::State),
    V10(fil_actor_multisig_state::v10::State),
    V11(fil_actor_multisig_state::v11::State),
    V12(fil_actor_multisig_state::v12::State),
    V13(fil_actor_multisig_state::v13::State),
    V14(fil_actor_multisig_state::v14::State),
    V15(fil_actor_multisig_state::v15::State),
}

/// Transaction type used in multisig actor
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
pub struct Transaction {
    pub id: i64,
    pub to: Address,
    pub value: TokenAmount,
    pub method: MethodNum,
    pub params: RawBytes,
    pub approved: Vec<Address>,
}

impl State {
    /// Returns amount locked in multisig contract
    pub fn locked_balance(&self, height: ChainEpoch) -> anyhow::Result<TokenAmount> {
        Ok(match self {
            State::V8(st) => st.amount_locked(height - st.start_epoch),
            State::V9(st) => st.amount_locked(height - st.start_epoch),
            State::V10(st) => from_token_v3_to_v2(&st.amount_locked(height - st.start_epoch)),
            State::V11(st) => from_token_v3_to_v2(&st.amount_locked(height - st.start_epoch)),
            State::V12(st) => from_token_v4_to_v2(&st.amount_locked(height - st.start_epoch)),
            State::V13(st) => from_token_v4_to_v2(&st.amount_locked(height - st.start_epoch)),
            State::V14(st) => from_token_v4_to_v2(&st.amount_locked(height - st.start_epoch)),
            State::V15(st) => from_token_v4_to_v2(&st.amount_locked(height - st.start_epoch)),
        })
    }

    /// Returns pending transactions for the given multisig wallet
    pub fn get_pending_txn<BS: Blockstore>(&self, store: &BS) -> anyhow::Result<Vec<Transaction>> {
        let mut res = Vec::new();
        match self {
            State::V8(st) => {
                let txns = fil_actors_shared::v8::make_map_with_root::<
                    BS,
                    fil_actor_multisig_state::v8::Transaction,
                >(&st.pending_txs, store)?;
                crate::parse_pending_transactions!(res, txns);
                Ok(res)
            }
            State::V9(st) => {
                let txns = fil_actors_shared::v9::make_map_with_root::<
                    BS,
                    fil_actor_multisig_state::v9::Transaction,
                >(&st.pending_txs, store)?;
                crate::parse_pending_transactions!(res, txns);
                Ok(res)
            }
            State::V10(st) => {
                let txns = fil_actors_shared::v10::make_map_with_root::<
                    BS,
                    fil_actor_multisig_state::v10::Transaction,
                >(&st.pending_txs, store)?;
                crate::parse_pending_transactions_v3!(res, txns);
                Ok(res)
            }
            State::V11(st) => {
                let txns = fil_actors_shared::v11::make_map_with_root::<
                    BS,
                    fil_actor_multisig_state::v11::Transaction,
                >(&st.pending_txs, store)?;
                crate::parse_pending_transactions_v3!(res, txns);
                Ok(res)
            }
            State::V12(st) => {
                let txns = fil_actor_multisig_state::v12::PendingTxnMap::load(
                    store,
                    &st.pending_txs,
                    fil_actor_multisig_state::v12::PENDING_TXN_CONFIG,
                    "pending txns",
                )
                .expect("Could not load pending transactions");
                crate::parse_pending_transactions_v4!(res, txns);
                Ok(res)
            }
            State::V13(st) => {
                let txns = fil_actor_multisig_state::v13::PendingTxnMap::load(
                    store,
                    &st.pending_txs,
                    fil_actor_multisig_state::v13::PENDING_TXN_CONFIG,
                    "pending txns",
                )
                .expect("Could not load pending transactions");
                crate::parse_pending_transactions_v4!(res, txns);
                Ok(res)
            }
            State::V14(st) => {
                let txns = fil_actor_multisig_state::v14::PendingTxnMap::load(
                    store,
                    &st.pending_txs,
                    fil_actor_multisig_state::v14::PENDING_TXN_CONFIG,
                    "pending txns",
                )
                .expect("Could not load pending transactions");
                crate::parse_pending_transactions_v4!(res, txns);
                Ok(res)
            }
            State::V15(st) => {
                let txns = fil_actor_multisig_state::v15::PendingTxnMap::load(
                    store,
                    &st.pending_txs,
                    fil_actor_multisig_state::v15::PENDING_TXN_CONFIG,
                    "pending txns",
                )
                .expect("Could not load pending transactions");
                crate::parse_pending_transactions_v4!(res, txns);
                Ok(res)
            }
        }
    }
}