-
Notifications
You must be signed in to change notification settings - Fork 82
/
parameters.rs
457 lines (402 loc) · 12.3 KB
/
parameters.rs
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
use crate::admin_controlled::PausedMask;
use crate::fungible_token::FungibleTokenMetadata;
use crate::json::{JsonError, JsonValue, ParseError};
use crate::prelude::{
format, is_valid_account_id, AccountId, Balance, BorshDeserialize, BorshSerialize, EthAddress,
RawAddress, RawH256, RawU256, SdkUnwrap, String, ToString, TryFrom, Vec,
};
use crate::proof::Proof;
use evm::backend::Log;
/// Borsh-encoded parameters for the `new` function.
#[derive(BorshSerialize, BorshDeserialize)]
pub struct NewCallArgs {
/// Chain id, according to the EIP-115 / ethereum-lists spec.
pub chain_id: RawU256,
/// Account which can upgrade this contract.
/// Use empty to disable updatability.
pub owner_id: AccountId,
/// Account of the bridge prover.
/// Use empty to not use base token as bridged asset.
pub bridge_prover_id: AccountId,
/// How many blocks after staging upgrade can deploy it.
pub upgrade_delay_blocks: u64,
}
/// Borsh-encoded parameters for the `meta_call` function.
#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct MetaCallArgs {
pub signature: [u8; 64],
pub v: u8,
pub nonce: RawU256,
pub fee_amount: RawU256,
pub fee_address: RawAddress,
pub contract_address: RawAddress,
pub value: RawU256,
pub method_def: String,
pub args: Vec<u8>,
}
/// Borsh-encoded log for use in a `SubmitResult`.
#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct ResultLog {
pub topics: Vec<RawU256>,
pub data: Vec<u8>,
}
impl From<Log> for ResultLog {
fn from(log: Log) -> Self {
let topics = log
.topics
.into_iter()
.map(|topic| topic.0)
.collect::<Vec<_>>();
ResultLog {
topics,
data: log.data,
}
}
}
/// The status of a transaction.
#[derive(Debug, BorshSerialize, BorshDeserialize, PartialEq, Eq)]
pub enum TransactionStatus {
Succeed(Vec<u8>),
Revert(Vec<u8>),
OutOfGas,
OutOfFund,
OutOfOffset,
CallTooDeep,
}
impl TransactionStatus {
pub fn is_ok(&self) -> bool {
matches!(*self, TransactionStatus::Succeed(_))
}
pub fn is_revert(&self) -> bool {
matches!(*self, TransactionStatus::Revert(_))
}
pub fn is_fail(&self) -> bool {
*self == TransactionStatus::OutOfGas
|| *self == TransactionStatus::OutOfFund
|| *self == TransactionStatus::OutOfOffset
|| *self == TransactionStatus::CallTooDeep
}
}
impl AsRef<[u8]> for TransactionStatus {
fn as_ref(&self) -> &[u8] {
match self {
Self::Succeed(_) => b"SUCCESS",
Self::Revert(_) => b"ERR_REVERT",
Self::OutOfFund => b"ERR_OUT_OF_FUNDS",
Self::OutOfGas => b"ERR_OUT_OF_GAS",
Self::OutOfOffset => b"ERR_OUT_OF_OFFSET",
Self::CallTooDeep => b"ERR_CALL_TOO_DEEP",
}
}
}
/// Borsh-encoded parameters for the `call`, `call_with_args`, `deploy_code`,
/// and `deploy_with_input` methods.
#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct SubmitResult {
pub status: TransactionStatus,
pub gas_used: u64,
pub logs: Vec<ResultLog>,
}
/// Borsh-encoded parameters for the `call` function.
#[derive(BorshSerialize, BorshDeserialize)]
pub struct FunctionCallArgs {
pub contract: RawAddress,
pub input: Vec<u8>,
}
/// Borsh-encoded parameters for the `view` function.
#[derive(BorshSerialize, BorshDeserialize, Debug, Eq, PartialEq)]
pub struct ViewCallArgs {
pub sender: RawAddress,
pub address: RawAddress,
pub amount: RawU256,
pub input: Vec<u8>,
}
/// Borsh-encoded parameters for `deploy_erc20_token` function.
#[derive(BorshSerialize, BorshDeserialize, Debug, Eq, PartialEq)]
pub struct DeployErc20TokenArgs {
pub nep141: AccountId,
}
/// Borsh-encoded parameters for `get_erc20_from_nep141` function.
pub type GetErc20FromNep141CallArgs = DeployErc20TokenArgs;
/// Borsh-encoded parameters for the `get_storage_at` function.
#[derive(BorshSerialize, BorshDeserialize)]
pub struct GetStorageAtArgs {
pub address: RawAddress,
pub key: RawH256,
}
/// Borsh-encoded (genesis) account balance used by the `begin_chain` function.
#[cfg(feature = "evm_bully")]
#[derive(BorshSerialize, BorshDeserialize)]
pub struct AccountBalance {
pub address: RawAddress,
pub balance: RawU256,
}
/// Borsh-encoded parameters for the `begin_chain` function.
#[cfg(feature = "evm_bully")]
#[derive(BorshSerialize, BorshDeserialize)]
pub struct BeginChainArgs {
pub chain_id: RawU256,
pub genesis_alloc: Vec<AccountBalance>,
}
/// Borsh-encoded parameters for the `begin_block` function.
#[cfg(feature = "evm_bully")]
#[derive(BorshSerialize, BorshDeserialize)]
pub struct BeginBlockArgs {
/// The current block's hash (for replayer use).
pub hash: RawU256,
/// The current block's beneficiary address.
pub coinbase: RawAddress,
/// The current block's timestamp (in seconds since the Unix epoch).
pub timestamp: RawU256,
/// The current block's number (the genesis block is number zero).
pub number: RawU256,
/// The current block's difficulty.
pub difficulty: RawU256,
/// The current block's gas limit.
pub gaslimit: RawU256,
}
/// Borsh-encoded parameters for the `ft_transfer_call` function
/// for regular NEP-141 tokens.
pub struct NEP141FtOnTransferArgs {
pub sender_id: AccountId,
pub amount: Balance,
pub msg: String,
}
impl TryFrom<JsonValue> for NEP141FtOnTransferArgs {
type Error = JsonError;
fn try_from(value: JsonValue) -> Result<Self, Self::Error> {
Ok(Self {
sender_id: value.string("sender_id")?,
amount: value.u128("amount")?,
msg: value.string("msg")?,
})
}
}
impl TryFrom<NEP141FtOnTransferArgs> for String {
type Error = ParseError;
fn try_from(value: NEP141FtOnTransferArgs) -> Result<Self, Self::Error> {
if !is_valid_account_id(value.sender_id.as_bytes()) {
return Err(ParseError::InvalidAccountId);
}
Ok(format!(
r#"{{"sender_id": "{}", "amount": "{}", "msg": "{}"}}"#,
value.sender_id,
value.amount,
// Escape message to avoid json injection attacks
value.msg.replace("\\", "\\\\").replace("\"", "\\\"")
))
}
}
/// Eth-connector deposit arguments
#[derive(BorshSerialize, BorshDeserialize)]
pub struct DepositCallArgs {
/// Proof data
pub proof: Proof,
/// Optional relayer address
pub relayer_eth_account: Option<EthAddress>,
}
/// Eth-connector isUsedProof arguments
#[derive(BorshSerialize, BorshDeserialize)]
pub struct IsUsedProofCallArgs {
/// Proof data
pub proof: Proof,
}
/// withdraw result for eth-connector
#[derive(BorshSerialize)]
#[cfg_attr(not(target_arch = "wasm32"), derive(BorshDeserialize))]
pub struct WithdrawResult {
pub amount: Balance,
pub recipient_id: RawAddress,
pub eth_custodian_address: RawAddress,
}
/// ft_resolve_transfer eth-connector call args
#[derive(BorshSerialize)]
pub struct FtResolveTransfer {
pub receiver_id: AccountId,
pub amount: Balance,
pub current_account_id: AccountId,
}
/// Fungible token storage balance
#[derive(Default)]
pub struct StorageBalance {
pub total: Balance,
pub available: Balance,
}
impl StorageBalance {
pub fn to_json_bytes(&self) -> Vec<u8> {
format!(
"{{\"total\": \"{}\", \"available\": \"{}\"}}",
self.total.to_string(),
self.available.to_string()
)
.as_bytes()
.to_vec()
}
}
/// resolve_transfer eth-connector call args
#[derive(BorshSerialize, BorshDeserialize)]
pub struct ResolveTransferCallArgs {
pub sender_id: AccountId,
pub amount: Balance,
pub receiver_id: AccountId,
}
/// Finish deposit NEAR eth-connector call args
#[derive(BorshSerialize, BorshDeserialize)]
pub struct FinishDepositCallArgs {
pub new_owner_id: AccountId,
pub amount: Balance,
pub proof_key: String,
pub relayer_id: AccountId,
pub fee: Balance,
pub msg: Option<Vec<u8>>,
}
/// Deposit ETH args
#[derive(Default, BorshDeserialize, BorshSerialize, Clone)]
pub struct DepositEthCallArgs {
pub proof: Proof,
pub relayer_eth_account: EthAddress,
}
/// Finish deposit NEAR eth-connector call args
#[derive(BorshSerialize, BorshDeserialize)]
pub struct FinishDepositEthCallArgs {
pub new_owner_id: EthAddress,
pub amount: Balance,
pub fee: Balance,
pub relayer_eth_account: AccountId,
pub proof: Proof,
}
/// Eth-connector initial args
#[derive(BorshSerialize, BorshDeserialize)]
pub struct InitCallArgs {
pub prover_account: AccountId,
pub eth_custodian_address: AccountId,
pub metadata: FungibleTokenMetadata,
}
/// Eth-connector Set contract data call args
pub type SetContractDataCallArgs = InitCallArgs;
/// transfer eth-connector call args
#[derive(BorshSerialize, BorshDeserialize)]
pub struct TransferCallCallArgs {
pub receiver_id: AccountId,
pub amount: Balance,
pub memo: Option<String>,
pub msg: String,
}
impl From<JsonValue> for TransferCallCallArgs {
fn from(v: JsonValue) -> Self {
Self {
receiver_id: v.string("receiver_id").sdk_unwrap(),
amount: v.u128("amount").sdk_unwrap(),
memo: v.string("memo").ok(),
msg: v.string("msg").sdk_unwrap(),
}
}
}
/// storage_balance_of eth-connector call args
#[derive(BorshSerialize, BorshDeserialize)]
pub struct StorageBalanceOfCallArgs {
pub account_id: AccountId,
}
impl From<JsonValue> for StorageBalanceOfCallArgs {
fn from(v: JsonValue) -> Self {
Self {
account_id: v.string("account_id").sdk_unwrap(),
}
}
}
/// storage_deposit eth-connector call args
#[derive(BorshSerialize, BorshDeserialize)]
pub struct StorageDepositCallArgs {
pub account_id: Option<AccountId>,
pub registration_only: Option<bool>,
}
impl From<JsonValue> for StorageDepositCallArgs {
fn from(v: JsonValue) -> Self {
Self {
account_id: v.string("account_id").ok(),
registration_only: v.bool("registration_only").ok(),
}
}
}
/// storage_withdraw eth-connector call args
#[derive(BorshSerialize, BorshDeserialize)]
pub struct StorageWithdrawCallArgs {
pub amount: Option<u128>,
}
impl From<JsonValue> for StorageWithdrawCallArgs {
fn from(v: JsonValue) -> Self {
Self {
amount: v.u128("amount").ok(),
}
}
}
/// transfer args for json invocation
#[derive(BorshSerialize, BorshDeserialize)]
pub struct TransferCallArgs {
pub receiver_id: AccountId,
pub amount: Balance,
pub memo: Option<String>,
}
impl From<JsonValue> for TransferCallArgs {
fn from(v: JsonValue) -> Self {
Self {
receiver_id: v.string("receiver_id").sdk_unwrap(),
amount: v.u128("amount").sdk_unwrap(),
memo: v.string("memo").ok(),
}
}
}
/// balance_of args for json invocation
#[derive(BorshSerialize, BorshDeserialize)]
pub struct BalanceOfCallArgs {
pub account_id: AccountId,
}
#[derive(BorshSerialize, BorshDeserialize)]
pub struct BalanceOfEthCallArgs {
pub address: EthAddress,
}
impl From<JsonValue> for BalanceOfCallArgs {
fn from(v: JsonValue) -> Self {
Self {
account_id: v.string("account_id").sdk_unwrap(),
}
}
}
#[derive(BorshSerialize, BorshDeserialize)]
pub struct RegisterRelayerCallArgs {
pub address: EthAddress,
}
#[derive(BorshSerialize, BorshDeserialize)]
pub struct PauseEthConnectorCallArgs {
pub paused_mask: PausedMask,
}
impl From<JsonValue> for ResolveTransferCallArgs {
fn from(v: JsonValue) -> Self {
Self {
sender_id: v.string("sender_id").sdk_unwrap(),
receiver_id: v.string("receiver_id").sdk_unwrap(),
amount: v.u128("amount").sdk_unwrap(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_view_call_fail() {
let bytes = [0; 71];
let _ = ViewCallArgs::try_from_slice(&bytes).unwrap_err();
}
#[test]
fn test_roundtrip_view_call() {
let x = ViewCallArgs {
sender: [1; 20],
address: [2; 20],
amount: [3; 32],
input: vec![1, 2, 3],
};
let bytes = x.try_to_vec().unwrap();
let res = ViewCallArgs::try_from_slice(&bytes).unwrap();
assert_eq!(x, res);
}
}