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

#![allow(deprecated)]
use sp_core::RuntimeDebug;
use sp_std::prelude::*;

use bridge_types::H160;
use ethabi::{self, Function, Param, ParamType, StateMutability, Token};

fn migrate_erc20_function() -> Function {
    Function {
        name: "migrateNativeErc20".into(),
        state_mutability: StateMutability::NonPayable,
        constant: None,
        outputs: vec![],
        inputs: vec![
            Param {
                name: "contractAddress".into(),
                kind: ParamType::Address,
                internal_type: None,
            },
            Param {
                name: "erc20nativeTokens".into(),
                kind: ParamType::Array(Box::new(ParamType::Address)),
                internal_type: None,
            },
        ],
    }
}

fn migrate_eth_function() -> Function {
    Function {
        name: "migrateEth".into(),
        state_mutability: StateMutability::NonPayable,
        constant: None,
        outputs: vec![],
        inputs: vec![Param {
            name: "contractAddress".into(),
            kind: ParamType::Address,
            internal_type: None,
        }],
    }
}

fn migrate_sidechain_function() -> Function {
    Function {
        name: "migrateSidechain".into(),
        state_mutability: StateMutability::NonPayable,
        constant: None,
        outputs: vec![],
        inputs: vec![
            Param {
                name: "contractAddress".into(),
                kind: ParamType::Address,
                internal_type: None,
            },
            Param {
                name: "sidechainTokens".into(),
                kind: ParamType::Array(Box::new(ParamType::Address)),
                internal_type: None,
            },
        ],
    }
}

// Message to Ethereum (ABI-encoded)
#[derive(Clone, PartialEq, Eq, RuntimeDebug)]
pub struct MigrateErc20Payload {
    pub contract_address: H160,
    pub erc20_tokens: Vec<H160>,
}

impl MigrateErc20Payload {
    /// ABI-encode this payload
    pub fn encode(&self) -> Result<Vec<u8>, ethabi::Error> {
        let tokens = vec![
            Token::Address(self.contract_address),
            Token::Array(
                self.erc20_tokens
                    .iter()
                    .map(|token| Token::Address(*token))
                    .collect(),
            ),
        ];
        migrate_erc20_function().encode_input(tokens.as_ref())
    }
}

// Message to Ethereum (ABI-encoded)
#[derive(Clone, PartialEq, Eq, RuntimeDebug)]
pub struct MigrateSidechainPayload {
    pub contract_address: H160,
    pub sidechain_tokens: Vec<H160>,
}

impl MigrateSidechainPayload {
    /// ABI-encode this payload
    pub fn encode(&self) -> Result<Vec<u8>, ethabi::Error> {
        let tokens = vec![
            Token::Address(self.contract_address),
            Token::Array(
                self.sidechain_tokens
                    .iter()
                    .map(|token| Token::Address(*token))
                    .collect(),
            ),
        ];
        migrate_sidechain_function().encode_input(tokens.as_ref())
    }
}

// Message to Ethereum (ABI-encoded)
#[derive(Clone, PartialEq, Eq, RuntimeDebug)]
pub struct MigrateEthPayload {
    pub contract_address: H160,
}

impl MigrateEthPayload {
    /// ABI-encode this payload
    pub fn encode(&self) -> Result<Vec<u8>, ethabi::Error> {
        let tokens = vec![Token::Address(self.contract_address)];
        migrate_eth_function().encode_input(tokens.as_ref())
    }
}