Class: Bct::Etherscan

Inherits:
Object
  • Object
show all
Defined in:
lib/bct/etherscan1.rb,
lib/bct/etherscan2.rb

Overview

classe para processar carteiras & transacoes normais e tokens

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(dad, pop) ⇒ Etherscan

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?



24
25
26
27
28
 
# File 'lib/bct/etherscan1.rb', line 24

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

Instance Attribute Details

#api ⇒ Apies (readonly)

Returns API etherscan.

Returns:

  • (Apies) —

    API etherscan



13
14
15
 
# File 'lib/bct/etherscan1.rb', line 13

def api
  @api
end

#dbq ⇒ Array<Hash> (readonly)

Returns todos os dados bigquery.

Returns:

  • (Array<Hash>) —

    todos os dados bigquery



15
16
17
 
# File 'lib/bct/etherscan1.rb', line 15

def dbq
  @dbq
end

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

Returns opcoes trabalho.

Returns:

  • (Thor::CoreExt::HashWithIndifferentAccess) —

    opcoes trabalho



17
18
19
 
# File 'lib/bct/etherscan1.rb', line 17

def ops
  @ops
end

Instance Method Details

#base_bc(hbc) ⇒ Hash

Returns dados etherscan - address, saldo & transacoes.

Parameters:

  • hbc (Hash) —

    dados etherscan

Returns:

  • (Hash) —

    dados etherscan - address, saldo & transacoes



67
68
69
70
71
72
73
74
75
 
# File 'lib/bct/etherscan1.rb', line 67

def base_bc(hbc)
  a = hbc[:account]
  {
    ax: a,
    sl: (hbc[:balance].to_d / 10**18).round(10),
    tx: filtrar_tx(a, api.norml_tx(a)),
    kx: filtrar_tx(a, api.token_tx(a))
  }
end

#bnk ⇒ Array<Integer>

Returns lista indices transacoes token novas.

Returns:

  • (Array<Integer>) —

    lista indices transacoes token novas



51
52
53
 
# File 'lib/bct/etherscan1.rb', line 51

def bnk
  @bnk ||= (dbc.map { |e| e[:kx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : dbq[:nk].map { |t| t[:itx] }))
end

#bnt ⇒ Array<Integer>

Returns lista indices transacoes normais novas.

Returns:

  • (Array<Integer>) —

    lista indices transacoes normais novas



46
47
48
 
# File 'lib/bct/etherscan1.rb', line 46

def bnt
  @bnt ||= (dbc.map { |e| e[:tx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : dbq[:nt].map { |t| t[:itx] }))
end

#bq_bc(hbq, hbc) ⇒ Hash

Returns dados juntos bigquery & etherscan.

Parameters:

  • hbq (Hash) —

    dados bigquery

  • hbc (Hash) —

    dados etherscan

Returns:

  • (Hash) —

    dados juntos bigquery & etherscan



80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/bct/etherscan1.rb', line 80

def bq_bc(hbq, hbc)
  {
    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: hbc[:sl],
    et: hbc[:tx],
    ek: hbc[:kx]
  }
end

#dados ⇒ Array<Hash>

Returns todos os dados juntos bigquery & etherscan.

Returns:

  • (Array<Hash>) —

    todos os dados juntos bigquery & etherscan



41
42
43
 
# File 'lib/bct/etherscan1.rb', line 41

def dados
  @dados ||= dbq[:wb].map { |b| bq_bc(b, dbc.select { |s| b[:ax] == s[:ax] }.first) }
end

#dbc ⇒ Array<Hash>

Returns todos os dados etherscan - saldos & transacoes.

Returns:

  • (Array<Hash>) —

    todos os dados etherscan - saldos & transacoes



36
37
38
 
# File 'lib/bct/etherscan1.rb', line 36

def dbc
  @dbc ||= api.(lax).map { |e| base_bc(e) }
end

#filtrar_tx(add, ary) ⇒ Array<Hash>

Returns devolve lista de transacoes/token transfer events filtrada.

Parameters:

  • add (String) —

    endereco carteira ETH

  • ary (Array<Hash>) —

    lista das transacoes

Returns:

  • (Array<Hash>) —

    devolve lista de transacoes/token transfer events filtrada



96
97
98
99
100
101
 
# File 'lib/bct/etherscan1.rb', line 96

def filtrar_tx(add, ary)
  # elimina transferencia from: (lax) to: (add) - esta transferencia aparece em from: (add) to: (lax)
  # elimina chaves irrelevantes (DL) & adiciona chave indice itx & adiciona identificador da carteira iax
  ary.delete_if { |h| h[:to] == add && lax.include?(h[:from]) }
     .map { |h| h.delete_if { |k, _| DL.include?(k) }.merge(itx: Integer(h[:blockNumber]), iax: add) }
end

#formata_carteira(hjn) ⇒ String

Returns texto formatado duma carteira.

Parameters:

  • hjn (Hash) —

    dados juntos bigquery & etherscan

Returns:

  • (String) —

    texto formatado duma carteira



9
10
11
12
13
14
15
 
# File 'lib/bct/etherscan2.rb', line 9

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

#formata_endereco(add, max) ⇒ String

Returns endereco formatado.

Examples:

ether address inicio..fim

0x10f3a0cf0b534c..c033cf32e8a03586

Parameters:

  • max (Integer) —

    chars a mostrar

  • add (String) —

    endereco carteira ETH

Returns:

  • (String) —

    endereco formatado



43
44
45
46
47
 
# File 'lib/bct/etherscan2.rb', line 43

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.

Parameters:

  • htx (Hash) —

    transacao normal

Returns:

  • (String) —

    texto formatado transacao normal



51
52
53
54
55
56
57
58
59
60
 
# File 'lib/bct/etherscan2.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.

Parameters:

  • hkx (Hash) —

    transacao token

Returns:

  • (String) —

    texto formatado transacao token



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

def formata_transacao_token(hkx)
  format(
    '%<bn>9i %<fr>-20.20s %<to>-20.20s %<dt>10.10s %<vl>11.3f %<sy>-5.5s',
    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.

Parameters:

  • hjn (Hash) —

    dados juntos bigquery & etherscan

Returns:

  • (String) —

    texto formatado valores duma carteira



19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/bct/etherscan2.rb', line 19

def formata_valores(hjn)
  format(
    '%<v1>11.6f %<n1>2i %<n3>2i %<v2>12.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

#lax ⇒ Array<String>

Returns lista dos meus enderecos.

Returns:

  • (Array<String>) —

    lista dos meus enderecos



31
32
33
 
# File 'lib/bct/etherscan1.rb', line 31

def lax
  @lax ||= dbq[:wb].map { |h| h[:ax] }
end

#mostra_configuracao_ajuste_dias ⇒ String

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

Returns:

  • (String) —

    texto configuracao ajuste dias das transacoes (normais & token)



104
105
106
107
108
 
# File 'lib/bct/etherscan2.rb', line 104

def mostra_configuracao_ajuste_dias
  return unless (novtx.count + novkx.count).positive?

  puts("\nstring ajuste dias\n-h=#{sorax.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/bct/etherscan2.rb', line 77

def mostra_resumo
  return unless dados.count.positive?

  puts("\nid     address                             bigquery nm tk    etherscan nm tk")
  dados.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/bct/etherscan2.rb', line 88

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

  puts("\ntx normal from                 to                   data                   valor")
  sortx.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/bct/etherscan2.rb', line 96

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

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

#novkx ⇒ Array<Hash>

Returns lista transacoes token novas.

Returns:

  • (Array<Hash>) —

    lista transacoes token novas



61
62
63
 
# File 'lib/bct/etherscan1.rb', line 61

def novkx
  @novkx ||= dbc.map { |e| e[:kx].select { |n| bnk.include?(n[:itx]) } }.flatten
end

#novtx ⇒ Array<Hash>

Returns lista transacoes normais novas.

Returns:

  • (Array<Hash>) —

    lista transacoes normais novas



56
57
58
 
# File 'lib/bct/etherscan1.rb', line 56

def novtx
  @novtx ||= dbc.map { |e| e[:tx].select { |n| bnt.include?(n[:itx]) } }.flatten
end

#ok?(hjn) ⇒ Boolean

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

Parameters:

  • hjn (Hash) —

    dados juntos bigquery & etherscan

Returns:

  • (Boolean) —

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



34
35
36
 
# File 'lib/bct/etherscan2.rb', line 34

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

#sorax ⇒ Array<Hash>

Returns lista ordenada transacoes (normais & token) novas.

Returns:

  • (Array<Hash>) —

    lista ordenada transacoes (normais & token) novas



114
115
116
 
# File 'lib/bct/etherscan1.rb', line 114

def sorax
  (novtx + novkx).sort { |a, b| a[:itx] <=> b[:itx] }
end

#sorkx ⇒ Array<Hash>

Returns lista ordenada transacoes token novas.

Returns:

  • (Array<Hash>) —

    lista ordenada transacoes token novas



109
110
111
 
# File 'lib/bct/etherscan1.rb', line 109

def sorkx
  novkx.sort { |a, b| a[:itx] <=> b[:itx] }
end

#sortx ⇒ Array<Hash>

Returns lista ordenada transacoes normais novas.

Returns:

  • (Array<Hash>) —

    lista ordenada transacoes normais novas



104
105
106
 
# File 'lib/bct/etherscan1.rb', line 104

def sortx
  novtx.sort { |a, b| a[:itx] <=> b[:itx] }
end