cns 0.8.6 → 0.8.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4fb8ef5137e35f64fabed9a151d6547d12f21487e602c91404ba5eedcd88a34
-  data.tar.gz: 037a388cdcd7652fa803d76131ba1e7076b2a0983c74f835484005791c3a1fc3
+  metadata.gz: d136cac1b44b857085a4a5a3f2225edcc54f3f377c1eb5034583f2401b5c1a87
+  data.tar.gz: 34b8884a1f2f23ce546f3ca2d49b8ef66d67682ebd5cf3b1f0074c070129945d
 SHA512:
-  metadata.gz: bd36261022378f795e64bc814434879b9f99cd7f7c3ff974a719aa0aed0d40bc16a341fcd11038f49c0e1056ea298acb21bca79644dcff7251eb27d69b4b6118
-  data.tar.gz: b6c078fcfb4e878f6058b785051ba702d8e49afc150767f7a99412d4d9202890e98cd3f3f3896afd11d80d2dc083e94fb220e1ff7a25fd261c8a1c781884abf2
+  metadata.gz: bd0594653343221c13ab4e73f0635934754b2cdddba8e09c38ed144a15b925af6226df340eb6a0256c20698f3c2c7add741f084cbd2f43fd5665b73004984e0c
+  data.tar.gz: bb9aa97dad83b36a9d621bf8c66c5505719e01e42f531ed29f499cd44b0249f744b3b3a44c7356d907d6ab9a30383270c9686e8ddb5eeb8157b0e34bc04133dc

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cns (0.8.6)
+    cns (0.8.8)
       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],
@@ -41,47 +42,47 @@ module Cns
     end
 
     # mostra situacao completa entre kraken/bitcoinde/paymium/therock/etherscan/greymass & bigquery
-    def mostra_tudo
-      apius.mostra_resumo
-      apide.mostra_resumo
-      apies.mostra_resumo
-      apigm.mostra_resumo
+    def mtudo
+      apius.mresumo
+      apide.mresumo
+      apies.mresumo
+      apigm.mresumo
     end
 
     # mostra situacao completa entre kraken/etherscan & bigquery
-    def mostra_skrk
-      apius.mostra_resumo
-      apies.mostra_resumo
+    def mskrk
+      apius.mresumo
+      apies.mresumo
     end
 
     # mostra situacao completa entre etherscan & bigquery
-    def mostra_seth
-      apies.mostra_resumo_simples
+    def mseth
+      apies.mresumo_simples
     end
 
     # @return [String] texto inicial transacoes
-    def trs_ini
-      Time.now.strftime('TRANSACOES  %Y-%m-%d %H:%M:%S ')
+    def tct
+      Time.now.strftime('TRANSACOES  %Y-%m-%d %H:%M:%S')
     end
 
     # insere (caso existam) dados novos kraken/bitcoinde/paymium/therock/etherscan/greymass no bigquery
-    def processa_tudo
-      puts(trs_ini + "#{processa_us}, #{processa_de}, #{processa_eth}, #{processa_eos}")
+    def ptudo
+      puts("#{tct} #{pus}, #{pde}, #{peth}, #{peos}")
     end
 
     # insere (caso existam) dados novos kraken/etherscan no bigquery
-    def processa_wkrk
-      puts(trs_ini + "#{processa_us}, #{processa_eth}")
+    def pwkrk
+      puts("#{tct} #{pus}, #{peth}")
     end
 
     # insere (caso existam) dados novos etherscan no bigquery
-    def processa_weth
-      puts(trs_ini + processa_eth)
+    def pweth
+      puts("#{tct} #{peth}")
     end
 
     # insere (caso existam) dados novos etherscan no bigquery (output to file)
-    def processa_ceth
-      File.open(FO, mode: 'a') { |out| out.puts(trs_ini + processa_ethc) }
+    def pceth
+      File.open(FO, mode: 'a') { |out| out.puts("#{tct} #{pethc}") }
     end
 
     private
@@ -89,35 +90,35 @@ module Cns
     # insere transacoes blockchain novas nas tabelas netht (norml), nethi (internas), nethp (block), nethw (withdrawals), nethk (token)
     #
     # @return [String] linhas & tabelas afetadas
-    def processa_eth
+    def peth
       tabelas_out(apies, %w[ETH], %i[t i p w k], 'neth')
     end
 
     # insere transacoes blockchain novas nas tabelas netht (norml), nethi (internas), nethp (block), nethw (withdrawals), nethk (token)
     #
     # @return [String] linhas & tabelas afetadas
-    def processa_ethc
+    def pethc
       tabelas_out(apiesc, %w[ETH], %i[t i p w k], 'neth')
     end
 
     # insere transacoes exchange kraken novas nas tabelas ust (trades), usl (ledger)
     #
     # @return [String] linhas & tabelas afetadas
-    def processa_us
+    def pus
       tabelas_cus(apius, %w[KRAKEN], %i[cust cusl])
     end
 
     # insere transacoes exchange bitcoinde novas nas tabelas det (trades), del (ledger)
     #
     # @return [String] linhas & tabelas afetadas
-    def processa_de
+    def pde
       tabelas_out(apide, %w[BITCOINDE], %i[cdet cdel])
     end
 
     # insere transacoes blockchain novas na tabela eos
     #
     # @return [String] linhas & tabelas afetadas
-    def processa_eos
+    def peos
       tabelas_out(apigm, %w[EOS], %i[neost])
     end
 
@@ -128,7 +129,6 @@ module Cns
     def job?(cmd)
       @job = api.query_job(cmd)
       job.wait_until_done!
-
       return false unless job.failed?
 
       puts("BigQuery Error: #{job.error['message']}")
@@ -152,7 +152,7 @@ module Cns
       job?(cmd) ? 0 : job.num_dml_affected_rows
     end
 
-    def initialize_etherscan_client(prx)
+    def apiesg(prx)
       Etherscan.new(
         {
           wb: sql("SELECT * FROM #{BD}.wet#{prx[-1]} ORDER BY ax"),
@@ -168,12 +168,12 @@ module Cns
 
     # @return [Etherscan] API blockchain ETH
     def apies
-      @apies ||= initialize_etherscan_client('netb')
+      @apies ||= apiesg('netb')
     end
 
     # @return [Etherscan] API blockchain ETH
     def apiesc
-      @apiesc ||= initialize_etherscan_client('netc')
+      @apiesc ||= apiesg('netc')
     end
 
     # @return [Greymass] API blockchain EOS
@@ -210,7 +210,7 @@ module Cns
         novx = src.send("nov#{prx}#{itm}")
         next if novx.empty?
 
-        str << format(' %<n>i %<t>s', n: dml(insert_cus(prx, itm, novx)), t: prx + itm.to_s)
+        str << format(' %<n>i %<t>s', n: dml(insert_cus(prx, itm, novx)), t: "#{prx}#{itm}")
       end
       str.join
     end
@@ -220,7 +220,7 @@ module Cns
         novx = src.send("nov#{prx}#{itm}")
         next if novx.empty?
 
-        str << format(' %<n>i %<t>s', n: dml(insert_out(prx, itm, novx)), t: prx + itm.to_s)
+        str << format(' %<n>i %<t>s', n: dml(insert_out(prx, itm, novx)), t: "#{prx}#{itm}")
       end
       str.join
     end
@@ -237,37 +237,33 @@ module Cns
 
     # SQL value formatting methods with improved safety
     def fqt(value)
-      return 'null' if value.nil? || value.empty?
-
-      "'#{value}'"
+      value.nil? || value.empty? ? 'null' : "'#{value}'"
     end
 
     def fnm(value)
-      return 'null' if value.nil?
-
-      "CAST('#{value}' AS NUMERIC)"
+      "CAST(#{value.to_d} AS NUMERIC)"
+    rescue StandardError
+      'CAST(0 AS NUMERIC)'
     end
 
     def fin(value)
-      return '0' if value.nil?
-
       Integer(value).to_s
     rescue StandardError
-      'null'
+      '0'
     end
 
     def ftm(sec)
-      "PARSE_DATETIME('%s', '#{String(sec.round)}')"
+      "PARSE_DATETIME('%s', '#{sec.round}')"
     end
 
     def fts(value)
-      "DATETIME(TIMESTAMP('#{value}'))"
+      "DATETIME(TIMESTAMP('#{value.iso8601}'))"
     end
 
     # @param [Hash] htx transacao norml etherscan
     # @return [String] valores formatados netht (norml parte1)
     def netht_val(htx)
-      "(#{[
+      vls = [
         fin(htx[:blockNumber]),
         fin(htx[:timeStamp]),
         fqt(htx[:hash]),
@@ -286,13 +282,14 @@ module Cns
         fqt(htx[:input]),
         fqt(htx[:contractAddress]),
         fin(ops.dig(:h, htx[:hash]))
-      ].join(',')})"
+      ]
+      "(#{vls.join(',')})"
     end
 
     # @param [Hash] htx transacao internas etherscan
     # @return [String] valores formatados nethi (internas parte1)
     def nethi_val(htx)
-      "(#{[
+      vls = [
         fin(htx[:blockNumber]),
         fin(htx[:timeStamp]),
         fqt(htx[:hash]),
@@ -307,35 +304,38 @@ module Cns
         fnm(htx[:gasUsed]),
         fqt(htx[:traceId]),
         fin(htx[:isError]),
-        fin(htx[:errCode]),
+        fqt(htx[:errCode]),
         fin(ops.dig(:h, htx[:hash]))
-      ].join(',')})"
+      ]
+      "(#{vls.join(',')})"
     end
 
     # @param [Hash] htx transacao block etherscan
     # @return [String] valores formatados nethi (block parte1)
     def nethp_val(htx)
-      "(#{[fin(htx[:blockNumber]), fin(htx[:timeStamp]), fnm(htx[:blockReward]), fqt(htx[:iax]), fin(ops.dig(:h, htx[:blockNumber]))].join(',')})"
+      vls = [fin(htx[:blockNumber]), fin(htx[:timeStamp]), fnm(htx[:blockReward]), fqt(htx[:iax]), fin(ops.dig(:h, htx[:blockNumber]))]
+      "(#{vls.join(',')})"
     end
 
     # @param [Hash] htx transacao withdrawals etherscan
     # @return [String] valores formatados nethi (withdrawals parte1)
     def nethw_val(htx)
-      "(#{[
+      vls = [
         fin(htx[:withdrawalIndex]),
         fin(htx[:validatorIndex]),
         fqt(htx[:address]),
         fnm(htx[:amount]),
         fin(htx[:blockNumber]),
-        fin(htx[:timestamp]),
+        fin(htx[:timeStamp]),
         fin(ops.dig(:h, htx[:withdrawalIndex]))
-      ].join(',')})"
+      ]
+      "(#{vls.join(',')})"
     end
 
     # @param [Hash] hkx token event etherscan
     # @return [String] valores formatados nethk (token parte1)
     def nethk_val(htx)
-      "(#{[
+      vls = [
         fin(htx[:blockNumber]),
         fin(htx[:timeStamp]),
         fqt(htx[:hash]),
@@ -355,38 +355,40 @@ module Cns
         fqt(htx[:input]),
         fqt(htx[:contractAddress]),
         fin(ops.dig(:h, htx[:hash]))
-      ].join(',')})"
+      ]
+      "(#{vls.join(',')})"
     end
 
     # @example (see Apibc#ledger_gm)
     # @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]),
-        qtd.to_d,
-        fqt(qtd[/[[:upper:]]+/]),
-        fqt(str),
+        fnm(htx[:quantity]),
+        fqt(htx[:moe]),
+        fqt(htx[:memo]),
         fin(ops.dig(:h, htx[:itx]))
-      ].join(',')})"
+      ]
+      "(#{vls.join(',')})"
     end
 
     # @param [Hash] htx trade bitcoinde
     # @return [String] valores formatados det (trades parte1)
     def cdet_val(htx)
-      "(#{[
+      vls = [
         fqt(htx[:trade_id]),
         fts(htx[:successfully_finished_at]),
         fqt(htx[:type]),
@@ -395,34 +397,36 @@ module Cns
         fnm(htx[:volume_currency_to_pay_after_fee]),
         fts(htx[:trade_marked_as_paid_at]),
         fin(ops.dig(:h, htx[:trade_id]))
-      ].join(',')})"
+      ]
+      "(#{vls.join(',')})"
     end
 
     # @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])
-      ].join(',')})"
+      ]
+      "(#{vls.join(',')})"
     end
 
     # @param [String] idx identificador transacao
     # @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]),
@@ -431,16 +435,18 @@ module Cns
         fnm(htx[:vol]),
         fnm(htx[:margin]),
         fqt(htx[:misc]),
-        fqt(apius.novcusl.select { |_, obj| obj[:refid] == idx.to_s }.keys.join(',')),
+        fqt(ldg),
         fin(ops.dig(:h, idx))
-      ].join(',')})"
+      ]
+      "(#{vls.join(',')})"
     end
 
     # @param idx (see ust_val)
     # @param [Hash] hlx ledger kraken
     # @return [String] valores formatados usl (ledger)
     def cusl_val(idx, hlx)
-      "(#{[fqt(idx), fqt(hlx[:refid]), ftm(hlx[:time]), fqt(hlx[:type]), fqt(hlx[:aclass]), fqt(hlx[:asset]), fnm(hlx[:amount]), fnm(hlx[:fee])].join(',')})"
+      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
 end

data/lib/cns/bitcoinde.rb

@@ -36,13 +36,13 @@ module Cns
     end
 
     # @return [String] texto saldos & transacoes & ajuste dias
-    def mostra_resumo
+    def mresumo
       puts("\nBITCOINDE\ntipo              bitcoinde              bigquery")
-      exd[:sl].sort { |ant, prx| ant <=> prx }.each { |key, val| puts(formata_saldos(key, val)) }
-      mostra_totais
+      exd[:sl].sort.each { |key, val| puts(formata_saldos(key, val)) }
+      mtotais
 
-      mostra_trades
-      mostra_ledger
+      mtrades
+      mledger
       return if novcdet.empty?
 
       puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |obj| "#{obj}:0" }.join(' ')}")
@@ -50,7 +50,7 @@ module Cns
 
     # @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 }
+      @exd ||= { sl: pdea(api.account_de), tt: pdet(api.trades_de), tl: pdel(api.deposits_de + api.withdrawals_de) }
     end
 
     # @return [Array<String>] lista txid dos trades novos
@@ -67,8 +67,8 @@ module Cns
     # @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 +84,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,16 +99,16 @@ 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
 
     # @return [String] texto numero de transacoes
-    def mostra_totais
+    def mtotais
       vtt = exd[:tt].count
       vnt = bqd[:nt].count
       vtl = exd[:tl].count
@@ -119,19 +119,50 @@ module Cns
     end
 
     # @return [String] texto transacoes trades
-    def mostra_trades
+    def mtrades
       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
-    def mostra_ledger
+    def mledger
       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
+
+    private
+
+    # 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,84 +130,57 @@ 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
-    def mostra_resumo_simples
+    def mresumo_simples
       return unless dados.count.positive?
 
       puts("\nid     address                                        etherscan      bigquery")
       dados.each { |obj| puts(formata_carteira_simples(obj)) }
-      mostra_tx_norml
-      mostra_tx_inter
-      mostra_tx_block
-      mostra_tx_token
-      mostra_tx_withw
-      mostra_configuracao_ajuste_dias
+      mtx_norml
+      mtx_inter
+      mtx_block
+      mtx_token
+      mtx_withw
+      mconfiguracao_ajuste_dias
     end
 
     # @return [String] texto carteiras & transacoes & ajuste dias
-    def mostra_resumo
+    def mresumo
       return unless dados.count.positive?
 
       puts("\nid     address      etherscan  tn ti tb tk   tw    bigquery  tn ti tb tk   tw")
       dados.each { |obj| puts(formata_carteira(obj)) }
-      mostra_tx_norml
-      mostra_tx_inter
-      mostra_tx_block
-      mostra_tx_token
-      mostra_tx_withw
-      mostra_configuracao_ajuste_dias
+      mtx_norml
+      mtx_inter
+      mtx_block
+      mtx_token
+      mtx_withw
+      mconfiguracao_ajuste_dias
     end
 
     # @param [Hash] hjn dados juntos bigquery & etherscan
@@ -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,17 +301,11 @@ 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
-    def mostra_tx_norml
+    def mtx_norml
       return unless ops[:v] && novnetht.count.positive?
 
       puts("\ntx normal                     from            to              data         valor")
@@ -364,7 +313,7 @@ module Cns
     end
 
     # @return [String] texto transacoes internas
-    def mostra_tx_inter
+    def mtx_inter
       return unless ops[:v] && novnethi.count.positive?
 
       puts("\ntx intern                     from            to              data         valor")
@@ -372,7 +321,7 @@ module Cns
     end
 
     # @return [String] texto transacoes block
-    def mostra_tx_block
+    def mtx_block
       return unless ops[:v] && novnethp.count.positive?
 
       puts("\ntx block  address                                   data                   valor")
@@ -380,7 +329,7 @@ module Cns
     end
 
     # @return [String] texto transacoes token
-    def mostra_tx_token
+    def mtx_token
       return unless ops[:v] && novnethk.count.positive?
 
       puts("\ntx token                from            to              data         valor moeda")
@@ -388,7 +337,7 @@ module Cns
     end
 
     # @return [String] texto transacoes withdrawals
-    def mostra_tx_withw
+    def mtx_withw
       return unless ops[:v] && novnethw.count.positive?
 
       puts("\nwithdrawal validator data            valor")
@@ -396,12 +345,35 @@ module Cns
     end
 
     # @return [String] texto configuracao ajuste dias das transacoes (normais & token)
-    def mostra_configuracao_ajuste_dias
+    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 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: pesot(xbq, api.ledger_gm(xbq)) }
     end
 
     # @param wbq (see base_bc)
@@ -78,34 +73,14 @@ 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 mostra_resumo
+    def mresumo
       return unless dados.count.positive?
 
       puts("\naddress            greymass  ntx       bigquery  ntx")
       dados.each { |obj| puts(formata_carteira(obj)) }
-      mostra_transacoes_novas
-      mostra_configuracao_ajuste_dias
+      mtransacoes_novas
+      mconfiguracao_ajuste_dias
     end
 
     # @param [Hash] hjn dados juntos bigquery & greymass
@@ -134,29 +109,63 @@ 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
 
     # @return [String] texto transacoes
-    def mostra_transacoes_novas
+    def mtransacoes_novas
       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 mostra_configuracao_ajuste_dias
+    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 pesot(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

@@ -36,13 +36,13 @@ module Cns
     end
 
     # @return [String] texto saldos & transacoes & ajuste dias
-    def mostra_resumo
+    def mresumo
       puts("\nKRAKEN\ntipo                 kraken              bigquery")
-      exd[:sl].sort { |ant, prx| ant <=> prx }.each { |key, val| puts(formata_saldos(key, val)) }
-      mostra_totais
+      exd[:sl].sort.each { |key, val| puts(formata_saldos(key, val)) }
+      mtotais
 
-      mostra_trades
-      mostra_ledger
+      mtrades
+      mledger
       return if novcust.empty?
 
       puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |obj| "#{obj}:0" }.join(' ')}")
@@ -50,7 +50,7 @@ module Cns
 
     # @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 }
+      @exd ||= { sl: pusa(api.account_us), kt: pust(api.trades_us), kl: pusl(api.ledger_us) }
     end
 
     # @return [Array<String>] lista txid dos trades novos
@@ -68,14 +68,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
 
@@ -84,14 +83,14 @@ module Cns
     # @return [String] texto formatado trade
     def formata_trades(idx, htx)
       format(
-        '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-8.8s %<pr>8.2f %<vl>15.7f %<co>8.2f',
+        '%<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,16 +101,16 @@ 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
 
     # @return [String] texto totais numero de transacoes
-    def mostra_totais
+    def mtotais
       vkt = exd[:kt].count
       vnt = bqd[:nt].count
       vkl = exd[:kl].count
@@ -122,19 +121,36 @@ module Cns
     end
 
     # @return [String] texto transacoes trades
-    def mostra_trades
+    def mtrades
       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)) }
+      puts("\ntrade  data       hora     tipo       par         preco     volume         custo")
+      novcust.sort_by { |itm| -itm[1][:srx] }.each { |key, val| puts(formata_trades(key, val)) }
     end
 
     # @return [String] texto transacoes ledger
-    def mostra_ledger
+    def mledger
       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
+
+    private
+
+    # 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.6'
+  VERSION = '0.8.8'
 end

data/lib/cns.rb

@@ -18,21 +18,21 @@ module Cns
     option :t, type: :boolean, default: false, desc: 'mostra transacoes todas ou somente novas'
     # mostra eth transacoes
     def seth
-      Bigquery.new(options).mostra_seth
+      Bigquery.new(options).mseth
     end
 
     desc 'weth', 'carrega transacoes eth no bigquery'
     option :h, type: :hash, default: {}, desc: 'configuracao ajuste reposicionamento temporal'
     # carrega transacoes eth no bigquery
     def weth
-      Bigquery.new(options).processa_weth
+      Bigquery.new(options).pweth
     end
 
     desc 'ceth', 'carrega transacoes eth no bigquery (cron)'
     option :h, type: :hash, default: {}, desc: 'configuracao ajuste reposicionamento temporal'
     # carrega transacoes eth no bigquery (output to file)
     def ceth
-      Bigquery.new(options).processa_ceth
+      Bigquery.new(options).pceth
     end
 
     desc 'skrk', 'mostra kraken/eth transacoes'
@@ -40,21 +40,21 @@ module Cns
     option :t, type: :boolean, default: false, desc: 'mostra transacoes todas ou somente novas'
     # mostra kraken/eth transacoes
     def skrk
-      Bigquery.new(options).mostra_skrk
+      Bigquery.new(options).mskrk
     end
 
     desc 'wkrk', 'carrega transacoes kraken/eth no bigquery'
     option :h, type: :hash, default: {}, desc: 'configuracao ajuste reposicionamento temporal'
     # carrega transacoes kraken/eth no bigquery
     def wkrk
-      Bigquery.new(options).processa_wkrk
+      Bigquery.new(options).pwkrk
     end
 
     desc 'work', 'carrega transacoes novas no bigquery'
     option :h, type: :hash, default: {}, desc: 'configuracao ajuste reposicionamento temporal'
     # carrega transacoes novas no bigquery
     def work
-      Bigquery.new(options).processa_tudo
+      Bigquery.new(options).ptudo
     end
 
     desc 'show', 'mostra resumo transacoes'
@@ -62,7 +62,7 @@ module Cns
     option :t, type: :boolean, default: false, desc: 'mostra transacoes todas ou somente novas'
     # mostra resumo transacoes
     def show
-      Bigquery.new(options).mostra_tudo
+      Bigquery.new(options).mtudo
     end
 
     default_task :seth

metadata

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