cns 0.8.9 → 0.8.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa9737420761247a9d82111220ba71741c591fa08fe035da2f8f4717cd8b179d
-  data.tar.gz: 6e5b7f03930de50c278a0a1d0a6442b6535c67bfa1874f0402b2c4075c363108
+  metadata.gz: 867a92f29645226b50d14524ebe09fac049968d037d99427778742a92e8fba1c
+  data.tar.gz: '03930aae6c757152fcaf20f6c02c509819b6b53b0941e8f4ddfa9b05370c1d22'
 SHA512:
-  metadata.gz: 92144b9670390bf051d131f2bdf1b35a8c475ac16fa935dc2f6bb37b04298a5304ceadceeac467da687d70e847ee5cfc3974d6deca8519b8a368c3bec446334d
-  data.tar.gz: 1f519cc3912a0ea47d1cabb557eb191c04dafd6dc308d08da23969ae2fc604f720f3441844c277b1259f446a20aad28645ccf4868d6c5e795efeef17e7f5ef97
+  metadata.gz: e014d93d603bb89e74cbe9f17f814c2f717183d77c654688fba7417bc9c2685e1d318b01c013d341d69addba0793c9497e84a5e56bf30272dea76569a005e473
+  data.tar.gz: 86f502cca84614606f28f025723be61b0acfa289072590890b39aa1e6c4aa5f6e3ebaa5aab12f207eb4ac7751dac8d7656b19fc43ca54bb8e89d0b34226c51b8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cns (0.8.9)
+    cns (0.8.10)
       curb
       faraday
       google-cloud-bigquery
@@ -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)

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

@@ -27,137 +27,9 @@ 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)) }
@@ -171,7 +43,7 @@ module Cns
 
     # @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)) }
@@ -183,6 +55,8 @@ module Cns
       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 +98,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
@@ -274,8 +157,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'),
@@ -306,7 +189,7 @@ module Cns
 
     # @return [String] texto transacoes normais
     def mtx_norml
-      return unless ops[:v] && novnetht.count.positive?
+      return unless ops[:v] && novnetht.any?
 
       puts("\ntx normal                     from            to              data         valor")
       sortx.each { |obj| puts(formata_tx_ti(obj)) }
@@ -314,7 +197,7 @@ module Cns
 
     # @return [String] texto transacoes internas
     def mtx_inter
-      return unless ops[:v] && novnethi.count.positive?
+      return unless ops[:v] && novnethi.any?
 
       puts("\ntx intern                     from            to              data         valor")
       sorix.each { |obj| puts(formata_tx_ti(obj)) }
@@ -322,7 +205,7 @@ module Cns
 
     # @return [String] texto transacoes block
     def mtx_block
-      return unless ops[:v] && novnethp.count.positive?
+      return unless ops[:v] && novnethp.any?
 
       puts("\ntx block  address                                   data                   valor")
       sorpx.each { |obj| puts(formata_tx_block(obj)) }
@@ -330,15 +213,15 @@ module Cns
 
     # @return [String] texto transacoes token
     def mtx_token
-      return unless ops[:v] && novnethk.count.positive?
+      return unless ops[:v] && novnethk.any?
 
-      puts("\ntx token                from            to              data         valor moeda")
+      puts("\ntx token             from            to              data            valor moeda")
       sorkx.each { |obj| puts(formata_tx_token(obj)) }
     end
 
     # @return [String] texto transacoes withdrawals
     def mtx_withw
-      return unless ops[:v] && novnethw.count.positive?
+      return unless ops[:v] && novnethw.any?
 
       puts("\nwithdrawal validator data            valor")
       sorwx.each { |obj| puts(formata_tx_withw(obj)) }
@@ -346,20 +229,175 @@ module Cns
 
     # @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?
+      puts("\najuste dias transacoes normais    \n-h=#{sortx.map { |obj| "#{obj[:hash]}:0"            }.join(' ')}") if novnetht.any?
+      puts("\najuste dias transacoes internas   \n-h=#{sorix.map { |obj| "#{obj[:hash]}:0"            }.join(' ')}") if novnethi.any?
+      puts("\najuste dias transacoes block      \n-h=#{sorpx.map { |obj| "#{obj[:blockNumber]}:0"     }.join(' ')}") if novnethp.any?
+      puts("\najuste dias transacoes token      \n-h=#{sorkx.map { |obj| "#{obj[:hash]}:0"            }.join(' ')}") if novnethk.any?
+      puts("\najuste dias transacoes withdrawals\n-h=#{sorwx.map { |obj| "#{obj[:withdrawalIndex]}:0" }.join(' ')}") if novnethw.any?
     end
 
-    private
+    # @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
+
+    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
+
+    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
+
+    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
+
+    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
+
+    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)
+      {
+        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 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,9 @@ 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
-
     # @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 +35,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)
@@ -121,7 +75,7 @@ module Cns
 
     # @return [String] texto transacoes
     def mtransacoes_novas
-      return unless ops[:v] && novneost.count.positive?
+      return unless ops[:v] && novneost.any?
 
       puts("\nsequence num from         to           accao      data              valor moeda")
       soreost.each { |obj| puts(formata_ledger(obj)) }
@@ -129,16 +83,65 @@ module Cns
 
     # @return [String] texto configuracao ajuste dias das transacoes
     def mconfiguracao_ajuste_dias
-      return unless novneost.count.positive?
+      return unless novneost.any?
 
       puts("\nstring ajuste dias\n-h=#{soreost.map { |obj| "#{obj[:itx]}: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 { |obq| bq_bc(obq, bcd.select { |obj| obq[:ax] == obj[:ax] }.first) }
+    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

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.8.10'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cns
 version: !ruby/object:Gem::Version
-  version: 0.8.9
+  version: 0.8.10
 platform: ruby
 authors:
 - Hernâni Rodrigues Vaz