cns 0.8.7 → 0.8.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3630eeaca7e56e765e2702bc46c885b19c9e5127239f6788ce510358d3b2d7e
-  data.tar.gz: b2b87a278f6042d604d964f1c2bdd8d20db4b7a7d8d3c9448f36afbc2e2d8a08
+  metadata.gz: aa9737420761247a9d82111220ba71741c591fa08fe035da2f8f4717cd8b179d
+  data.tar.gz: 6e5b7f03930de50c278a0a1d0a6442b6535c67bfa1874f0402b2c4075c363108
 SHA512:
-  metadata.gz: ec9c373225a2870fa14bc4eeefde9c20f6a2152a173108ce14e0f6b4bf948c7784b85337c3b0dc2f94ebaae005313c9145849805eff161f6bff094538ba942eb
-  data.tar.gz: ebd9ed2c6d303bd6e6ba9fd533b9d9198dd8751ebe2f86c81e4b8dfcae4e5b8e632310e45a322b9dd1ed7f78a1bda4efb0a4127fc953710b133f2248b009722c
+  metadata.gz: 92144b9670390bf051d131f2bdf1b35a8c475ac16fa935dc2f6bb37b04298a5304ceadceeac467da687d70e847ee5cfc3974d6deca8519b8a368c3bec446334d
+  data.tar.gz: 1f519cc3912a0ea47d1cabb557eb191c04dafd6dc308d08da23969ae2fc604f720f3441844c277b1259f446a20aad28645ccf4868d6c5e795efeef17e7f5ef97

data/Gemfile.lock

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

data/lib/cns/bigquery.rb

@@ -7,6 +7,7 @@ require('bigdecimal/util')
 module Cns
   BD = 'hernanirvaz.coins'
   FO = File.expand_path("~/#{File.basename($PROGRAM_NAME)}.log")
+  EM = %i[EOS XETH ZEUR btc eth]
   TB = {
     i: %w[blocknumber timestamp txhash axfrom axto iax value contractaddress input type gas gasused traceid iserror errcode dias],
     p: %w[blocknumber timestamp blockreward iax dias],
@@ -44,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
@@ -209,6 +210,7 @@ module Cns
         novx = src.send("nov#{prx}#{itm}")
         next if novx.empty?
 
+        # puts(insert_cus(prx, itm, novx))
         str << format(' %<n>i %<t>s', n: dml(insert_cus(prx, itm, novx)), t: "#{prx}#{itm}")
       end
       str.join
@@ -219,6 +221,7 @@ module Cns
         novx = src.send("nov#{prx}#{itm}")
         next if novx.empty?
 
+        # puts(insert_out(prx, itm, novx))
         str << format(' %<n>i %<t>s', n: dml(insert_out(prx, itm, novx)), t: "#{prx}#{itm}")
       end
       str.join
@@ -256,7 +259,7 @@ module Cns
     end
 
     def fts(value)
-      "DATETIME(TIMESTAMP('#{value}'))"
+      "DATETIME(TIMESTAMP('#{value.iso8601}'))"
     end
 
     # @param [Hash] htx transacao norml etherscan
@@ -303,7 +306,7 @@ module Cns
         fnm(htx[:gasUsed]),
         fqt(htx[:traceId]),
         fin(htx[:isError]),
-        fin(htx[:errCode]),
+        fqt(htx[:errCode]),
         fin(ops.dig(:h, htx[:hash]))
       ]
       "(#{vls.join(',')})"
@@ -325,7 +328,7 @@ module Cns
         fqt(htx[:address]),
         fnm(htx[:amount]),
         fin(htx[:blockNumber]),
-        fin(htx[:timestamp]),
+        fin(htx[:timeStamp]),
         fin(ops.dig(:h, htx[:withdrawalIndex]))
       ]
       "(#{vls.join(',')})"
@@ -362,23 +365,23 @@ module Cns
     # @param [Hash] hlx ledger greymass
     # @return [String] valores formatados para insert eos (parte1)
     def neost_val(htx)
-      act = htx[:action_trace][:act]
-      dat = act[:data]
-      qtd = dat[:quantity].to_s
-      str = dat[:memo].inspect
+      # act = htx[:action_trace][:act]
+      # dat = act[:data]
+      # qtd = dat[:quantity].to_s
+      # str = dat[:memo].inspect
       vls = [
         fin(htx[:global_action_seq]),
         fin(htx[:account_action_seq]),
         fin(htx[:block_num]),
         fts(htx[:block_time]),
-        fqt(act[:account]),
-        fqt(act[:name]),
-        fqt(dat[:from]),
-        fqt(dat[:to]),
+        fqt(htx[:account]),
+        fqt(htx[:name]),
+        fqt(htx[:from]),
+        fqt(htx[:to]),
         fqt(htx[:iax]),
-        fnm(qtd),
-        fqt(qtd[/[[:upper:]]+/]),
-        fqt(str),
+        fnm(htx[:quantity]),
+        fqt(htx[:moe]),
+        fqt(htx[:memo]),
         fin(ops.dig(:h, htx[:itx]))
       ]
       "(#{vls.join(',')})"
@@ -403,15 +406,13 @@ module Cns
     # @param [Hash] hlx ledger (deposits + withdrawals) bitcoinde
     # @return [String] valores formatados del (ledger)
     def cdel_val(htx)
-      tip = htx[:tp]
-      qtd = htx[:qt]
       vls = [
         fin(htx[:txid]),
-        fts(htx[:time].iso8601),
-        fqt(tip),
+        fts(htx[:time]),
+        fqt(htx[:tp]),
         fqt(htx[:add]),
         fqt(htx[:moe]),
-        fnm(tip == 'withdrawal' ? "-#{qtd}" : "#{qtd}"),
+        fnm(htx[:tp] == 'withdrawal' ? "-#{htx[:qt]}" : "#{htx[:qt]}"),
         fnm(htx[:fee])
       ]
       "(#{vls.join(',')})"
@@ -421,12 +422,13 @@ module Cns
     # @param [Hash] htx trade kraken
     # @return [String] valores formatados ust (trades parte1)
     def cust_val(idx, htx)
+      # gets ledgers related to this trade
       ldg = apius.exd[:kl].select { |_, obj| obj[:refid] == idx.to_s }.keys.join(',')
       vls = [
         fqt(idx),
         fqt(htx[:ordertxid]),
         fqt(htx[:pair]),
-        ftm(htx[:time]),
+        fts(htx[:time]),
         fqt(htx[:type]),
         fqt(htx[:ordertype]),
         fnm(htx[:price]),
@@ -445,7 +447,7 @@ module Cns
     # @param [Hash] hlx ledger kraken
     # @return [String] valores formatados usl (ledger)
     def cusl_val(idx, hlx)
-      vls = [fqt(idx), fqt(hlx[:refid]), ftm(hlx[:time]), fqt(hlx[:type]), fqt(hlx[:aclass]), fqt(hlx[:asset]), fnm(hlx[:amount]), fnm(hlx[:fee])]
+      vls = [fqt(idx), fqt(hlx[:refid]), fts(hlx[:time]), fqt(hlx[:type]), fqt(hlx[:aclass]), fqt(hlx[:asset]), fnm(hlx[:amount]), fnm(hlx[:fee])]
       "(#{vls.join(',')})"
     end
   end

data/lib/cns/bitcoinde.rb

@@ -25,6 +25,11 @@ module Cns
       @ops = pop.transform_keys(&:to_sym)
     end
 
+    # @return [Hash] dados exchange bitcoinde - saldos & trades & deposits & withdrawals
+    def exd
+      @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]) }
@@ -38,7 +43,7 @@ module Cns
     # @return [String] texto saldos & transacoes & ajuste dias
     def mresumo
       puts("\nBITCOINDE\ntipo              bitcoinde              bigquery")
-      exd[:sl].sort { |ant, prx| ant <=> prx }.each { |key, val| puts(formata_saldos(key, val)) }
+      exd[:sl].sort.each { |key, val| puts(formata_saldos(key, val)) }
       mtotais
 
       mtrades
@@ -48,27 +53,36 @@ module Cns
       puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |obj| "#{obj}:0" }.join(' ')}")
     end
 
-    # @return [Hash] dados exchange bitcoinde - saldos & trades & deposits & withdrawals
-    def exd
-      @exd ||= { sl: api.account_de, tt: api.trades_de, tl: api.deposits_de + api.withdrawals_de }
+    private
+
+    def show_all?
+      ops[:t] || false
+    end
+
+    def bqkyt
+      show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid] } || [])
+    end
+
+    def bqkyl
+      show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid] } || [])
     end
 
     # @return [Array<String>] lista txid dos trades novos
     def kyt
-      @kyt ||= exd[:tt].map { |oex| oex[:trade_id] }.flatten - (ops[:t] ? [] : bqd[:nt].map { |obq| obq[:txid] })
+      @kyt ||= exd[:tt].map { |oex| oex[:trade_id] } - bqkyt
     end
 
     # @return [Array<Integer>] lista txid dos ledger novos
     def kyl
-      @kyl ||= exd[:tl].map { |oex| oex[:txid] }.flatten - (ops[:t] ? [] : bqd[:nl].map { |obq| obq[:txid] })
+      @kyl ||= exd[:tl].map { |oex| oex[:txid] } - bqkyl
     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)
-      vbq = bqd[:sl][moe.downcase.to_sym].to_d.round(9)
-      vex = hsx[:total_amount].to_d.round(9)
+      vbq = bqd[:sl][moe.downcase.to_sym].to_d
+      vex = hsx[:total_amount]
       format(
         '%<mo>-5.5s %<ex>21.9f %<bq>21.9f %<ok>3.3s',
         mo: moe.upcase,
@@ -84,12 +98,12 @@ module Cns
       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],
-        dt: Time.parse(htx[:successfully_finished_at]),
-        dp: Time.parse(htx[:trade_marked_as_paid_at]),
+        dt: htx[:successfully_finished_at].strftime('%F %T'),
+        dp: htx[:trade_marked_as_paid_at].strftime('%F'),
         ty: htx[:type],
-        mo: htx[:trading_pair].upcase,
-        vl: htx[:amount_currency_to_trade].to_d,
-        co: htx[:volume_currency_to_pay].to_d
+        mo: htx[:trading_pair],
+        vl: htx[:amount_currency_to_trade],
+        co: htx[:volume_currency_to_pay]
       )
     end
 
@@ -99,11 +113,11 @@ module Cns
       format(
         '%<ky>6i %<dt>19.19s %<ty>-10.10s %<mo>-3.3s %<pr>19.8f %<vl>18.8f',
         ky: hlx[:txid],
-        dt: hlx[:time],
+        dt: hlx[:time].strftime('%F %T'),
         ty: hlx[:tp],
-        mo: hlx[:moe].upcase,
-        pr: hlx[:qt].to_d,
-        vl: hlx[:fee].to_d
+        mo: hlx[:moe],
+        pr: hlx[:qt],
+        vl: hlx[:fee]
       )
     end
 
@@ -123,7 +137,7 @@ module Cns
       return unless ops[:v] && !novcdet.empty?
 
       puts("\ntrades data       hora     dt criacao tipo  par                     qtd      eur")
-      novcdet.sort { |ant, prx| Time.parse(prx[:successfully_finished_at]) <=> Time.parse(ant[:successfully_finished_at]) }.each { |obj| puts(formata_trades(obj)) }
+      novcdet.sort_by { |itm| -itm[:srx] }.each { |obj| puts(formata_trades(obj)) }
     end
 
     # @return [String] texto transacoes ledger
@@ -131,7 +145,36 @@ module Cns
       return unless ops[:v] && !novcdel.empty?
 
       puts("\nledger data       hora     tipo       moe          quantidade              custo")
-      novcdel.sort { |ant, prx| prx[:time] <=> ant[:time] }.each { |obj| puts(formata_ledger(obj)) }
+      novcdel.sort_by { |itm| -itm[:srx] }.each { |obj| puts(formata_ledger(obj)) }
+    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) }
+    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),
+          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,
+          trading_pair: t[:trading_pair].upcase
+        )
+      end
+    end
+
+    # 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
     end
   end
 end

data/lib/cns/etherscan.rb

@@ -69,32 +69,27 @@ module Cns
 
     # @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] })
+      @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] })
+      @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] })
+      @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] })
+      @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] })
+      @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)
@@ -104,12 +99,12 @@ module Cns
       acc = abc[:account].downcase
       {
         ax: acc,
-        sl: (abc[:balance].to_d / (10**18)),
-        tx: filtrar_tx(acc, api.norml_es(acc)),
-        ix: filtrar_tx(acc, api.inter_es(acc)),
-        px: filtrar_px(acc, api.block_es(acc)),
-        wx: filtrar_wx(acc, api.withw_es(acc)),
-        kx: filtrar_tx(acc, api.token_es(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
 
@@ -135,56 +130,29 @@ module Cns
       }
     end
 
-    # @param add (see Apibc#norml_es)
-    # @param [Array<Hash>] ary lista transacoes/token events
-    # @return [Array<Hash>] lista transacoes/token events filtrada
-    def filtrar_tx(add, ary)
-      # elimina transferencia from: (lax) to: (add) - esta transferencia aparece em from: (add) to: (lax)
-      # .delete_if { |odl| add.casecmp?(odl[:to]) && lax.include?(odl[:from].downcase) }
-      # elimina chaves irrelevantes (DL) & adiciona chave indice itx & adiciona identificador da carteira iax
-      ary.map { |omp| omp.delete_if { |key, _| DL.include?(key) }.merge(itx: String(omp[:hash]), iax: add, srx: Integer(omp[:timeStamp])) }
-    end
-
-    # @param add (see Apibc#norml_es)
-    # @param [Array<Hash>] ary lista blocks events
-    # @return [Array<Hash>] lista blocks events filtrada
-    def filtrar_px(add, ary)
-      # adiciona chave indice itx & adiciona identificador da carteira iax
-      ary.map { |omp| omp.merge(itx: Integer(omp[:blockNumber]), iax: add) }
-    end
-
-    # @param add (see Apibc#norml_es)
-    # @param [Array<Hash>] ary lista blocks events
-    # @return [Array<Hash>] lista blocks events filtrada
-    def filtrar_wx(add, ary)
-      # adiciona chave indice itx & adiciona identificador da carteira iax
-      ary.map { |omp| omp.merge(itx: Integer(omp[:withdrawalIndex]), iax: add) }
-    end
-
-    # dt: Time.at(Integer(htx[:timeStamp])),
     # @return [Array<Hash>] lista ordenada transacoes normais novas
     def sortx
-      novnetht.sort { |ant, prx| ant[:srx] <=> prx[:srx] }
+      novnetht.sort_by { |itm| -itm[:srx] }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes internas novas
     def sorix
-      novnethi.sort { |ant, prx| ant[:srx] <=> prx[:srx] }
+      novnethi.sort_by { |itm| -itm[:srx] }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes block novas
     def sorpx
-      novnethp.sort { |ant, prx| ant[:itx] <=> prx[:itx] }
+      novnethp.sort_by { |itm| -itm[:itx] }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes withdrawals novas
     def sorwx
-      novnethw.sort { |ant, prx| ant[:itx] <=> prx[:itx] }
+      novnethw.sort_by { |itm| -itm[:itx] }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes token novas
     def sorkx
-      novnethk.sort { |ant, prx| ant[:srx] <=> prx[:srx] }
+      novnethk.sort_by { |itm| -itm[:srx] }
     end
 
     # @return [String] texto carteiras & transacoes & ajuste dias
@@ -230,23 +198,12 @@ module Cns
     # @param (see formata_carteira)
     # @return [String] texto formatado valores duma carteira
     def formata_valores_simples(hjn)
-      # id     address                                        etherscan      bigquery
-      # me-app 0x27c7f54e48956a906af2cbfbc8684b437776403d     22.377364     22.377364 OK
-      # mm-hot 0x534029b6371dc4453dd750bc1198181f55c859fe      4.556609      4.556609 OK
-      format(
-        '%<v1>13.6f %<v2>13.6f %<ok>-3s',
-        v1: hjn[:es],
-        v2: hjn[:bs],
-        ok: ok?(hjn) ? 'OK' : 'NOK'
-      )
+      format('%<v1>13.6f %<v2>13.6f %<ok>-3s', 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)
-      # id     address      etherscan  tn ti tb tk   tw    bigquery  tn ti tb tk   tw
-      # me-app 0x27c..b43     22.3774  31  6  0 16 2190     22.3774  25  6  0 16 2190 OK
-      # mm-hot 0x534..81f      4.5566 182 18 74  7   51      4.5566  33 18 74  6   51 OK
       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',
         v1: hjn[:es],
@@ -272,7 +229,6 @@ module Cns
 
     # @example ether address inicio..fim
     #  0x10f3a0cf0b534c..c033cf32e8a03586
-    # @param add (see filtrar_tx)
     # @param [Integer] max chars a mostrar
     # @return [String] endereco formatado
     def formata_enderec1(add, max)
@@ -286,7 +242,6 @@ module Cns
 
     # @example ether address inicio..fim
     #  me-app..4b437776403d
-    # @param add (see filtrar_tx)
     # @param [Integer] max chars a mostrar
     # @return [String] endereco formatado
     def formata_enderec2(add, max)
@@ -309,8 +264,8 @@ module Cns
         hx: formata_enderec1(htx[:hash], 29),
         fr: formata_enderec2(htx[:from], 15),
         to: formata_enderec2(htx[:to], 15),
-        dt: Time.at(Integer(htx[:timeStamp])),
-        vl: (htx[:value].to_d / (10**18)).round(10)
+        dt: htx[:timeStamp].strftime('%F'),
+        vl: htx[:value] / (10**18)
       )
     end
 
@@ -323,8 +278,8 @@ module Cns
         hx: formata_enderec1(hkx[:hash], 23),
         fr: formata_enderec2(hkx[:from], 15),
         to: formata_enderec2(hkx[:to], 15),
-        dt: Time.at(Integer(hkx[:timeStamp])),
-        vl: (hkx[:value].to_d / (10**18)).round(10),
+        dt: hkx[:timeStamp].strftime('%F'),
+        vl: hkx[:value] / (10**18),
         sy: hkx[:tokenSymbol]
       )
     end
@@ -337,8 +292,8 @@ module Cns
         '%<bn>9i %<fr>-41.41s %<dt>10.10s %<vl>17.6f',
         bn: htx[:blockNumber],
         fr: formata_enderec2(htx[:iax], 41),
-        dt: Time.at(Integer(htx[:timeStamp])),
-        vl: (htx[:blockReward].to_d / (10**18)).round(10)
+        dt: htx[:timeStamp].strftime('%F'),
+        vl: htx[:blockReward] / (10**18)
       )
     end
 
@@ -346,13 +301,7 @@ module Cns
     # @param [Hash] htx transacao withdrawals etherscan
     # @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: Time.at(Integer(htx[:timestamp])),
-        vl: (htx[:amount].to_d / (10**9)).round(10)
-      )
+      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
@@ -400,8 +349,31 @@ module Cns
       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 withdrawals\n-h=#{sorwx.map { |obj| "#{obj[:withdrawalIndex]}:0" }.join(' ')}") if novnethw.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?
+    end
+
+    private
+
+    # @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)) }
+    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]))) }
     end
   end
 end

data/lib/cns/greymass.rb

@@ -47,8 +47,7 @@ module Cns
 
     # @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] })
+      @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)
@@ -56,11 +55,7 @@ module Cns
     # @return [Hash] dados greymass - address, saldo & transacoes
     def base_bc(wbq)
       xbq = wbq[:ax]
-      {
-        ax: xbq,
-        sl: greymass_sl(xbq).reduce(:+),
-        tx: filtrar_tx(xbq, api.ledger_gm(xbq))
-      }
+      { ax: xbq, sl: peosa(xbq).reduce(:+), tx: peost(xbq, api.ledger_gm(xbq)) }
     end
 
     # @param wbq (see base_bc)
@@ -78,26 +73,6 @@ module Cns
       }
     end
 
-    # @param (see filtrar_tx)
-    # @return [Array<BigDecimal>] lista recursos - liquido, net, spu
-    def greymass_sl(add)
-      hac = api.account_gm(add)
-      htr = hac[:total_resources]
-      [hac[:core_liquid_balance].to_d, htr[:net_weight].to_d, htr[:cpu_weight].to_d]
-    end
-
-    # @param add (see Apibc#account_gm)
-    # @param [Array<Hash>] ary lista transacoes
-    # @return [Array<Hash>] lista transacoes filtrada
-    def filtrar_tx(add, ary)
-      # elimina transferencia from: (lax) to: (add) - esta transferencia aparece em from: (add) to: (lax)
-      # adiciona chave indice itx & adiciona identificador da carteira iax
-      (ary.delete_if do |odl|
-        adt = odl[:action_trace][:act][:data]
-        adt[:to] == add && lax.include?(adt[:from])
-      end).map { |omp| omp.merge(itx: omp[:global_action_seq], iax: add) }
-    end
-
     # @return [String] texto carteiras & transacoes & ajuste dias
     def mresumo
       return unless dados.count.positive?
@@ -134,13 +109,13 @@ module Cns
     def formata_ledger(hlx)
       format(
         '%<bn>12i %<fr>-12.12s %<to>-12.12s %<ac>-10.10s %<dt>10.10s %<vl>12.4f %<sy>-6.6s',
-        ac: (act = hlx[:action_trace][:act])[:name],
-        fr: (adt = act[:data])[:from],
-        vl: (aqt = adt[:quantity].to_s).to_d,
+        ac: hlx[:name],
+        fr: hlx[:from],
+        vl: hlx[:quantity],
         bn: hlx[:itx],
-        to: adt[:to],
-        dt: Date.parse(hlx[:block_time]),
-        sy: aqt[/[[:upper:]]+/]
+        to: hlx[:to],
+        dt: hlx[:block_time].strftime('%F'),
+        sy: hlx[:moe]
       )
     end
 
@@ -149,14 +124,48 @@ module Cns
       return unless ops[:v] && novneost.count.positive?
 
       puts("\nsequence num from         to           accao      data              valor moeda")
-      novneost.sort { |ant, prx| prx[:itx] <=> ant[:itx] }.each { |obj| puts(formata_ledger(obj)) }
+      soreost.each { |obj| puts(formata_ledger(obj)) }
     end
 
     # @return [String] texto configuracao ajuste dias das transacoes
     def mconfiguracao_ajuste_dias
       return unless novneost.count.positive?
 
-      puts("\nstring ajuste dias\n-h=#{novneost.sort { |ant, prx| prx[:itx] <=> ant[:itx] }.map { |obj| "#{obj[:itx]}:0" }.join(' ')}")
+      puts("\nstring ajuste dias\n-h=#{soreost.map { |obj| "#{obj[:itx]}:0" }.join(' ')}")
+    end
+
+    private
+
+    # @return [Array<Hash>] lista ordenada transacoes
+    def soreost
+      novneost.sort_by { |itm| -itm[:itx] }
+    end
+
+    # @return [Array<BigDecimal>] lista recursos - liquido, net, spu
+    def peosa(add)
+      hac = api.account_gm(add)
+      htr = hac[:total_resources]
+      [hac[:core_liquid_balance].to_d, htr[:net_weight].to_d, htr[:cpu_weight].to_d]
+    end
+
+    # @param add (see Apibc#account_gm)
+    # @param [Array<Hash>] ary lista transacoes
+    # @return [Array<Hash>] lista transacoes filtrada
+    def peost(add, ary)
+      ary.map do |omp|
+        omp.merge(
+          name: (act = omp[:action_trace][:act])[:name],
+          from: (adt = act[:data])[:from],
+          quantity: (qtd = adt[:quantity].to_s).to_d,
+          account: act[:account],
+          to: adt[:to],
+          memo: String(adt[:memo]).gsub(/\p{C}/, ''), # remove Non-Printable Characters
+          moe: qtd[/[[:upper:]]+/],
+          itx: omp[:global_action_seq],
+          iax: add,
+          block_time: Time.parse(omp[:block_time])
+        )
+      end
     end
   end
 end

data/lib/cns/kraken.rb

@@ -25,6 +25,11 @@ module Cns
       @ops = pop.transform_keys(&:to_sym)
     end
 
+    # @return [Hash] dados exchange kraken - saldos & transacoes trades e ledger
+    def exd
+      @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)
@@ -38,7 +43,7 @@ module Cns
     # @return [String] texto saldos & transacoes & ajuste dias
     def mresumo
       puts("\nKRAKEN\ntipo                 kraken              bigquery")
-      exd[:sl].sort { |ant, prx| ant <=> prx }.each { |key, val| puts(formata_saldos(key, val)) }
+      exd[:sl].sort.each { |key, val| puts(formata_saldos(key, val)) }
       mtotais
 
       mtrades
@@ -48,19 +53,28 @@ module Cns
       puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |obj| "#{obj}:0" }.join(' ')}")
     end
 
-    # @return [Hash] dados exchange kraken - saldos & transacoes trades e ledger
-    def exd
-      @exd ||= { sl: api.account_us, kt: api.trades_us, kl: api.ledger_us }
+    private
+
+    def show_all?
+      ops[:t] || false
+    end
+
+    def bqkyt
+      show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid].to_sym } || [])
+    end
+
+    def bqkyl
+      show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid].to_sym } || [])
     end
 
     # @return [Array<String>] lista txid dos trades novos
     def kyt
-      @kyt ||= exd[:kt].keys - (ops[:t] ? [] : bqd[:nt].map { |obj| obj[:txid].to_sym })
+      @kyt ||= exd[:kt].keys - bqkyt
     end
 
     # @return [Array<String>] lista txid dos ledger novos
     def kyl
-      @kyl ||= exd[:kl].keys - (ops[:t] ? [] : bqd[:nl].map { |obj| obj[:txid].to_sym })
+      @kyl ||= exd[:kl].keys - bqkyl
     end
 
     # @example (see Apice#account_us)
@@ -68,14 +82,13 @@ module Cns
     # @param [BigDecimal] sal saldo kraken da moeda
     # @return [String] texto formatado saldos
     def formata_saldos(moe, sal)
-      vbq = bqd[:sl][moe.downcase.to_sym].to_d.round(9)
-      vsl = sal.to_d.round(9)
+      vbq = bqd[:sl][moe.downcase.to_sym].to_d
       format(
         '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
         mo: moe.upcase,
-        kr: vsl,
+        kr: sal,
         bq: vbq,
-        ok: vbq == vsl ? 'OK' : 'NOK'
+        ok: vbq == sal ? 'OK' : 'NOK'
       )
     end
 
@@ -86,12 +99,12 @@ module Cns
       format(
         '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-8.8s %<pr>8.2f %<vl>10.4f %<co>13.2f',
         ky: idx,
-        dt: Time.at(htx[:time]),
+        dt: htx[:time].strftime('%F %T'),
         ty: "#{htx[:type]}/#{htx[:ordertype]}",
-        mo: htx[:pair].upcase,
-        pr: htx[:price].to_d,
-        vl: htx[:vol].to_d,
-        co: htx[:cost].to_d
+        mo: htx[:pair],
+        pr: htx[:price],
+        vl: htx[:vol],
+        co: htx[:cost]
       )
     end
 
@@ -102,11 +115,11 @@ module Cns
       format(
         '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-4.4s %<pr>18.7f %<vl>18.7f',
         ky: idx,
-        dt: Time.at(hlx[:time]),
+        dt: hlx[:time].strftime('%F %T'),
         ty: hlx[:type],
-        mo: hlx[:asset].upcase,
-        pr: hlx[:amount].to_d,
-        vl: hlx[:fee].to_d
+        mo: hlx[:asset],
+        pr: hlx[:amount],
+        vl: hlx[:fee]
       )
     end
 
@@ -126,7 +139,7 @@ module Cns
       return unless ops[:v] && novcust.count.positive?
 
       puts("\ntrade  data       hora     tipo       par         preco     volume         custo")
-      novcust.sort { |ant, prx| prx[1][:time] <=> ant[1][:time] }.each { |key, val| puts(formata_trades(key, val)) }
+      novcust.sort_by { |itm| -itm[1][:srx] }.each { |key, val| puts(formata_trades(key, val)) }
     end
 
     # @return [String] texto transacoes ledger
@@ -134,7 +147,22 @@ module Cns
       return unless ops[:v] && novcusl.count.positive?
 
       puts("\nledger data       hora     tipo       moeda        quantidade              custo")
-      novcusl.sort { |ant, prx| prx[1][:time] <=> ant[1][:time] }.each { |key, val| puts(formata_ledger(key, val)) }
+      novcusl.sort_by { |itm| -itm[1][:srx] }.each { |key, val| puts(formata_ledger(key, val)) }
+    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 }
+    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) }
+    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) }
     end
   end
 end

data/lib/cns/version.rb

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

metadata

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