cns 0.9.2 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f54f4e0bf0d8e859722edf7c9a4430d625b3789ac50761b03061db0050956062
-  data.tar.gz: 7e2fbaa074c7cb51157849b8db9798271cf54f4b7b6404869278dd48ceedd55c
+  metadata.gz: f5864db949cd54475943852878f488bcb0e62e342dafcc2f0be4d2e418a6e4a8
+  data.tar.gz: 2f33d2a740c1787f92246625ff11d44f1cc06d4ac8cbe2a54e610aca6a2309ed
 SHA512:
-  metadata.gz: 917f7140253dbaa7e0619792c3912fb78533618640de779c473f86a1665e68ec5688d2f0d6624c0ed33678e698d19a5cadc47b5c20ce833d5273a8cbf7f87ff7
-  data.tar.gz: e56c3b51a6e0d539569b9deace1d491da55a63afaf44e3aaa08abb25807272c33164b55626f9de526b0660d27823514a6524c074b5449995c6d6161f0154a74f
+  metadata.gz: 989d84cf9d660f93068f135d35f8963633431787446a2a666562230560965711430820cc57ebc8ec7e6dd540005c920d1791431ac20e9acd0a71e84565a24dc4
+  data.tar.gz: b8818edca07d3e902cd1a126e9474efe1ff15c3088ca6939f27be8f5422fd91f88a024e2b407a75dd156426cbb4f30b9971548c23ccad0f648348607bd6da435

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cns (0.9.2)
+    cns (0.9.3)
       curb
       faraday
       google-cloud-bigquery

data/lib/cns/bitcoinde.rb

@@ -7,11 +7,9 @@ module Cns
   # classe para processar transacoes trades/ledger do bitcoinde
   class Bitcoinde
     # @return [Apius] API bitcoinde
-    attr_reader :api
     # @return [Array<Hash>] todos os dados bigquery
-    attr_reader :bqd
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
-    attr_reader :ops
+    attr_reader :api, :bqd, :ops
 
     # @param [Hash] dad todos os dados bigquery
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
@@ -33,7 +31,7 @@ module Cns
     # @return [String] texto saldos & transacoes & ajuste dias
     def mresumo
       puts("\nBITCOINDE\ntipo              bitcoinde              bigquery")
-      exd[:sl].sort.each { |key, val| puts(formata_saldos(key, val)) }
+      exd[:sl].sort.each { |k, v| puts(fos(k, v)) }
       mtotais
 
       mtrades
@@ -45,42 +43,37 @@ module Cns
 
     private
 
-    def show_all?
-      ops[:t] || false
-    end
-
-    def bqkyt
-      @bqkyt ||= show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid] } || [])
-    end
+    # mosta contadores transacoes
+    def mtotais
+      vtt = exd[:tt].count
+      vnt = bqd[:nt].count
+      vtl = exd[:tl].count
+      vnl = bqd[:nl].count
 
-    def bqkyl
-      @bqkyl ||= show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid] } || [])
+      puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: vtt, b: vnt, o: vtt == vnt ? 'OK' : 'NOK')}")
+      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: vtl, d: vnl, o: vtl == vnl ? 'OK' : 'NOK')}")
     end
 
-    # @return [Array<String>] lista txid dos trades novos
-    def kyt
-      @kyt ||= exd[:tt].map { |oex| oex[:trade_id] } - bqkyt
-    end
+    # mosta transacoes trades
+    def mtrades
+      return unless ops[:v] && novcdet.any?
 
-    # @return [Array<Integer>] lista txid dos ledger novos
-    def kyl
-      @kyl ||= exd[:tl].map { |oex| oex[:txid] } - bqkyl
+      puts("\ntrades data       hora     dt criacao tipo  par                     btc      eur")
+      novcdet.sort_by { |i| -i[:srx] }.each { |o| puts(fot(o)) }
     end
 
-    # @return [Array<Hash>] lista trades bitcoinde novos
-    def novcdet
-      @novcdet ||= exd[:tt].select { |obj| kyt.include?(obj[:trade_id]) }
-    end
+    # mosta transacoes ledger
+    def mledger
+      return unless ops[:v] && novcdel.any?
 
-    # @return [Array<Hash>] lista ledger (deposits + withdrawals) bitcoinde novos
-    def novcdel
-      @novcdel ||= exd[:tl].select { |obj| kyl.include?(obj[:txid]) }
+      puts("\nledger data       hora     tipo       moe          quantidade              custo")
+      novcdel.sort_by { |i| -i[:srx] }.each { |o| puts(fol(o)) }
     end
 
     # @param [String] moe codigo bitcoinde da moeda
     # @param [Hash] hsx saldo bitcoinde da moeda
     # @return [String] texto formatado saldos
-    def formata_saldos(moe, hsx)
+    def fos(moe, hsx)
       vbq = bqd[:sl][moe.downcase.to_sym].to_d
       vex = hsx[:total_amount]
       format(
@@ -92,9 +85,9 @@ module Cns
       )
     end
 
-    # @param (see Bigquery#det_val1)
+    # @param [Hash] htn trades bitcoinde
     # @return [String] texto formatado trade
-    def formata_trades(htx)
+    def fot(htx)
       format(
         '%<ky>-6.6s %<dt>19.19s %<dp>10.10s %<ty>-5.5s %<mo>-8.8s %<vl>18.8f %<co>8.2f',
         ky: htx[:trade_id],
@@ -107,9 +100,9 @@ module Cns
       )
     end
 
-    # @param (see Bigquery#del_val)
+    # @param [Hash] htn ledger bitcoinde
     # @return [String] texto formatado ledger
-    def formata_ledger(hlx)
+    def fol(hlx)
       format(
         '%<ky>6i %<dt>19.19s %<ty>-10.10s %<mo>-3.3s %<pr>19.8f %<vl>18.8f',
         ky: hlx[:txid],
@@ -121,51 +114,33 @@ module Cns
       )
     end
 
-    # @return [String] texto numero de transacoes
-    def mtotais
-      vtt = exd[:tt].count
-      vnt = bqd[:nt].count
-      vtl = exd[:tl].count
-      vnl = bqd[:nl].count
-
-      puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: vtt, b: vnt, o: vtt == vnt ? 'OK' : 'NOK')}")
-      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: vtl, d: vnl, o: vtl == vnl ? 'OK' : 'NOK')}")
-    end
-
-    # @return [String] texto transacoes trades
-    def mtrades
-      return unless ops[:v] && novcdet.any?
-
-      puts("\ntrades data       hora     dt criacao tipo  par                     btc      eur")
-      novcdet.sort_by { |i| -i[:srx] }.each { |o| puts(formata_trades(o)) }
-    end
-
-    # @return [String] texto transacoes ledger
-    def mledger
-      return unless ops[:v] && novcdel.any?
-
-      puts("\nledger data       hora     tipo       moe          quantidade              custo")
-      novcdel.sort_by { |i| -i[:srx] }.each { |o| puts(formata_ledger(o)) }
+    def show_all?
+      ops[:t] || false
     end
 
-    # Processa os trades para garantir que as datas estejam no formato correto
+    # @param [Hash] itm recursos bitcoinde
+    # @return [Hash<BigDecimal>] moedas & sados
     def pdea(itm)
       itm.select { |k, _| EM.include?(k) }.transform_values { |o| o.merge(total_amount: o[:total_amount].to_d) }
     end
 
-    # Processa time field somtimes is string
-    def ptm(itm)
-      itm.is_a?(String) ? Time.parse(itm) : itm
+    # @param [Object] val time bitcoinde
+    # @return [Time] processa time (somtimes is string)
+    def ptm(val)
+      val.is_a?(String) ? Time.parse(val) : val
     end
 
+    # @param [Hash] itm transacao bitcoinde
+    # @return [Hash] transaccao filtrada
     def pdes(key, itm)
       tym = ptm(itm[key])
       itm.merge(srx: Integer(tym), key => tym)
     end
 
-    # Processa os trades para garantir que as datas estejam no formato correto
-    def pdet(itm)
-      itm.map do |t|
+    # @param [Array<Hash>] htx trade bitcoinde
+    # @return [Array<Hash>] transaccao filtrada
+    def pdet(htx)
+      htx.map do |t|
         pdes(:successfully_finished_at, t).merge(
           trade_marked_as_paid_at: ptm(t[:trade_marked_as_paid_at]),
           username: t[:trading_partner_information][:username],
@@ -176,10 +151,40 @@ module Cns
       end
     end
 
-    # Processa os ledger entries para garantir que as datas estejam no formato correto
+    # @param [Array<Hash>] hlx ledger bitcoinde
+    # @return [Array<Hash>] transaccao filtrada
+    def pdel(hlx)
+      hlx.map { |t| pdes(:time, t).merge(qtd: (t[:tp] == 'withdrawal' ? -1 : 1) * t[:qt].to_d, nxid: t[:txid], fee: t[:fee].to_d, moe: t[:moe].upcase) }
+    end
+
+    # @return [Array<String>] indices trades bigquery
+    def bqkyt
+      @bqkyt ||= show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid] } || [])
+    end
+
+    # @return [Array<Integer>] indices ledger bigquery
+    def bqkyl
+      @bqkyl ||= show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid] } || [])
+    end
+
+    # @return [Array<String>] lista txid trades novos
+    def kyt
+      @kyt ||= exd[:tt].map { |t| t[:trade_id] } - bqkyt
+    end
 
-    def pdel(itm)
-      itm.map { |t| pdes(:time, t).merge(qtd: (t[:tp] == 'withdrawal' ? -1 : 1) * t[:qt].to_d, nxid: t[:txid], fee: t[:fee].to_d, moe: t[:moe].upcase) }
+    # @return [Array<Integer>] lista txid ledger novos
+    def kyl
+      @kyl ||= exd[:tl].map { |t| t[:txid] } - bqkyl
+    end
+
+    # @return [Array<Hash>] lista trades bitcoinde novos
+    def novcdet
+      @novcdet ||= exd[:tt].select { |obj| kyt.include?(obj[:trade_id]) }
+    end
+
+    # @return [Array<Hash>] lista ledger (deposits + withdrawals) bitcoinde novos
+    def novcdel
+      @novcdel ||= exd[:tl].select { |obj| kyl.include?(obj[:txid]) }
     end
   end
 end

data/lib/cns/etherscan.rb

@@ -4,50 +4,45 @@ require('bigdecimal/util')
 
 # @author Hernani Rodrigues Vaz
 module Cns
-  # chaves a eliminar da API - resultado deve ser ignirado pois muda a cada pedido API feito
-  DL = %i[cumulativeGasUsed confirmations].freeze
-
   # classe para processar transacoes do etherscan
   class Etherscan
     # @return [Apibc] API blockchains
-    attr_reader :api
     # @return [Array<Hash>] todos os dados bigquery
-    attr_reader :bqd
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
-    attr_reader :ops
+    attr_reader :api, :bqd, :ops
 
     TT = {
       normal: {
         new: :novnetht,
-        format: :formata_tx_ti,
+        format: :foti,
         header: "\ntx normal                     from            to              data         valor",
         sork: :srx,
         adjk: :hash
       },
       internal: {
         new: :novnethi,
-        format: :formata_tx_ti,
+        format: :foti,
         header: "\ntx intern                     from            to              data         valor",
         sork: :srx,
         adjk: :hash
       },
       block: {
         new: :novnethp,
-        format: :formata_tx_block,
+        format: :fop,
         header: "\ntx block  address                                   data                   valor",
         sork: :itx,
         adjk: :blockNumber
       },
       token: {
         new: :novnethk,
-        format: :formata_tx_token,
+        format: :fok,
         header: "\ntx token             from            to              data            valor moeda",
         sork: :srx,
         adjk: :hash
       },
       withdrawal: {
         new: :novnethw,
-        format: :formata_tx_withw,
+        format: :fow,
         header: "\nwithdrawal validator data            valor",
         sork: :itx,
         adjk: :withdrawalIndex
@@ -57,59 +52,77 @@ module Cns
     # @param [Hash] dad todos os dados bigquery
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
     # @option pop [Hash] :h ({}) configuracao dias ajuste reposicionamento temporal
-    # @option pop [Boolean] :v (false) mostra dados transacoes normais & tokens?
-    # @return [Etherscan] API etherscan - processar transacoes normais e tokens
+    # @option pop [Boolean] :v (false) mostra dados transacoes
+    # @return [Etherscan] API etherscan - processar transacoes
     def initialize(dad, pop)
       @api = Apibc.new
       @bqd = dad
       @ops = pop.transform_keys(&:to_sym)
     end
 
-    # @return [String] texto carteiras & transacoes & ajuste dias
+    # mostra resumo carteiras & transacoes & ajuste dias
     def mresumo_simples
       return unless dados.any?
 
       puts("\nid     address                                        etherscan      bigquery")
-      dados.each { |obj| puts(formata_carteira_simples(obj)) }
+      dados.each { |o| puts(focs(o)) }
       mtransacoes_novas
       mconfiguracao_ajuste_dias
     end
 
-    # @return [String] texto carteiras & transacoes & ajuste dias
+    # mostra resumo carteiras & transacoes & ajuste dias (com contadores)
     def mresumo
       return unless dados.any?
 
       puts("\nid     address      etherscan  tn ti tb tk   tw    bigquery  tn ti tb tk   tw")
-      dados.each { |obj| puts(formata_carteira(obj)) }
+      dados.each { |o| puts(foct(o)) }
       mtransacoes_novas
       mconfiguracao_ajuste_dias
     end
 
     private
 
-    # @param [Hash] hjn dados juntos bigquery & etherscan
-    # @return [String] texto formatado duma carteira
-    def formata_carteira_simples(hjn)
-      format('%<s1>-6.6s %<s2>-42.42s ', s1: hjn[:id], s2: hjn[:ax]) + formata_valores_simples(hjn)
+    # mosta transacoes novas
+    def mtransacoes_novas
+      TT.each do |_, cfg|
+        ntx = send(cfg[:new])
+        next unless ops[:v] && ntx.any?
+
+        puts(cfg[:header])
+        ntx.sort_by { |s| -s[cfg[:sork]] }.each { |t| puts(send(cfg[:format], t)) }
+      end
     end
 
-    # @param [Hash] hjn dados juntos bigquery & etherscan
-    # @return [String] texto formatado duma carteira
-    def formata_carteira(hjn)
-      format('%<s1>-6.6s %<s2>-10.10s ', s1: hjn[:id], s2: formata_enderec1(hjn[:ax], 10)) + formata_valores(hjn)
+    # mostra configuration text for adjusting days
+    def mconfiguracao_ajuste_dias
+      TT.each do |typ, cfg|
+        ntx = send(cfg[:new])
+        next unless ntx.any?
+
+        puts("\najuste dias transacoes #{typ}\n-h=#{ntx.sort_by { |s| -s[cfg[:sork]] }.map { |t| "#{t[cfg[:adjk]]}:0" }.join(' ')}")
+      end
     end
 
-    # @param (see formata_carteira)
-    # @return [String] texto formatado valores duma carteira
-    def formata_valores_simples(hjn)
-      format('%<v1>13.6f %<v2>13.6f %<ok>-3s', v1: hjn[:es], v2: hjn[:bs], ok: ok?(hjn) ? 'OK' : 'NOK')
+    # @param [Hash] hjn dados juntos bigquery & etherscan
+    # @return [String] texto formatado duma carteira
+    def focs(hjn)
+      format(
+        '%<s1>-6.6s %<s2>-42.42s %<v1>13.6f %<v2>13.6f %<ok>-3s',
+        s1: hjn[:id],
+        s2: hjn[:ax],
+        v1: hjn[:es],
+        v2: hjn[:bs],
+        ok: ok?(hjn) ? 'OK' : 'NOK'
+      )
     end
 
-    # @param (see formata_carteira)
-    # @return [String] texto formatado valores duma carteira
-    def formata_valores(hjn)
+    # @param (see focs)
+    # @return [String] texto formatado duma carteira (com contadores)
+    def foct(hjn)
       format(
-        '%<v1>11.4f %<n1>3i %<n2>2i %<n3>2i %<n4>2i %<w1>4i %<v2>11.4f %<n5>3i %<n6>2i %<n7>2i %<n8>2i %<w2>4i %<ok>-3s',
+        '%<s1>-6.6s %<s2>-10.10s %<v1>11.4f %<n1>3i %<n2>2i %<n3>2i %<n4>2i %<w1>4i %<v2>11.4f %<n5>3i %<n6>2i %<n7>2i %<n8>2i %<w2>4i %<ok>-3s',
+        s1: hjn[:id],
+        s2: foe1(hjn[:ax], 10),
         v1: hjn[:es],
         n1: hjn[:et].count,
         n2: hjn[:ei].count,
@@ -126,25 +139,30 @@ module Cns
       )
     end
 
-    # @return [Boolean] carteira tem transacoes novas(sim=NOK, nao=OK)?
+    # @param (see focs)
+    # @return [Boolean] check saldo & contadores ipwtk
     def ok?(hjn)
       oks?(hjn) && okipw?(hjn) && hjn[:bt].count == hjn[:et].count && hjn[:bk].count == hjn[:ek].count
     end
 
+    # @param (see focs)
+    # @return [Boolean] check contadores ipw
     def okipw?(hjn)
       oks?(hjn) && hjn[:bi].count == hjn[:ei].count && hjn[:bp].count == hjn[:ep].count && hjn[:bw].count == hjn[:ew].count
     end
 
-    # @return [Boolean] carteira tem transacoes novas(sim=NOK, nao=OK)?
+    # @param (see focs)
+    # @return [Boolean] carteira tem transacoes novas (sim=NOK, nao=OK)?
     def oks?(hjn)
       hjn[:es].round(6) == hjn[:bs].round(6)
     end
 
     # @example ether address inicio..fim
     #  0x10f3a0cf0b534c..c033cf32e8a03586
+    # @param [String] add endereco ETH
     # @param [Integer] max chars a mostrar
     # @return [String] endereco formatado
-    def formata_enderec1(add, max)
+    def foe1(add, max)
       return 'erro' if max < 7
 
       max -= 2
@@ -155,97 +173,137 @@ module Cns
 
     # @example ether address inicio..fim
     #  me-app..4b437776403d
+    # @param add (see foe1)
     # @param [Integer] max chars a mostrar
     # @return [String] endereco formatado
-    def formata_enderec2(add, max)
+    def foe2(add, max)
       return 'erro' if max < 7
 
       max -= 2
       ini = Integer(max / 2)
       inf = max % 2
-      hid = bqd[:wb].find { |obj| obj[:ax] == add }
+      hid = bqd[:wb].find { |o| o[:ax] == add }
       ndd = hid ? "#{hid[:id]}-#{add}" : add
       "#{ndd[0, ini]}..#{ndd[-inf - ini..]}"
     end
 
-    # @example (see Apibc#norml_es)
-    # @param [Hash] htx transacao normal etherscan
-    # @return [String] texto formatado transacao normal etherscan
-    def formata_tx_ti(htx)
+    # @param [Hash] htx transacao etherscan normal(t)/(i)nternal
+    # @return [String] texto formatado
+    def foti(htx)
       format(
         '%<hx>-29.29s %<fr>-15.15s %<to>-15.15s %<dt>10.10s %<vl>7.3f',
-        hx: formata_enderec1(htx[:hash], 29),
-        fr: formata_enderec2(htx[:from], 15),
-        to: formata_enderec2(htx[:to], 15),
+        hx: foe1(htx[:hash], 29),
+        fr: foe2(htx[:from], 15),
+        to: foe2(htx[:to], 15),
         dt: htx[:timeStamp].strftime('%F'),
         vl: htx[:value] / (10**18)
       )
     end
 
-    # @example (see Apibc#token_es)
-    # @param [Hash] hkx transacao token etherscan
-    # @return [String] texto formatado transacao token etherscan
-    def formata_tx_token(hkx)
+    # @param [Hash] hkx transacao etherscan to(k)en
+    # @return [String] texto formatado
+    def fok(hkx)
       format(
         '%<hx>-20.20s %<fr>-15.15s %<to>-15.15s %<dt>10.10s %<vl>10.3f %<sy>-5.5s',
-        hx: formata_enderec1(hkx[:hash], 20),
-        fr: formata_enderec2(hkx[:from], 15),
-        to: formata_enderec2(hkx[:to], 15),
+        hx: foe1(hkx[:hash], 20),
+        fr: foe2(hkx[:from], 15),
+        to: foe2(hkx[:to], 15),
         dt: hkx[:timeStamp].strftime('%F'),
         vl: hkx[:value] / (10**18),
         sy: hkx[:tokenSymbol]
       )
     end
 
-    # @example (see Apibc#block_es)
-    # @param [Hash] htx transacao block etherscan
-    # @return [String] texto formatado transacao block etherscan
-    def formata_tx_block(htx)
-      format(
-        '%<bn>9i %<fr>-41.41s %<dt>10.10s %<vl>17.6f',
-        bn: htx[:blockNumber],
-        fr: formata_enderec2(htx[:iax], 41),
-        dt: htx[:timeStamp].strftime('%F'),
-        vl: htx[:blockReward] / (10**18)
-      )
+    # @param [Hash] hpx transacao etherscan (p)roduced blocks
+    # @return [String] texto formatado
+    def fop(hpx)
+      format('%<bn>9i %<fr>-41.41s %<dt>10.10s %<vl>17.6f', bn: hpx[:blockNumber], fr: foe2(hpx[:iax], 41), dt: hpx[:timeStamp].strftime('%F'), vl: hpx[:blockReward] / (10**18))
     end
 
-    # @example (see Apibc#block_es)
-    # @param [Hash] htx transacao withdrawals etherscan
+    # @param [Hash] hwx transacao etherscan (w)ithdrawals
     # @return [String] texto formatado transacao withdrawals etherscan
-    def formata_tx_withw(htx)
-      format('%<bn>10i %<vi>9i %<dt>10.10s %<vl>10.6f', bn: htx[:withdrawalIndex], vi: htx[:validatorIndex], dt: htx[:timeStamp].strftime('%F'), vl: htx[:amount] / (10**9))
+    def fow(hwx)
+      format('%<bn>10i %<vi>9i %<dt>10.10s %<vl>10.6f', bn: hwx[:withdrawalIndex], vi: hwx[:validatorIndex], dt: hwx[:timeStamp].strftime('%F'), vl: hwx[:amount] / (10**9))
     end
 
-    # @return [String] Display all new transactions based on verbose option
-    def mtransacoes_novas
-      TT.each do |_, cfg|
-        ntx = send(cfg[:new])
-        next unless ops[:v] && ntx.any?
+    # @param [Hash] abc account etherscan
+    # @return [Hash] dados etherscan - address, saldo & transacoes
+    def base_bc(abc)
+      acc = abc[:account].downcase
+      {
+        ax: acc,
+        sl: abc[:balance].to_d / (10**18),
+        tx: ftik(acc, api.norml_es(acc)),
+        ix: ftik(acc, api.inter_es(acc)),
+        px: fppp(acc, api.block_es(acc)),
+        wx: fwww(acc, api.withw_es(acc)),
+        kx: ftik(acc, api.token_es(acc))
+      }
+    end
 
-        puts(cfg[:header])
-        ntx.sort_by { |s| -s[cfg[:sork]] }.each { |t| puts(send(cfg[:format], t)) }
-      end
+    # @param [Hash] wbq wallet bigquery
+    # @param [Hash] hbc dados etherscan - address, saldo & transacoes
+    # @return [Hash] dados juntos bigquery & etherscan
+    def bq_bc(wbq, hbc)
+      xbq = wbq[:ax]
+      {
+        id: wbq[:id],
+        ax: xbq,
+        bs: wbq[:sl],
+        bt: bqd[:nt].select { |ont| ont[:iax].casecmp?(xbq) },
+        bi: bqd[:ni].select { |oni| oni[:iax].casecmp?(xbq) },
+        bp: bqd[:np].select { |onp| onp[:iax].casecmp?(xbq) },
+        bw: bqd[:nw].select { |onw| onw[:iax].casecmp?(xbq) },
+        bk: bqd[:nk].select { |onk| onk[:iax].casecmp?(xbq) },
+        es: hbc[:sl],
+        et: hbc[:tx],
+        ei: hbc[:ix],
+        ep: hbc[:px],
+        ew: hbc[:wx],
+        ek: hbc[:kx]
+      }
     end
 
-    # @return [String] Configuration text for adjusting transaction days
-    def mconfiguracao_ajuste_dias
-      TT.each do |typ, cfg|
-        ntx = send(cfg[:new])
-        next unless ntx.any?
+    def show_all?
+      ops[:t] || false
+    end
 
-        puts("\najuste dias transacoes #{typ}\n-h=#{ntx.sort_by { |s| -s[cfg[:sork]] }.map { |t| "#{t[cfg[:adjk]]}:0" }.join(' ')}")
-      end
+    # @param [Hash] htx transacao
+    # @return [Hash] transaccao filtrada
+    def pess(htx)
+      tym = Integer(htx[:timeStamp])
+      htx.merge(srx: tym, timeStamp: Time.at(tym))
+    end
+
+    # @param add (see foe1)
+    # @param [Array<Hash>] ary lista transacoes normal(t)/(i)nternal/to(k)en
+    # @return [Array<Hash>] lista transacoes filtrada
+    def ftik(add, ary)
+      ary.map { |o| pess(o).merge(itx: String(o[:hash]), iax: add, value: o[:value].to_d) }
+    end
+
+    # @param add (see foe1)
+    # @param [Array<Hash>] ary lista transacoes (p)roduced blocks
+    # @return [Array<Hash>] lista transacoes filtrada
+    def fppp(add, ary)
+      ary.map { |o| o.merge(itx: Integer(o[:blockNumber]), iax: add, blockReward: o[:blockReward].to_d, timeStamp: Time.at(Integer(o[:timeStamp]))) }
     end
 
-    # @return [Array<String>] lista dos meus enderecos
+    # @param add (see foe1)
+    # @param [Array<Hash>] ary lista transacoes (w)ithdrawals
+    # @return [Array<Hash>] lista transacoes filtrada
+    def fwww(add, ary)
+      ary.map { |o| o.merge(itx: Integer(o[:withdrawalIndex]), iax: add, amount: o[:amount].to_d, timeStamp: Time.at(Integer(o[:timestamp]))) }
+    end
+
+    # @return [Array<String>] lista enderecos
     def lax
-      @lax ||= bqd[:wb].map { |obj| obj[:ax] }
+      @lax ||= bqd[:wb].map { |o| o[:ax] }
     end
 
     # @return [Array<Hash>] todos os dados etherscan - saldos & transacoes
     def bcd
-      @bcd ||= api.account_es(lax).map { |obj| base_bc(obj) }
+      @bcd ||= api.account_es(lax).map { |o| base_bc(o) }
     end
 
     # @return [Array<Hash>] todos os dados juntos bigquery & etherscan
@@ -253,143 +311,79 @@ module Cns
       @dados ||= bqd[:wb].map { |b| bq_bc(b, bcd.find { |e| b[:ax] == e[:ax] }) }
     end
 
-    def show_all?
-      ops[:t] || false
-    end
-
+    # @return [Array<Integer>] indices transacoes bigquery
     def bqidt
       @bqidt ||= show_all? ? [] : (bqd[:nt]&.map { |i| i[:itx] } || [])
     end
 
-    # @return [Array<Integer>] lista indices transacoes novas
-    def idt
-      @idt ||= bcd.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
-    end
-
+    # @return [Array<Integer>] indices transacoes bigquery
     def bqidi
       @bqidi ||= show_all? ? [] : (bqd[:ni]&.map { |i| i[:itx] } || [])
     end
 
-    # @return [Array<Integer>] lista indices transacoes novas
-    def idi
-      @idi ||= bcd.map { |o| o[:ix].map { |i| i[:itx] } }.flatten - bqidi
-    end
-
+    # @return [Array<Integer>] indices transacoes bigquery
     def bqidp
       @bqidp ||= show_all? ? [] : (bqd[:np]&.map { |i| i[:itx] } || [])
     end
 
-    # @return [Array<Integer>] lista indices transacoes novas
-    def idp
-      @idp ||= bcd.map { |o| o[:px].map { |i| i[:itx] } }.flatten - bqidp
-    end
-
+    # @return [Array<Integer>] indices transacoes bigquery
     def bqidw
       @bqidw ||= show_all? ? [] : (bqd[:nw]&.map { |i| i[:itx] } || [])
     end
 
-    # @return [Array<Integer>] lista indices transacoes novas
-    def idw
-      @idw ||= bcd.map { |o| o[:wx].map { |i| i[:itx] } }.flatten - bqidw
-    end
-
+    # @return [Array<Integer>] indices transacoes bigquery
     def bqidk
       @bqidk ||= show_all? ? [] : (bqd[:nk]&.map { |i| i[:itx] } || [])
     end
 
-    # @return [Array<Integer>] lista indices transacoes novas
-    def idk
-      @idk ||= bcd.map { |o| o[:kx].map { |i| i[:itx] } }.flatten - bqidk
+    # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
+    def idt
+      @idt ||= bcd.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
     end
 
-    # @example (see Apibc#account_es)
-    # @param [Hash] abc account etherscan
-    # @return [Hash] dados etherscan - address, saldo & transacoes
-    def base_bc(abc)
-      acc = abc[:account].downcase
-      {
-        ax: acc,
-        sl: abc[:balance].to_d / (10**18),
-        tx: ftik(acc, api.norml_es(acc)),
-        ix: ftik(acc, api.inter_es(acc)),
-        px: fppp(acc, api.block_es(acc)),
-        wx: fwww(acc, api.withw_es(acc)),
-        kx: ftik(acc, api.token_es(acc))
-      }
+    # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
+    def idi
+      @idi ||= bcd.map { |o| o[:ix].map { |i| i[:itx] } }.flatten - bqidi
     end
 
-    # @param [Hash] wbq wallet bigquery
-    # @param [Hash] hbc dados etherscan - address, saldo & transacoes
-    # @return [Hash] dados juntos bigquery & etherscan
-    def bq_bc(wbq, hbc)
-      xbq = wbq[:ax]
-      {
-        id: wbq[:id],
-        ax: xbq,
-        bs: wbq[:sl],
-        bt: bqd[:nt].select { |ont| ont[:iax].casecmp?(xbq) },
-        bi: bqd[:ni].select { |oni| oni[:iax].casecmp?(xbq) },
-        bp: bqd[:np].select { |onp| onp[:iax].casecmp?(xbq) },
-        bw: bqd[:nw].select { |onw| onw[:iax].casecmp?(xbq) },
-        bk: bqd[:nk].select { |onk| onk[:iax].casecmp?(xbq) },
-        es: hbc[:sl],
-        et: hbc[:tx],
-        ei: hbc[:ix],
-        ep: hbc[:px],
-        ew: hbc[:wx],
-        ek: hbc[:kx]
-      }
+    # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
+    def idp
+      @idp ||= bcd.map { |o| o[:px].map { |i| i[:itx] } }.flatten - bqidp
+    end
+
+    # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
+    def idw
+      @idw ||= bcd.map { |o| o[:wx].map { |i| i[:itx] } }.flatten - bqidw
+    end
+
+    # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
+    def idk
+      @idk ||= bcd.map { |o| o[:kx].map { |i| i[:itx] } }.flatten - bqidk
     end
 
     # @return [Array<Hash>] lista transacoes normais novas
     def novnetht
-      @novnetht ||= bcd.map { |obc| obc[:tx].select { |obj| idt.include?(obj[:itx]) } }.flatten.uniq { |itm| itm[:itx] }
+      @novnetht ||= bcd.map { |o| o[:tx].select { |t| idt.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
     # @return [Array<Hash>] lista transacoes internas novas
     def novnethi
-      @novnethi ||= bcd.map { |obc| obc[:ix].select { |obj| idi.include?(obj[:itx]) } }.flatten.uniq { |itm| itm[:itx] }
+      @novnethi ||= bcd.map { |o| o[:ix].select { |t| idi.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
     # @return [Array<Hash>] lista transacoes block novas
     def novnethp
-      @novnethp ||= bcd.map { |obc| obc[:px].select { |obj| idp.include?(obj[:itx]) } }.flatten.uniq { |itm| itm[:itx] }
+      @novnethp ||= bcd.map { |o| o[:px].select { |t| idp.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
     # @return [Array<Hash>] lista transacoes withdrawals novas
     def novnethw
-      @novnethw ||= bcd.map { |obc| obc[:wx].select { |obj| idw.include?(obj[:itx]) } }.flatten.uniq { |itm| itm[:itx] }
+      @novnethw ||= bcd.map { |o| o[:wx].select { |t| idw.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
     # @return [Array<Hash>] lista transacoes token novas
     def novnethk
-      @novnethk ||= bcd.map { |obc| obc[:kx].select { |obj| idk.include?(obj[:itx]) } }.flatten.uniq { |itm| itm[:itx] }
-    end
-
-    def pess(itm)
-      tym = Integer(itm[:timeStamp])
-      itm.merge(srx: tym, timeStamp: Time.at(tym))
-    end
-
-    # @param add (see Apibc#norml_es)
-    # @param [Array<Hash>] ary lista transacoes/token events
-    # @return [Array<Hash>] lista transacoes/token events filtrada
-    def ftik(add, ary)
-      ary.map { |o| pess(o).merge(itx: String(o[:hash]), iax: add, value: o[:value].to_d) }
-    end
-
-    # @param add (see Apibc#norml_es)
-    # @param [Array<Hash>] ary lista blocks events
-    # @return [Array<Hash>] lista blocks events filtrada
-    def fppp(add, ary)
-      ary.map { |o| o.merge(itx: Integer(o[:blockNumber]), iax: add, blockReward: o[:blockReward].to_d, timeStamp: Time.at(Integer(o[:timeStamp]))) }
-    end
-
-    # @param add (see Apibc#norml_es)
-    # @param [Array<Hash>] ary lista blocks events
-    # @return [Array<Hash>] lista blocks events filtrada
-    def fwww(add, ary)
-      ary.map { |o| o.merge(itx: Integer(o[:withdrawalIndex]), iax: add, amount: o[:amount].to_d, timeStamp: Time.at(Integer(o[:timestamp]))) }
+      @novnethk ||= bcd.map { |o| o[:kx].select { |t| idk.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
   end
 end

data/lib/cns/greymass.rb

@@ -7,11 +7,17 @@ module Cns
   # classe para processar transacoes do greymass
   class Greymass
     # @return [Apibc] API blockchains
-    attr_reader :api
     # @return [Array<Hash>] todos os dados bigquery
-    attr_reader :bqd
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
-    attr_reader :ops
+    attr_reader :api, :bqd, :ops
+
+    TT = {
+      new: :novneost,
+      format: :fol,
+      header: "\nsequence num from         to           accao      data              valor moeda",
+      sork: :itx,
+      adjk: :itx
+    }
 
     # @param [Hash] dad todos os dados bigquery
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
@@ -25,29 +31,38 @@ module Cns
       @ops = pop.transform_keys(&:to_sym)
     end
 
-    TT = {
-      new: :novneost,
-      format: :formata_ledger,
-      header: "\nsequence num from         to           accao      data              valor moeda",
-      sork: :itx,
-      adjk: :itx
-    }
-
     # @return [String] texto carteiras & transacoes & ajuste dias
     def mresumo
       return unless dados.any?
 
       puts("\naddress            greymass  ntx       bigquery  ntx")
-      dados.each { |obj| puts(formata_carteira(obj)) }
+      dados.each { |o| puts(foct(o)) }
       mtransacoes_novas
       mconfiguracao_ajuste_dias
     end
 
     private
 
+    # mosta transacoes novas
+    def mtransacoes_novas
+      ntx = send(TT[:new])
+      return unless ops[:v] && ntx.any?
+
+      puts(TT[:header])
+      ntx.sort_by { |s| -s[TT[:sork]] }.each { |t| puts(send(TT[:format], t)) }
+    end
+
+    # mostra configuration text for adjusting days
+    def mconfiguracao_ajuste_dias
+      ntx = send(TT[:new])
+      return unless ntx.any?
+
+      puts("\nstring ajuste dias\n-h=#{ntx.sort_by { |s| -s[TT[:sork]] }.map { |t| "#{t[TT[:adjk]]}:0" }.join(' ')}")
+    end
+
     # @param [Hash] hjn dados juntos bigquery & greymass
     # @return [String] texto formatado duma carteira
-    def formata_carteira(hjn)
+    def foct(hjn)
       format(
         '%<s1>-12.12s %<v1>14.4f %<n1>4i %<v2>14.4f %<n2>4i %<ok>-3s',
         s1: hjn[:ax],
@@ -59,16 +74,15 @@ module Cns
       )
     end
 
-    # @param (see formata_carteira)
+    # @param (see foct)
     # @return [Boolean] carteira tem transacoes novas(sim=NOK, nao=OK)?
     def ok?(hjn)
       hjn[:bs] == hjn[:es] && hjn[:bt].count == hjn[:et].count
     end
 
-    # @example (see Apibc#ledger_gm)
     # @param [Hash] hlx ledger greymass
-    # @return [String] texto formatado ledger greymass
-    def formata_ledger(hlx)
+    # @return [String] texto formatado
+    def fol(hlx)
       format(
         '%<bn>12i %<fr>-12.12s %<to>-12.12s %<ac>-10.10s %<dt>10.10s %<vl>12.4f %<sy>-6.6s',
         ac: hlx[:name],
@@ -81,47 +95,6 @@ module Cns
       )
     end
 
-    # @return [String] Display new transactions based on verbose option
-    def mtransacoes_novas
-      ntx = send(TT[:new])
-      return unless ops[:v] && ntx.any?
-
-      puts(TT[:header])
-      ntx.sort_by { |s| -s[TT[:sork]] }.each { |t| puts(send(TT[:format], t)) }
-    end
-
-    # @return [String] texto configuracao ajuste dias das transacoes
-    def mconfiguracao_ajuste_dias
-      ntx = send(TT[:new])
-      return unless ntx.any?
-
-      puts("\nstring ajuste dias\n-h=#{ntx.sort_by { |s| -s[TT[:sork]] }.map { |t| "#{t[TT[:adjk]]}:0" }.join(' ')}")
-    end
-
-    # @return [Array<Hash>] todos os dados greymass - saldos & transacoes
-    def bcd
-      @bcd ||= bqd[:wb].map { |obj| base_bc(obj) }
-    end
-
-    # @return [Array<Hash>] todos os dados juntos bigquery & greymass
-    def dados
-      @dados ||= bqd[:wb].map { |b| bq_bc(b, bcd.find { |g| b[:ax] == g[:ax] }) }
-    end
-
-    def show_all?
-      ops[:t] || false
-    end
-
-    def bqidt
-      @bqidt ||= show_all? ? [] : (bqd[:nt]&.map { |i| i[:itx] } || [])
-    end
-
-    # @return [Array<Integer>] lista indices transacoes novas
-    def idt
-      @idt ||= bcd.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
-    end
-
-    # @example (see Apibc#account_gm)
     # @param [Hash] wbq wallet bigquery
     # @return [Hash] dados greymass - address, saldo & transacoes
     def base_bc(wbq)
@@ -138,17 +111,17 @@ module Cns
         id: wbq[:id],
         ax: xbq,
         bs: wbq[:sl],
-        bt: bqd[:nt].select { |obj| obj[:iax] == xbq },
+        bt: bqd[:nt].select { |o| o[:iax] == xbq },
         es: hbc[:sl],
         et: hbc[:tx]
       }
     end
 
-    # @return [Array<Hash>] lista transacoes novas
-    def novneost
-      @novneost ||= bcd.map { |obc| obc[:tx].select { |obj| idt.include?(obj[:itx]) } }.flatten
+    def show_all?
+      ops[:t] || false
     end
 
+    # @param [String] add EOS account name
     # @return [Array<BigDecimal>] lista recursos - liquido, net, spu
     def peosa(add)
       hac = api.account_gm(add)
@@ -156,7 +129,7 @@ module Cns
       [hac[:core_liquid_balance].to_d, htr[:net_weight].to_d, htr[:cpu_weight].to_d]
     end
 
-    # @param add (see Apibc#account_gm)
+    # @param add (see peosa)
     # @param [Array<Hash>] ary lista transacoes
     # @return [Array<Hash>] lista transacoes filtrada
     def peost(add, ary)
@@ -178,5 +151,30 @@ module Cns
         )
       end
     end
+
+    # @return [Array<Hash>] todos os dados greymass - saldos & transacoes
+    def bcd
+      @bcd ||= bqd[:wb].map { |o| base_bc(o) }
+    end
+
+    # @return [Array<Hash>] todos os dados juntos bigquery & greymass
+    def dados
+      @dados ||= bqd[:wb].map { |b| bq_bc(b, bcd.find { |g| b[:ax] == g[:ax] }) }
+    end
+
+    # @return [Array<Integer>] indices transacoes bigquery
+    def bqidt
+      @bqidt ||= show_all? ? [] : (bqd[:nt]&.map { |i| i[:itx] } || [])
+    end
+
+    # @return [Array<Integer>] indices transacoes novas (greymass - bigquery)
+    def idt
+      @idt ||= bcd.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
+    end
+
+    # @return [Array<Hash>] lista transacoes novas
+    def novneost
+      @novneost ||= bcd.map { |obc| obc[:tx].select { |o| idt.include?(o[:itx]) } }.flatten
+    end
   end
 end

data/lib/cns/kraken.rb

@@ -7,11 +7,9 @@ module Cns
   # 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 :bqd
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
-    attr_reader :ops
+    attr_reader :api, :bqd, :ops
 
     # @param [Hash] dad todos os dados bigquery
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
@@ -33,7 +31,7 @@ module Cns
     # @return [String] texto saldos & transacoes & ajuste dias
     def mresumo
       puts("\nKRAKEN\ntipo                 kraken              bigquery")
-      exd[:sl].sort.each { |key, val| puts(formata_saldos(key, val)) }
+      exd[:sl].sort.each { |key, val| puts(fos(key, val)) }
       mtotais
 
       mtrades
@@ -45,43 +43,37 @@ module Cns
 
     private
 
-    def show_all?
-      ops[:t] || false
-    end
-
-    def bqkyt
-      @bqkyt ||= show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid].to_sym } || [])
-    end
+    # mosta contadores transacoes
+    def mtotais
+      vkt = exd[:kt].count
+      vnt = bqd[:nt].count
+      vkl = exd[:kl].count
+      vnl = bqd[:nl].count
 
-    def bqkyl
-      @bqkyl ||= show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid].to_sym } || [])
+      puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: vkt, b: vnt, o: vkt == vnt ? 'OK' : 'NOK')}")
+      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: vkl, d: vnl, o: vkl == vnl ? 'OK' : 'NOK')}")
     end
 
-    # @return [Array<String>] lista txid dos trades novos
-    def kyt
-      @kyt ||= exd[:kt].keys - bqkyt
-    end
+    # mosta transacoes trades
+    def mtrades
+      return unless ops[:v] && novcust.any?
 
-    # @return [Array<String>] lista txid dos ledger novos
-    def kyl
-      @kyl ||= exd[:kl].keys - bqkyl
+      puts("\ntrade  data       hora     tipo       par         preco     volume         custo")
+      novcust.sort_by { |_, v| -v[:srx] }.each { |k, t| puts(fot(k, t)) }
     end
 
-    # @return [Hash] trades kraken novos
-    def novcust
-      @novcust ||= exd[:kt].slice(*kyt)
-    end
+    # mosta transacoes ledger
+    def mledger
+      return unless ops[:v] && novcusl.any?
 
-    # @return [Hash] ledger kraken novos
-    def novcusl
-      @novcusl ||= exd[:kl].slice(*kyl)
+      puts("\nledger data       hora     tipo       moeda        quantidade              custo")
+      novcusl.sort_by { |_, v| -v[:srx] }.each { |k, t| puts(fol(k, t)) }
     end
 
-    # @example (see Apice#account_us)
     # @param [String] moe codigo kraken da moeda
     # @param [BigDecimal] sal saldo kraken da moeda
     # @return [String] texto formatado saldos
-    def formata_saldos(moe, sal)
+    def fos(moe, sal)
       vbq = bqd[:sl][moe.downcase.to_sym].to_d
       format(
         '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
@@ -92,10 +84,10 @@ module Cns
       )
     end
 
-    # @example (see Apice#trades_us)
-    # @param (see Bigquery#ust_val1)
+    # @param [Symbol] idx id da transacao
+    # @param [Hash] htn trades kraken
     # @return [String] texto formatado trade
-    def formata_trades(idx, htx)
+    def fot(idx, htx)
       format(
         '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-8.8s %<pr>8.2f %<vl>10.4f %<co>13.2f',
         ky: idx,
@@ -108,10 +100,10 @@ module Cns
       )
     end
 
-    # @example (see Apice#ledger_us)
-    # @param (see Bigquery#usl_val)
+    # @param idx (see fot)
+    # @param [Hash] hln ledger kraken
     # @return [String] texto formatado ledger
-    def formata_ledger(idx, hlx)
+    def fol(idx, hlx)
       format(
         '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-4.4s %<pr>18.7f %<vl>18.7f',
         ky: idx,
@@ -123,39 +115,18 @@ module Cns
       )
     end
 
-    # @return [String] texto totais numero de transacoes
-    def mtotais
-      vkt = exd[:kt].count
-      vnt = bqd[:nt].count
-      vkl = exd[:kl].count
-      vnl = bqd[:nl].count
-
-      puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: vkt, b: vnt, o: vkt == vnt ? 'OK' : 'NOK')}")
-      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: vkl, d: vnl, o: vkl == vnl ? 'OK' : 'NOK')}")
-    end
-
-    # @return [String] texto transacoes trades
-    def mtrades
-      return unless ops[:v] && novcust.any?
-
-      puts("\ntrade  data       hora     tipo       par         preco     volume         custo")
-      novcust.sort_by { |_, v| -v[:srx] }.each { |k, t| puts(formata_trades(k, t)) }
-    end
-
-    # @return [String] texto transacoes ledger
-    def mledger
-      return unless ops[:v] && novcusl.any?
-
-      puts("\nledger data       hora     tipo       moeda        quantidade              custo")
-      novcusl.sort_by { |_, v| -v[:srx] }.each { |k, t| puts(formata_ledger(k, t)) }
+    def show_all?
+      ops[:t] || false
     end
 
-    # Processa accounts para garantir formato correto
+    # @param [Hash] itm recursos kraken
+    # @return [Hash<BigDecimal>] moedas & sados
     def pusa(itm)
       itm.select { |k, _| EM.include?(k) }.transform_values { |v| v.to_d }
     end
 
-    # Processa campos comuns para garantir formato correto
+    # @param [Hash] itm transacao kraken
+    # @return [Hash] transaccao filtrada
     def pusk(itm)
       itm.map do |k, v|
         t = Integer(v[:time])
@@ -163,14 +134,46 @@ module Cns
       end.to_h
     end
 
-    # Processa trades para garantir formato correto
-    def pust(itm)
-      pusk(itm).transform_values { |t| t.merge(pair: t[:pair].upcase, price: t[:price].to_d, vol: t[:vol].to_d, cost: t[:cost].to_d) }
+    # @param [Hash] htx trade kraken
+    # @return [Hash] transaccao filtrada
+    def pust(htx)
+      pusk(htx).transform_values { |t| t.merge(pair: t[:pair].upcase, price: t[:price].to_d, vol: t[:vol].to_d, cost: t[:cost].to_d) }
+    end
+
+    # @param [Hash] hlx ledger kraken
+    # @return [Hash] transaccao filtrada
+    def pusl(hlx)
+      pusk(hlx).transform_values { |t| t.merge(asset: t[:asset].upcase, amount: t[:amount].to_d, fee: t[:fee].to_d) }
+    end
+
+    # @return [Array<Symbol>] indices trades bigquery
+    def bqkyt
+      @bqkyt ||= show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid].to_sym } || [])
     end
 
-    # Processa ledgers para garantir formato correto
-    def pusl(itm)
-      pusk(itm).transform_values { |t| t.merge(asset: t[:asset].upcase, amount: t[:amount].to_d, fee: t[:fee].to_d) }
+    # @return [Array<Symbol>] indices ledger bigquery
+    def bqkyl
+      @bqkyl ||= show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid].to_sym } || [])
+    end
+
+    # @return [Array<Symbol>] lista txid trades novos
+    def kyt
+      @kyt ||= exd[:kt].keys - bqkyt
+    end
+
+    # @return [Array<Symbol>] lista txid ledger novos
+    def kyl
+      @kyl ||= exd[:kl].keys - bqkyl
+    end
+
+    # @return [Hash] trades kraken novos
+    def novcust
+      @novcust ||= exd[:kt].slice(*kyt)
+    end
+
+    # @return [Hash] ledger kraken novos
+    def novcusl
+      @novcusl ||= exd[:kl].slice(*kyl)
     end
   end
 end

data/lib/cns/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cns
-  VERSION = '0.9.2'
+  VERSION = '0.9.3'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: cns
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors:
 - Hernâni Rodrigues Vaz
 bindir: exe
 cert_chain: []
-date: 2025-03-03 00:00:00.000000000 Z
+date: 2025-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler