cns 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5864db949cd54475943852878f488bcb0e62e342dafcc2f0be4d2e418a6e4a8
-  data.tar.gz: 2f33d2a740c1787f92246625ff11d44f1cc06d4ac8cbe2a54e610aca6a2309ed
+  metadata.gz: d70ccf3bf3c61dccaf39f5fe5e34b3f629efd8182fbd036f1d1193e2e0d842e4
+  data.tar.gz: 969e4c7d275aa2b14a6e9b1324e007b84d9f61522b099fdbb6c6d8a9bc129708
 SHA512:
-  metadata.gz: 989d84cf9d660f93068f135d35f8963633431787446a2a666562230560965711430820cc57ebc8ec7e6dd540005c920d1791431ac20e9acd0a71e84565a24dc4
-  data.tar.gz: b8818edca07d3e902cd1a126e9474efe1ff15c3088ca6939f27be8f5422fd91f88a024e2b407a75dd156426cbb4f30b9971548c23ccad0f648348607bd6da435
+  metadata.gz: c406b44bacdf24f32dc6babc0c08d51cf5fe4f88724466e1af7d8770b08ae23da74c8811cc9f0bea0bdb11cf13ffb9fe3d8080de2626f8f3a0d6f22739e1e82f
+  data.tar.gz: 47e0b4e735ac2c3b11a11018ac5a9830ec1cf24c253b4cb7ab0b353bc2c262f55c572938668ccd00618bf367b5d1019381a30037789fecf13dd2a3b5e5a698b9

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cns (0.9.3)
+    cns (0.9.4)
       curb
       faraday
       google-cloud-bigquery
@@ -79,7 +79,7 @@ GEM
       google-cloud-errors (~> 1.0)
     google-cloud-env (2.2.1)
       faraday (>= 1.0, < 3.a)
-    google-cloud-errors (1.4.0)
+    google-cloud-errors (1.5.0)
     google-logging-utils (0.1.0)
     googleauth (1.13.1)
       faraday (>= 1.0, < 3.a)
@@ -137,7 +137,7 @@ GEM
     reverse_markdown (3.0.0)
       nokogiri
     rexml (3.4.1)
-    rubocop (1.73.1)
+    rubocop (1.73.2)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)

data/lib/cns/bigquery.rb

@@ -9,16 +9,16 @@ module Cns
   FO = File.expand_path("~/#{File.basename($PROGRAM_NAME)}.log")
   EM = %i[EOS XETH ZEUR btc eth]
   TB = {
-    netht: %w[blocknumber timestamp txhash nonce blockhash transactionindex axfrom axto iax value gas gasprice gasused iserror txreceipt_status input contractaddress dias],
-    hetht: %i[blockNumber timeStamp hash nonce blockHash transactionIndex from to iax value gas gasPrice gasUsed isError txreceipt_status input contractAddress],
-    nethi: %w[blocknumber timestamp txhash axfrom axto iax value contractaddress input type gas gasused traceid iserror errcode dias],
-    hethi: %i[blockNumber timeStamp hash from to iax value contractAddress input type gas gasUsed traceId isError errCode],
+    netht: %w[txhash blocknumber timestamp nonce blockhash transactionindex axfrom axto iax value gas gasprice gasused iserror txreceipt_status input contractaddress dias],
+    hetht: %i[hash blockNumber timeStamp nonce blockHash transactionIndex from to iax value gas gasPrice gasUsed isError txreceipt_status input contractAddress],
+    nethi: %w[txhash blocknumber timestamp axfrom axto iax value contractaddress input type gas gasused traceid iserror errcode dias],
+    hethi: %i[hash blockNumber timeStamp from to iax value contractAddress input type gas gasUsed traceId isError errCode],
     nethp: %w[blocknumber timestamp blockreward iax dias],
     hethp: %i[blockNumber timeStamp blockReward iax],
     nethw: %w[withdrawalindex validatorindex address amount blocknumber timestamp dias],
     hethw: %i[withdrawalIndex validatorIndex address amount blockNumber timeStamp],
-    nethk: %w[blocknumber timestamp txhash nonce blockhash transactionindex axfrom axto iax value tokenname tokensymbol tokendecimal gas gasprice gasused input contractaddress dias],
-    hethk: %i[blockNumber timeStamp hash nonce blockHash transactionIndex from to iax value tokenName tokenSymbol tokenDecimal gas gasPrice gasUsed input contractAddress],
+    nethk: %w[txhash blocknumber timestamp nonce blockhash transactionindex axfrom axto iax value tokenname tokensymbol tokendecimal gas gasprice gasused input contractaddress dias],
+    hethk: %i[hash blockNumber timeStamp nonce blockHash transactionIndex from to iax value tokenName tokenSymbol tokenDecimal gas gasPrice gasUsed input contractAddress],
     neost: %w[gseq aseq bnum time contract action acfrom acto iax amount moeda memo dias],
     heost: %i[global_action_seq account_action_seq block_num block_time account name from to iax quantity moe memo],
     cdet: %w[txid time tp user btc eur dtc dias],
@@ -30,6 +30,21 @@ module Cns
     cusl: %w[txid refid time type aclass asset amount fee],
     husl: %i[txid refid time type aclass asset amount fee]
   }
+  # para testes bigquery
+  TL = {
+    ins: 'INSERT',
+    exo: false,
+    est: '', # ' limit 226',
+    esi: '', # ' limit 22',
+    esp: '', # ' limit 72',
+    esw: '', # ' limit 2299',
+    esk: '', # ' limit 20',
+    gmt: '', # ' limit 1091',
+    ust: '', # ' limit 182',
+    usl: '', # ' limit 448',
+    det: '', # ' limit 27',
+    del: '' # ' limit 16'
+  }
 
   # classe para processar bigquery
   class Bigquery
@@ -154,11 +169,11 @@ module Cns
       Etherscan.new(
         {
           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")
+          nt: sql("SELECT * FROM #{BD}.#{prx}t#{TL[:est]}"),
+          ni: sql("SELECT * FROM #{BD}.#{prx}i#{TL[:esi]}"),
+          np: sql("SELECT * FROM #{BD}.#{prx}p#{TL[:esp]}"),
+          nw: sql("SELECT * FROM #{BD}.#{prx}w#{TL[:esw]}"),
+          nk: sql("SELECT * FROM #{BD}.#{prx}k#{TL[:esk]}")
         },
         ops
       )
@@ -176,32 +191,39 @@ module Cns
 
     # @return [Greymass] API blockchain EOS
     def apigm
-      @apigm ||= Greymass.new({wb: sql("select * from #{BD}.weos ORDER BY ax"), nt: sql("select * from #{BD}.neosx")}, ops)
+      @apigm ||= Greymass.new({wb: sql("select * from #{BD}.weos ORDER BY ax"), nt: sql("select * from #{BD}.neosx#{TL[:gmt]}")}, ops)
     end
 
     # @return [Kraken] API exchange kraken
     def apius
-      @apius ||= Kraken.new({sl: sql("select * from #{BD}.cuss").first, nt: sql("select * from #{BD}.cust"), nl: sql("select * from #{BD}.cusl")}, ops)
+      @apius ||= Kraken.new({sl: sql("select * from #{BD}.cuss").first, nt: sql("select * from #{BD}.cust#{TL[:ust]}"), nl: sql("select * from #{BD}.cusl#{TL[:usl]}")}, ops)
     end
 
     # @return [Bitcoinde] API exchange bitcoinde
     def apide
-      @apide ||= Bitcoinde.new({sl: sql("select * from #{BD}.cdes").first, nt: sql("select * from #{BD}.cdet"), nl: sql("select * from #{BD}.cdel")}, ops)
+      @apide ||= Bitcoinde.new({sl: sql("select * from #{BD}.cdes").first, nt: sql("select * from #{BD}.cdet#{TL[:det]}"), nl: sql("select * from #{BD}.cdel#{TL[:del]}")}, ops)
     end
 
     # @return [String] comando insert SQL formatado
     def ins_sql(tbl, lin)
-      "INSERT #{BD}.#{tbl} (#{TB[tbl].join(',')}) VALUES #{lin.map { |i| send("#{tbl}_val", i) }.join(',')}"
+      # para testes bigquery
+      if TL[:exo]
+        exl = lin.map { |i| send("#{tbl}_val", i)[1..-2] }
+        exi = exl.map { |f| f.split(',').first }.join(',')
+        exo = "SELECT #{TB[tbl].join(',')} FROM #{BD}.#{tbl} WHERE #{TB[tbl].first} IN (#{exi}) union all select "
+        puts(exo + exl.join(' union all select ') + ' order by 1')
+      end
+      "#{TL[:ins]} #{BD}.#{tbl} (#{TB[tbl].join(',')}) VALUES #{lin.map { |i| send("#{tbl}_val", i) }.join(',')}"
     end
 
     # @return [String] relatorio execucao dml
     def dml_out(src, str, ltb)
       str.concat(
-        ltb.filter_map do |itm|
-          novx = src.send("nov#{itm}")
+        ltb.filter_map do |i|
+          novx = src.send("nov#{i}")
           next if novx.empty?
 
-          format(' %<n>i %<t>s', n: dml(ins_sql(itm, %i[cust cusl].include?(itm) ? novx.values : novx)), t: "#{itm}")
+          format(' %<n>i %<t>s', n: dml(ins_sql(i, %i[cust cusl].include?(i) ? novx.values : novx)), t: "#{i}")
         end
       )
       str.join
@@ -290,7 +312,7 @@ module Cns
     # @param [Hash] htx ledger greymass
     # @return [String] valores formatados neost
     def neost_val(htx)
-      fvals(htx, TB[:heost], :itx)
+      fvals(htx, TB[:heost], :global_action_seq)
     end
 
     # @param [Hash] htx trades bitcoinde
@@ -308,7 +330,7 @@ module Cns
     # @param [Hash] htx trades kraken
     # @return [String] valores formatados cust
     def cust_val(htx)
-      fvals(htx.merge(ledgers: apius.exd[:kl].select { |_, o| o[:refid] == htx[:txid] }.keys.join(',')), TB[:hust], :txid)
+      fvals(htx.merge(ledgers: apius.uskl.select { |_, o| o[:refid] == htx[:txid] }.keys.join(',')), TB[:hust], :txid)
     end
 
     # @param [Hash] htx ledger kraken

data/lib/cns/bitcoinde.rb

@@ -23,15 +23,10 @@ module Cns
       @ops = pop.transform_keys(&:to_sym)
     end
 
-    # @return [Hash] dados exchange bitcoinde - saldos & trades & deposits & withdrawals
-    def exd
-      @exd ||= {sl: pdea(api.account_de), tt: pdet(api.trades_de), tl: pdel(api.deposits_de + api.withdrawals_de)}
-    end
-
     # @return [String] texto saldos & transacoes & ajuste dias
     def mresumo
       puts("\nBITCOINDE\ntipo              bitcoinde              bigquery")
-      exd[:sl].sort.each { |k, v| puts(fos(k, v)) }
+      ded[:sl].sort.each { |k, v| puts(fos(k, v)) }
       mtotais
 
       mtrades
@@ -45,9 +40,9 @@ module Cns
 
     # mosta contadores transacoes
     def mtotais
-      vtt = exd[:tt].count
+      vtt = ded[:tt].count
       vnt = bqd[:nt].count
-      vtl = exd[:tl].count
+      vtl = ded[:tl].count
       vnl = bqd[:nl].count
 
       puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: vtt, b: vnt, o: vtt == vnt ? 'OK' : 'NOK')}")
@@ -114,6 +109,7 @@ module Cns
       )
     end
 
+    # @return [Boolean] mostra todas/novas transacoes
     def show_all?
       ops[:t] || false
     end
@@ -157,34 +153,39 @@ module Cns
       hlx.map { |t| pdes(:time, t).merge(qtd: (t[:tp] == 'withdrawal' ? -1 : 1) * t[:qt].to_d, nxid: t[:txid], fee: t[:fee].to_d, moe: t[:moe].upcase) }
     end
 
+    # @return [Hash] dados exchange bitcoinde - saldos & trades & deposits & withdrawals
+    def ded
+      @ded ||= {sl: pdea(api.account_de), tt: pdet(api.trades_de), tl: pdel(api.deposits_de + api.withdrawals_de)}
+    end
+
     # @return [Array<String>] indices trades bigquery
     def bqkyt
-      @bqkyt ||= show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid] } || [])
+      @bqkyt ||= show_all? ? [] : bqd[:nt].map { |t| t[:txid] }
     end
 
     # @return [Array<Integer>] indices ledger bigquery
     def bqkyl
-      @bqkyl ||= show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid] } || [])
+      @bqkyl ||= show_all? ? [] : bqd[:nl].map { |l| l[:txid] }
     end
 
     # @return [Array<String>] lista txid trades novos
     def kyt
-      @kyt ||= exd[:tt].map { |t| t[:trade_id] } - bqkyt
+      @kyt ||= ded[:tt].map { |t| t[:trade_id] } - bqkyt
     end
 
     # @return [Array<Integer>] lista txid ledger novos
     def kyl
-      @kyl ||= exd[:tl].map { |t| t[:txid] } - bqkyl
+      @kyl ||= ded[:tl].map { |t| t[:txid] } - bqkyl
     end
 
     # @return [Array<Hash>] lista trades bitcoinde novos
     def novcdet
-      @novcdet ||= exd[:tt].select { |obj| kyt.include?(obj[:trade_id]) }
+      @novcdet ||= ded[:tt].select { |obj| kyt.include?(obj[:trade_id]) }
     end
 
     # @return [Array<Hash>] lista ledger (deposits + withdrawals) bitcoinde novos
     def novcdel
-      @novcdel ||= exd[:tl].select { |obj| kyl.include?(obj[:txid]) }
+      @novcdel ||= ded[:tl].select { |obj| kyl.include?(obj[:txid]) }
     end
   end
 end

data/lib/cns/etherscan.rb

@@ -84,22 +84,22 @@ module Cns
 
     # mosta transacoes novas
     def mtransacoes_novas
-      TT.each do |_, cfg|
-        ntx = send(cfg[:new])
+      TT.each do |_, c|
+        ntx = send(c[:new])
         next unless ops[:v] && ntx.any?
 
-        puts(cfg[:header])
-        ntx.sort_by { |s| -s[cfg[:sork]] }.each { |t| puts(send(cfg[:format], t)) }
+        puts(c[:header])
+        ntx.sort_by { |s| -s[c[:sork]] }.each { |t| puts(send(c[:format], t)) }
       end
     end
 
     # mostra configuration text for adjusting days
     def mconfiguracao_ajuste_dias
-      TT.each do |typ, cfg|
-        ntx = send(cfg[:new])
+      TT.each do |p, c|
+        ntx = send(c[:new])
         next unless ntx.any?
 
-        puts("\najuste dias transacoes #{typ}\n-h=#{ntx.sort_by { |s| -s[cfg[:sork]] }.map { |t| "#{t[cfg[:adjk]]}:0" }.join(' ')}")
+        puts("\najuste dias transacoes #{p}\n-h=#{ntx.sort_by { |s| -s[c[:sork]] }.map { |t| "#{t[c[:adjk]]}:0" }.join(' ')}")
       end
     end
 
@@ -226,44 +226,7 @@ module Cns
       format('%<bn>10i %<vi>9i %<dt>10.10s %<vl>10.6f', bn: hwx[:withdrawalIndex], vi: hwx[:validatorIndex], dt: hwx[:timeStamp].strftime('%F'), vl: hwx[:amount] / (10**9))
     end
 
-    # @param [Hash] abc account etherscan
-    # @return [Hash] dados etherscan - address, saldo & transacoes
-    def base_bc(abc)
-      acc = abc[:account].downcase
-      {
-        ax: acc,
-        sl: abc[:balance].to_d / (10**18),
-        tx: ftik(acc, api.norml_es(acc)),
-        ix: ftik(acc, api.inter_es(acc)),
-        px: fppp(acc, api.block_es(acc)),
-        wx: fwww(acc, api.withw_es(acc)),
-        kx: ftik(acc, api.token_es(acc))
-      }
-    end
-
-    # @param [Hash] wbq wallet bigquery
-    # @param [Hash] hbc dados etherscan - address, saldo & transacoes
-    # @return [Hash] dados juntos bigquery & etherscan
-    def bq_bc(wbq, hbc)
-      xbq = wbq[:ax]
-      {
-        id: wbq[:id],
-        ax: xbq,
-        bs: wbq[:sl],
-        bt: bqd[:nt].select { |ont| ont[:iax].casecmp?(xbq) },
-        bi: bqd[:ni].select { |oni| oni[:iax].casecmp?(xbq) },
-        bp: bqd[:np].select { |onp| onp[:iax].casecmp?(xbq) },
-        bw: bqd[:nw].select { |onw| onw[:iax].casecmp?(xbq) },
-        bk: bqd[:nk].select { |onk| onk[:iax].casecmp?(xbq) },
-        es: hbc[:sl],
-        et: hbc[:tx],
-        ei: hbc[:ix],
-        ep: hbc[:px],
-        ew: hbc[:wx],
-        ek: hbc[:kx]
-      }
-    end
-
+    # @return [Boolean] mostra todas/novas transacoes
     def show_all?
       ops[:t] || false
     end
@@ -296,94 +259,132 @@ module Cns
       ary.map { |o| o.merge(itx: Integer(o[:withdrawalIndex]), iax: add, amount: o[:amount].to_d, timeStamp: Time.at(Integer(o[:timestamp]))) }
     end
 
+    # @param [Hash] aes account etherscan
+    # @return [Hash] dados etherscan - address, saldo & transacoes
+    def bses(aes)
+      acc = aes[:account].downcase
+      {
+        ax: acc,
+        sl: aes[:balance].to_d / (10**18),
+        tx: ftik(acc, api.norml_es(acc)),
+        ix: ftik(acc, api.inter_es(acc)),
+        px: fppp(acc, api.block_es(acc)),
+        wx: fwww(acc, api.withw_es(acc)),
+        kx: ftik(acc, api.token_es(acc))
+      }
+    end
+
+    # @param [Hash] wbq wallet bigquery
+    # @param [Hash] hes dados etherscan - address, saldo & transacoes
+    # @return [Hash] dados juntos bigquery & etherscan
+    def bqes(wbq, hes)
+      xbq = wbq[:ax]
+      {
+        id: wbq[:id],
+        ax: xbq,
+        bs: wbq[:sl],
+        bt: bqd[:nt].select { |t| t[:iax].casecmp?(xbq) },
+        bi: bqd[:ni].select { |i| i[:iax].casecmp?(xbq) },
+        bp: bqd[:np].select { |p| p[:iax].casecmp?(xbq) },
+        bw: bqd[:nw].select { |w| w[:iax].casecmp?(xbq) },
+        bk: bqd[:nk].select { |k| k[:iax].casecmp?(xbq) },
+        es: hes[:sl],
+        et: hes[:tx],
+        ei: hes[:ix],
+        ep: hes[:px],
+        ew: hes[:wx],
+        ek: hes[:kx]
+      }
+    end
+
     # @return [Array<String>] lista enderecos
     def lax
       @lax ||= bqd[:wb].map { |o| o[:ax] }
     end
 
     # @return [Array<Hash>] todos os dados etherscan - saldos & transacoes
-    def bcd
-      @bcd ||= api.account_es(lax).map { |o| base_bc(o) }
+    def esd
+      @esd ||= api.account_es(lax).map { |o| bses(o) }
     end
 
     # @return [Array<Hash>] todos os dados juntos bigquery & etherscan
     def dados
-      @dados ||= bqd[:wb].map { |b| bq_bc(b, bcd.find { |e| b[:ax] == e[:ax] }) }
+      @dados ||= bqd[:wb].map { |b| bqes(b, esd.find { |e| b[:ax] == e[:ax] }) }
     end
 
     # @return [Array<Integer>] indices transacoes bigquery
     def bqidt
-      @bqidt ||= show_all? ? [] : (bqd[:nt]&.map { |i| i[:itx] } || [])
+      @bqidt ||= show_all? ? [] : bqd[:nt].map { |i| i[:itx] }
     end
 
     # @return [Array<Integer>] indices transacoes bigquery
     def bqidi
-      @bqidi ||= show_all? ? [] : (bqd[:ni]&.map { |i| i[:itx] } || [])
+      @bqidi ||= show_all? ? [] : bqd[:ni].map { |i| i[:itx] }
     end
 
     # @return [Array<Integer>] indices transacoes bigquery
     def bqidp
-      @bqidp ||= show_all? ? [] : (bqd[:np]&.map { |i| i[:itx] } || [])
+      @bqidp ||= show_all? ? [] : bqd[:np].map { |i| i[:itx] }
     end
 
     # @return [Array<Integer>] indices transacoes bigquery
     def bqidw
-      @bqidw ||= show_all? ? [] : (bqd[:nw]&.map { |i| i[:itx] } || [])
+      @bqidw ||= show_all? ? [] : bqd[:nw].map { |i| i[:itx] }
     end
 
     # @return [Array<Integer>] indices transacoes bigquery
     def bqidk
-      @bqidk ||= show_all? ? [] : (bqd[:nk]&.map { |i| i[:itx] } || [])
+      @bqidk ||= show_all? ? [] : bqd[:nk].map { |i| i[:itx] }
     end
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
     def idt
-      @idt ||= bcd.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
+      @idt ||= esd.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
     end
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
     def idi
-      @idi ||= bcd.map { |o| o[:ix].map { |i| i[:itx] } }.flatten - bqidi
+      @idi ||= esd.map { |o| o[:ix].map { |i| i[:itx] } }.flatten - bqidi
     end
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
     def idp
-      @idp ||= bcd.map { |o| o[:px].map { |i| i[:itx] } }.flatten - bqidp
+      @idp ||= esd.map { |o| o[:px].map { |i| i[:itx] } }.flatten - bqidp
     end
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
     def idw
-      @idw ||= bcd.map { |o| o[:wx].map { |i| i[:itx] } }.flatten - bqidw
+      @idw ||= esd.map { |o| o[:wx].map { |i| i[:itx] } }.flatten - bqidw
     end
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
     def idk
-      @idk ||= bcd.map { |o| o[:kx].map { |i| i[:itx] } }.flatten - bqidk
+      @idk ||= esd.map { |o| o[:kx].map { |i| i[:itx] } }.flatten - bqidk
     end
 
     # @return [Array<Hash>] lista transacoes normais novas
     def novnetht
-      @novnetht ||= bcd.map { |o| o[:tx].select { |t| idt.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      @novnetht ||= esd.map { |o| o[:tx].select { |t| idt.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
     # @return [Array<Hash>] lista transacoes internas novas
     def novnethi
-      @novnethi ||= bcd.map { |o| o[:ix].select { |t| idi.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      @novnethi ||= esd.map { |o| o[:ix].select { |t| idi.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
     # @return [Array<Hash>] lista transacoes block novas
     def novnethp
-      @novnethp ||= bcd.map { |o| o[:px].select { |t| idp.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      @novnethp ||= esd.map { |o| o[:px].select { |t| idp.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
     # @return [Array<Hash>] lista transacoes withdrawals novas
     def novnethw
-      @novnethw ||= bcd.map { |o| o[:wx].select { |t| idw.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      @novnethw ||= esd.map { |o| o[:wx].select { |t| idw.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
     # @return [Array<Hash>] lista transacoes token novas
     def novnethk
-      @novnethk ||= bcd.map { |o| o[:kx].select { |t| idk.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      @novnethk ||= esd.map { |o| o[:kx].select { |t| idk.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
   end
 end

data/lib/cns/greymass.rb

@@ -95,28 +95,7 @@ module Cns
       )
     end
 
-    # @param [Hash] wbq wallet bigquery
-    # @return [Hash] dados greymass - address, saldo & transacoes
-    def base_bc(wbq)
-      xbq = wbq[:ax]
-      {ax: xbq, sl: peosa(xbq).reduce(:+), tx: peost(xbq, api.ledger_gm(xbq))}
-    end
-
-    # @param wbq (see base_bc)
-    # @param [Hash] hbc dados greymass - address, saldo & transacoes
-    # @return [Hash] dados juntos bigquery & greymass
-    def bq_bc(wbq, hbc)
-      xbq = wbq[:ax]
-      {
-        id: wbq[:id],
-        ax: xbq,
-        bs: wbq[:sl],
-        bt: bqd[:nt].select { |o| o[:iax] == xbq },
-        es: hbc[:sl],
-        et: hbc[:tx]
-      }
-    end
-
+    # @return [Boolean] mostra todas/novas transacoes
     def show_all?
       ops[:t] || false
     end
@@ -133,11 +112,11 @@ module Cns
     # @param [Array<Hash>] ary lista transacoes
     # @return [Array<Hash>] lista transacoes filtrada
     def peost(add, ary)
-      ary.map do |omp|
-        act = omp[:action_trace][:act]
+      ary.map do |t|
+        act = t[:action_trace][:act]
         adt = act[:data]
         qtd = adt[:quantity].to_s
-        omp.merge(
+        t.merge(
           name: act[:name],
           from: adt[:from],
           quantity: qtd.to_d,
@@ -145,36 +124,58 @@ module Cns
           to: adt[:to],
           memo: String(adt[:memo]).gsub(/\p{C}/, ''), # remove Non-Printable Characters
           moe: qtd[/[[:upper:]]+/],
-          itx: omp[:global_action_seq],
+          itx: t[:global_action_seq],
           iax: add,
-          block_time: Time.parse(omp[:block_time])
+          block_time: Time.parse(t[:block_time])
         )
       end
     end
 
+    # @param [Hash] wbq wallet bigquery
+    # @return [Hash] dados greymass - address, saldo & transacoes
+    def bsgm(wbq)
+      xbq = wbq[:ax]
+      {ax: xbq, sl: peosa(xbq).reduce(:+), tx: peost(xbq, api.ledger_gm(xbq))}
+    end
+
+    # @param wbq (see bsgm)
+    # @param [Hash] hgm dados greymass - address, saldo & transacoes
+    # @return [Hash] dados juntos bigquery & greymass
+    def bqgm(wbq, hgm)
+      xbq = wbq[:ax]
+      {
+        id: wbq[:id],
+        ax: xbq,
+        bs: wbq[:sl],
+        bt: bqd[:nt].select { |o| o[:iax] == xbq },
+        es: hgm[:sl],
+        et: hgm[:tx]
+      }
+    end
+
     # @return [Array<Hash>] todos os dados greymass - saldos & transacoes
-    def bcd
-      @bcd ||= bqd[:wb].map { |o| base_bc(o) }
+    def gmd
+      @gmd ||= bqd[:wb].map { |o| bsgm(o) }
     end
 
     # @return [Array<Hash>] todos os dados juntos bigquery & greymass
     def dados
-      @dados ||= bqd[:wb].map { |b| bq_bc(b, bcd.find { |g| b[:ax] == g[:ax] }) }
+      @dados ||= bqd[:wb].map { |b| bqgm(b, gmd.find { |g| b[:ax] == g[:ax] }) }
     end
 
     # @return [Array<Integer>] indices transacoes bigquery
     def bqidt
-      @bqidt ||= show_all? ? [] : (bqd[:nt]&.map { |i| i[:itx] } || [])
+      @bqidt ||= show_all? ? [] : bqd[:nt].map { |i| i[:itx] }
     end
 
     # @return [Array<Integer>] indices transacoes novas (greymass - bigquery)
     def idt
-      @idt ||= bcd.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
+      @idt ||= gmd.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
     end
 
     # @return [Array<Hash>] lista transacoes novas
     def novneost
-      @novneost ||= bcd.map { |obc| obc[:tx].select { |o| idt.include?(o[:itx]) } }.flatten
+      @novneost ||= gmd.map { |t| t[:tx].select { |o| idt.include?(o[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
   end
 end

data/lib/cns/kraken.rb

@@ -23,15 +23,10 @@ module Cns
       @ops = pop.transform_keys(&:to_sym)
     end
 
-    # @return [Hash] dados exchange kraken - saldos & transacoes trades e ledger
-    def exd
-      @exd ||= {sl: pusa(api.account_us), kt: pust(api.trades_us), kl: pusl(api.ledger_us)}
-    end
-
     # @return [String] texto saldos & transacoes & ajuste dias
     def mresumo
       puts("\nKRAKEN\ntipo                 kraken              bigquery")
-      exd[:sl].sort.each { |key, val| puts(fos(key, val)) }
+      usd[:sl].sort.each { |key, val| puts(fos(key, val)) }
       mtotais
 
       mtrades
@@ -41,13 +36,18 @@ module Cns
       puts("\nstring ajuste dias dos trades\n-h=#{novcust.sort_by { |_, v| -v[:srx] }.map { |k, _v| "#{k}:0" }.join(' ')}")
     end
 
+    # @return [Hash] ledgers exchange kraken
+    def uskl
+      usd[:kl]
+    end
+
     private
 
     # mosta contadores transacoes
     def mtotais
-      vkt = exd[:kt].count
+      vkt = usd[:kt].count
       vnt = bqd[:nt].count
-      vkl = exd[:kl].count
+      vkl = usd[:kl].count
       vnl = bqd[:nl].count
 
       puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: vkt, b: vnt, o: vkt == vnt ? 'OK' : 'NOK')}")
@@ -115,6 +115,7 @@ module Cns
       )
     end
 
+    # @return [Boolean] mostra todas/novas transacoes
     def show_all?
       ops[:t] || false
     end
@@ -146,34 +147,39 @@ module Cns
       pusk(hlx).transform_values { |t| t.merge(asset: t[:asset].upcase, amount: t[:amount].to_d, fee: t[:fee].to_d) }
     end
 
+    # @return [Hash] dados exchange kraken - saldos & transacoes trades e ledger
+    def usd
+      @usd ||= {sl: pusa(api.account_us), kt: pust(api.trades_us), kl: pusl(api.ledger_us)}
+    end
+
     # @return [Array<Symbol>] indices trades bigquery
     def bqkyt
-      @bqkyt ||= show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid].to_sym } || [])
+      @bqkyt ||= show_all? ? [] : bqd[:nt].map { |t| t[:txid].to_sym }
     end
 
     # @return [Array<Symbol>] indices ledger bigquery
     def bqkyl
-      @bqkyl ||= show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid].to_sym } || [])
+      @bqkyl ||= show_all? ? [] : bqd[:nl].map { |l| l[:txid].to_sym }
     end
 
     # @return [Array<Symbol>] lista txid trades novos
     def kyt
-      @kyt ||= exd[:kt].keys - bqkyt
+      @kyt ||= usd[:kt].keys - bqkyt
     end
 
     # @return [Array<Symbol>] lista txid ledger novos
     def kyl
-      @kyl ||= exd[:kl].keys - bqkyl
+      @kyl ||= usd[:kl].keys - bqkyl
     end
 
     # @return [Hash] trades kraken novos
     def novcust
-      @novcust ||= exd[:kt].slice(*kyt)
+      @novcust ||= usd[:kt].slice(*kyt)
     end
 
     # @return [Hash] ledger kraken novos
     def novcusl
-      @novcusl ||= exd[:kl].slice(*kyl)
+      @novcusl ||= usd[:kl].slice(*kyl)
     end
   end
 end

data/lib/cns/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cns
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors:
 - Hernâni Rodrigues Vaz