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

use crate::scenario::model::{
    AddressValue, BigUintValue, BytesValue, TxDCT, TxTransfer, TxValidatorReward, U64Value,
};

#[derive(Debug, Default)]
pub struct TransferStep {
    pub id: String,
    pub tx_id: Option<String>,
    pub comment: Option<String>,
    pub tx: Box<TxTransfer>,
}

#[derive(Debug)]
pub struct ValidatorRewardStep {
    pub id: String,
    pub tx_id: Option<String>,
    pub comment: Option<String>,
    pub tx: Box<TxValidatorReward>,
}

impl TransferStep {
    pub fn new() -> Self {
        // 50,000 is the gas limit for simple MOAX transfers, so it is default for convenience
        // DCT transfers will need more
        Self::default().gas_limit("50,000")
    }

    pub fn from<A>(mut self, address: A) -> Self
    where
        AddressValue: From<A>,
    {
        self.tx.from = AddressValue::from(address);
        self
    }

    pub fn to<A>(mut self, address: A) -> Self
    where
        AddressValue: From<A>,
    {
        self.tx.to = AddressValue::from(address);
        self
    }

    pub fn moax_value<A>(mut self, amount: A) -> Self
    where
        BigUintValue: From<A>,
    {
        if !self.tx.dct_value.is_empty() {
            panic!("Cannot transfer both MOAX and DCT");
        }

        self.tx.moax_value = BigUintValue::from(amount);
        self
    }

    pub fn dct_transfer<T, N, A>(mut self, token_id: T, token_nonce: N, amount: A) -> Self
    where
        BytesValue: From<T>,
        U64Value: From<N>,
        BigUintValue: From<A>,
    {
        if self.tx.moax_value.value > 0u32.into() {
            panic!("Cannot transfer both MOAX and DCT");
        }

        self.tx.dct_value.push(TxDCT {
            dct_token_identifier: BytesValue::from(token_id),
            nonce: U64Value::from(token_nonce),
            dct_value: BigUintValue::from(amount),
        });

        self
    }

    pub fn gas_limit<V>(mut self, value: V) -> Self
    where
        U64Value: From<V>,
    {
        self.tx.gas_limit = U64Value::from(value);
        self
    }
}