Class: Peatio::Tron::Wallet

Inherits:
Wallet::Abstract
  • Object
show all
Includes:
Encryption
Defined in:
lib/peatio/tron/wallet.rb

Constant Summary collapse

DEFAULT_FEE = 
{ fee_limit: 1000000 }
DEFAULT_FEATURES = 
{ skip_deposit_collection: false }.freeze

Constants included from Encryption

Encryption::ALGO

Instance Method Summary collapse

Methods included from Encryption

#abi_encode, #decode_hex, #encode_hex, #reformat_decode_address, #reformat_encode_address, #reformat_txid

Constructor Details

#initialize(custom_features = {}) ⇒ Wallet

Returns a new instance of Wallet.



9
10
11
12
 
# File 'lib/peatio/tron/wallet.rb', line 9

def initialize(custom_features = {})
  @features = DEFAULT_FEATURES.merge(custom_features).slice(*SUPPORTED_FEATURES)
  @settings = {}
end

Instance Method Details

#configure(settings = {}) ⇒ Object 



14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/peatio/tron/wallet.rb', line 14

def configure(settings = {})
  # Clean client state during configure.
  @client = nil

  @settings.merge!(settings.slice(*SUPPORTED_SETTINGS))

  @wallet = @settings.fetch(:wallet) do
    raise Peatio::Wallet::MissingSettingError, :wallet
  end.slice(:uri, :address, :secret)

  @currency = @settings.fetch(:currency) do
    raise Peatio::Wallet::MissingSettingError, :currency
  end.slice(:id, :base_factor, :options)
end

#create_address!(options = {}) ⇒ Object 



29
30
31
32
33
34
 
# File 'lib/peatio/tron/wallet.rb', line 29

def create_address!(options = {})
  client.json_rpc(path: 'wallet/generateaddress')
        .yield_self { |r| { address: r.fetch('address'), secret: r.fetch('privateKey') } }
rescue Tron::Client::Error => e
  raise Peatio::Wallet::ClientError, e
end

#create_transaction!(transaction, options = {}) ⇒ Object 



36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/peatio/tron/wallet.rb', line 36

def create_transaction!(transaction, options = {})
  if @currency.dig(:options, :trc10_token_id).present?
    create_trc10_transaction!(transaction)
  elsif @currency.dig(:options, :trc20_contract_address).present?
    create_trc20_transaction!(transaction, options)
  else
    create_coin_transaction!(transaction, options)
  end
rescue Tron::Client::Error => e
  raise Peatio::Wallet::ClientError, e
end

#load_balance! ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/peatio/tron/wallet.rb', line 65

def load_balance!
  if @currency.dig(:options, :trc10_token_id).present?
    client.json_rpc(path: 'wallet/getaccount',
                    params: { address: reformat_decode_address(@wallet.fetch(:address)) }
    ).fetch('assetV2', [])
          .find { |a| a['key'] == @currency[:options][:trc10_token_id] }
          .try(:fetch, 'value', 0)
  elsif @currency.dig(:options, :trc20_contract_address).present?
    client.json_rpc(path: 'wallet/triggersmartcontract',
                    params: {
                      owner_address: reformat_decode_address(@wallet.fetch(:address)),
                      contract_address: reformat_decode_address(@currency.dig(:options, :trc20_contract_address)),
                      function_selector: 'balanceOf(address)',
                      parameter: abi_encode(reformat_decode_address(@wallet.fetch(:address))[2..42]) }
    ).fetch('constant_result')[0].hex
  else
    client.json_rpc(path: 'wallet/getaccount',
                    params: { address: reformat_decode_address(@wallet.fetch(:address)) }
    ).fetch('balance', nil)
  end.yield_self { |amount| convert_from_base_unit(amount.to_i) }
rescue Tron::Client::Error => e
  raise Peatio::Wallet::ClientError, e
end

#prepare_deposit_collection!(transaction, deposit_spread, deposit_currency) ⇒ Object 



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/peatio/tron/wallet.rb', line 48

def prepare_deposit_collection!(transaction, deposit_spread, deposit_currency)
  # Don't prepare for deposit_collection in case of coin(tron) deposit.
  return [] if is_coin?(deposit_currency)
  return [] if deposit_spread.blank?

  options = DEFAULT_FEE.merge(deposit_currency.fetch(:options).slice(:fee_limit))

  # We collect fees depending on the number of spread deposit size
  # Example: if deposit spreads on three wallets need to collect tron fee for 3 transactions
  fees = convert_from_base_unit(options.fetch(:fee_limit).to_i)
  transaction.amount = fees * deposit_spread.size

  [create_coin_transaction!(transaction)]
rescue Tron::Client::Error => e
  raise Peatio::Wallet::ClientError, e
end