cns 0.9.1 → 0.9.3

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,
-      sort_key: :itx,
-      format: :formata_ledger,
-      header: "\nsequence num from         to           accao      data              valor moeda",
-      adjustment_key: :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,52 +95,11 @@ 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[:sort_key]] }.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.map { |t| "#{t[TT[:adjustment_key]]}: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
-
-    def show_all?
-      ops[:t] || false
-    end
-
-    def bqidt
-      @bqidt ||= show_all? ? [] : (bqd[:nt]&.map { |i| i[:itx] } || [])
-    end
-
-    # @return [Array<Integer>] lista indices transacoes novas
-    def idt
-      @idt ||= bcd.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
-    end
-
-    # @example (see Apibc#account_gm)
     # @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)) }
+      {ax: xbq, sl: peosa(xbq).reduce(:+), tx: peost(xbq, api.ledger_gm(xbq))}
     end
 
     # @param wbq (see base_bc)
@@ -138,22 +111,17 @@ module Cns
         id: wbq[:id],
         ax: xbq,
         bs: wbq[:sl],
-        bt: bqd[:nt].select { |obj| obj[:iax] == xbq },
+        bt: bqd[:nt].select { |o| o[:iax] == xbq },
         es: hbc[:sl],
         et: hbc[:tx]
       }
     end
 
-    # @return [Array<Hash>] lista transacoes novas
-    def novneost
-      @novneost ||= bcd.map { |obc| obc[:tx].select { |obj| idt.include?(obj[:itx]) } }.flatten
-    end
-
-    # @return [Array<Hash>] lista ordenada transacoes
-    def soreost
-      novneost.sort_by { |i| -i[:itx] }
+    def show_all?
+      ops[:t] || false
     end
 
+    # @param [String] add EOS account name
     # @return [Array<BigDecimal>] lista recursos - liquido, net, spu
     def peosa(add)
       hac = api.account_gm(add)
@@ -161,7 +129,7 @@ module Cns
       [hac[:core_liquid_balance].to_d, htr[:net_weight].to_d, htr[:cpu_weight].to_d]
     end
 
-    # @param add (see Apibc#account_gm)
+    # @param add (see peosa)
     # @param [Array<Hash>] ary lista transacoes
     # @return [Array<Hash>] lista transacoes filtrada
     def peost(add, ary)
@@ -183,5 +151,30 @@ module Cns
         )
       end
     end
+
+    # @return [Array<Hash>] todos os dados greymass - saldos & transacoes
+    def bcd
+      @bcd ||= bqd[:wb].map { |o| base_bc(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] }) }
+    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 ||= bcd.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
+    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
@@ -27,61 +25,55 @@ module Cns
 
     # @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) }
+      @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)) }
+      exd[:sl].sort.each { |key, val| puts(fos(key, val)) }
       mtotais
 
       mtrades
       mledger
       return if novcust.empty?
 
-      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |obj| "#{obj}:0" }.join(' ')}")
+      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
-    end
-
-    def bqkyt
-      @bqkyt ||= show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid].to_sym } || [])
-    end
+    # mosta contadores transacoes
+    def mtotais
+      vkt = exd[:kt].count
+      vnt = bqd[:nt].count
+      vkl = exd[:kl].count
+      vnl = bqd[:nl].count
 
-    def bqkyl
-      @bqkyl ||= show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid].to_sym } || [])
+      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 trades novos
-    def kyt
-      @kyt ||= exd[:kt].keys - bqkyt
-    end
+    # mosta transacoes trades
+    def mtrades
+      return unless ops[:v] && novcust.any?
 
-    # @return [Array<String>] lista txid dos ledger novos
-    def kyl
-      @kyl ||= exd[:kl].keys - bqkyl
+      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] trades kraken novos
-    def novcust
-      @novcust ||= exd[:kt].slice(*kyt)
-    end
+    # mosta transacoes ledger
+    def mledger
+      return unless ops[:v] && novcusl.any?
 
-    # @return [Hash] ledger kraken novos
-    def novcusl
-      @novcusl ||= exd[:kl].slice(*kyl)
+      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,51 +115,65 @@ 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
+    def show_all?
+      ops[:t] || false
+    end
 
-      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')}")
+    # @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
 
-    # @return [String] texto transacoes trades
-    def mtrades
-      return unless ops[:v] && novcust.any?
+    # @param [Hash] itm transacao kraken
+    # @return [Hash] transaccao filtrada
+    def pusk(itm)
+      itm.map do |k, v|
+        t = Integer(v[:time])
+        [k, v.merge(txid: k.to_s, srx: t, time: Time.at(t))]
+      end.to_h
+    end
 
-      puts("\ntrade  data       hora     tipo       par         preco     volume         custo")
-      novcust.sort_by { |_, v| -v[:srx] }.each { |i, t| puts(formata_trades(i, t)) }
+    # @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
 
-    # @return [String] texto transacoes ledger
-    def mledger
-      return unless ops[:v] && novcusl.any?
+    # @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
 
-      puts("\nledger data       hora     tipo       moeda        quantidade              custo")
-      novcusl.sort_by { |_, v| -v[:srx] }.each { |i, t| puts(formata_ledger(i, t)) }
+    # @return [Array<Symbol>] indices trades bigquery
+    def bqkyt
+      @bqkyt ||= show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid].to_sym } || [])
     end
 
-    # Processa os trades para garantir que as datas estejam no formato correto
-    def pusa(itm)
-      itm.select { |k, _| EM.include?(k) }.transform_values { |v| v.to_d }
+    # @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 ||= exd[:kt].keys - bqkyt
     end
 
-    def puss(itm)
-      tym = Integer(itm[:time])
-      itm.merge(srx: tym, time: Time.at(tym))
+    # @return [Array<Symbol>] lista txid ledger novos
+    def kyl
+      @kyl ||= exd[:kl].keys - bqkyl
     end
 
-    # Processa os trades para garantir que as datas estejam no formato correto
-    def pust(itm)
-      itm.transform_values { |t| puss(t).merge(pair: t[:pair].upcase, price: t[:price].to_d, vol: t[:vol].to_d, cost: t[:cost].to_d) }
+    # @return [Hash] trades kraken novos
+    def novcust
+      @novcust ||= exd[:kt].slice(*kyt)
     end
 
-    # Processa os ledger entries para garantir que as datas estejam no formato correto
-    def pusl(itm)
-      itm.transform_values { |t| puss(t).merge(asset: t[:asset].upcase, amount: t[:amount].to_d, fee: t[:fee].to_d) }
+    # @return [Hash] ledger kraken novos
+    def novcusl
+      @novcusl ||= exd[:kl].slice(*kyl)
     end
   end
 end

data/lib/cns/version.rb

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

metadata

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