cns 0.8.3 → 0.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 447a7eabc62ea51c62ff66775c277f6ea40a8812a781f28b695ce00f773dc2b7
-  data.tar.gz: '06778bee30d6d2e7ed2cd6ff13749b13941eb9006c961fbbaf80e358d38cb653'
+  metadata.gz: 8f7ae1ef8366ed9cf561233f61e42435ab6d5b7202c64936310d057f99689138
+  data.tar.gz: 29610ef7729632d29c3d97aeccc1732cac387265de5536327734d5f4af54a265
 SHA512:
-  metadata.gz: a308f6d97e7685d5b2335225ee180347ab1b806ff08780eac84edbf1b732b74627d860026803d9871ccb90c9b0bf74e323e1b24b23d6d64f10916d6dd0f0dae4
-  data.tar.gz: 705c5c84272baeb7b2e60af69d5a6c802c7a6c28a9c34420a94395b87464829ac7e1a25fa37c60fe62a655aea7971cf210f827100638f37a1794d45cd6d8a89c
+  metadata.gz: 5c28857d6b4fe429e9f8f9eb6ddfdca805343c6f5347b40624a6ea03a687bd9b90d4c257c1d7434629d404df6914f9dfa6c62883babb843cc74842643cd7d39e
+  data.tar.gz: b3a334a6580af627911d51037bad7065af7129239fd2ccbaf45750cba7f8c7a57b48ab28f4605a00ac9b5bbadb304a9f80e6af1519ad7d0c677d6acafb153bc3

data/.rubocop.yml

@@ -18,7 +18,7 @@ Metrics/AbcSize:
 
 # Formatting Rules
 Layout/LineLength:
-  Max: 160
+  Max: 180
   AllowHeredoc: true
   AllowURI: true
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cns (0.8.3)
+    cns (0.8.5)
       curb
       faraday
       google-cloud-bigquery
@@ -89,7 +89,8 @@ GEM
       multi_json (~> 1.11)
       os (>= 0.9, < 2.0)
       signet (>= 0.16, < 2.a)
-    httpclient (2.8.3)
+    httpclient (2.9.0)
+      mutex_m
     jaro_winkler (1.6.0)
     json (2.10.1)
     jwt (2.10.1)
@@ -106,7 +107,7 @@ GEM
     mutex_m (0.3.0)
     net-http (0.6.0)
       uri
-    nokogiri (1.18.2-x86_64-linux-gnu)
+    nokogiri (1.18.3-x86_64-linux-gnu)
       racc (~> 1.4)
     observer (0.1.2)
     os (1.1.4)

data/lib/cns/bigquery.rb

@@ -7,17 +7,26 @@ require('bigdecimal/util')
 module Cns
   BD = 'hernanirvaz.coins'
   FO = File.expand_path("~/#{File.basename($PROGRAM_NAME)}.log")
+  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],
+    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],
+    cdet: %w[txid time tp user btc eur dtc dias],
+    cdel: %w[txid time tp add moe qt fee],
+    cust: %w[txid ordertxid pair time type ordertype price cost fee vol margin misc ledgers dias],
+    cusl: %w[txid refid time type aclass asset amount fee]
+  }
 
   # classe para processar bigquery
   class Bigquery
     # @return [Google::Cloud::Bigquery] API bigquery
-    attr_reader :api
     # @return [Google::Cloud::Bigquery::QueryJob] job bigquery
-    attr_reader :job
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
-    attr_reader :ops
     # @return (see sql)
-    attr_reader :sqr
+    attr_reader :api, :job, :ops, :sqr
 
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
     # @option pop [Hash] :h ({}) configuracao ajuste reposicionamento temporal
@@ -28,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
@@ -57,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
@@ -85,55 +90,35 @@ module Cns
     #
     # @return [String] linhas & tabelas afetadas
     def processa_eth
-      str = 'ETH'
-      str += format(' %<n>i netht', n: dml(netht_ins)) if apies.novtx.count.positive?
-      str += format(' %<n>i nethi', n: dml(nethi_ins)) if apies.novix.count.positive?
-      str += format(' %<n>i nethp', n: dml(nethp_ins)) if apies.novpx.count.positive?
-      str += format(' %<n>i nethw', n: dml(nethw_ins)) if apies.novwx.count.positive?
-      str += format(' %<n>i nethk', n: dml(nethk_ins)) if apies.novkx.count.positive?
-      str
+      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
-      str = 'ETH'
-      str += format(' %<n>i netht', n: dml(netbt_ins)) if apiesc.novtx.count.positive?
-      str += format(' %<n>i nethi', n: dml(netbi_ins)) if apiesc.novix.count.positive?
-      str += format(' %<n>i nethp', n: dml(netbp_ins)) if apiesc.novpx.count.positive?
-      str += format(' %<n>i nethw', n: dml(netbw_ins)) if apiesc.novwx.count.positive?
-      str += format(' %<n>i nethk', n: dml(netbk_ins)) if apiesc.novkx.count.positive?
-      str
+      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
@@ -143,9 +128,11 @@ module Cns
     def job?(cmd)
       @job = api.query_job(cmd)
       job.wait_until_done!
-      fld = job.failed?
-      puts(job.error['message']) if fld
-      fld
+
+      return false unless job.failed?
+
+      puts("BigQuery Error: #{job.error['message']}")
+      true
     end
 
     # cria Structured Query Language (SQL) job bigquery
@@ -165,34 +152,28 @@ module Cns
       job?(cmd) ? 0 : job.num_dml_affected_rows
     end
 
-    # @return [Etherscan] API blockchain ETH
-    def apies
-      @apies ||= Etherscan.new(
+    def initialize_etherscan_client(prx)
+      Etherscan.new(
         {
-          wb: sql("select * from #{BD}.wetb order by ax"),
-          ni: sql("select * from #{BD}.netbi"),
-          nk: sql("select * from #{BD}.netbk"),
-          np: sql("select * from #{BD}.netbp"),
-          nt: sql("select * from #{BD}.netbt"),
-          nw: sql("select * from #{BD}.netbw")
+          wb: sql("SELECT * FROM #{BD}.wet#{prx[-1]} ORDER BY ax"),
+          ni: sql("SELECT * FROM #{BD}.#{prx}i"),
+          nk: sql("SELECT * FROM #{BD}.#{prx}k"),
+          np: sql("SELECT * FROM #{BD}.#{prx}p"),
+          nt: sql("SELECT * FROM #{BD}.#{prx}t"),
+          nw: sql("SELECT * FROM #{BD}.#{prx}w")
         },
         ops
       )
     end
 
+    # @return [Etherscan] API blockchain ETH
+    def apies
+      @apies ||= initialize_etherscan_client('netb')
+    end
+
     # @return [Etherscan] API blockchain ETH
     def apiesc
-      @apiesc ||= Etherscan.new(
-        {
-          wb: sql("select * from #{BD}.wetc order by ax"),
-          ni: sql("select * from #{BD}.netci"),
-          nk: sql("select * from #{BD}.netck"),
-          np: sql("select * from #{BD}.netcp"),
-          nt: sql("select * from #{BD}.netct"),
-          nw: sql("select * from #{BD}.netcw")
-        },
-        ops
-      )
+      @apiesc ||= initialize_etherscan_client('netc')
     end
 
     # @return [Greymass] API blockchain EOS
@@ -224,297 +205,240 @@ module Cns
       )
     end
 
-    # @return [String] comando insert SQL formatado netht (norml)
-    def bnetht_ins
-      "insert #{BD}.netht(blocknumber,timestamp,txhash,nonce,blockhash,transactionindex,axfrom,axto,iax," \
-        'value,gas,gasprice,gasused,iserror,txreceipt_status,input,contractaddress,dias) VALUES'
-    end
+    def tabelas_cus(src, str, ltb, prx = '')
+      ltb.each do |itm|
+        novx = src.send("nov#{prx}#{itm}")
+        next if novx.empty?
 
-    # @return [String] comando insert SQL formatado nethi (internas)
-    def bnethi_ins
-      "insert #{BD}.nethi(blocknumber,timestamp,txhash,axfrom,axto,iax," \
-        'value,contractaddress,input,type,gas,gasused,traceid,iserror,errcode) VALUES'
+        str << format(' %<n>i %<t>s', n: dml(insert_cus(prx, itm, novx)), t: prx + itm.to_s)
+      end
+      str.join
     end
 
-    # @return [String] comando insert SQL formatado nethp (block)
-    def bnethp_ins
-      "insert #{BD}.nethp(blocknumber,timestamp,blockreward,iax) VALUES"
-    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 nethw (withdrawals)
-    def bnethw_ins
-      "insert #{BD}.nethw(withdrawalindex,validatorindex,address,amount,blocknumber,timestamp) VALUES"
+        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 nethk (token)
-    def bnethk_ins
-      "insert #{BD}.nethk(blocknumber,timestamp,txhash,nonce,blockhash,transactionindex,axfrom,axto,iax," \
-        'value,tokenname,tokensymbol,tokendecimal,gas,gasprice,gasused,input,contractaddress,dias) VALUES'
+    # @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 netht (norml)
-    def netht_ins
-      "#{bnetht_ins}#{apies.novtx.map { |obj| netht_val(obj) }.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
 
-    # @return [String] comando insert SQL formatado nethi (internas)
-    def nethi_ins
-      "#{bnethi_ins}#{apies.novix.map { |obj| nethi_val(obj) }.join(',')}"
-    end
+    # SQL value formatting methods with improved safety
+    def quote(value)
+      return 'null' if value.nil? || value.empty?
 
-    # @return [String] comando insert SQL formatado nethp (block)
-    def nethp_ins
-      "#{bnethp_ins}#{apies.novpx.map { |obj| nethp_val(obj) }.join(',')}"
+      "'#{value}'"
     end
 
-    # @return [String] comando insert SQL formatado nethw (withdrawals)
-    def nethw_ins
-      "#{bnethw_ins}#{apies.novwx.map { |obj| nethw_val(obj) }.join(',')}"
-    end
+    def numeric(value)
+      return 'null' if value.nil?
 
-    # @return [String] comando insert SQL formatado nethk (token)
-    def nethk_ins
-      "#{bnethk_ins}#{apies.novkx.map { |obj| nethk_val(obj) }.join(',')}"
+      "CAST('#{value}' AS NUMERIC)"
     end
 
-    # @return [String] comando insert SQL formatado netht (norml)
-    def netbt_ins
-      "#{bnetht_ins}#{apiesc.novtx.map { |obj| netht_val(obj) }.join(',')}"
-    end
+    def integer(value)
+      return '0' if value.nil?
 
-    # @return [String] comando insert SQL formatado nethi (internas)
-    def netbi_ins
-      "#{bnethi_ins}#{apiesc.novix.map { |obj| nethi_val(obj) }.join(',')}"
+      Integer(value).to_s
+    rescue StandardError
+      'null'
     end
 
-    # @return [String] comando insert SQL formatado nethp (block)
-    def netbp_ins
-      "#{bnethp_ins}#{apiesc.novpx.map { |obj| nethp_val(obj) }.join(',')}"
+    def ptime(sec)
+      "PARSE_DATETIME('%s', '#{String(sec.round)}')"
     end
 
-    # @return [String] comando insert SQL formatado nethw (withdrawals)
-    def netbw_ins
-      "#{bnethw_ins}#{apiesc.novwx.map { |obj| nethw_val(obj) }.join(',')}"
+    def ptimestamp(value)
+      "DATETIME(TIMESTAMP('#{value}'))"
     end
 
-    # @return [String] comando insert SQL formatado nethk (token)
-    def netbk_ins
-      "#{bnethk_ins}#{apiesc.novkx.map { |obj| nethk_val(obj) }.join(',')}"
-    end
-
-    # @return [String] comando insert SQL formatado eos
-    def eost_ins
-      "insert #{BD}.neost(gseq,aseq,bnum,time,contract,action,acfrom,acto,iax,amount,moeda,memo,dias" \
-        ") VALUES#{apigm.novax.map { |obj| eost_val(obj) }.join(',')}"
-    end
-
-    # @return [String] comando insert SQL formatado det (trades)
-    def det_ins
-      "insert #{BD}.cdet(txid,time,tp,user,btc,eur,dtc,dias) VALUES#{apide.trades.map { |obj| det_val(obj) }.join(',')}"
-    end
-
-    # @return [String] comando insert SQL formatado del (ledger)
-    def del_ins
-      "insert #{BD}.cdel(txid,time,tp,add,moe,qt,fee) VALUES#{apide.ledger.map { |obj| del_val(obj) }.join(',')}"
-    end
-
-    # @return [String] comando insert SQL formatado ust (trades)
-    def ust_ins
-      "insert #{BD}.cust(txid,ordertxid,pair,time,type,ordertype,price,cost,fee,vol,margin,misc,ledgers,dias) " \
-        "VALUES#{apius.trades.map { |key, val| ust_val(key, val) }.join(',')}"
-    end
-
-    # @return [String] comando insert SQL formatado usl (ledger)
-    def usl_ins
-      "insert #{BD}.cusl(txid,refid,time,type,aclass,asset,amount,fee) " \
-        "VALUES#{apius.ledger.map { |key, val| usl_val(key, val) }.join(',')}"
-    end
-
-    # @example (see Apibc#norml_es)
     # @param [Hash] htx transacao norml etherscan
     # @return [String] valores formatados netht (norml parte1)
     def netht_val(htx)
-      txr = htx[:txreceipt_status]
-      cta = htx[:contractAddress]
-      inp = htx[:input]
-      "(#{Integer(htx[:blockNumber])}," \
-        "#{Integer(htx[:timeStamp])}," \
-        "'#{htx[:hash]}'," \
-        "#{Integer(htx[:nonce])}," \
-        "'#{htx[:blockHash]}'," \
-        "#{Integer(htx[:transactionIndex])}," \
-        "'#{htx[:from]}'," \
-        "'#{htx[:to]}'," \
-        "'#{htx[:iax]}'," \
-        "cast('#{htx[:value]}' as numeric)," \
-        "cast('#{htx[:gas]}' as numeric)," \
-        "cast('#{htx[:gasPrice]}' as numeric)," \
-        "cast('#{htx[:gasUsed]}' as numeric)," \
-        "#{Integer(htx[:isError])}," \
-        "#{txr.empty? ? 'null' : txr}," \
-        "#{inp.empty? ? 'null' : "'#{inp}'"}," \
-        "#{cta.empty? ? 'null' : "'#{cta}'"}," \
-        "#{Integer(ops[:h][htx[:blockNumber]] || 0)})"
-    end
-
-    # @example (see Apibc#inter_es)
+      "(#{[
+        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]),
+        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])}," \
-        "'#{htx[:hash]}'," \
-        "'#{htx[:from]}'," \
-        "'#{htx[:to]}'," \
-        "'#{htx[:iax]}'," \
-        "cast('#{htx[:value]}' as numeric)," \
-        "#{cta.empty? ? 'null' : "'#{cta}'"}," \
-        "#{inp.empty? ? 'null' : "'#{inp}'"}," \
-        "'#{htx[:type]}'," \
-        "cast('#{htx[:gas]}' as numeric)," \
-        "cast('#{htx[:gasUsed]}' as numeric)," \
-        "#{tid.empty? ? 'null' : "'#{tid}'"}," \
-        "#{Integer(htx[:isError])}," \
-        "#{txr.empty? ? 'null' : txr})"
-    end
-
-    # @example (see Apibc#block_es)
+      "(#{[
+        integer(htx[:blockNumber]),
+        integer(htx[:timeStamp]),
+        quote(htx[:hash]),
+        quote(htx[:from]),
+        quote(htx[:to]),
+        quote(htx[:iax]),
+        numeric(htx[:value]),
+        quote(htx[:contractAddress]),
+        quote(htx[:input]),
+        quote(htx[:type]),
+        numeric(htx[:gas]),
+        numeric(htx[:gasUsed]),
+        quote(htx[:traceId]),
+        integer(htx[:isError]),
+        integer(htx[:errCode])
+      ].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])}," \
-        "cast('#{htx[:blockReward]}' as numeric)," \
-        "'#{htx[:iax]}')"
+      "(#{[integer(htx[:blockNumber]), integer(htx[:timeStamp]), numeric(htx[:blockReward]), quote(htx[:iax])].join(',')})"
     end
 
-    # @example (see Apibc#block_es)
     # @param [Hash] htx transacao withdrawals etherscan
     # @return [String] valores formatados nethi (withdrawals parte1)
     def nethw_val(htx)
-      "(#{Integer(htx[:withdrawalIndex])}," \
-        "#{Integer(htx[:validatorIndex])}," \
-        "'#{htx[:address]}'," \
-        "cast('#{htx[:amount]}' as numeric)," \
-        "#{Integer(htx[:blockNumber])}," \
-        "#{Integer(htx[:timestamp])})"
+      "(#{[
+        integer(htx[:withdrawalIndex]),
+        integer(htx[:validatorIndex]),
+        quote(htx[:address]),
+        numeric(htx[:amount]),
+        integer(htx[:blockNumber]),
+        integer(htx[:timestamp])
+      ].join(',')})"
     end
 
-    # @example (see Apibc#token_es)
     # @param [Hash] hkx token event etherscan
     # @return [String] valores formatados nethk (token parte1)
-    def nethk_val(hkx)
-      cta = hkx[:contractAddress]
-      inp = hkx[:input]
-      "(#{Integer(hkx[:blockNumber])}," \
-        "#{Integer(hkx[:timeStamp])}," \
-        "'#{hkx[:hash]}'," \
-        "#{Integer(hkx[:nonce])}," \
-        "'#{hkx[:blockHash]}'," \
-        "#{Integer(hkx[:transactionIndex])}," \
-        "'#{hkx[:from]}'," \
-        "'#{hkx[:to]}'," \
-        "'#{hkx[:iax]}'," \
-        "cast('#{hkx[:value]}' as numeric)," \
-        "'#{hkx[:tokenName]}'," \
-        "'#{hkx[:tokenSymbol]}'," \
-        "#{Integer(hkx[:tokenDecimal])}," \
-        "cast('#{hkx[:gas]}' as numeric)," \
-        "cast('#{hkx[:gasPrice]}' as numeric)," \
-        "cast('#{hkx[:gasUsed]}' as numeric)," \
-        "#{inp.empty? ? 'null' : "'#{inp}'"}," \
-        "#{cta.empty? ? 'null' : "'#{cta}'"}," \
-        "#{Integer(ops[:h][hkx[:blockNumber]] || 0)})"
+    def nethk_val(htx)
+      "(#{[
+        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]),
+        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
+    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
+    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
+    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
+    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
+    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
@@ -108,7 +108,7 @@ module Cns
         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_px(acc, api.withw_es(acc)),
+        wx: filtrar_wx(acc, api.withw_es(acc)),
         kx: filtrar_tx(acc, api.token_es(acc))
       }
     end
@@ -153,30 +153,38 @@ module Cns
       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
-      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
@@ -339,9 +347,9 @@ module Cns
     # @return [String] texto formatado transacao withdrawals etherscan
     def formata_transacao_withw(htx)
       format(
-        '%<vi>9i %<bn>9i %<dt>10.10s %<vl>10.6f',
+        '%<vi>9i %<bn>10i %<dt>10.10s %<vl>10.6f',
         vi: htx[:validatorIndex],
-        bn: htx[:blockNumber],
+        bn: htx[:withdrawalIndex],
         dt: Time.at(Integer(htx[:timestamp])),
         vl: (htx[:amount].to_d / (10**9)).round(10)
       )
@@ -349,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)) }
@@ -357,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)) }
@@ -365,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)) }
@@ -373,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)) }
@@ -381,16 +389,16 @@ 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     block data            valor")
+      puts("\nvalidator withdrawal data            valor")
       sorwx.each { |obj| puts(formata_transacao_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("\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.3'
+  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.3
+  version: 0.8.5
 platform: ruby
 authors:
 - Hernâni Rodrigues Vaz
 bindir: exe
 cert_chain: []
-date: 2025-02-18 00:00:00.000000000 Z
+date: 2025-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler