cns 0.9.2 → 0.9.4

data/lib/cns/greymass.rb

@@ -7,11 +7,17 @@ module Cns
   # classe para processar transacoes do greymass
   class Greymass
     # @return [Apibc] API blockchains
-    attr_reader :api
     # @return [Array<Hash>] todos os dados bigquery
-    attr_reader :bqd
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
-    attr_reader :ops
+    attr_reader :api, :bqd, :ops
+
+    TT = {
+      new: :novneost,
+      format: :fol,
+      header: "\nsequence num from         to           accao      data              valor moeda",
+      sork: :itx,
+      adjk: :itx
+    }
 
     # @param [Hash] dad todos os dados bigquery
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
@@ -25,29 +31,38 @@ module Cns
       @ops = pop.transform_keys(&:to_sym)
     end
 
-    TT = {
-      new: :novneost,
-      format: :formata_ledger,
-      header: "\nsequence num from         to           accao      data              valor moeda",
-      sork: :itx,
-      adjk: :itx
-    }
-
     # @return [String] texto carteiras & transacoes & ajuste dias
     def mresumo
       return unless dados.any?
 
       puts("\naddress            greymass  ntx       bigquery  ntx")
-      dados.each { |obj| puts(formata_carteira(obj)) }
+      dados.each { |o| puts(foct(o)) }
       mtransacoes_novas
       mconfiguracao_ajuste_dias
     end
 
     private
 
+    # mosta transacoes novas
+    def mtransacoes_novas
+      ntx = send(TT[:new])
+      return unless ops[:v] && ntx.any?
+
+      puts(TT[:header])
+      ntx.sort_by { |s| -s[TT[:sork]] }.each { |t| puts(send(TT[:format], t)) }
+    end
+
+    # mostra configuration text for adjusting days
+    def mconfiguracao_ajuste_dias
+      ntx = send(TT[:new])
+      return unless ntx.any?
+
+      puts("\nstring ajuste dias\n-h=#{ntx.sort_by { |s| -s[TT[:sork]] }.map { |t| "#{t[TT[:adjk]]}:0" }.join(' ')}")
+    end
+
     # @param [Hash] hjn dados juntos bigquery & greymass
     # @return [String] texto formatado duma carteira
-    def formata_carteira(hjn)
+    def foct(hjn)
       format(
         '%<s1>-12.12s %<v1>14.4f %<n1>4i %<v2>14.4f %<n2>4i %<ok>-3s',
         s1: hjn[:ax],
@@ -59,16 +74,15 @@ module Cns
       )
     end
 
-    # @param (see formata_carteira)
+    # @param (see foct)
     # @return [Boolean] carteira tem transacoes novas(sim=NOK, nao=OK)?
     def ok?(hjn)
       hjn[:bs] == hjn[:es] && hjn[:bt].count == hjn[:et].count
     end
 
-    # @example (see Apibc#ledger_gm)
     # @param [Hash] hlx ledger greymass
-    # @return [String] texto formatado ledger greymass
-    def formata_ledger(hlx)
+    # @return [String] texto formatado
+    def fol(hlx)
       format(
         '%<bn>12i %<fr>-12.12s %<to>-12.12s %<ac>-10.10s %<dt>10.10s %<vl>12.4f %<sy>-6.6s',
         ac: hlx[:name],
@@ -81,102 +95,87 @@ module Cns
       )
     end
 
-    # @return [String] Display new transactions based on verbose option
-    def mtransacoes_novas
-      ntx = send(TT[:new])
-      return unless ops[:v] && ntx.any?
-
-      puts(TT[:header])
-      ntx.sort_by { |s| -s[TT[:sork]] }.each { |t| puts(send(TT[:format], t)) }
-    end
-
-    # @return [String] texto configuracao ajuste dias das transacoes
-    def mconfiguracao_ajuste_dias
-      ntx = send(TT[:new])
-      return unless ntx.any?
-
-      puts("\nstring ajuste dias\n-h=#{ntx.sort_by { |s| -s[TT[:sork]] }.map { |t| "#{t[TT[:adjk]]}:0" }.join(' ')}")
-    end
-
-    # @return [Array<Hash>] todos os dados greymass - saldos & transacoes
-    def bcd
-      @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.find { |g| b[:ax] == g[:ax] }) }
-    end
-
+    # @return [Boolean] mostra todas/novas transacoes
     def show_all?
       ops[:t] || false
     end
 
-    def bqidt
-      @bqidt ||= show_all? ? [] : (bqd[:nt]&.map { |i| i[:itx] } || [])
+    # @param [String] add EOS account name
+    # @return [Array<BigDecimal>] lista recursos - liquido, net, spu
+    def peosa(add)
+      hac = api.account_gm(add)
+      htr = hac[:total_resources]
+      [hac[:core_liquid_balance].to_d, htr[:net_weight].to_d, htr[:cpu_weight].to_d]
     end
 
-    # @return [Array<Integer>] lista indices transacoes novas
-    def idt
-      @idt ||= bcd.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
+    # @param add (see peosa)
+    # @param [Array<Hash>] ary lista transacoes
+    # @return [Array<Hash>] lista transacoes filtrada
+    def peost(add, ary)
+      ary.map do |t|
+        act = t[:action_trace][:act]
+        adt = act[:data]
+        qtd = adt[:quantity].to_s
+        t.merge(
+          name: act[:name],
+          from: adt[:from],
+          quantity: qtd.to_d,
+          account: act[:account],
+          to: adt[:to],
+          memo: String(adt[:memo]).gsub(/\p{C}/, ''), # remove Non-Printable Characters
+          moe: qtd[/[[:upper:]]+/],
+          itx: t[:global_action_seq],
+          iax: add,
+          block_time: Time.parse(t[:block_time])
+        )
+      end
     end
 
-    # @example (see Apibc#account_gm)
     # @param [Hash] wbq wallet bigquery
     # @return [Hash] dados greymass - address, saldo & transacoes
-    def base_bc(wbq)
+    def bsgm(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
+    # @param wbq (see bsgm)
+    # @param [Hash] hgm dados greymass - address, saldo & transacoes
     # @return [Hash] dados juntos bigquery & greymass
-    def bq_bc(wbq, hbc)
+    def bqgm(wbq, hgm)
       xbq = wbq[:ax]
       {
         id: wbq[:id],
         ax: xbq,
         bs: wbq[:sl],
-        bt: bqd[:nt].select { |obj| obj[:iax] == xbq },
-        es: hbc[:sl],
-        et: hbc[:tx]
+        bt: bqd[:nt].select { |o| o[:iax] == xbq },
+        es: hgm[:sl],
+        et: hgm[:tx]
       }
     end
 
-    # @return [Array<Hash>] lista transacoes novas
-    def novneost
-      @novneost ||= bcd.map { |obc| obc[:tx].select { |obj| idt.include?(obj[:itx]) } }.flatten
+    # @return [Array<Hash>] todos os dados greymass - saldos & transacoes
+    def gmd
+      @gmd ||= bqd[:wb].map { |o| bsgm(o) }
     end
 
-    # @return [Array<BigDecimal>] lista recursos - liquido, net, spu
-    def peosa(add)
-      hac = api.account_gm(add)
-      htr = hac[:total_resources]
-      [hac[:core_liquid_balance].to_d, htr[:net_weight].to_d, htr[:cpu_weight].to_d]
+    # @return [Array<Hash>] todos os dados juntos bigquery & greymass
+    def dados
+      @dados ||= bqd[:wb].map { |b| bqgm(b, gmd.find { |g| b[:ax] == g[:ax] }) }
     end
 
-    # @param add (see Apibc#account_gm)
-    # @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]
-        adt = act[:data]
-        qtd = adt[:quantity].to_s
-        omp.merge(
-          name: act[:name],
-          from: adt[:from],
-          quantity: qtd.to_d,
-          account: act[:account],
-          to: adt[:to],
-          memo: String(adt[:memo]).gsub(/\p{C}/, ''), # remove Non-Printable Characters
-          moe: qtd[/[[:upper:]]+/],
-          itx: omp[:global_action_seq],
-          iax: add,
-          block_time: Time.parse(omp[:block_time])
-        )
-      end
+    # @return [Array<Integer>] indices transacoes bigquery
+    def bqidt
+      @bqidt ||= show_all? ? [] : bqd[:nt].map { |i| i[:itx] }
+    end
+
+    # @return [Array<Integer>] indices transacoes novas (greymass - bigquery)
+    def idt
+      @idt ||= gmd.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
+    end
+
+    # @return [Array<Hash>] lista transacoes novas
+    def novneost
+      @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

@@ -7,11 +7,9 @@ module Cns
   # classe para processar transacoes trades/ledger do kraken
   class Kraken
     # @return [Apius] API kraken
-    attr_reader :api
     # @return [Array<Hash>] todos os dados bigquery
-    attr_reader :bqd
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
-    attr_reader :ops
+    attr_reader :api, :bqd, :ops
 
     # @param [Hash] dad todos os dados bigquery
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
@@ -25,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(formata_saldos(key, val)) }
+      usd[:sl].sort.each { |key, val| puts(fos(key, val)) }
       mtotais
 
       mtrades
@@ -43,45 +36,44 @@ module Cns
       puts("\nstring ajuste dias dos trades\n-h=#{novcust.sort_by { |_, v| -v[:srx] }.map { |k, _v| "#{k}:0" }.join(' ')}")
     end
 
-    private
-
-    def show_all?
-      ops[:t] || false
+    # @return [Hash] ledgers exchange kraken
+    def uskl
+      usd[:kl]
     end
 
-    def bqkyt
-      @bqkyt ||= show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid].to_sym } || [])
-    end
+    private
 
-    def bqkyl
-      @bqkyl ||= show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid].to_sym } || [])
-    end
+    # mosta contadores transacoes
+    def mtotais
+      vkt = usd[:kt].count
+      vnt = bqd[:nt].count
+      vkl = usd[:kl].count
+      vnl = bqd[:nl].count
 
-    # @return [Array<String>] lista txid dos trades novos
-    def kyt
-      @kyt ||= exd[:kt].keys - bqkyt
+      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 [Array<String>] lista txid dos ledger novos
-    def kyl
-      @kyl ||= exd[:kl].keys - bqkyl
-    end
+    # mosta transacoes trades
+    def mtrades
+      return unless ops[:v] && novcust.any?
 
-    # @return [Hash] trades kraken novos
-    def novcust
-      @novcust ||= exd[:kt].slice(*kyt)
+      puts("\ntrade  data       hora     tipo       par         preco     volume         custo")
+      novcust.sort_by { |_, v| -v[:srx] }.each { |k, t| puts(fot(k, t)) }
     end
 
-    # @return [Hash] ledger kraken novos
-    def novcusl
-      @novcusl ||= exd[:kl].slice(*kyl)
+    # mosta transacoes ledger
+    def mledger
+      return unless ops[:v] && novcusl.any?
+
+      puts("\nledger data       hora     tipo       moeda        quantidade              custo")
+      novcusl.sort_by { |_, v| -v[:srx] }.each { |k, t| puts(fol(k, t)) }
     end
 
-    # @example (see Apice#account_us)
     # @param [String] moe codigo kraken da moeda
     # @param [BigDecimal] sal saldo kraken da moeda
     # @return [String] texto formatado saldos
-    def formata_saldos(moe, sal)
+    def fos(moe, sal)
       vbq = bqd[:sl][moe.downcase.to_sym].to_d
       format(
         '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
@@ -92,10 +84,10 @@ module Cns
       )
     end
 
-    # @example (see Apice#trades_us)
-    # @param (see Bigquery#ust_val1)
+    # @param [Symbol] idx id da transacao
+    # @param [Hash] htn trades kraken
     # @return [String] texto formatado trade
-    def formata_trades(idx, htx)
+    def fot(idx, htx)
       format(
         '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-8.8s %<pr>8.2f %<vl>10.4f %<co>13.2f',
         ky: idx,
@@ -108,10 +100,10 @@ module Cns
       )
     end
 
-    # @example (see Apice#ledger_us)
-    # @param (see Bigquery#usl_val)
+    # @param idx (see fot)
+    # @param [Hash] hln ledger kraken
     # @return [String] texto formatado ledger
-    def formata_ledger(idx, hlx)
+    def fol(idx, hlx)
       format(
         '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-4.4s %<pr>18.7f %<vl>18.7f',
         ky: idx,
@@ -123,39 +115,19 @@ module Cns
       )
     end
 
-    # @return [String] texto totais numero de transacoes
-    def mtotais
-      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: 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 mtrades
-      return unless ops[:v] && novcust.any?
-
-      puts("\ntrade  data       hora     tipo       par         preco     volume         custo")
-      novcust.sort_by { |_, v| -v[:srx] }.each { |k, t| puts(formata_trades(k, t)) }
-    end
-
-    # @return [String] texto transacoes ledger
-    def mledger
-      return unless ops[:v] && novcusl.any?
-
-      puts("\nledger data       hora     tipo       moeda        quantidade              custo")
-      novcusl.sort_by { |_, v| -v[:srx] }.each { |k, t| puts(formata_ledger(k, t)) }
+    # @return [Boolean] mostra todas/novas transacoes
+    def show_all?
+      ops[:t] || false
     end
 
-    # Processa accounts para garantir formato correto
+    # @param [Hash] itm recursos kraken
+    # @return [Hash<BigDecimal>] moedas & sados
     def pusa(itm)
       itm.select { |k, _| EM.include?(k) }.transform_values { |v| v.to_d }
     end
 
-    # Processa campos comuns para garantir formato correto
+    # @param [Hash] itm transacao kraken
+    # @return [Hash] transaccao filtrada
     def pusk(itm)
       itm.map do |k, v|
         t = Integer(v[:time])
@@ -163,14 +135,51 @@ module Cns
       end.to_h
     end
 
-    # Processa trades para garantir formato correto
-    def pust(itm)
-      pusk(itm).transform_values { |t| t.merge(pair: t[:pair].upcase, price: t[:price].to_d, vol: t[:vol].to_d, cost: t[:cost].to_d) }
+    # @param [Hash] htx trade kraken
+    # @return [Hash] transaccao filtrada
+    def pust(htx)
+      pusk(htx).transform_values { |t| t.merge(pair: t[:pair].upcase, price: t[:price].to_d, vol: t[:vol].to_d, cost: t[:cost].to_d) }
+    end
+
+    # @param [Hash] hlx ledger kraken
+    # @return [Hash] transaccao filtrada
+    def pusl(hlx)
+      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
 
-    # Processa ledgers para garantir formato correto
-    def pusl(itm)
-      pusk(itm).transform_values { |t| t.merge(asset: t[:asset].upcase, amount: t[:amount].to_d, fee: t[:fee].to_d) }
+    # @return [Array<Symbol>] indices trades bigquery
+    def bqkyt
+      @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 }
+    end
+
+    # @return [Array<Symbol>] lista txid trades novos
+    def kyt
+      @kyt ||= usd[:kt].keys - bqkyt
+    end
+
+    # @return [Array<Symbol>] lista txid ledger novos
+    def kyl
+      @kyl ||= usd[:kl].keys - bqkyl
+    end
+
+    # @return [Hash] trades kraken novos
+    def novcust
+      @novcust ||= usd[:kt].slice(*kyt)
+    end
+
+    # @return [Hash] ledger kraken novos
+    def novcusl
+      @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.2'
+  VERSION = '0.9.4'
 end

metadata

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