cns 0.1.1 → 0.1.2

data/lib/cns/etherscan2.rb

@@ -2,8 +2,19 @@
 
 # @author Hernani Rodrigues Vaz
 module Cns
-  # classe para processar carteiras & transacoes normais e tokens
+  # classe para processar transacoes do etherscan
   class Etherscan
+    # @return [String] texto carteiras & transacoes & ajuste dias
+    def mostra_resumo
+      return unless dados.count.positive?
+
+      puts("\nid     address                            etherscan nm tk     bigquery nm tk")
+      dados.each { |e| puts(formata_carteira(e)) }
+      mostra_transacao_norml
+      mostra_transacao_token
+      mostra_configuracao_ajuste_dias
+    end
+
     # @param [Hash] hjn dados juntos bigquery & etherscan
     # @return [String] texto formatado duma carteira
     def formata_carteira(hjn)
@@ -19,12 +30,12 @@ module Cns
     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,
+        v1: hjn[:es],
+        n1: hjn[:et].count,
+        n3: hjn[:ek].count,
+        v2: hjn[:bs],
+        n2: hjn[:bt].count,
+        n4: hjn[:bk].count,
         ok: ok?(hjn) ? 'OK' : 'NOK'
       )
     end
@@ -42,12 +53,13 @@ module Cns
     # @return [String] endereco formatado
     def formata_endereco(add, max)
       i = Integer((max - 2) / 2)
-      e = (max <= 20 ? dbq[:wb].select { |s| s[:ax] == add }.first : nil) || { id: add }
+      e = (max <= 20 ? bqd[:wb].select { |s| s[:ax] == add }.first : nil) || { id: add }
       max < 7 ? 'erro' : "#{e[:id][0, i - 3]}..#{add[-i - 3..]}"
     end
 
-    # @param [Hash] htx transacao normal
-    # @return [String] texto formatado transacao normal
+    # @example (see Apibc#norml_es)
+    # @param [Hash] htx transacao normal etherscan
+    # @return [String] texto formatado transacao normal etherscan
     def formata_transacao_norml(htx)
       format(
         '%<bn>9i %<fr>-20.20s %<to>-20.20s %<dt>10.10s %<vl>17.6f',
@@ -59,8 +71,9 @@ module Cns
       )
     end
 
-    # @param [Hash] hkx transacao token
-    # @return [String] texto formatado transacao token
+    # @example (see Apibc#token_es)
+    # @param [Hash] hkx transacao token etherscan
+    # @return [String] texto formatado transacao token etherscan
     def formata_transacao_token(hkx)
       format(
         '%<bn>9i %<fr>-20.20s %<to>-20.20s %<dt>10.10s %<vl>11.3f %<sy>-5.5s',
@@ -73,17 +86,6 @@ module Cns
       )
     end
 
-    # @return [String] texto carteiras & transacoes & ajuste dias
-    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
-
     # @return [String] texto transacoes normais
     def mostra_transacao_norml
       return unless ops[:v] && novtx.count.positive?

data/lib/cns/greymass1.rb

@@ -6,10 +6,10 @@ require('bigdecimal/util')
 module Cns
   # (see Greymass)
   class Greymass
-    # @return [Apigm] API greymass
+    # @return [Apibc] API blockchains
     attr_reader :api
     # @return [Array<Hash>] todos os dados bigquery
-    attr_reader :dbq
+    attr_reader :bqd
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
     attr_reader :ops
 
@@ -20,56 +20,57 @@ module Cns
     # @option pop [Boolean] :t (false) mostra transacoes todas ou somente novas?
     # @return [Greymass] API greymass - processar transacoes
     def initialize(dad, pop)
-      @api = Apigm.new
-      @dbq = dad
+      @api = Apibc.new
+      @bqd = dad
       @ops = pop
     end
 
+    # @return [Array<Hash>] lista transacoes novas
+    def novax
+      @novax ||= bcd.map { |e| e[:tx].select { |s| idt.include?(s[:itx]) } }.flatten
+    end
+
     # @return [Array<String>] lista dos meus enderecos
     def lax
-      @lax ||= dbq[:wb].map { |h| h[:ax] }
+      @lax ||= bqd[:wb].map { |h| h[:ax] }
     end
 
     # @return [Array<Hash>] todos os dados greymass - saldos & transacoes
-    def dbc
-      @dbc ||= dbq[:wb].map { |e| base_bc(e) }
+    def bcd
+      @bcd ||= bqd[:wb].map { |e| base_bc(e) }
     end
 
     # @return [Array<Hash>] todos os dados juntos bigquery & greymass
     def dados
-      @dados ||= dbq[:wb].map { |b| bq_bc(b, dbc.select { |s| b[:ax] == s[:ax] }.first) }
+      @dados ||= bqd[:wb].map { |b| bq_bc(b, bcd.select { |s| b[:ax] == s[:ax] }.first) }
     end
 
     # @return [Array<Integer>] lista indices transacoes novas
-    def bnt
-      @bnt ||= (dbc.map { |e| e[:tx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : dbq[:nt].map { |t| t[:itx] }))
-    end
-
-    # @return [Array<Hash>] lista transacoes novas
-    def novax
-      @novax ||= dbc.map { |e| e[:tx].select { |s| bnt.include?(s[:itx]) } }.flatten
+    def idt
+      @idt ||= (bcd.map { |e| e[:tx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : bqd[:nt].map { |t| t[:itx] }))
     end
 
-    # @param [Hash] hbq dados bigquery wallet
+    # @example (see Apibc#account_gm)
+    # @param [Hash] wbq wallet bigquery
     # @return [Hash] dados greymass - address, saldo & transacoes
-    def base_bc(hbq)
-      a = hbq[:ax]
+    def base_bc(wbq)
+      a = wbq[:ax]
       {
         ax: a,
         sl: greymass_sl(a).inject(:+),
-        tx: filtrar_tx(a, api.all_tx(a))
+        tx: filtrar_tx(a, api.ledger_gm(a))
       }
     end
 
-    # @param hbq (see base_bc)
-    # @param [Hash] hbc dados greymass
+    # @param wbq (see base_bc)
+    # @param [Hash] hbc dados greymass - address, saldo & transacoes
     # @return [Hash] dados juntos bigquery & greymass
-    def bq_bc(hbq, hbc)
+    def bq_bc(wbq, hbc)
       {
-        id: hbq[:id],
-        ax: hbq[:ax],
-        bs: hbq[:sl],
-        bt: dbq[:nt].select { |t| t[:iax] == hbq[:ax] },
+        id: wbq[:id],
+        ax: wbq[:ax],
+        bs: wbq[:sl],
+        bt: bqd[:nt].select { |t| t[:iax] == wbq[:ax] },
         es: hbc[:sl],
         et: hbc[:tx]
       }
@@ -78,7 +79,7 @@ module Cns
     # @param (see filtrar_tx)
     # @return [Array<BigDecimal>] lista recursos - liquido, net, spu
     def greymass_sl(add)
-      v = api.account(account_name: add)
+      v = api.account_gm(add)
       [
         v[:core_liquid_balance].to_d,
         v[:total_resources][:net_weight].to_d,
@@ -86,9 +87,9 @@ module Cns
       ]
     end
 
-    # @param [String] add endereco carteira EOS
-    # @param [Array<Hash>] ary lista das transacoes
-    # @return [Array<Hash>] lista transacoes ligadas a uma carteira filtrada
+    # @param add (see Apibc#account_gm)
+    # @param [Array<Hash>] ary lista transacoes
+    # @return [Array<Hash>] lista transacoes filtrada
     def filtrar_tx(add, ary)
       # elimina transferencia from: (lax) to: (add) - esta transferencia aparece em from: (add) to: (lax)
       # adiciona chave indice itx & adiciona identificador da carteira iax

data/lib/cns/greymass2.rb

@@ -2,18 +2,28 @@
 
 # @author Hernani Rodrigues Vaz
 module Cns
-  # classe para processar carteiras & transacoes
+  # classe para processar transacoes do greymass
   class Greymass
+    # @return [String] texto carteiras & transacoes & ajuste dias
+    def mostra_resumo
+      return unless dados.count.positive?
+
+      puts("\naddress            greymass  ntx       bigquery  ntx")
+      dados.each { |e| puts(formata_carteira(e)) }
+      mostra_transacoes_novas
+      mostra_configuracao_ajuste_dias
+    end
+
     # @param [Hash] hjn dados juntos bigquery & greymass
     # @return [String] texto formatado duma carteira
     def formata_carteira(hjn)
       format(
         '%<s1>-12.12s %<v1>14.4f %<n1>4i %<v2>14.4f %<n2>4i %<ok>-3s',
         s1: hjn[:ax],
-        v1: hjn[:bs],
-        n1: hjn[:bt].count,
-        v2: hjn[:es],
-        n2: hjn[:et].count,
+        v1: hjn[:es],
+        n1: hjn[:et].count,
+        v2: hjn[:bs],
+        n2: hjn[:bt].count,
         ok: ok?(hjn) ? 'OK' : 'NOK'
       )
     end
@@ -24,47 +34,38 @@ module Cns
       hjn[:bs] == hjn[:es] && hjn[:bt].count == hjn[:et].count
     end
 
-    # @param [Hash] htx transacao
-    # @return [String] texto formatado transacao
-    def formata_transacao(htx)
+    # @example (see Apibc#ledger_gm)
+    # @param [Hash] hlx ledger greymass
+    # @return [String] texto formatado ledger greymass
+    def formata_ledger(hlx)
       format(
         '%<bn>12i %<fr>-12.12s %<to>-12.12s %<ac>-10.10s %<dt>10.10s %<vl>12.4f %<sy>-6.6s',
-        bn: htx[:itx],
-        fr: act_data(htx)[:from],
-        to: act_data(htx)[:to],
-        ac: act(htx)[:name],
-        dt: Date.parse(htx[:block_time]),
-        vl: act_data_quantity(htx).to_d,
-        sy: act_data_quantity(htx)[/[[:upper:]]+/]
+        bn: hlx[:itx],
+        fr: act_data(hlx)[:from],
+        to: act_data(hlx)[:to],
+        ac: act(hlx)[:name],
+        dt: Date.parse(hlx[:block_time]),
+        vl: act_data_quantity(hlx).to_d,
+        sy: act_data_quantity(hlx)[/[[:upper:]]+/]
       )
     end
 
-    # @param (see formata_transacao)
+    # @param (see formata_ledger)
     # @return [Hash] dados da acao
-    def act(htx)
-      htx[:action_trace][:act]
+    def act(hlx)
+      hlx[:action_trace][:act]
     end
 
-    # @param (see formata_transacao)
+    # @param (see formata_ledger)
     # @return [Hash] dados da acao
-    def act_data(htx)
-      act(htx)[:data]
+    def act_data(hlx)
+      act(hlx)[:data]
     end
 
-    # @param (see formata_transacao)
+    # @param (see formata_ledger)
     # @return [String] dados da quantidade
-    def act_data_quantity(htx)
-      act_data(htx)[:quantity].to_s
-    end
-
-    # @return [String] texto carteiras & transacoes & ajuste dias
-    def mostra_resumo
-      return unless dados.count.positive?
-
-      puts("\naddress            bigquery  ntx       greymass  ntx")
-      dados.each { |e| puts(formata_carteira(e)) }
-      mostra_transacoes_novas
-      mostra_configuracao_ajuste_dias
+    def act_data_quantity(hlx)
+      act_data(hlx)[:quantity].to_s
     end
 
     # @return [String] texto transacoes
@@ -72,7 +73,7 @@ module Cns
       return unless ops[:v] && novax.count.positive?
 
       puts("\nsequence num from         to           accao      data              valor moeda")
-      sorax.each { |e| puts(formata_transacao(e)) }
+      sorax.each { |e| puts(formata_ledger(e)) }
     end
 
     # @return [String] texto configuracao ajuste dias das transacoes

data/lib/cns/kraken.rb

@@ -4,12 +4,12 @@ require('bigdecimal/util')
 
 # @author Hernani Rodrigues Vaz
 module Cns
-  # classe para processar saldos & transacoes trades e ledger
+  # classe para processar transacoes trades/ledger do kraken
   class Kraken
     # @return [Apius] API kraken
     attr_reader :api
     # @return [Array<Hash>] todos os dados bigquery
-    attr_reader :dbq
+    attr_reader :bqd
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
     attr_reader :ops
 
@@ -20,59 +20,71 @@ module Cns
     # @option pop [Boolean] :t (false) mostra transacoes todas ou somente novas?
     # @return [Kraken] API kraken - obter saldos & transacoes trades e ledger
     def initialize(dad, pop)
-      # API kraken base
-      @api = Apius.new
-      @dbq = dad
+      @api = Apice.new
+      @bqd = dad
       @ops = pop
     end
 
+    # @return [Hash] trades kraken novos
+    def trades
+      @trades ||= exd[:kt].select { |k, _| kyt.include?(k) }
+    end
+
+    # @return [Hash] ledger kraken novos
+    def ledger
+      @ledger ||= exd[:kl].select { |k, _| kyl.include?(k) }
+    end
+
+    # @return [String] texto saldos & transacoes & ajuste dias
+    def mostra_resumo
+      puts("\nKRAKEN\ntipo                 kraken              bigquery")
+      exd[:sl].each { |k, v| puts(formata_saldos(k, v)) }
+      mostra_totais
+
+      mostra_trades
+      mostra_ledger
+      return if trades.empty?
+
+      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |e| "#{e}:0" }.join(' ')}")
+    end
+
     # @return [Hash] dados exchange kraken - saldos & transacoes trades e ledger
     def exd
       @exd ||= {
-        sl: api.account,
-        kt: api.trades,
-        kl: api.ledger
+        sl: api.account_us,
+        kt: api.trades_us,
+        kl: api.ledger_us
       }
     end
 
-    # @return [Array<String>] lista txid de transacoes trades
+    # @return [Array<String>] lista txid dos trades novos
     def kyt
-      @kyt ||= exd[:kt].keys - (ops[:t] ? [] : dbq[:nt].map { |e| e[:txid].to_sym })
+      @kyt ||= exd[:kt].keys - (ops[:t] ? [] : bqd[:nt].map { |e| e[:txid].to_sym })
     end
 
-    # @return [Array<String>] lista txid de transacoes ledger
+    # @return [Array<String>] lista txid dos ledger novos
     def kyl
-      @kyl ||= exd[:kl].keys - (ops[:t] ? [] : dbq[:nl].map { |e| e[:txid].to_sym })
-    end
-
-    # @return [Hash] transacoes trades
-    def trades
-      @trades ||= exd[:kt].select { |k, _| kyt.include?(k) }
+      @kyl ||= exd[:kl].keys - (ops[:t] ? [] : bqd[:nl].map { |e| e[:txid].to_sym })
     end
 
-    # @return [Hash] transacoes ledger
-    def ledger
-      @ledger ||= exd[:kl].select { |k, _| kyl.include?(k) }
-    end
-
-    # @example (see Apius#account)
+    # @example (see Apice#account_us)
     # @param [String] moe codigo kraken da moeda
     # @param [BigDecimal] sal saldo kraken da moeda
-    # @return [String] texto formatado saldos (kraken/bigquery) & iguais/ok/nok?
+    # @return [String] texto formatado saldos
     def formata_saldos(moe, sal)
-      t = dbq[:sl][moe.downcase.to_sym].to_d
+      t = bqd[:sl][moe.downcase.to_sym].to_d
       format(
         '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
         mo: moe.upcase,
-        kr: sal,
+        kr: sal.to_d,
         bq: t,
-        ok: t == sal ? 'OK' : 'NOK'
+        ok: t == sal.to_d ? 'OK' : 'NOK'
       )
     end
 
-    # @example (see Apius#trades)
+    # @example (see Apice#trades_us)
     # @param (see Bigquery#ust_val1)
-    # @return [String] texto formatado transacao trade
+    # @return [String] texto formatado trade
     def formata_trades(idx, htx)
       format(
         '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-8.8s %<pr>8.2f %<vl>15.7f %<co>8.2f',
@@ -86,9 +98,9 @@ module Cns
       )
     end
 
-    # @example (see Apius#ledger)
+    # @example (see Apice#ledger_us)
     # @param (see Bigquery#usl_val)
-    # @return [String] texto formatado transacao ledger
+    # @return [String] texto formatado ledger
     def formata_ledger(idx, hlx)
       format(
         '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-4.4s %<pr>18.7f %<vl>18.7f',
@@ -101,16 +113,15 @@ module Cns
       )
     end
 
-    # @return [String] texto saldos & transacoes & ajuste dias
-    def mostra_resumo
-      puts("\nKRAKEN\nmoeda          saldo kraken        saldo bigquery")
-      exd[:sl].each { |k, v| puts(formata_saldos(k, v.to_d)) }
+    # @return [String] texto totais numero de transacoes
+    def mostra_totais
+      a = exd[:kt].count
+      b = bqd[:nt].count
+      c = exd[:kl].count
+      d = bqd[:nl].count
 
-      mostra_trades
-      mostra_ledger
-      return unless trades.count.positive?
-
-      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |e| "#{e}:0" }.join(' ')}")
+      puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: a, b: b, o: a == b ? 'OK' : 'NOK')}")
+      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: c, d: d, o: c == d ? 'OK' : 'NOK')}")
     end
 
     # @return [String] texto transacoes trades