cns 0.8.4 → 0.8.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1bca1a698024e59b3f4e8d69775a26223730139af0e7b5a717c26512046ec06
-  data.tar.gz: a3d3734c9322ae42283f1871314c28864c536a24a23219474f3eab5ec97a90da
+  metadata.gz: f4fb8ef5137e35f64fabed9a151d6547d12f21487e602c91404ba5eedcd88a34
+  data.tar.gz: 037a388cdcd7652fa803d76131ba1e7076b2a0983c74f835484005791c3a1fc3
 SHA512:
-  metadata.gz: 0047d7643b0e402d6d059bf1f0e7b4fdc024ec8439929e5dc53fac26a5c617df4d0923fb3dca0e1188887006aaf89f78ee3770c402335ca39845fc8a098de250
-  data.tar.gz: 9bb7c6ad69b0635f9bc09304918dba12f5d7f0a97a4b1413a020ac5b704b1694ef3b3a854260bd7706f544233c2753fa3a3d26b950fe1b0b5f0da27f3585db6f
+  metadata.gz: bd36261022378f795e64bc814434879b9f99cd7f7c3ff974a719aa0aed0d40bc16a341fcd11038f49c0e1056ea298acb21bca79644dcff7251eb27d69b4b6118
+  data.tar.gz: b6c078fcfb4e878f6058b785051ba702d8e49afc150767f7a99412d4d9202890e98cd3f3f3896afd11d80d2dc083e94fb220e1ff7a25fd261c8a1c781884abf2

data/Gemfile.lock

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

data/lib/cns/bigquery.rb

@@ -7,11 +7,10 @@ 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 = {
-    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],
+  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],
+    w: %w[withdrawalindex validatorindex address amount blocknumber timestamp dias],
     t: %w[blocknumber timestamp txhash nonce blockhash transactionindex axfrom axto iax value gas gasprice gasused iserror txreceipt_status input contractaddress dias],
     k: %w[blocknumber timestamp txhash nonce blockhash transactionindex axfrom axto iax value tokenname tokensymbol tokendecimal gas gasprice gasused input contractaddress dias],
     neost: %w[gseq aseq bnum time contract action acfrom acto iax amount moeda memo dias],
@@ -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,249 +205,242 @@ 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)
+    def fqt(value)
       return 'null' if value.nil? || value.empty?
 
-      "'#{value.gsub('\'', "''")}'" # Escape single quotes
+      "'#{value}'"
     end
 
-    def numeric(value)
+    def fnm(value)
+      return 'null' if value.nil?
+
       "CAST('#{value}' AS NUMERIC)"
     end
 
-    def integer(value)
+    def fin(value)
+      return '0' if value.nil?
+
       Integer(value).to_s
     rescue StandardError
       'null'
     end
 
+    def ftm(sec)
+      "PARSE_DATETIME('%s', '#{String(sec.round)}')"
+    end
+
+    def fts(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]),
-        quote(htx[:hash]),
-        integer(htx[:nonce]),
-        quote(htx[:blockHash]),
-        integer(htx[:transactionIndex]),
-        quote(htx[:from]),
-        quote(htx[:to]),
-        quote(htx[:iax]),
-        numeric(htx[:value]),
-        numeric(htx[:gas]),
-        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)
+        fin(htx[:blockNumber]),
+        fin(htx[:timeStamp]),
+        fqt(htx[:hash]),
+        fin(htx[:nonce]),
+        fqt(htx[:blockHash]),
+        fin(htx[:transactionIndex]),
+        fqt(htx[:from]),
+        fqt(htx[:to]),
+        fqt(htx[:iax]),
+        fnm(htx[:value]),
+        fnm(htx[:gas]),
+        fnm(htx[:gasPrice]),
+        fnm(htx[:gasUsed]),
+        fin(htx[:isError]),
+        fin(htx[:txreceipt_status]),
+        fqt(htx[:input]),
+        fqt(htx[:contractAddress]),
+        fin(ops.dig(:h, htx[:hash]))
       ].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]),
-        quote(htx[:hash]),
-        quote(htx[:from]),
-        quote(htx[:to]),
-        quote(htx[:iax]),
-        numeric(htx[:value]),
-        cta.empty? ? 'null' : quote(cta),
-        inp.empty? ? 'null' : quote(inp),
-        quote(htx[:type]),
-        numeric(htx[:gas]),
-        numeric(htx[:gasUsed]),
-        tid.empty? ? 'null' : quote(tid),
-        integer(htx[:isError]),
-        txr.empty? ? 'null' : integer(txr)
+        fin(htx[:blockNumber]),
+        fin(htx[:timeStamp]),
+        fqt(htx[:hash]),
+        fqt(htx[:from]),
+        fqt(htx[:to]),
+        fqt(htx[:iax]),
+        fnm(htx[:value]),
+        fqt(htx[:contractAddress]),
+        fqt(htx[:input]),
+        fqt(htx[:type]),
+        fnm(htx[:gas]),
+        fnm(htx[:gasUsed]),
+        fqt(htx[:traceId]),
+        fin(htx[:isError]),
+        fin(htx[:errCode]),
+        fin(ops.dig(:h, htx[:hash]))
       ].join(',')})"
     end
 
     # @param [Hash] htx transacao block etherscan
     # @return [String] valores formatados nethi (block parte1)
     def nethp_val(htx)
-      "(#{[integer(htx[:blockNumber]), integer(htx[:timeStamp]), numeric(htx[:blockReward]), quote(htx[:iax])].join(',')})"
+      "(#{[fin(htx[:blockNumber]), fin(htx[:timeStamp]), fnm(htx[:blockReward]), fqt(htx[:iax]), fin(ops.dig(:h, htx[:blockNumber]))].join(',')})"
     end
 
     # @param [Hash] htx transacao withdrawals etherscan
     # @return [String] valores formatados nethi (withdrawals parte1)
     def nethw_val(htx)
       "(#{[
-        integer(htx[:withdrawalIndex]),
-        integer(htx[:validatorIndex]),
-        quote(htx[:address]),
-        numeric(htx[:amount]),
-        integer(htx[:blockNumber]),
-        integer(htx[:timestamp])
+        fin(htx[:withdrawalIndex]),
+        fin(htx[:validatorIndex]),
+        fqt(htx[:address]),
+        fnm(htx[:amount]),
+        fin(htx[:blockNumber]),
+        fin(htx[:timestamp]),
+        fin(ops.dig(:h, htx[:withdrawalIndex]))
       ].join(',')})"
     end
 
     # @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]),
-        quote(htx[:hash]),
-        integer(htx[:nonce]),
-        quote(htx[:blockHash]),
-        integer(htx[:transactionIndex]),
-        quote(htx[:from]),
-        quote(htx[:to]),
-        quote(htx[:iax]),
-        numeric(htx[:value]),
-        quote(htx[:tokenName]),
-        quote(htx[:tokenSymbol]),
-        integer(htx[:tokenDecimal]),
-        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)
+        fin(htx[:blockNumber]),
+        fin(htx[:timeStamp]),
+        fqt(htx[:hash]),
+        fin(htx[:nonce]),
+        fqt(htx[:blockHash]),
+        fin(htx[:transactionIndex]),
+        fqt(htx[:from]),
+        fqt(htx[:to]),
+        fqt(htx[:iax]),
+        fnm(htx[:value]),
+        fqt(htx[:tokenName]),
+        fqt(htx[:tokenSymbol]),
+        fin(htx[:tokenDecimal]),
+        fnm(htx[:gas]),
+        fnm(htx[:gasPrice]),
+        fnm(htx[:gasUsed]),
+        fqt(htx[:input]),
+        fqt(htx[:contractAddress]),
+        fin(ops.dig(:h, htx[:hash]))
       ].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})"
+      "(#{[
+        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[:iax]),
+        qtd.to_d,
+        fqt(qtd[/[[:upper:]]+/]),
+        fqt(str),
+        fin(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)
+      "(#{[
+        fqt(htx[:trade_id]),
+        fts(htx[:successfully_finished_at]),
+        fqt(htx[:type]),
+        fqt(htx[:trading_partner_information][:username]),
+        fnm(htx[:type] == 'buy' ? htx[:amount_currency_to_trade_after_fee] : "-#{htx[:amount_currency_to_trade]}"),
+        fnm(htx[:volume_currency_to_pay_after_fee]),
+        fts(htx[:trade_marked_as_paid_at]),
+        fin(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]
+      "(#{[
+        fin(htx[:txid]),
+        fts(htx[:time].iso8601),
+        fqt(tip),
+        fqt(htx[:add]),
+        fqt(htx[:moe]),
+        fnm(tip == 'withdrawal' ? "-#{qtd}" : qtd),
+        fnm(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)
+      "(#{[
+        fqt(idx),
+        fqt(htx[:ordertxid]),
+        fqt(htx[:pair]),
+        ftm(htx[:time]),
+        fqt(htx[:type]),
+        fqt(htx[:ordertype]),
+        fnm(htx[:price]),
+        fnm(htx[:cost]),
+        fnm(htx[:fee]),
+        fnm(htx[:vol]),
+        fnm(htx[:margin]),
+        fqt(htx[:misc]),
+        fqt(apius.novcusl.select { |_, obj| obj[:refid] == idx.to_s }.keys.join(',')),
+        fin(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)
+      "(#{[fqt(idx), fqt(hlx[:refid]), ftm(hlx[:time]), fqt(hlx[:type]), fqt(hlx[:aclass]), fqt(hlx[:asset]), fnm(hlx[:amount]), fnm(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
@@ -193,11 +193,11 @@ module Cns
 
       puts("\nid     address                                        etherscan      bigquery")
       dados.each { |obj| puts(formata_carteira_simples(obj)) }
-      mostra_transacao_norml
-      mostra_transacao_inter
-      mostra_transacao_block
-      mostra_transacao_token
-      mostra_transacao_withw
+      mostra_tx_norml
+      mostra_tx_inter
+      mostra_tx_block
+      mostra_tx_token
+      mostra_tx_withw
       mostra_configuracao_ajuste_dias
     end
 
@@ -207,11 +207,11 @@ module Cns
 
       puts("\nid     address      etherscan  tn ti tb tk   tw    bigquery  tn ti tb tk   tw")
       dados.each { |obj| puts(formata_carteira(obj)) }
-      mostra_transacao_norml
-      mostra_transacao_inter
-      mostra_transacao_block
-      mostra_transacao_token
-      mostra_transacao_withw
+      mostra_tx_norml
+      mostra_tx_inter
+      mostra_tx_block
+      mostra_tx_token
+      mostra_tx_withw
       mostra_configuracao_ajuste_dias
     end
 
@@ -297,27 +297,42 @@ module Cns
       inf = max % 2
       hid = bqd[:wb].select { |obj| obj[:ax] == add }.first
       ndd = hid ? "#{hid[:id]}-#{add}" : add
-      "#{ndd[0, ini - 3]}..#{ndd[-inf - ini - 3..]}"
+      "#{ndd[0, ini]}..#{ndd[-inf - ini..]}"
     end
 
     # @example (see Apibc#norml_es)
     # @param [Hash] htx transacao normal etherscan
     # @return [String] texto formatado transacao normal etherscan
-    def formata_transacao_norml(htx)
+    def formata_tx_ti(htx)
       format(
-        '%<bn>9i %<fr>-20.20s %<to>-20.20s %<dt>10.10s %<vl>17.6f',
-        bn: htx[:blockNumber],
-        fr: formata_enderec2(htx[:from], 20),
-        to: formata_enderec2(htx[:to], 20),
+        '%<hx>-29.29s %<fr>-15.15s %<to>-15.15s %<dt>10.10s %<vl>7.3f',
+        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)
       )
     end
 
+    # @example (see Apibc#token_es)
+    # @param [Hash] hkx transacao token etherscan
+    # @return [String] texto formatado transacao token etherscan
+    def formata_tx_token(hkx)
+      format(
+        '%<hx>-23.23s %<fr>-15.15s %<to>-15.15s %<dt>10.10s %<vl>7.3f %<sy>-5.5s',
+        hx: formata_enderec1(hkx[:hash], 23),
+        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),
+        sy: hkx[:tokenSymbol]
+      )
+    end
+
     # @example (see Apibc#block_es)
     # @param [Hash] htx transacao block etherscan
     # @return [String] texto formatado transacao block etherscan
-    def formata_transacao_block(htx)
+    def formata_tx_block(htx)
       format(
         '%<bn>9i %<fr>-41.41s %<dt>10.10s %<vl>17.6f',
         bn: htx[:blockNumber],
@@ -327,78 +342,66 @@ module Cns
       )
     end
 
-    # @example (see Apibc#token_es)
-    # @param [Hash] hkx transacao token etherscan
-    # @return [String] texto formatado transacao token etherscan
-    def formata_transacao_token(hkx)
-      format(
-        '%<bn>9i %<fr>-20.20s %<to>-20.20s %<dt>10.10s %<vl>11.3f %<sy>-5.5s',
-        bn: hkx[:blockNumber],
-        fr: formata_enderec2(hkx[:from], 20),
-        to: formata_enderec2(hkx[:to], 20),
-        dt: Time.at(Integer(hkx[:timeStamp])),
-        vl: (hkx[:value].to_d / (10**18)).round(10),
-        sy: hkx[:tokenSymbol]
-      )
-    end
-
     # @example (see Apibc#block_es)
     # @param [Hash] htx transacao withdrawals etherscan
     # @return [String] texto formatado transacao withdrawals etherscan
-    def formata_transacao_withw(htx)
+    def formata_tx_withw(htx)
       format(
-        '%<vi>9i %<bn>10i %<dt>10.10s %<vl>10.6f',
-        vi: htx[:validatorIndex],
+        '%<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)
       )
     end
 
     # @return [String] texto transacoes normais
-    def mostra_transacao_norml
-      return unless ops[:v] && novtx.count.positive?
+    def mostra_tx_norml
+      return unless ops[:v] && novnetht.count.positive?
 
-      puts("\ntx normal from                 to                   data                   valor")
-      sortx.each { |obj| puts(formata_transacao_norml(obj)) }
+      puts("\ntx normal                     from            to              data         valor")
+      sortx.each { |obj| puts(formata_tx_ti(obj)) }
     end
 
     # @return [String] texto transacoes internas
-    def mostra_transacao_inter
-      return unless ops[:v] && novix.count.positive?
+    def mostra_tx_inter
+      return unless ops[:v] && novnethi.count.positive?
 
-      puts("\ntx intern from                 to                   data                   valor")
-      sorix.each { |obj| puts(formata_transacao_norml(obj)) }
+      puts("\ntx intern                     from            to              data         valor")
+      sorix.each { |obj| puts(formata_tx_ti(obj)) }
     end
 
     # @return [String] texto transacoes block
-    def mostra_transacao_block
-      return unless ops[:v] && novpx.count.positive?
+    def mostra_tx_block
+      return unless ops[:v] && novnethp.count.positive?
 
       puts("\ntx block  address                                   data                   valor")
-      sorpx.each { |obj| puts(formata_transacao_block(obj)) }
+      sorpx.each { |obj| puts(formata_tx_block(obj)) }
     end
 
     # @return [String] texto transacoes token
-    def mostra_transacao_token
-      return unless ops[:v] && novkx.count.positive?
+    def mostra_tx_token
+      return unless ops[:v] && novnethk.count.positive?
 
-      puts("\ntx token  from                 to                   data             valor")
-      sorkx.each { |obj| puts(formata_transacao_token(obj)) }
+      puts("\ntx token                from            to              data         valor moeda")
+      sorkx.each { |obj| puts(formata_tx_token(obj)) }
     end
 
     # @return [String] texto transacoes withdrawals
-    def mostra_transacao_withw
-      return unless ops[:v] && novwx.count.positive?
+    def mostra_tx_withw
+      return unless ops[:v] && novnethw.count.positive?
 
-      puts("\nvalidator withdrawal data            valor")
-      sorwx.each { |obj| puts(formata_transacao_withw(obj)) }
+      puts("\nwithdrawal validator data            valor")
+      sorwx.each { |obj| puts(formata_tx_withw(obj)) }
     end
 
     # @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("\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?
     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.6'
 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.6
 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