Class: Etht::Carteiras

Inherits:
Object
  • Object
show all
Defined in:
lib/etht/formatar.rb,
lib/etht/carteiras.rb

Overview

classe para processar carteiras & transacoes normais e tokens

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(dad, pop) ⇒ Carteiras

Returns API etherscan - processar transacoes normais e tokens.

Parameters:

  • dad (Hash) —

    todos os dados bigquery

  • pop (Thor::CoreExt::HashWithIndifferentAccess) —

    opcoes trabalho

Options Hash (pop):

  • :h (Hash) — default: {} —

    configuracao dias ajuste reposicionamento temporal

  • :v (Boolean) — default: false —

    mostra dados transacoes normais & tokens?



21
22
23
24
25
 
# File 'lib/etht/carteiras.rb', line 21

def initialize(dad, pop)
  @api = Etherscan.new
  @dbq = dad
  @ops = pop
end

Instance Attribute Details

#api ⇒ Etherscan (readonly)

Returns API etherscan.

Returns:



10
11
12
 
# File 'lib/etht/carteiras.rb', line 10

def api
  @api
end

#dbq ⇒ Array<Hash> (readonly)

Returns todos os dados bigquery.

Returns:

  • (Array<Hash>) —

    todos os dados bigquery



12
13
14
 
# File 'lib/etht/carteiras.rb', line 12

def dbq
  @dbq
end

#ops ⇒ Thor::CoreExt::HashWithIndifferentAccess (readonly)

Returns opcoes trabalho.

Returns:

  • (Thor::CoreExt::HashWithIndifferentAccess) —

    opcoes trabalho



14
15
16
 
# File 'lib/etht/carteiras.rb', line 14

def ops
  @ops
end

Instance Method Details

#base_etherscan(hes) ⇒ Hash

Returns dados etherscan - address, saldo & transacoes.

Parameters:

  • hes (Hash) —

    dados etherscan

Returns:

  • (Hash) —

    dados etherscan - address, saldo & transacoes



76
77
78
79
80
81
82
83
 
# File 'lib/etht/carteiras.rb', line 76

def base_etherscan(hes)
  {
    ax: hes['account'],
    sl: (hes['balance'].to_d / 10**18).round(10),
    tx: etherscan_tx(hes['account']),
    kx: etherscan_kx(hes['account'])
  }
end

#bigquery_etherscan(hbq, hes) ⇒ Hash

Returns dados juntos bigquery & etherscan.

Parameters:

  • hbq (Hash) —

    dados bigquery

  • hes (Hash) —

    dados etherscan

Returns:

  • (Hash) —

    dados juntos bigquery & etherscan



88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/etht/carteiras.rb', line 88

def bigquery_etherscan(hbq, hes)
  {
    id: hbq[:id],
    ax: hbq[:ax],
    bs: hbq[:sl],
    bt: dbq[:nt].select { |t| t[:iax] == hbq[:ax] },
    bk: dbq[:nk].select { |t| t[:iax] == hbq[:ax] },
    es: hes[:sl],
    et: hes[:tx],
    ek: hes[:kx]
  }
end

#bnk ⇒ Array<Integer>

Returns lista blocknumbers de transacoes token.

Returns:

  • (Array<Integer>) —

    lista blocknumbers de transacoes token



44
45
46
47
 
# File 'lib/etht/carteiras.rb', line 44

def bnk
  @bnk ||= (des.map { |e| e[:kx].map { |n| Integer(n['blockNumber']) } }.flatten -
           (ops[:t] ? [] : dbq[:nk].map { |t| t[:blocknumber] })).uniq
end

#bnt ⇒ Array<Integer>

Returns lista blocknumbers de transacoes normais.

Returns:

  • (Array<Integer>) —

    lista blocknumbers de transacoes normais



38
39
40
41
 
# File 'lib/etht/carteiras.rb', line 38

def bnt
  @bnt ||= (des.map { |e| e[:tx].map { |n| Integer(n['blockNumber']) } }.flatten -
           (ops[:t] ? [] : dbq[:nt].map { |t| t[:blocknumber] })).uniq
end

#des ⇒ Array<Hash>

Returns todos os dados etherscan - saldos & transacoes.

Returns:

  • (Array<Hash>) —

    todos os dados etherscan - saldos & transacoes



28
29
30
 
# File 'lib/etht/carteiras.rb', line 28

def des
  @des ||= api.multi_address_balance(dbq[:wb].map { |c| c[:ax] }).map { |e| base_etherscan(e) }
end

#djn ⇒ Array<Hash>

Returns todos os dados juntos bigquery & etherscan.

Returns:

  • (Array<Hash>) —

    todos os dados juntos bigquery & etherscan



33
34
35
 
# File 'lib/etht/carteiras.rb', line 33

def djn
  @djn ||= dbq[:wb].map { |b| bigquery_etherscan(b, des.select { |s| b[:ax] == s[:ax] }.first) }
end

#etherscan_kx(add) ⇒ Array<Hash>

Returns lista transacoes token ligadas a uma carteira - sem elementos irrelevantes.

Parameters:

  • add (String) —

    endereco carteira ether

Returns:

  • (Array<Hash>) —

    lista transacoes token ligadas a uma carteira - sem elementos irrelevantes



113
114
115
116
117
118
119
 
# File 'lib/etht/carteiras.rb', line 113

def etherscan_kx(add)
  api.token_tx(add).map do |e|
    e.delete('cumulativeGasUsed')
    e.delete('confirmations')
    e
  end
end

#etherscan_tx(add) ⇒ Array<Hash>

Returns lista transacoes normais ligadas a uma carteira - sem elementos irrelevantes.

Parameters:

  • add (String) —

    endereco carteira ether

Returns:

  • (Array<Hash>) —

    lista transacoes normais ligadas a uma carteira - sem elementos irrelevantes



103
104
105
106
107
108
109
 
# File 'lib/etht/carteiras.rb', line 103

def etherscan_tx(add)
  api.normal_tx(add).map do |e|
    e.delete('cumulativeGasUsed')
    e.delete('confirmations')
    e
  end
end

#formata_carteira(hjn) ⇒ String

Returns texto formatado duma carteira.

Returns:

  • (String) —

    texto formatado duma carteira



20
21
22
23
24
25
26
 
# File 'lib/etht/formatar.rb', line 20

def formata_carteira(hjn)
  format(
    '%<s1>-6.6s %<s2>-34.34s ',
    s1: hjn[:id],
    s2: formata_endereco(hjn[:ax], 34)
  ) + formata_valores(hjn)
end

#formata_endereco(add, max) ⇒ String

Returns endereco ether formatado.

Examples:

ether address inicio..fim

0x10f3a0cf0b534c..c033cf32e8a03586

Parameters:

  • add (String) —

    endereco carteira ether

  • max (Integer) —

    chars a mostrar

Returns:

  • (String) —

    endereco ether formatado



12
13
14
15
16
 
# File 'lib/etht/formatar.rb', line 12

def formata_endereco(add, max)
  i = Integer((max - 2) / 2)
  e = (max <= 20 ? dbq[:wb].select { |s| s[:ax] == add }.first : nil) || { id: add }
  max < 7 ? 'erro' : "#{e[:id][0, i - 3]}..#{add[-i - 3..]}"
end

#formata_transacao_norml(htx) ⇒ String

Returns texto formatado transacao normal.

Returns:

  • (String) —

    texto formatado transacao normal



51
52
53
54
55
56
57
58
59
60
 
# File 'lib/etht/formatar.rb', line 51

def formata_transacao_norml(htx)
  format(
    '%<bn>9i %<fr>-20.20s %<to>-20.20s %<dt>10.10s %<vl>17.6f',
    bn: htx['blockNumber'],
    fr: formata_endereco(htx['from'], 20),
    to: formata_endereco(htx['to'], 20),
    dt: Time.at(Integer(htx['timeStamp'])),
    vl: (htx['value'].to_d / 10**18).round(10)
  )
end

#formata_transacao_token(hkx) ⇒ String

Returns texto formatado transacao token.

Returns:

  • (String) —

    texto formatado transacao token



64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/etht/formatar.rb', line 64

def formata_transacao_token(hkx)
  format(
    '%<bn>9i %<fr>-20.20s %<to>-20.20s %<dt>10.10s %<sy>-5.5s %<vl>11.3f',
    bn: hkx['blockNumber'],
    fr: formata_endereco(hkx['from'], 20),
    to: formata_endereco(hkx['to'], 20),
    dt: Time.at(Integer(hkx['timeStamp'])),
    vl: (hkx['value'].to_d / 10**18).round(10),
    sy: hkx['tokenSymbol']
  )
end

#formata_valores(hjn) ⇒ String

Returns texto formatado valores duma carteira.

Returns:

  • (String) —

    texto formatado valores duma carteira



36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/etht/formatar.rb', line 36

def formata_valores(hjn)
  format(
    '%<v1>10.6f %<n1>2i %<n3>2i %<v2>11.6f %<n2>2i %<n4>2i %<ok>-3s',
    v1: hjn[:bs],
    n1: hjn[:bt].count,
    n3: hjn[:bk].count,
    v2: hjn[:es],
    n2: hjn[:et].count,
    n4: hjn[:ek].count,
    ok: ok?(hjn) ? 'OK' : 'NOK'
  )
end

#mostra_configuracao_ajuste_dias ⇒ String

Returns texto configuracao ajuste dias das transacoes (normais & tokan).

Returns:

  • (String) —

    texto configuracao ajuste dias das transacoes (normais & tokan)



104
105
106
107
108
 
# File 'lib/etht/formatar.rb', line 104

def mostra_configuracao_ajuste_dias
  return unless (norml.count + token.count).positive?

  puts("\nstring ajuste dias\n-h=#{todas_sort.map { |e| "#{e['blockNumber']}:0" }.join(' ')}")
end

#mostra_resumo ⇒ String

Returns texto carteiras & transacoes & ajuste dias.

Returns:

  • (String) —

    texto carteiras & transacoes & ajuste dias



77
78
79
80
81
82
83
84
85
 
# File 'lib/etht/formatar.rb', line 77

def mostra_resumo
  return unless djn.count.positive?

  puts("\nid     address                            ----bigquery---- ----etherscan----")
  djn.each { |e| puts(formata_carteira(e)) }
  mostra_transacao_norml
  mostra_transacao_token
  mostra_configuracao_ajuste_dias
end

#mostra_transacao_norml ⇒ String

Returns texto transacoes normais.

Returns:

  • (String) —

    texto transacoes normais



88
89
90
91
92
93
 
# File 'lib/etht/formatar.rb', line 88

def mostra_transacao_norml
  return unless ops[:v] && norml.count.positive?

  puts("\ntx normal address from         address to           ---data--- ------valor------")
  norml_sort.each { |e| puts(formata_transacao_norml(e)) }
end

#mostra_transacao_token ⇒ String

Returns texto transacoes token.

Returns:

  • (String) —

    texto transacoes token



96
97
98
99
100
101
 
# File 'lib/etht/formatar.rb', line 96

def mostra_transacao_token
  return unless ops[:v] && token.count.positive?

  puts("\ntx token  address from         address to           ---data--- token ---valor---")
  token_sort.each { |e| puts(formata_transacao_token(e)) }
end

#norml ⇒ Array<Hash>

Returns lista transacoes normais.

Returns:

  • (Array<Hash>) —

    lista transacoes normais



50
51
52
 
# File 'lib/etht/carteiras.rb', line 50

def norml
  @norml ||= des.map { |e| e[:tx].select { |s| bnt.include?(Integer(s['blockNumber'])) } }.flatten.uniq
end

#norml_sort ⇒ Array<Hash>

Returns lista ordenada transacoes normais.

Returns:

  • (Array<Hash>) —

    lista ordenada transacoes normais



60
61
62
 
# File 'lib/etht/carteiras.rb', line 60

def norml_sort
  norml.sort { |a, b| Integer(a['blockNumber']) <=> Integer(b['blockNumber']) }
end

#ok?(hjn) ⇒ Boolean

Returns carteira tem transacoes novas(sim=NOK, nao=OK)?.

Returns:

  • (Boolean) —

    carteira tem transacoes novas(sim=NOK, nao=OK)?



30
31
32
 
# File 'lib/etht/formatar.rb', line 30

def ok?(hjn)
  hjn[:bs] == hjn[:es] && hjn[:bt].count == hjn[:et].count && hjn[:bk].count == hjn[:ek].count
end

#todas_sort ⇒ Array<Hash>

Returns lista ordenada todas as transacoes (normais & tokan).

Returns:

  • (Array<Hash>) —

    lista ordenada todas as transacoes (normais & tokan)



70
71
72
 
# File 'lib/etht/carteiras.rb', line 70

def todas_sort
  (norml + token).sort { |a, b| Integer(a['blockNumber']) <=> Integer(b['blockNumber']) }
end

#token ⇒ Array<Hash>

Returns lista transacoes tokan.

Returns:

  • (Array<Hash>) —

    lista transacoes tokan



55
56
57
 
# File 'lib/etht/carteiras.rb', line 55

def token
  @token ||= des.map { |e| e[:kx].select { |s| bnk.include?(Integer(s['blockNumber'])) } }.flatten.uniq
end

#token_sort ⇒ Array<Hash>

Returns lista ordenada transacoes tokan.

Returns:

  • (Array<Hash>) —

    lista ordenada transacoes tokan



65
66
67
 
# File 'lib/etht/carteiras.rb', line 65

def token_sort
  token.sort { |a, b| Integer(a['blockNumber']) <=> Integer(b['blockNumber']) }
end