tronic 0.4.0

A modular, async-first Rust client for the Tron blockchain.
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

use std::time::Duration;

use tronic::client::pending::{AutoSigning, ManualSigning, PendingTransaction};
use tronic::domain::permission::{Key, Ops, PermissionParams};
use tronic::domain::transaction::TxCode;
use tronic::provider::TronProvider;
use tronic::trx;

use crate::helpers::{Tronic, NODE};

#[tokio::test]
async fn multisig_trx_transfer() {
    let tronic = Tronic::new().await;
    let zion = NODE.read().zion_addr();
    let multisig_participant = NODE.read().new_account().await;

    // Configure permissions
    let mut permissions = tronic
        .account_permissions(tronic.signer_address().unwrap())
        .await
        .unwrap();
    permissions
        .set_actives(vec![PermissionParams {
            permission_name: "CustomPermissions".try_into().unwrap(),
            threshold: 2,
            parent_id: 0,
            operations: vec![Ops::TransferContract],
            keys: vec![
                Key {
                    address: multisig_participant.address(),
                    weight: 1,
                },
                Key {
                    address: tronic.signer_address().unwrap(),
                    weight: 2,
                },
            ],
        }])
        .unwrap();
    let txid = permissions
        .update_permission::<AutoSigning>()
        .await
        .unwrap()
        .broadcast(&())
        .await
        .unwrap();
    tokio::time::sleep(Duration::from_secs(7)).await;
    let txinfo = tronic.provider().get_transaction_info(txid).await.unwrap();
    assert_eq!(txinfo.result, TxCode::Sucess);

    // Make multisig transaction
    let mut tx = tronic
        .send_trx()
        .amount(trx!(1.0 TRX))
        .to(zion)
        .build::<ManualSigning>()
        .await
        .unwrap();
    tx.set_permission(2).await.unwrap();
    let tx = tx.serialize();

    let mut tx = PendingTransaction::try_deserialize(&tronic, &tx).unwrap();
    tx.sign(tronic.signer(), &()).await.unwrap();
    tx.sign(&multisig_participant, &()).await.unwrap();

    let txid = tx.broadcast().await.unwrap();

    tokio::time::sleep(Duration::from_secs(7)).await;
    let txinfo = tronic.provider().get_transaction_info(txid).await.unwrap();
    assert_eq!(txinfo.result, TxCode::Sucess);
}