cns 0.1.4 → 0.2.1

data/lib/cns/greymass1.rb

@@ -27,38 +27,39 @@ module Cns
 
     # @return [Array<Hash>] lista transacoes novas
     def novax
-      @novax ||= bcd.map { |e| e[:tx].select { |s| idt.include?(s[:itx]) } }.flatten
+      @novax ||= bcd.map { |obc| obc[:tx].select { |obj| idt.include?(obj[:itx]) } }.flatten
     end
 
     # @return [Array<String>] lista dos meus enderecos
     def lax
-      @lax ||= bqd[:wb].map { |h| h[:ax] }
+      @lax ||= bqd[:wb].map { |obj| obj[:ax] }
     end
 
     # @return [Array<Hash>] todos os dados greymass - saldos & transacoes
     def bcd
-      @bcd ||= bqd[:wb].map { |e| base_bc(e) }
+      @bcd ||= bqd[:wb].map { |obj| base_bc(obj) }
     end
 
     # @return [Array<Hash>] todos os dados juntos bigquery & greymass
     def dados
-      @dados ||= bqd[:wb].map { |b| bq_bc(b, bcd.select { |s| b[:ax] == s[:ax] }.first) }
+      @dados ||= bqd[:wb].map { |obq| bq_bc(obq, bcd.select { |obj| obq[:ax] == obj[:ax] }.first) }
     end
 
     # @return [Array<Integer>] lista indices transacoes novas
     def idt
-      @idt ||= (bcd.map { |e| e[:tx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : bqd[:nt].map { |t| t[:itx] }))
+      @idt ||= bcd.map { |obc| obc[:tx].map { |obj| obj[:itx] } }.flatten -
+               (ops[:t] ? [] : bqd[:nt].map { |obq| obq[:itx] })
     end
 
     # @example (see Apibc#account_gm)
     # @param [Hash] wbq wallet bigquery
     # @return [Hash] dados greymass - address, saldo & transacoes
     def base_bc(wbq)
-      a = wbq[:ax]
+      xbq = wbq[:ax]
       {
-        ax: a,
-        sl: greymass_sl(a).inject(:+),
-        tx: filtrar_tx(a, api.ledger_gm(a))
+        ax: xbq,
+        sl: greymass_sl(xbq).inject(:+),
+        tx: filtrar_tx(xbq, api.ledger_gm(xbq))
       }
     end
 
@@ -66,11 +67,12 @@ module Cns
     # @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: wbq[:ax],
+        ax: xbq,
         bs: wbq[:sl],
-        bt: bqd[:nt].select { |t| t[:iax] == wbq[:ax] },
+        bt: bqd[:nt].select { |obj| obj[:iax] == xbq },
         es: hbc[:sl],
         et: hbc[:tx]
       }
@@ -79,11 +81,12 @@ module Cns
     # @param (see filtrar_tx)
     # @return [Array<BigDecimal>] lista recursos - liquido, net, spu
     def greymass_sl(add)
-      v = api.account_gm(add)
+      hac = api.account_gm(add)
+      htr = hac[:total_resources]
       [
-        v[:core_liquid_balance].to_d,
-        v[:total_resources][:net_weight].to_d,
-        v[:total_resources][:cpu_weight].to_d
+        hac[:core_liquid_balance].to_d,
+        htr[:net_weight].to_d,
+        htr[:cpu_weight].to_d
       ]
     end
 
@@ -93,13 +96,15 @@ module Cns
     def filtrar_tx(add, ary)
       # elimina transferencia from: (lax) to: (add) - esta transferencia aparece em from: (add) to: (lax)
       # adiciona chave indice itx & adiciona identificador da carteira iax
-      ary.delete_if { |h| act_data(h)[:to] == add && lax.include?(act_data(h)[:from]) }
-         .map { |h| h.merge(itx: h[:global_action_seq], iax: add) }
+      (ary.delete_if do |odl|
+        adt = odl[:action_trace][:act][:data]
+        adt[:to] == add && lax.include?(adt[:from])
+      end).map { |omp| omp.merge(itx: omp[:global_action_seq], iax: add) }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes novas
     def sorax
-      novax.sort { |a, b| b[:itx] <=> a[:itx] }
+      novax.sort { |ant, prx| prx[:itx] <=> ant[:itx] }
     end
   end
 end

data/lib/cns/greymass2.rb

@@ -9,7 +9,7 @@ module Cns
       return unless dados.count.positive?
 
       puts("\naddress            greymass  ntx       bigquery  ntx")
-      dados.each { |e| puts(formata_carteira(e)) }
+      dados.each { |obj| puts(formata_carteira(obj)) }
       mostra_transacoes_novas
       mostra_configuracao_ajuste_dias
     end
@@ -40,47 +40,29 @@ module Cns
     def formata_ledger(hlx)
       format(
         '%<bn>12i %<fr>-12.12s %<to>-12.12s %<ac>-10.10s %<dt>10.10s %<vl>12.4f %<sy>-6.6s',
+        ac: (act = hlx[:action_trace][:act])[:name],
+        fr: (adt = act[:data])[:from],
+        vl: (aqt = adt[:quantity].to_s).to_d,
         bn: hlx[:itx],
-        fr: act_data(hlx)[:from],
-        to: act_data(hlx)[:to],
-        ac: act(hlx)[:name],
+        to: adt[:to],
         dt: Date.parse(hlx[:block_time]),
-        vl: act_data_quantity(hlx).to_d,
-        sy: act_data_quantity(hlx)[/[[:upper:]]+/]
+        sy: aqt[/[[:upper:]]+/]
       )
     end
 
-    # @param (see formata_ledger)
-    # @return [Hash] dados da acao
-    def act(hlx)
-      hlx[:action_trace][:act]
-    end
-
-    # @param (see formata_ledger)
-    # @return [Hash] dados da acao
-    def act_data(hlx)
-      act(hlx)[:data]
-    end
-
-    # @param (see formata_ledger)
-    # @return [String] dados da quantidade
-    def act_data_quantity(hlx)
-      act_data(hlx)[:quantity].to_s
-    end
-
     # @return [String] texto transacoes
     def mostra_transacoes_novas
       return unless ops[:v] && novax.count.positive?
 
       puts("\nsequence num from         to           accao      data              valor moeda")
-      sorax.each { |e| puts(formata_ledger(e)) }
+      sorax.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?
 
-      puts("\nstring ajuste dias\n-h=#{sorax.map { |e| "#{e[:itx]}:0" }.join(' ')}")
+      puts("\nstring ajuste dias\n-h=#{sorax.map { |obj| "#{obj[:itx]}:0" }.join(' ')}")
     end
   end
 end

data/lib/cns/kraken.rb

@@ -27,25 +27,25 @@ module Cns
 
     # @return [Hash] trades kraken novos
     def trades
-      @trades ||= exd[:kt].select { |k, _| kyt.include?(k) }
+      @trades ||= exd[:kt].select { |key, _| kyt.include?(key) }
     end
 
     # @return [Hash] ledger kraken novos
     def ledger
-      @ledger ||= exd[:kl].select { |k, _| kyl.include?(k) }
+      @ledger ||= exd[:kl].select { |key, _| kyl.include?(key) }
     end
 
     # @return [String] texto saldos & transacoes & ajuste dias
     def mostra_resumo
       puts("\nKRAKEN\ntipo                 kraken              bigquery")
-      exd[:sl].each { |k, v| puts(formata_saldos(k, v)) }
+      exd[:sl].each { |key, val| puts(formata_saldos(key, val)) }
       mostra_totais
 
       mostra_trades
       mostra_ledger
       return if trades.empty?
 
-      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |e| "#{e}:0" }.join(' ')}")
+      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |obj| "#{obj}:0" }.join(' ')}")
     end
 
     # @return [Hash] dados exchange kraken - saldos & transacoes trades e ledger
@@ -59,12 +59,12 @@ module Cns
 
     # @return [Array<String>] lista txid dos trades novos
     def kyt
-      @kyt ||= exd[:kt].keys - (ops[:t] ? [] : bqd[:nt].map { |e| e[:txid].to_sym })
+      @kyt ||= exd[:kt].keys - (ops[:t] ? [] : bqd[:nt].map { |obj| obj[:txid].to_sym })
     end
 
     # @return [Array<String>] lista txid dos ledger novos
     def kyl
-      @kyl ||= exd[:kl].keys - (ops[:t] ? [] : bqd[:nl].map { |e| e[:txid].to_sym })
+      @kyl ||= exd[:kl].keys - (ops[:t] ? [] : bqd[:nl].map { |obj| obj[:txid].to_sym })
     end
 
     # @example (see Apice#account_us)
@@ -72,13 +72,14 @@ module Cns
     # @param [BigDecimal] sal saldo kraken da moeda
     # @return [String] texto formatado saldos
     def formata_saldos(moe, sal)
-      t = bqd[:sl][moe.downcase.to_sym].to_d
+      vbq = bqd[:sl][moe.downcase.to_sym].to_d
+      vsl = sal.to_d
       format(
         '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
         mo: moe.upcase,
-        kr: sal.to_d,
-        bq: t,
-        ok: t == sal.to_d ? 'OK' : 'NOK'
+        kr: vsl,
+        bq: vbq,
+        ok: vbq == vsl ? 'OK' : 'NOK'
       )
     end
 
@@ -115,29 +116,29 @@ module Cns
 
     # @return [String] texto totais numero de transacoes
     def mostra_totais
-      a = exd[:kt].count
-      b = bqd[:nt].count
-      c = exd[:kl].count
-      d = bqd[:nl].count
+      vkt = exd[:kt].count
+      vnt = bqd[:nt].count
+      vkl = exd[:kl].count
+      vnl = bqd[:nl].count
 
-      puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: a, b: b, o: a == b ? 'OK' : 'NOK')}")
-      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: c, d: d, o: c == d ? 'OK' : 'NOK')}")
+      puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: vkt, b: vnt, o: vkt == vnt ? 'OK' : 'NOK')}")
+      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: vkl, d: vnl, o: vkl == vnl ? 'OK' : 'NOK')}")
     end
 
     # @return [String] texto transacoes trades
     def mostra_trades
       return unless ops[:v] && trades.count.positive?
 
-      puts("\ntrade  data       hora     tipo       par      ---preco ---------volume ---custo")
-      trades.sort { |a, b| b[1][:time] <=> a[1][:time] }.each { |k, v| puts(formata_trades(k, v)) }
+      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)) }
     end
 
     # @return [String] texto transacoes ledger
     def mostra_ledger
       return unless ops[:v] && ledger.count.positive?
 
-      puts("\nledger data       hora     tipo       moeda -------quantidade -------------custo")
-      ledger.sort { |a, b| b[1][:time] <=> a[1][:time] }.each { |k, v| puts(formata_ledger(k, v)) }
+      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)) }
     end
   end
 end

data/lib/cns/paymium.rb

@@ -27,7 +27,7 @@ module Cns
 
     # @return [Array<Hash>] lista ledger paymium novos
     def ledger
-      @ledger ||= exd[:kl].map { |h| h[:account_operations].select { |o| kyl.include?(o[:uuid]) } }.flatten
+      @ledger ||= exd[:kl].map { |map| map[:account_operations].select { |obj| kyl.include?(obj[:uuid]) } }.flatten
     end
 
     # @return [String] texto saldos & transacoes & ajuste dias
@@ -40,7 +40,7 @@ module Cns
       mostra_ledger
       return unless ledger.count.positive?
 
-      puts("\nstring ajuste dias da ledger\n-h=#{kyl.map { |e| "#{e}:0" }.join(' ')}")
+      puts("\nstring ajuste dias da ledger\n-h=#{kyl.map { |obj| "#{obj}:0" }.join(' ')}")
     end
 
     # @return [Hash] dados exchange paymium - saldos & transacoes ledger
@@ -53,22 +53,22 @@ module Cns
 
     # @return [Array<String>] lista txid dos ledger novos
     def kyl
-      @kyl ||= exd[:kl].map { |h| h[:account_operations].map { |o| o[:uuid] } }.flatten -
-               (ops[:t] ? [] : bqd[:nl].map { |e| e[:txid] })
+      @kyl ||= exd[:kl].map { |oex| oex[:account_operations].map { |obj| obj[:uuid] } }.flatten -
+               (ops[:t] ? [] : bqd[:nl].map { |obq| obq[:txid] })
     end
 
     # @example (see Apice#account_fr)
     # @param [Symbol] bqm symbol paymium da moeda
     # @return [String] texto formatado saldos
     def formata_saldos(bqm)
-      b = bqd[:sl][bqm].to_d
-      t = exd[:sl]["balance_#{bqm}".to_sym].to_d
+      vbq = bqd[:sl][bqm].to_d
+      vkr = exd[:sl]["balance_#{bqm}".to_sym].to_d
       format(
         '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
         mo: bqm.upcase,
-        kr: t,
-        bq: b,
-        ok: t == b ? 'OK' : 'NOK'
+        kr: vkr,
+        bq: vbq,
+        ok: vkr == vbq ? 'OK' : 'NOK'
       )
     end
 
@@ -90,16 +90,16 @@ module Cns
     # @param [Integer] max chars a mostrar
     # @return [String] texto formatado identificacor da ledger
     def formata_uuid(uid, max)
-      i = Integer(max / 2)
-      max < 7 ? 'erro' : "#{uid[0, i]}#{uid[-i..]}"
+      int = Integer(max / 2)
+      max < 7 ? 'erro' : "#{uid[0, int]}#{uid[-int..]}"
     end
 
     # @return [String] texto totais numero de transacoes
     def mostra_totais
-      c = exd[:kl].map { |h| h[:account_operations].count }.flatten.inject(:+)
-      d = bqd[:nl].count
+      vkl = exd[:kl].map { |obj| obj[:account_operations].count }.flatten.inject(:+)
+      vnl = bqd[:nl].count
 
-      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: c, d: d, o: c == d ? 'OK' : 'NOK')}")
+      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: vkl, d: vnl, o: vkl == vnl ? 'OK' : 'NOK')}")
     end
 
     # @return [String] texto transacoes ledger
@@ -107,7 +107,7 @@ module Cns
       return unless ops[:v] && ledger.count.positive?
 
       puts("\nledger             data       hora     tipo              moeda        quantidade")
-      ledger.sort { |a, b| b[:created_at_int] <=> a[:created_at_int] }.each { |o| puts(formata_ledger(o)) }
+      ledger.sort { |ant, prx| prx[:created_at_int] <=> ant[:created_at_int] }.each { |obj| puts(formata_ledger(obj)) }
     end
   end
 end

data/lib/cns/therock.rb

@@ -27,19 +27,19 @@ module Cns
 
     # @return [Array<Hash>] lista ledger therock novos
     def ledger
-      @ledger ||= exd[:kl].select { |o| kyl.include?(o[:id]) }
+      @ledger ||= exd[:kl].select { |obj| kyl.include?(obj[:id]) }
     end
 
     # @return [String] texto saldos & transacoes & ajuste dias
     def mostra_resumo
       puts("\nTHEROCK\ntipo                therock              bigquery")
-      exd[:sl].each { |h| puts(formata_saldos(h)) }
+      exd[:sl].each { |obj| puts(formata_saldos(obj)) }
       mostra_totais
 
       mostra_ledger
       return unless ledger.count.positive?
 
-      puts("\nstring ajuste dias da ledger\n-h=#{kyl.map { |e| "#{e}:0" }.join(' ')}")
+      puts("\nstring ajuste dias da ledger\n-h=#{kyl.map { |obj| "#{obj}:0" }.join(' ')}")
     end
 
     # @return [Hash] dados exchange therock - saldos & transacoes ledger
@@ -52,21 +52,22 @@ module Cns
 
     # @return [Array<String>] lista txid dos ledger novos
     def kyl
-      @kyl ||= exd[:kl].map { |h| h[:id] } - (ops[:t] ? [] : bqd[:nl].map { |e| e[:txid] })
+      @kyl ||= exd[:kl].map { |oex| oex[:id] } - (ops[:t] ? [] : bqd[:nl].map { |obq| obq[:txid] })
     end
 
     # @example (see Apice#account_mt)
     # @param [Hash] hsl saldo therock da moeda
     # @return [String] texto formatado saldos
     def formata_saldos(hsl)
-      b = bqd[:sl][hsl[:currency].downcase.to_sym].to_d
-      k = hsl[:balance].to_d
+      cur = hsl[:currency]
+      vbq = bqd[:sl][cur.downcase.to_sym].to_d
+      vkr = hsl[:balance].to_d
       format(
         '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
-        mo: hsl[:currency].upcase,
-        kr: k,
-        bq: b,
-        ok: k == b ? 'OK' : 'NOK'
+        mo: cur.upcase,
+        kr: vkr,
+        bq: vbq,
+        ok: vkr == vbq ? 'OK' : 'NOK'
       )
     end
 
@@ -86,18 +87,18 @@ module Cns
 
     # @return [String] texto totais numero de transacoes
     def mostra_totais
-      c = exd[:kl].count
-      d = bqd[:nl].count
+      vkl = exd[:kl].count
+      vnl = bqd[:nl].count
 
-      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: c, d: d, o: c == d ? 'OK' : 'NOK')}")
+      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: vkl, d: vnl, o: vkl == vnl ? 'OK' : 'NOK')}")
     end
 
     # @return [String] texto transacoes ledger
     def mostra_ledger
       return unless ops[:v] && ledger.count.positive?
 
-      puts("\nledger data       hora     tipo                        moeda ---------quantidade")
-      ledger.sort { |a, b| b[:id] <=> a[:id] }.each { |o| puts(formata_ledger(o)) }
+      puts("\nledger data       hora     tipo                        moeda          quantidade")
+      ledger.sort { |ant, prx| prx[:id] <=> ant[:id] }.each { |obj| puts(formata_ledger(obj)) }
     end
   end
 end

data/lib/cns/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cns
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.1
 platform: ruby
 authors:
 - Hernâni Rodrigues Vaz
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-22 00:00:00.000000000 Z
+date: 2021-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -39,13 +39,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: curb
+  name: reek
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -53,7 +53,63 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: solargraph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: curb
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,7 +123,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: google-cloud-bigquery
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,7 +137,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: thor
+  name: google-cloud-bigquery
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -95,7 +151,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -118,6 +174,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".reek.yml"
 - ".rubocop.yml"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
@@ -134,6 +191,8 @@ files:
 - lib/cns/apibc.rb
 - lib/cns/apice1.rb
 - lib/cns/apice2.rb
+- lib/cns/beaconchain1.rb
+- lib/cns/beaconchain2.rb
 - lib/cns/bigquery1.rb
 - lib/cns/bigquery2.rb
 - lib/cns/bigquery3.rb
@@ -159,9 +218,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="