cns 0.8.9 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa9737420761247a9d82111220ba71741c591fa08fe035da2f8f4717cd8b179d
-  data.tar.gz: 6e5b7f03930de50c278a0a1d0a6442b6535c67bfa1874f0402b2c4075c363108
+  metadata.gz: fff5558da7a0b92a4511bf3f73b8330d3ad59d92d46c76b64a70bfd19e3dfd1e
+  data.tar.gz: eafa8884b41f68f83fa20b547474c7a0717281f8c47d0a948805e9d0a7ae19f4
 SHA512:
-  metadata.gz: 92144b9670390bf051d131f2bdf1b35a8c475ac16fa935dc2f6bb37b04298a5304ceadceeac467da687d70e847ee5cfc3974d6deca8519b8a368c3bec446334d
-  data.tar.gz: 1f519cc3912a0ea47d1cabb557eb191c04dafd6dc308d08da23969ae2fc604f720f3441844c277b1259f446a20aad28645ccf4868d6c5e795efeef17e7f5ef97
+  metadata.gz: 8409acef5de4ce834e309710521c44cfe35414e3ec6c3d11b8dce9173720414d828fb320c6865c693867bdac1bf14c41e8f6ac5ac5172dc11253ff77683cd307
+  data.tar.gz: 072e66dc223d7c14c20248f25e2c5a72f5e918314881c60faf3b8377cb77d11534d9c5b6d0eaf8e2ab2c7966c4956414d3bfdf433b98e57eb3691fa0b46e78ac

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cns (0.8.9)
+    cns (0.9.0)
       curb
       faraday
       google-cloud-bigquery
@@ -137,7 +137,7 @@ GEM
     reverse_markdown (3.0.0)
       nokogiri
     rexml (3.4.1)
-    rubocop (1.72.2)
+    rubocop (1.73.1)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)
@@ -148,7 +148,7 @@ GEM
       rubocop-ast (>= 1.38.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 4.0)
-    rubocop-ast (1.38.0)
+    rubocop-ast (1.38.1)
       parser (>= 3.3.1.0)
     rubocop-rake (0.7.1)
       lint_roller (~> 1.1)
@@ -159,7 +159,7 @@ GEM
       faraday (>= 0.17.5, < 3.a)
       jwt (>= 1.5, < 3.0)
       multi_json (~> 1.10)
-    solargraph (0.51.2)
+    solargraph (0.52.0)
       backport (~> 1.2)
       benchmark
       bundler (~> 2.0)
@@ -177,6 +177,7 @@ GEM
       thor (~> 1.0)
       tilt (~> 2.0)
       yard (~> 0.9, >= 0.9.24)
+      yard-solargraph (~> 0.1)
     thor (1.3.2)
     tilt (2.6.0)
     trailblazer-option (0.1.2)
@@ -184,8 +185,10 @@ GEM
     unicode-display_width (3.1.4)
       unicode-emoji (~> 4.0, >= 4.0.4)
     unicode-emoji (4.0.4)
-    uri (1.0.2)
+    uri (1.0.3)
     yard (0.9.37)
+    yard-solargraph (0.1.0)
+      yard (~> 0.9)
     zeitwerk (2.6.18)
 
 PLATFORMS

data/lib/cns/bigquery.rb

@@ -45,8 +45,8 @@ module Cns
     def mtudo
       apius.mresumo
       apide.mresumo
-      # apies.mresumo
-      # apigm.mresumo
+      apies.mresumo
+      apigm.mresumo
     end
 
     # mostra situacao completa entre kraken/etherscan & bigquery
@@ -183,26 +183,12 @@ module Cns
 
     # @return [Kraken] API exchange kraken
     def apius
-      @apius ||= Kraken.new(
-        {
-          sl: sql("select * from #{BD}.cuss").first,
-          nt: sql("select * from #{BD}.cust order by time,txid"),
-          nl: sql("select * from #{BD}.cusl order by time,txid")
-        },
-        ops
-      )
+      @apius ||= Kraken.new({ sl: sql("select * from #{BD}.cuss").first, nt: sql("select * from #{BD}.cust"), nl: sql("select * from #{BD}.cusl") }, ops)
     end
 
     # @return [Bitcoinde] API exchange bitcoinde
     def apide
-      @apide ||= Bitcoinde.new(
-        {
-          sl: sql("select * from #{BD}.cdes").first,
-          nt: sql("select * from #{BD}.cdet order by time,txid"),
-          nl: sql("select * from #{BD}.cdel order by time,txid")
-        },
-        ops
-      )
+      @apide ||= Bitcoinde.new({ sl: sql("select * from #{BD}.cdes").first, nt: sql("select * from #{BD}.cdet"), nl: sql("select * from #{BD}.cdel") }, ops)
     end
 
     def tabelas_cus(src, str, ltb, prx = '')

data/lib/cns/bitcoinde.rb

@@ -30,16 +30,6 @@ module Cns
       @exd ||= { sl: pdea(api.account_de), tt: pdet(api.trades_de), tl: pdel(api.deposits_de + api.withdrawals_de) }
     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
-
     # @return [String] texto saldos & transacoes & ajuste dias
     def mresumo
       puts("\nBITCOINDE\ntipo              bitcoinde              bigquery")
@@ -60,11 +50,11 @@ module Cns
     end
 
     def bqkyt
-      show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid] } || [])
+      @bqkyt ||= show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid] } || [])
     end
 
     def bqkyl
-      show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid] } || [])
+      @bqkyl ||= show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid] } || [])
     end
 
     # @return [Array<String>] lista txid dos trades novos
@@ -77,6 +67,16 @@ module Cns
       @kyl ||= exd[:tl].map { |oex| oex[: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
+
     # @param [String] moe codigo bitcoinde da moeda
     # @param [Hash] hsx saldo bitcoinde da moeda
     # @return [String] texto formatado saldos
@@ -134,31 +134,39 @@ module Cns
 
     # @return [String] texto transacoes trades
     def mtrades
-      return unless ops[:v] && !novcdet.empty?
+      return unless ops[:v] && novcdet.any?
 
       puts("\ntrades data       hora     dt criacao tipo  par                     qtd      eur")
-      novcdet.sort_by { |itm| -itm[:srx] }.each { |obj| puts(formata_trades(obj)) }
+      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.empty?
+      return unless ops[:v] && novcdel.any?
 
       puts("\nledger data       hora     tipo       moe          quantidade              custo")
-      novcdel.sort_by { |itm| -itm[:srx] }.each { |obj| puts(formata_ledger(obj)) }
+      novcdel.sort_by { |i| -i[:srx] }.each { |o| puts(formata_ledger(o)) }
     end
 
     # Processa os trades para garantir que as datas estejam no formato correto
     def pdea(itm)
-      itm.select { |ky1, _| EM.include?(ky1) }.transform_values { |o| o.merge(total_amount: o[:total_amount].to_d) }
+      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
+    end
+
+    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|
-        t.merge(
-          successfully_finished_at: srx = ptm(t[:successfully_finished_at]),
-          srx: Integer(srx),
+        pdes(:successfully_finished_at, t).merge(
           trade_marked_as_paid_at: ptm(t[:trade_marked_as_paid_at]),
           amount_currency_to_trade: t[:amount_currency_to_trade].to_d,
           volume_currency_to_pay: t[:volume_currency_to_pay].to_d,
@@ -169,12 +177,7 @@ module Cns
 
     # Processa os ledger entries para garantir que as datas estejam no formato correto
     def pdel(itm)
-      itm.map { |t| t.merge(time: srx = ptm(t[:time]), srx: Integer(srx), qt: t[:qt].to_d, fee: t[:fee].to_d, moe: t[:moe].upcase) }
-    end
-
-    # Processa time field somtimes is string
-    def ptm(itm)
-      itm.is_a?(String) ? Time.parse(itm) : itm
+      itm.map { |t| pdes(:time, t).merge(qt: t[:qt].to_d, fee: t[:fee].to_d, moe: t[:moe].upcase) }
     end
   end
 end

data/lib/cns/etherscan.rb

@@ -16,6 +16,44 @@ module Cns
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
     attr_reader :ops
 
+    TT = {
+      normal: {
+        new: :novnetht,
+        sort_key: :srx,
+        format: :formata_tx_ti,
+        header: "\ntx normal                     from            to              data         valor",
+        adjustment_key: :hash
+      },
+      internal: {
+        new: :novnethi,
+        sort_key: :srx,
+        format: :formata_tx_ti,
+        header: "\ntx intern                     from            to              data         valor",
+        adjustment_key: :hash
+      },
+      block: {
+        new: :novnethp,
+        sort_key: :itx,
+        format: :formata_tx_block,
+        header: "\ntx block  address                                   data                   valor",
+        adjustment_key: :blockNumber
+      },
+      token: {
+        new: :novnethk,
+        sort_key: :srx,
+        format: :formata_tx_token,
+        header: "\ntx token             from            to              data            valor moeda",
+        adjustment_key: :hash
+      },
+      withdrawal: {
+        new: :novnethw,
+        sort_key: :itx,
+        format: :formata_tx_withw,
+        header: "\nwithdrawal validator data            valor",
+        adjustment_key: :withdrawalIndex
+      }
+    }
+
     # @param [Hash] dad todos os dados bigquery
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
     # @option pop [Hash] :h ({}) configuracao dias ajuste reposicionamento temporal
@@ -27,162 +65,28 @@ module Cns
       @ops = pop.transform_keys(&:to_sym)
     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] }
-    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] }
-    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] }
-    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] }
-    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
-
-    # @return [Array<String>] lista dos meus enderecos
-    def lax
-      @lax ||= bqd[:wb].map { |obj| obj[:ax] }
-    end
-
-    # @return [Array<Hash>] todos os dados etherscan - saldos & transacoes
-    def bcd
-      @bcd ||= api.account_es(lax).map { |obj| base_bc(obj) }
-    end
-
-    # @return [Array<Hash>] todos os dados juntos bigquery & etherscan
-    def dados
-      @dados ||= bqd[:wb].map { |obq| bq_bc(obq, bcd.select { |obc| obq[:ax] == obc[:ax] }.first) }
-    end
-
-    # @return [Array<Integer>] lista indices transacoes normais novas
-    def idt
-      @idt ||= bcd.map { |obc| obc[:tx].map { |obj| obj[:itx] } }.flatten - (ops[:t] ? [] : bqd[:nt].map { |obq| obq[:itx] })
-    end
-
-    # @return [Array<Integer>] lista indices transacoes internas novas
-    def idi
-      @idi ||= bcd.map { |obc| obc[:ix].map { |obj| obj[:itx] } }.flatten - (ops[:t] ? [] : bqd[:ni].map { |obq| obq[:itx] })
-    end
-
-    # @return [Array<Integer>] lista indices transacoes block novas
-    def idp
-      @idp ||= bcd.map { |obc| obc[:px].map { |obj| obj[:itx] } }.flatten - (ops[:t] ? [] : bqd[:np].map { |obq| obq[:itx] })
-    end
-
-    # @return [Array<Integer>] lista indices transacoes withdrawals novas
-    def idw
-      @idw ||= bcd.map { |obc| obc[:wx].map { |obj| obj[:itx] } }.flatten - (ops[:t] ? [] : bqd[:nw].map { |obq| obq[:itx] })
-    end
-
-    # @return [Array<Integer>] lista indices transacoes token novas
-    def idk
-      @idk ||= bcd.map { |obc| obc[:kx].map { |obj| obj[:itx] } }.flatten - (ops[:t] ? [] : bqd[:nk].map { |obq| obq[:itx] })
-    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))
-      }
-    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)
-      {
-        id: wbq[:id],
-        ax: xbq = wbq[:ax],
-        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 [Array<Hash>] lista ordenada transacoes normais novas
-    def sortx
-      novnetht.sort_by { |itm| -itm[:srx] }
-    end
-
-    # @return [Array<Hash>] lista ordenada transacoes internas novas
-    def sorix
-      novnethi.sort_by { |itm| -itm[:srx] }
-    end
-
-    # @return [Array<Hash>] lista ordenada transacoes block novas
-    def sorpx
-      novnethp.sort_by { |itm| -itm[:itx] }
-    end
-
-    # @return [Array<Hash>] lista ordenada transacoes withdrawals novas
-    def sorwx
-      novnethw.sort_by { |itm| -itm[:itx] }
-    end
-
-    # @return [Array<Hash>] lista ordenada transacoes token novas
-    def sorkx
-      novnethk.sort_by { |itm| -itm[:srx] }
-    end
-
     # @return [String] texto carteiras & transacoes & ajuste dias
     def mresumo_simples
-      return unless dados.count.positive?
+      return unless dados.any?
 
       puts("\nid     address                                        etherscan      bigquery")
       dados.each { |obj| puts(formata_carteira_simples(obj)) }
-      mtx_norml
-      mtx_inter
-      mtx_block
-      mtx_token
-      mtx_withw
+      mtransacoes_novas
       mconfiguracao_ajuste_dias
     end
 
     # @return [String] texto carteiras & transacoes & ajuste dias
     def mresumo
-      return unless dados.count.positive?
+      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)) }
-      mtx_norml
-      mtx_inter
-      mtx_block
-      mtx_token
-      mtx_withw
+      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)
@@ -224,7 +128,16 @@ module Cns
 
     # @return [Boolean] carteira tem transacoes novas(sim=NOK, nao=OK)?
     def ok?(hjn)
-      hjn[:es].round(6) == hjn[:bs].round(6) && hjn[:bi].count == hjn[:ei].count && hjn[:bp].count == hjn[:ep].count && hjn[:bw].count == hjn[:ew].count
+      oks?(hjn) && okipw?(hjn) && hjn[:bt].count == hjn[:et].count && hjn[:bk].count == hjn[:ek].count
+    end
+
+    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)?
+    def oks?(hjn)
+      hjn[:es].round(6) == hjn[:bs].round(6)
     end
 
     # @example ether address inicio..fim
@@ -250,7 +163,7 @@ module Cns
       max -= 2
       ini = Integer(max / 2)
       inf = max % 2
-      hid = bqd[:wb].select { |obj| obj[:ax] == add }.first
+      hid = bqd[:wb].find { |obj| obj[:ax] == add }
       ndd = hid ? "#{hid[:id]}-#{add}" : add
       "#{ndd[0, ini]}..#{ndd[-inf - ini..]}"
     end
@@ -274,8 +187,8 @@ module Cns
     # @return [String] texto formatado transacao token etherscan
     def formata_tx_token(hkx)
       format(
-        '%<hx>-23.23s %<fr>-15.15s %<to>-15.15s %<dt>10.10s %<vl>7.3f %<sy>-5.5s',
-        hx: formata_enderec1(hkx[:hash], 23),
+        '%<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),
         dt: hkx[:timeStamp].strftime('%F'),
@@ -304,62 +217,190 @@ module Cns
       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))
     end
 
-    # @return [String] texto transacoes normais
-    def mtx_norml
-      return unless ops[:v] && novnetht.count.positive?
+    # @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?
+
+        puts(cfg[:header])
+        ntx.sort_by { |s| -s[cfg[:sort_key]] }.each { |t| puts(send(cfg[:format], t)) }
+      end
+    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?
+
+        puts("\najuste dias transacoes #{typ}\n-h=#{ntx.map { |t| "#{t[cfg[:adjustment_key]]}:0" }.join(' ')}")
+      end
+    end
+
+    # @return [Array<String>] lista dos meus enderecos
+    def lax
+      @lax ||= bqd[:wb].map { |obj| obj[:ax] }
+    end
+
+    # @return [Array<Hash>] todos os dados etherscan - saldos & transacoes
+    def bcd
+      @bcd ||= api.account_es(lax).map { |obj| base_bc(obj) }
+    end
 
-      puts("\ntx normal                     from            to              data         valor")
-      sortx.each { |obj| puts(formata_tx_ti(obj)) }
+    # @return [Array<Hash>] todos os dados juntos bigquery & etherscan
+    def dados
+      @dados ||= bqd[:wb].map { |b| bq_bc(b, bcd.find { |e| b[:ax] == e[:ax] }) }
     end
 
-    # @return [String] texto transacoes internas
-    def mtx_inter
-      return unless ops[:v] && novnethi.count.positive?
+    def show_all?
+      ops[:t] || false
+    end
 
-      puts("\ntx intern                     from            to              data         valor")
-      sorix.each { |obj| puts(formata_tx_ti(obj)) }
+    def bqidt
+      @bqidt ||= show_all? ? [] : (bqd[:nt]&.map { |i| i[:itx] } || [])
     end
 
-    # @return [String] texto transacoes block
-    def mtx_block
-      return unless ops[:v] && novnethp.count.positive?
+    # @return [Array<Integer>] lista indices transacoes novas
+    def idt
+      @idt ||= bcd.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
+    end
 
-      puts("\ntx block  address                                   data                   valor")
-      sorpx.each { |obj| puts(formata_tx_block(obj)) }
+    def bqidi
+      @bqidi ||= show_all? ? [] : (bqd[:ni]&.map { |i| i[:itx] } || [])
     end
 
-    # @return [String] texto transacoes token
-    def mtx_token
-      return unless ops[:v] && novnethk.count.positive?
+    # @return [Array<Integer>] lista indices transacoes novas
+    def idi
+      @idi ||= bcd.map { |o| o[:ix].map { |i| i[:itx] } }.flatten - bqidi
+    end
 
-      puts("\ntx token                from            to              data         valor moeda")
-      sorkx.each { |obj| puts(formata_tx_token(obj)) }
+    def bqidp
+      @bqidp ||= show_all? ? [] : (bqd[:np]&.map { |i| i[:itx] } || [])
     end
 
-    # @return [String] texto transacoes withdrawals
-    def mtx_withw
-      return unless ops[:v] && novnethw.count.positive?
+    # @return [Array<Integer>] lista indices transacoes novas
+    def idp
+      @idp ||= bcd.map { |o| o[:px].map { |i| i[:itx] } }.flatten - bqidp
+    end
 
-      puts("\nwithdrawal validator data            valor")
-      sorwx.each { |obj| puts(formata_tx_withw(obj)) }
+    def bqidw
+      @bqidw ||= show_all? ? [] : (bqd[:nw]&.map { |i| i[:itx] } || [])
     end
 
-    # @return [String] texto configuracao ajuste dias das transacoes (normais & token)
-    def mconfiguracao_ajuste_dias
-      puts("\najuste dias transacoes normais    \n-h=#{sortx.map { |obj| "#{obj[:hash]}:0"            }.join(' ')}") if novnetht.count.positive?
-      puts("\najuste dias transacoes internas   \n-h=#{sorix.map { |obj| "#{obj[:hash]}:0"            }.join(' ')}") if novnethi.count.positive?
-      puts("\najuste dias transacoes block      \n-h=#{sorpx.map { |obj| "#{obj[:blockNumber]}:0"     }.join(' ')}") if novnethp.count.positive?
-      puts("\najuste dias transacoes token      \n-h=#{sorkx.map { |obj| "#{obj[:hash]}:0"            }.join(' ')}") if novnethk.count.positive?
-      puts("\najuste dias transacoes withdrawals\n-h=#{sorwx.map { |obj| "#{obj[:withdrawalIndex]}:0" }.join(' ')}") if novnethw.count.positive?
+    # @return [Array<Integer>] lista indices transacoes novas
+    def idw
+      @idw ||= bcd.map { |o| o[:wx].map { |i| i[:itx] } }.flatten - bqidw
     end
 
-    private
+    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
+    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))
+      }
+    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 [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] }
+    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] }
+    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] }
+    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] }
+    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
+
+    # @return [Array<Hash>] lista ordenada transacoes normais novas
+    def sortx
+      novnetht.sort_by { |i| -i[:srx] }
+    end
+
+    # @return [Array<Hash>] lista ordenada transacoes internas novas
+    def sorix
+      novnethi.sort_by { |i| -i[:srx] }
+    end
+
+    # @return [Array<Hash>] lista ordenada transacoes block novas
+    def sorpx
+      novnethp.sort_by { |i| -i[:itx] }
+    end
+
+    # @return [Array<Hash>] lista ordenada transacoes withdrawals novas
+    def sorwx
+      novnethw.sort_by { |i| -i[:itx] }
+    end
+
+    # @return [Array<Hash>] lista ordenada transacoes token novas
+    def sorkx
+      novnethk.sort_by { |i| -i[:srx] }
+    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| o.merge(itx: String(o[:hash]), iax: add, value: o[:value].to_d, srx: (tym = Integer(o[:timeStamp])), timeStamp: Time.at(tym)) }
+      ary.map { |o| pess(o).merge(itx: String(o[:hash]), iax: add, value: o[:value].to_d) }
     end
 
     # @param add (see Apibc#norml_es)

data/lib/cns/greymass.rb

@@ -25,57 +25,17 @@ module Cns
       @ops = pop.transform_keys(&:to_sym)
     end
 
-    # @return [Array<Hash>] lista transacoes novas
-    def novneost
-      @novneost ||= bcd.map { |obc| obc[:tx].select { |obj| idt.include?(obj[:itx]) } }.flatten
-    end
-
-    # @return [Array<String>] lista dos meus enderecos
-    def lax
-      @lax ||= bqd[:wb].map { |obj| obj[:ax] }
-    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 { |obq| bq_bc(obq, bcd.select { |obj| obq[:ax] == obj[:ax] }.first) }
-    end
-
-    # @return [Array<Integer>] lista indices transacoes novas
-    def idt
-      @idt ||= bcd.map { |obc| obc[:tx].map { |obj| obj[:itx] } }.flatten - (ops[:t] ? [] : bqd[:nt].map { |obq| obq[:itx] })
-    end
-
-    # @example (see Apibc#account_gm)
-    # @param [Hash] wbq wallet bigquery
-    # @return [Hash] dados greymass - address, saldo & transacoes
-    def base_bc(wbq)
-      xbq = wbq[:ax]
-      { ax: xbq, sl: peosa(xbq).reduce(:+), tx: peost(xbq, api.ledger_gm(xbq)) }
-    end
-
-    # @param wbq (see base_bc)
-    # @param [Hash] hbc dados greymass - address, saldo & transacoes
-    # @return [Hash] dados juntos bigquery & greymass
-    def bq_bc(wbq, hbc)
-      xbq = wbq[:ax]
-      {
-        id: wbq[:id],
-        ax: xbq,
-        bs: wbq[:sl],
-        bt: bqd[:nt].select { |obj| obj[:iax] == xbq },
-        es: hbc[:sl],
-        et: hbc[:tx]
-      }
-    end
+    TT = {
+      new: :novneost,
+      sort_key: :itx,
+      format: :formata_ledger,
+      header: "\nsequence num from         to           accao      data              valor moeda",
+      adjustment_key: :itx
+    }
 
     # @return [String] texto carteiras & transacoes & ajuste dias
     def mresumo
-      return unless dados.count.positive?
+      return unless dados.any?
 
       puts("\naddress            greymass  ntx       bigquery  ntx")
       dados.each { |obj| puts(formata_carteira(obj)) }
@@ -83,6 +43,8 @@ module Cns
       mconfiguracao_ajuste_dias
     end
 
+    private
+
     # @param [Hash] hjn dados juntos bigquery & greymass
     # @return [String] texto formatado duma carteira
     def formata_carteira(hjn)
@@ -119,26 +81,77 @@ module Cns
       )
     end
 
-    # @return [String] texto transacoes
+    # @return [String] Display new transactions based on verbose option
     def mtransacoes_novas
-      return unless ops[:v] && novneost.count.positive?
+      ntx = send(TT[:new])
+      return unless ops[:v] && ntx.any?
 
-      puts("\nsequence num from         to           accao      data              valor moeda")
-      soreost.each { |obj| puts(formata_ledger(obj)) }
+      puts(TT[:header])
+      ntx.sort_by { |s| -s[TT[:sort_key]] }.each { |t| puts(send(TT[:format], t)) }
     end
 
     # @return [String] texto configuracao ajuste dias das transacoes
     def mconfiguracao_ajuste_dias
-      return unless novneost.count.positive?
+      ntx = send(TT[:new])
+      return unless ntx.any?
 
-      puts("\nstring ajuste dias\n-h=#{soreost.map { |obj| "#{obj[:itx]}:0" }.join(' ')}")
+      puts("\nstring ajuste dias\n-h=#{ntx.map { |t| "#{t[TT[:adjustment_key]]}:0" }.join(' ')}")
     end
 
-    private
+    # @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)
+      xbq = wbq[:ax]
+      { ax: xbq, sl: peosa(xbq).reduce(:+), tx: peost(xbq, api.ledger_gm(xbq)) }
+    end
+
+    # @param wbq (see base_bc)
+    # @param [Hash] hbc dados greymass - address, saldo & transacoes
+    # @return [Hash] dados juntos bigquery & greymass
+    def bq_bc(wbq, hbc)
+      xbq = wbq[:ax]
+      {
+        id: wbq[:id],
+        ax: xbq,
+        bs: wbq[:sl],
+        bt: bqd[:nt].select { |obj| obj[: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
+    end
 
     # @return [Array<Hash>] lista ordenada transacoes
     def soreost
-      novneost.sort_by { |itm| -itm[:itx] }
+      novneost.sort_by { |i| -i[:itx] }
     end
 
     # @return [Array<BigDecimal>] lista recursos - liquido, net, spu
@@ -153,10 +166,13 @@ module Cns
     # @return [Array<Hash>] lista transacoes filtrada
     def peost(add, ary)
       ary.map do |omp|
+        act = omp[:action_trace][:act]
+        adt = act[:data]
+        qtd = adt[:quantity].to_s
         omp.merge(
-          name: (act = omp[:action_trace][:act])[:name],
-          from: (adt = act[:data])[:from],
-          quantity: (qtd = adt[:quantity].to_s).to_d,
+          name: act[:name],
+          from: adt[:from],
+          quantity: qtd.to_d,
           account: act[:account],
           to: adt[:to],
           memo: String(adt[:memo]).gsub(/\p{C}/, ''), # remove Non-Printable Characters

data/lib/cns/kraken.rb

@@ -30,16 +30,6 @@ module Cns
       @exd ||= { sl: pusa(api.account_us), kt: pust(api.trades_us), kl: pusl(api.ledger_us) }
     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
-
     # @return [String] texto saldos & transacoes & ajuste dias
     def mresumo
       puts("\nKRAKEN\ntipo                 kraken              bigquery")
@@ -60,11 +50,11 @@ module Cns
     end
 
     def bqkyt
-      show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid].to_sym } || [])
+      @bqkyt ||= show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid].to_sym } || [])
     end
 
     def bqkyl
-      show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid].to_sym } || [])
+      @bqkyl ||= show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid].to_sym } || [])
     end
 
     # @return [Array<String>] lista txid dos trades novos
@@ -77,6 +67,16 @@ module Cns
       @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
+
     # @example (see Apice#account_us)
     # @param [String] moe codigo kraken da moeda
     # @param [BigDecimal] sal saldo kraken da moeda
@@ -136,33 +136,38 @@ module Cns
 
     # @return [String] texto transacoes trades
     def mtrades
-      return unless ops[:v] && novcust.count.positive?
+      return unless ops[:v] && novcust.any?
 
       puts("\ntrade  data       hora     tipo       par         preco     volume         custo")
-      novcust.sort_by { |itm| -itm[1][:srx] }.each { |key, val| puts(formata_trades(key, val)) }
+      novcust.sort_by { |_, v| -v[:srx] }.each { |i, t| puts(formata_trades(i, t)) }
     end
 
     # @return [String] texto transacoes ledger
     def mledger
-      return unless ops[:v] && novcusl.count.positive?
+      return unless ops[:v] && novcusl.any?
 
       puts("\nledger data       hora     tipo       moeda        quantidade              custo")
-      novcusl.sort_by { |itm| -itm[1][:srx] }.each { |key, val| puts(formata_ledger(key, val)) }
+      novcusl.sort_by { |_, v| -v[:srx] }.each { |i, t| puts(formata_ledger(i, t)) }
     end
 
     # Processa os trades para garantir que as datas estejam no formato correto
     def pusa(itm)
-      itm.select { |key, _| EM.include?(key) }.transform_values { |val| val.to_d }
+      itm.select { |k, _| EM.include?(k) }.transform_values { |v| v.to_d }
+    end
+
+    def puss(itm)
+      tym = Integer(itm[:time])
+      itm.merge(srx: tym, time: Time.at(tym))
     end
 
     # Processa os trades para garantir que as datas estejam no formato correto
     def pust(itm)
-      itm.transform_values { |t| t.merge(srx: (tym = Integer(t[:time])), time: Time.at(tym), pair: t[:pair].upcase, price: t[:price].to_d, vol: t[:vol].to_d, cost: t[:cost].to_d) }
+      itm.transform_values { |t| puss(t).merge(pair: t[:pair].upcase, price: t[:price].to_d, vol: t[:vol].to_d, cost: t[:cost].to_d) }
     end
 
     # Processa os ledger entries para garantir que as datas estejam no formato correto
     def pusl(itm)
-      itm.transform_values { |t| t.merge(srx: (tym = Integer(t[:time])), time: Time.at(tym), asset: t[:asset].upcase, amount: t[:amount].to_d, fee: t[:fee].to_d) }
+      itm.transform_values { |t| puss(t).merge(asset: t[:asset].upcase, amount: t[:amount].to_d, fee: t[:fee].to_d) }
     end
   end
 end

data/lib/cns/version.rb

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

metadata

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