cns 0.8.4 → 0.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1bca1a698024e59b3f4e8d69775a26223730139af0e7b5a717c26512046ec06
-  data.tar.gz: a3d3734c9322ae42283f1871314c28864c536a24a23219474f3eab5ec97a90da
+  metadata.gz: 8f7ae1ef8366ed9cf561233f61e42435ab6d5b7202c64936310d057f99689138
+  data.tar.gz: 29610ef7729632d29c3d97aeccc1732cac387265de5536327734d5f4af54a265
 SHA512:
-  metadata.gz: 0047d7643b0e402d6d059bf1f0e7b4fdc024ec8439929e5dc53fac26a5c617df4d0923fb3dca0e1188887006aaf89f78ee3770c402335ca39845fc8a098de250
-  data.tar.gz: 9bb7c6ad69b0635f9bc09304918dba12f5d7f0a97a4b1413a020ac5b704b1694ef3b3a854260bd7706f544233c2753fa3a3d26b950fe1b0b5f0da27f3585db6f
+  metadata.gz: 5c28857d6b4fe429e9f8f9eb6ddfdca805343c6f5347b40624a6ea03a687bd9b90d4c257c1d7434629d404df6914f9dfa6c62883babb843cc74842643cd7d39e
+  data.tar.gz: b3a334a6580af627911d51037bad7065af7129239fd2ccbaf45750cba7f8c7a57b48ab28f4605a00ac9b5bbadb304a9f80e6af1519ad7d0c677d6acafb153bc3

data/Gemfile.lock

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

data/lib/cns/bigquery.rb

@@ -7,8 +7,7 @@ require('bigdecimal/util')
 module Cns
   BD = 'hernanirvaz.coins'
   FO = File.expand_path("~/#{File.basename($PROGRAM_NAME)}.log")
-  # Define table configurations at the class level
-  TC = {
+  TB = {
     i: %w[blocknumber timestamp txhash axfrom axto iax value contractaddress input type gas gasused traceid iserror errcode],
     p: %w[blocknumber timestamp blockreward iax],
     w: %w[withdrawalindex validatorindex address amount blocknumber timestamp],
@@ -38,7 +37,7 @@ module Cns
       # usa env GOOGLE_APPLICATION_CREDENTIALS para obter credentials
       # @see https://cloud.google.com/bigquery/docs/authentication/getting-started
       @api = Google::Cloud::Bigquery.new
-      @ops = pop
+      @ops = pop.transform_keys(&:to_sym)
     end
 
     # mostra situacao completa entre kraken/bitcoinde/paymium/therock/etherscan/greymass & bigquery
@@ -67,26 +66,22 @@ module Cns
 
     # insere (caso existam) dados novos kraken/bitcoinde/paymium/therock/etherscan/greymass no bigquery
     def processa_tudo
-      str = "#{processa_us}, #{processa_de}, #{processa_eth}, #{processa_eos}"
-      puts(trs_ini + str)
+      puts(trs_ini + "#{processa_us}, #{processa_de}, #{processa_eth}, #{processa_eos}")
     end
 
     # insere (caso existam) dados novos kraken/etherscan no bigquery
     def processa_wkrk
-      str = "#{processa_us}, #{processa_eth}"
-      puts(trs_ini + str)
+      puts(trs_ini + "#{processa_us}, #{processa_eth}")
     end
 
     # insere (caso existam) dados novos etherscan no bigquery
     def processa_weth
-      str = processa_eth
-      puts(trs_ini + str)
+      puts(trs_ini + processa_eth)
     end
 
     # insere (caso existam) dados novos etherscan no bigquery (output to file)
     def processa_ceth
-      str = processa_ethc
-      File.open(FO, mode: 'a') { |out| out.puts(trs_ini + str) }
+      File.open(FO, mode: 'a') { |out| out.puts(trs_ini + processa_ethc) }
     end
 
     private
@@ -95,43 +90,35 @@ module Cns
     #
     # @return [String] linhas & tabelas afetadas
     def processa_eth
-      tabelas_eth(apies, 'netb')
+      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
-      tabelas_eth(apiesc, 'netc')
+      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
-      str = 'KRAKEN'
-      str += format(' %<n>i ust', n: dml(ust_ins)) if apius.trades.count.positive?
-      str += format(' %<n>i usl', n: dml(usl_ins)) if apius.ledger.count.positive?
-      str
+      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
-      str = 'BITCOINDE'
-      str += format(' %<n>i det', n: dml(det_ins)) if apide.trades.count.positive?
-      str += format(' %<n>i del', n: dml(del_ins)) if apide.ledger.count.positive?
-      str
+      tabelas_out(apide, %w[BITCOINDE], %i[cdet cdel])
     end
 
     # insere transacoes blockchain novas na tabela eos
     #
     # @return [String] linhas & tabelas afetadas
     def processa_eos
-      str = 'EOS'
-      str += format(' %<n>i eos ', n: dml(eost_ins)) if apigm.novax.count.positive?
-      str
+      tabelas_out(apigm, %w[EOS], %i[neost])
     end
 
     # cria job bigquery & verifica execucao
@@ -218,70 +205,68 @@ module Cns
       )
     end
 
-    # Generic ETH data processor
-    def tabelas_eth(src, prx)
-      str = ['ETH']
-      %i[t i p w k].each do |typ|
-        novx = src.send("nov#{typ}x")
+    def tabelas_cus(src, str, ltb, prx = '')
+      ltb.each do |itm|
+        novx = src.send("nov#{prx}#{itm}")
         next if novx.empty?
 
-        str << format(' %<n>i %<t>s', n: dml(insert_eht(typ, novx)), t: "#{prx.chop}h#{typ}")
+        str << format(' %<n>i %<t>s', n: dml(insert_cus(prx, itm, novx)), t: prx + itm.to_s)
       end
       str.join
     end
 
-    def insert_eht(typ, lin)
-      "INSERT #{BD}.neth#{typ} (#{TC[typ].join(',')}) VALUES #{lin.map { |itm| send("neth#{typ}_val", itm) }.join(',')}"
-    end
-
-    # @return [String] comando insert SQL formatado eos
-    def eost_ins
-      "insert #{BD}.neost(#{TC[:neost].join(',')}) VALUES#{apigm.novax.map { |obj| eost_val(obj) }.join(',')}"
-    end
-
-    # @return [String] comando insert SQL formatado det (trades)
-    def det_ins
-      "insert #{BD}.cdet(#{TC[:cdet].join(',')}) VALUES#{apide.trades.map { |obj| det_val(obj) }.join(',')}"
-    end
+    def tabelas_out(src, str, ltb, prx = '')
+      ltb.each do |itm|
+        novx = src.send("nov#{prx}#{itm}")
+        next if novx.empty?
 
-    # @return [String] comando insert SQL formatado del (ledger)
-    def del_ins
-      "insert #{BD}.cdel(#{TC[:cdel].join(',')}) VALUES#{apide.ledger.map { |obj| del_val(obj) }.join(',')}"
+        str << format(' %<n>i %<t>s', n: dml(insert_out(prx, itm, novx)), t: prx + itm.to_s)
+      end
+      str.join
     end
 
-    # @return [String] comando insert SQL formatado ust (trades)
-    def ust_ins
-      "insert #{BD}.cust(#{TC[:cust].join(',')}) VALUES#{apius.trades.map { |key, val| ust_val(key, val) }.join(',')}"
+    # @return [String] comando insert SQL formatado
+    def insert_cus(prx, tbl, lin)
+      "INSERT #{BD}.#{prx}#{tbl} (#{TB[tbl].join(',')}) VALUES #{lin.map { |key, val| send("#{prx}#{tbl}_val", key, val) }.join(',')}"
     end
 
-    # @return [String] comando insert SQL formatado usl (ledger)
-    def usl_ins
-      "insert #{BD}.cusl(#{TC[:cusl].join(',')}) VALUES#{apius.ledger.map { |key, val| usl_val(key, val) }.join(',')}"
+    # @return [String] comando insert SQL formatado
+    def insert_out(prx, tbl, lin)
+      "INSERT #{BD}.#{prx}#{tbl} (#{TB[tbl].join(',')}) VALUES #{lin.map { |itm| send("#{prx}#{tbl}_val", itm) }.join(',')}"
     end
 
     # SQL value formatting methods with improved safety
     def quote(value)
       return 'null' if value.nil? || value.empty?
 
-      "'#{value.gsub('\'', "''")}'" # Escape single quotes
+      "'#{value}'"
     end
 
     def numeric(value)
+      return 'null' if value.nil?
+
       "CAST('#{value}' AS NUMERIC)"
     end
 
     def integer(value)
+      return '0' if value.nil?
+
       Integer(value).to_s
     rescue StandardError
       'null'
     end
 
+    def ptime(sec)
+      "PARSE_DATETIME('%s', '#{String(sec.round)}')"
+    end
+
+    def ptimestamp(value)
+      "DATETIME(TIMESTAMP('#{value}'))"
+    end
+
     # @param [Hash] htx transacao norml etherscan
     # @return [String] valores formatados netht (norml parte1)
     def netht_val(htx)
-      txr = htx[:txreceipt_status]
-      inp = htx[:input]
-      cta = htx[:contractAddress]
       "(#{[
         integer(htx[:blockNumber]),
         integer(htx[:timeStamp]),
@@ -297,20 +282,16 @@ module Cns
         numeric(htx[:gasPrice]),
         numeric(htx[:gasUsed]),
         integer(htx[:isError]),
-        txr.empty? ? 'null' : integer(txr),
-        inp.empty? ? 'null' : quote(inp),
-        cta.empty? ? 'null' : quote(cta),
-        integer(ops.dig(:h, htx[:blockNumber]) || 0)
+        integer(htx[:txreceipt_status]),
+        quote(htx[:input]),
+        quote(htx[:contractAddress]),
+        integer(ops.dig(:h, htx[:blockNumber]))
       ].join(',')})"
     end
 
     # @param [Hash] htx transacao internas etherscan
     # @return [String] valores formatados nethi (internas parte1)
     def nethi_val(htx)
-      cta = htx[:contractAddress]
-      inp = htx[:input]
-      tid = htx[:traceId]
-      txr = htx[:errCode]
       "(#{[
         integer(htx[:blockNumber]),
         integer(htx[:timeStamp]),
@@ -319,14 +300,14 @@ module Cns
         quote(htx[:to]),
         quote(htx[:iax]),
         numeric(htx[:value]),
-        cta.empty? ? 'null' : quote(cta),
-        inp.empty? ? 'null' : quote(inp),
+        quote(htx[:contractAddress]),
+        quote(htx[:input]),
         quote(htx[:type]),
         numeric(htx[:gas]),
         numeric(htx[:gasUsed]),
-        tid.empty? ? 'null' : quote(tid),
+        quote(htx[:traceId]),
         integer(htx[:isError]),
-        txr.empty? ? 'null' : integer(txr)
+        integer(htx[:errCode])
       ].join(',')})"
     end
 
@@ -352,8 +333,6 @@ module Cns
     # @param [Hash] hkx token event etherscan
     # @return [String] valores formatados nethk (token parte1)
     def nethk_val(htx)
-      inp = htx[:input]
-      cta = htx[:contractAddress]
       "(#{[
         integer(htx[:blockNumber]),
         integer(htx[:timeStamp]),
@@ -371,96 +350,95 @@ module Cns
         numeric(htx[:gas]),
         numeric(htx[:gasPrice]),
         numeric(htx[:gasUsed]),
-        inp.empty? ? 'null' : quote(inp),
-        cta.empty? ? 'null' : quote(cta),
-        integer(ops.dig(:h, htx[:blockNumber]) || 0)
+        quote(htx[:input]),
+        quote(htx[:contractAddress]),
+        integer(ops.dig(:h, htx[:blockNumber]))
       ].join(',')})"
     end
 
     # @example (see Apibc#ledger_gm)
     # @param [Hash] hlx ledger greymass
     # @return [String] valores formatados para insert eos (parte1)
-    def eost_val(hlx)
-      act = hlx[:action_trace][:act]
+    def neost_val(htx)
+      act = htx[:action_trace][:act]
       dat = act[:data]
       qtd = dat[:quantity].to_s
       str = dat[:memo].inspect
-      "(#{hlx[:global_action_seq]}," \
-        "#{hlx[:account_action_seq]}," \
-        "#{hlx[:block_num]}," \
-        "DATETIME(TIMESTAMP('#{hlx[:block_time]}'))," \
-        "'#{act[:account]}'," \
-        "'#{act[:name]}'," \
-        "'#{dat[:from]}'," \
-        "'#{dat[:to]}'," \
-        "'#{hlx[:iax]}'," \
-        "#{qtd.to_d},'#{qtd[/[[:upper:]]+/]}'," \
-        "nullif('#{str.gsub(/['"]/, '')}','nil')," \
-        "#{ops[:h][String(hlx[:itx])] || 0})"
+      "(#{[
+        integer(htx[:global_action_seq]),
+        integer(htx[:account_action_seq]),
+        integer(htx[:block_num]),
+        ptimestamp(htx[:block_time]),
+        quote(act[:account]),
+        quote(act[:name]),
+        quote(dat[:from]),
+        quote(dat[:to]),
+        quote(htx[:iax]),
+        qtd.to_d,
+        quote(qtd[/[[:upper:]]+/]),
+        quote(str),
+        integer(ops.dig(:h, htx[:itx]))
+      ].join(',')})"
     end
 
     # @param [Hash] htx trade bitcoinde
     # @return [String] valores formatados det (trades parte1)
-    def det_val(htx)
-      "('#{htx[:trade_id]}'," \
-        "DATETIME(TIMESTAMP('#{htx[:successfully_finished_at]}'))," \
-        "'#{htx[:type]}'," \
-        "'#{htx[:trading_partner_information][:username]}'," \
-        'cast(' \
-        "#{htx[:type] == 'buy' ? htx[:amount_currency_to_trade_after_fee] : "-#{htx[:amount_currency_to_trade]}"} " \
-        'as numeric),' \
-        "cast(#{htx[:volume_currency_to_pay_after_fee]} as numeric)," \
-        "DATETIME(TIMESTAMP('#{htx[:trade_marked_as_paid_at]}'))," \
-        "#{Integer(ops[:h][htx[:trade_id]] || 0)})"
+    def cdet_val(htx)
+      "(#{[
+        quote(htx[:trade_id]),
+        ptimestamp(htx[:successfully_finished_at]),
+        quote(htx[:type]),
+        quote(htx[:trading_partner_information][:username]),
+        numeric(htx[:type] == 'buy' ? htx[:amount_currency_to_trade_after_fee] : "-#{htx[:amount_currency_to_trade]}"),
+        numeric(htx[:volume_currency_to_pay_after_fee]),
+        ptimestamp(htx[:trade_marked_as_paid_at]),
+        integer(ops.dig(:h, htx[:trade_id]))
+      ].join(',')})"
     end
 
     # @param [Hash] hlx ledger (deposits + withdrawals) bitcoinde
     # @return [String] valores formatados del (ledger)
-    def del_val(hlx)
-      tip = hlx[:tp]
-      "(#{hlx[:txid]}," \
-        "DATETIME(TIMESTAMP('#{hlx[:time].iso8601}'))," \
-        "'#{tip}'," \
-        "'#{hlx[:add]}'," \
-        "'#{hlx[:moe]}'," \
-        "cast(#{tip == 'withdrawal' ? '-' : ''}#{hlx[:qt]} as numeric)," \
-        "cast(#{hlx[:fee]} as numeric))"
+    def cdel_val(htx)
+      tip = htx[:tp]
+      qtd = htx[:qt]
+      "(#{[
+        integer(htx[:txid]),
+        ptimestamp(htx[:time].iso8601),
+        quote(tip),
+        quote(htx[:add]),
+        quote(htx[:moe]),
+        numeric(tip == 'withdrawal' ? "-#{qtd}" : qtd),
+        numeric(htx[:fee])
+      ].join(',')})"
     end
 
     # @param [String] idx identificador transacao
     # @param [Hash] htx trade kraken
     # @return [String] valores formatados ust (trades parte1)
-    def ust_val(idx, htx)
-      msc = htx[:misc].to_s
-      "('#{idx}'," \
-        "'#{htx[:ordertxid]}'," \
-        "'#{htx[:pair]}'," \
-        "PARSE_DATETIME('%s', '#{String(htx[:time].round)}')," \
-        "'#{htx[:type]}'," \
-        "'#{htx[:ordertype]}'," \
-        "cast(#{htx[:price]} as numeric)," \
-        "cast(#{htx[:cost]} as numeric)," \
-        "cast(#{htx[:fee]} as numeric)," \
-        "cast(#{htx[:vol]} as numeric)," \
-        "cast(#{htx[:margin]} as numeric)," \
-        "#{msc.empty? ? 'null' : "'#{msc}'"}," \
-        "'#{apius.ledger.select { |_, val| val[:refid] == idx }.keys.join(',') || ''}'," \
-        "#{Integer(ops[:h][idx] || 0)})"
+    def cust_val(idx, htx)
+      "(#{[
+        quote(idx),
+        quote(htx[:ordertxid]),
+        quote(htx[:pair]),
+        ptime(htx[:time]),
+        quote(htx[:type]),
+        quote(htx[:ordertype]),
+        numeric(htx[:price]),
+        numeric(htx[:cost]),
+        numeric(htx[:fee]),
+        numeric(htx[:vol]),
+        numeric(htx[:margin]),
+        quote(htx[:misc]),
+        quote(apius.novcusl.select { |_, obj| obj[:refid] == idx.to_s }.keys.join(',')),
+        integer(ops.dig(:h, idx))
+      ].join(',')})"
     end
 
     # @param idx (see ust_val)
     # @param [Hash] hlx ledger kraken
     # @return [String] valores formatados usl (ledger)
-    def usl_val(idx, hlx)
-      acl = hlx[:aclass].to_s
-      "('#{idx}'," \
-        "'#{hlx[:refid]}'," \
-        "PARSE_DATETIME('%s', '#{String(hlx[:time].round)}')," \
-        "'#{hlx[:type]}'," \
-        "#{acl.empty? ? 'null' : "'#{acl}'"}," \
-        "'#{hlx[:asset]}'," \
-        "cast(#{hlx[:amount]} as numeric)," \
-        "cast(#{hlx[:fee]} as numeric))"
+    def cusl_val(idx, hlx)
+      "(#{[quote(idx), quote(hlx[:refid]), ptime(hlx[:time]), quote(hlx[:type]), quote(hlx[:aclass]), quote(hlx[:asset]), numeric(hlx[:amount]), numeric(hlx[:fee])].join(',')})"
     end
   end
 end

data/lib/cns/bitcoinde.rb

@@ -22,17 +22,17 @@ module Cns
     def initialize(dad, pop)
       @api = Apice.new
       @bqd = dad
-      @ops = pop
+      @ops = pop.transform_keys(&:to_sym)
     end
 
     # @return [Array<Hash>] lista trades bitcoinde novos
-    def trades
-      @trades ||= exd[:tt].select { |obj| kyt.include?(obj[:trade_id]) }
+    def novcdet
+      @novcdet ||= exd[:tt].select { |obj| kyt.include?(obj[:trade_id]) }
     end
 
     # @return [Array<Hash>] lista ledger (deposits + withdrawals) bitcoinde novos
-    def ledger
-      @ledger ||= exd[:tl].select { |obj| kyl.include?(obj[:txid]) }
+    def novcdel
+      @novcdel ||= exd[:tl].select { |obj| kyl.include?(obj[:txid]) }
     end
 
     # @return [String] texto saldos & transacoes & ajuste dias
@@ -43,7 +43,7 @@ module Cns
 
       mostra_trades
       mostra_ledger
-      return if trades.empty?
+      return if novcdet.empty?
 
       puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |obj| "#{obj}:0" }.join(' ')}")
     end
@@ -120,20 +120,18 @@ module Cns
 
     # @return [String] texto transacoes trades
     def mostra_trades
-      return unless ops[:v] && !trades.empty?
+      return unless ops[:v] && !novcdet.empty?
 
       puts("\ntrades data       hora     dt criacao tipo  par                     qtd      eur")
-      trades
-        .sort { |ant, prx| Time.parse(prx[:successfully_finished_at]) <=> Time.parse(ant[:successfully_finished_at]) }
-        .each { |obj| puts(formata_trades(obj)) }
+      novcdet.sort { |ant, prx| Time.parse(prx[:successfully_finished_at]) <=> Time.parse(ant[:successfully_finished_at]) }.each { |obj| puts(formata_trades(obj)) }
     end
 
     # @return [String] texto transacoes ledger
     def mostra_ledger
-      return unless ops[:v] && !ledger.empty?
+      return unless ops[:v] && !novcdel.empty?
 
       puts("\nledger data       hora     tipo       moe          quantidade              custo")
-      ledger.sort { |ant, prx| prx[:time] <=> ant[:time] }.each { |obj| puts(formata_ledger(obj)) }
+      novcdel.sort { |ant, prx| prx[:time] <=> ant[:time] }.each { |obj| puts(formata_ledger(obj)) }
     end
   end
 end

data/lib/cns/etherscan.rb

@@ -24,32 +24,32 @@ module Cns
     def initialize(dad, pop)
       @api = Apibc.new
       @bqd = dad
-      @ops = pop
+      @ops = pop.transform_keys(&:to_sym)
     end
 
     # @return [Array<Hash>] lista transacoes normais novas
-    def novtx
-      @novtx ||= bcd.map { |obc| obc[:tx].select { |obj| idt.include?(obj[:itx]) } }.flatten.uniq { |itm| itm[:itx] }
+    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 novix
-      @novix ||= bcd.map { |obc| obc[:ix].select { |obj| idi.include?(obj[:itx]) } }.flatten.uniq { |itm| itm[:itx] }
+    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 novpx
-      @novpx ||= bcd.map { |obc| obc[:px].select { |obj| idp.include?(obj[:itx]) } }.flatten.uniq { |itm| itm[:itx] }
+    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 novwx
-      @novwx ||= bcd.map { |obc| obc[:wx].select { |obj| idw.include?(obj[:itx]) } }.flatten.uniq { |itm| itm[:itx] }
+    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 novkx
-      @novkx ||= bcd.map { |obc| obc[:kx].select { |obj| idk.include?(obj[:itx]) } }.flatten.uniq { |itm| itm[:itx] }
+    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
@@ -164,27 +164,27 @@ module Cns
     # dt: Time.at(Integer(htx[:timeStamp])),
     # @return [Array<Hash>] lista ordenada transacoes normais novas
     def sortx
-      novtx.sort { |ant, prx| ant[:srx] <=> prx[:srx] }
+      novnetht.sort { |ant, prx| ant[:srx] <=> prx[:srx] }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes internas novas
     def sorix
-      novix.sort { |ant, prx| ant[:srx] <=> prx[:srx] }
+      novnethi.sort { |ant, prx| ant[:srx] <=> prx[:srx] }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes block novas
     def sorpx
-      novpx.sort { |ant, prx| ant[:itx] <=> prx[:itx] }
+      novnethp.sort { |ant, prx| ant[:itx] <=> prx[:itx] }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes withdrawals novas
     def sorwx
-      novwx.sort { |ant, prx| ant[:itx] <=> prx[:itx] }
+      novnethw.sort { |ant, prx| ant[:itx] <=> prx[:itx] }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes token novas
     def sorkx
-      novkx.sort { |ant, prx| ant[:srx] <=> prx[:srx] }
+      novnethk.sort { |ant, prx| ant[:srx] <=> prx[:srx] }
     end
 
     # @return [String] texto carteiras & transacoes & ajuste dias
@@ -357,7 +357,7 @@ module Cns
 
     # @return [String] texto transacoes normais
     def mostra_transacao_norml
-      return unless ops[:v] && novtx.count.positive?
+      return unless ops[:v] && novnetht.count.positive?
 
       puts("\ntx normal from                 to                   data                   valor")
       sortx.each { |obj| puts(formata_transacao_norml(obj)) }
@@ -365,7 +365,7 @@ module Cns
 
     # @return [String] texto transacoes internas
     def mostra_transacao_inter
-      return unless ops[:v] && novix.count.positive?
+      return unless ops[:v] && novnethi.count.positive?
 
       puts("\ntx intern from                 to                   data                   valor")
       sorix.each { |obj| puts(formata_transacao_norml(obj)) }
@@ -373,7 +373,7 @@ module Cns
 
     # @return [String] texto transacoes block
     def mostra_transacao_block
-      return unless ops[:v] && novpx.count.positive?
+      return unless ops[:v] && novnethp.count.positive?
 
       puts("\ntx block  address                                   data                   valor")
       sorpx.each { |obj| puts(formata_transacao_block(obj)) }
@@ -381,7 +381,7 @@ module Cns
 
     # @return [String] texto transacoes token
     def mostra_transacao_token
-      return unless ops[:v] && novkx.count.positive?
+      return unless ops[:v] && novnethk.count.positive?
 
       puts("\ntx token  from                 to                   data             valor")
       sorkx.each { |obj| puts(formata_transacao_token(obj)) }
@@ -389,7 +389,7 @@ module Cns
 
     # @return [String] texto transacoes withdrawals
     def mostra_transacao_withw
-      return unless ops[:v] && novwx.count.positive?
+      return unless ops[:v] && novnethw.count.positive?
 
       puts("\nvalidator withdrawal data            valor")
       sorwx.each { |obj| puts(formata_transacao_withw(obj)) }
@@ -397,8 +397,8 @@ module Cns
 
     # @return [String] texto configuracao ajuste dias das transacoes (normais & token)
     def mostra_configuracao_ajuste_dias
-      puts("\nstring ajuste dias transacoes normais\n-h=#{sortx.map { |obj| "#{obj[:blockNumber]}:0" }.join(' ')}") if novtx.count.positive?
-      puts("\nstring ajuste dias transacoes token  \n-h=#{sorkx.map { |obj| "#{obj[:blockNumber]}:0" }.join(' ')}") if novkx.count.positive?
+      puts("\nstring ajuste dias transacoes normais\n-h=#{sortx.map { |obj| "#{obj[:blockNumber]}:0" }.join(' ')}") if novnetht.count.positive?
+      puts("\nstring ajuste dias transacoes token  \n-h=#{sorkx.map { |obj| "#{obj[:blockNumber]}:0" }.join(' ')}") if novnethk.count.positive?
     end
   end
 end

data/lib/cns/greymass.rb

@@ -22,12 +22,12 @@ module Cns
     def initialize(dad, pop)
       @api = Apibc.new
       @bqd = dad
-      @ops = pop
+      @ops = pop.transform_keys(&:to_sym)
     end
 
     # @return [Array<Hash>] lista transacoes novas
-    def novax
-      @novax ||= bcd.map { |obc| obc[:tx].select { |obj| idt.include?(obj[:itx]) } }.flatten
+    def novneost
+      @novneost ||= bcd.map { |obc| obc[:tx].select { |obj| idt.include?(obj[:itx]) } }.flatten
     end
 
     # @return [Array<String>] lista dos meus enderecos
@@ -98,11 +98,6 @@ module Cns
       end).map { |omp| omp.merge(itx: omp[:global_action_seq], iax: add) }
     end
 
-    # @return [Array<Hash>] lista ordenada transacoes novas
-    def sorax
-      novax.sort { |ant, prx| prx[:itx] <=> ant[:itx] }
-    end
-
     # @return [String] texto carteiras & transacoes & ajuste dias
     def mostra_resumo
       return unless dados.count.positive?
@@ -151,17 +146,17 @@ module Cns
 
     # @return [String] texto transacoes
     def mostra_transacoes_novas
-      return unless ops[:v] && novax.count.positive?
+      return unless ops[:v] && novneost.count.positive?
 
       puts("\nsequence num from         to           accao      data              valor moeda")
-      sorax.each { |obj| puts(formata_ledger(obj)) }
+      novneost.sort { |ant, prx| prx[:itx] <=> ant[:itx] }.each { |obj| puts(formata_ledger(obj)) }
     end
 
     # @return [String] texto configuracao ajuste dias das transacoes
     def mostra_configuracao_ajuste_dias
-      return unless novax.count.positive?
+      return unless novneost.count.positive?
 
-      puts("\nstring ajuste dias\n-h=#{sorax.map { |obj| "#{obj[:itx]}:0" }.join(' ')}")
+      puts("\nstring ajuste dias\n-h=#{novneost.sort { |ant, prx| prx[:itx] <=> ant[:itx] }.map { |obj| "#{obj[:itx]}:0" }.join(' ')}")
     end
   end
 end

data/lib/cns/kraken.rb

@@ -22,17 +22,17 @@ module Cns
     def initialize(dad, pop)
       @api = Apice.new
       @bqd = dad
-      @ops = pop
+      @ops = pop.transform_keys(&:to_sym)
     end
 
     # @return [Hash] trades kraken novos
-    def trades
-      @trades ||= exd[:kt].slice(*kyt)
+    def novcust
+      @novcust ||= exd[:kt].slice(*kyt)
     end
 
     # @return [Hash] ledger kraken novos
-    def ledger
-      @ledger ||= exd[:kl].slice(*kyl)
+    def novcusl
+      @novcusl ||= exd[:kl].slice(*kyl)
     end
 
     # @return [String] texto saldos & transacoes & ajuste dias
@@ -43,7 +43,7 @@ module Cns
 
       mostra_trades
       mostra_ledger
-      return if trades.empty?
+      return if novcust.empty?
 
       puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |obj| "#{obj}:0" }.join(' ')}")
     end
@@ -123,18 +123,18 @@ module Cns
 
     # @return [String] texto transacoes trades
     def mostra_trades
-      return unless ops[:v] && trades.count.positive?
+      return unless ops[:v] && novcust.count.positive?
 
       puts("\ntrade  data       hora     tipo       par         preco          volume    custo")
-      trades.sort { |ant, prx| prx[1][:time] <=> ant[1][:time] }.each { |key, val| puts(formata_trades(key, val)) }
+      novcust.sort { |ant, prx| prx[1][:time] <=> ant[1][:time] }.each { |key, val| puts(formata_trades(key, val)) }
     end
 
     # @return [String] texto transacoes ledger
     def mostra_ledger
-      return unless ops[:v] && ledger.count.positive?
+      return unless ops[:v] && novcusl.count.positive?
 
       puts("\nledger data       hora     tipo       moeda        quantidade              custo")
-      ledger.sort { |ant, prx| prx[1][:time] <=> ant[1][:time] }.each { |key, val| puts(formata_ledger(key, val)) }
+      novcusl.sort { |ant, prx| prx[1][:time] <=> ant[1][:time] }.each { |key, val| puts(formata_ledger(key, val)) }
     end
   end
 end

data/lib/cns/version.rb

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

data/lib/cns.rb

@@ -58,7 +58,7 @@ module Cns
     end
 
     desc 'show', 'mostra resumo transacoes'
-    option :v, type: :boolean, default: false, desc: 'mostra transacoes'
+    option :v, type: :boolean, default: true, desc: 'mostra transacoes'
     option :t, type: :boolean, default: false, desc: 'mostra transacoes todas ou somente novas'
     # mostra resumo transacoes
     def show

metadata

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