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
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

use std::collections::HashMap;

use anyhow::anyhow;

use crate::contracts::AbiEncode;
use crate::domain::address::TronAddress;
use crate::domain::trx::{self, Trx};
use crate::domain::{self, Hash32};
use crate::error::Error;
use crate::Result;

#[derive(Clone, Copy, Debug)]
pub struct MockProvider;

impl MockProvider {
    pub async fn new() -> Self {
        Self
    }
}

#[async_trait::async_trait]
impl crate::provider::TronProvider for MockProvider {
    async fn trasnfer_contract(
        &self,
        _: domain::address::TronAddress,
        _: domain::address::TronAddress,
        _: trx::Trx,
    ) -> Result<domain::transaction::TransactionExtention> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn trigger_smart_contract<A: AbiEncode + Send>(
        &self,
        _: TronAddress,
        _: TronAddress,
        _: A,
    ) -> Result<domain::transaction::TransactionExtention> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn broadcast_transaction(
        &self,
        _: domain::transaction::Transaction,
    ) -> Result<()> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn estimate_energy(
        &self,
        _: domain::contract::TriggerSmartContract,
    ) -> Result<i64> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn get_account(
        &self,
        _: TronAddress,
    ) -> Result<domain::account::Account> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn get_account_resources(
        &self,
        _: TronAddress,
    ) -> Result<domain::account::AccountResourceUsage> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn trigger_constant_contract(
        &self,
        _: domain::contract::TriggerSmartContract,
    ) -> Result<domain::transaction::TransactionExtention> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn get_now_block(&self) -> Result<domain::block::BlockExtention> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn account_permission_update(
        &self,
        _: domain::contract::AccountPermissionUpdateContract,
    ) -> Result<domain::transaction::TransactionExtention> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn get_transaction_by_id(
        &self,
        _: Hash32,
    ) -> Result<domain::transaction::Transaction> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn get_transaction_info(
        &self,
        _: Hash32,
    ) -> Result<domain::transaction::TransactionInfo> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn chain_parameters(&self) -> Result<HashMap<String, i64>> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn freeze_balance(
        &self,
        _: domain::contract::FreezeBalanceV2Contract,
    ) -> Result<domain::transaction::TransactionExtention> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn unfreeze_balance(
        &self,
        _: domain::contract::UnfreezeBalanceV2Contract,
    ) -> Result<domain::transaction::TransactionExtention> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn get_reward(&self, _address: TronAddress) -> Result<Trx> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn get_delegated_resource(
        &self,
        _: TronAddress,
        _: TronAddress,
    ) -> Result<Vec<domain::account::DelegatedResource>> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
    async fn get_delegated_resource_account(
        &self,
        _: TronAddress,
    ) -> Result<domain::account::DelegatedResourceAccountIndex> {
        Err(Error::Unexpected(anyhow!("mock provider")))
    }
}