cns 2.0.3 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 353a19c9f3ae3d6e28ce9495e8d8fdcc989a0ead6915a7d4ba6ad8b03c574971
-  data.tar.gz: 9d074553b5857af05315037f2bc6f7e0fd7a7402fe29406986d25720e03ad9f4
+  metadata.gz: d694cb783e1251f3f407be238aab038991afc5fb59ff3aedd47c9e7b916b5c82
+  data.tar.gz: 5fcc7fd02541ab31d788d04a83cac269bddc05bdd18c63308159c88062434e59
 SHA512:
-  metadata.gz: 620514e54c2e1d9bd29f1d1ad4be69b2bd01690fde7034fad875c6e1b17c7b8e195fe538f9047732701ba040fe9c76b33052500a9af17e17490b6d56ea9aa9ff
-  data.tar.gz: 8377df664f22714ef724d58bd34b43c6c0243a5e1e44c4cff444e68fbaf12b209824bf7c00c9e62fcc0b953c53ed5b43aaaa233b2a02cf14874ccd32edecf3ba
+  metadata.gz: a1a7d81e1fa81a8b843a17473644f0762b0d144cf97f267ffdb63bf160a5c84fac4eb105e05d11516aaf7f5985a6b075280aa8115bfb40f0535f6fa8d619d1ae
+  data.tar.gz: d02c614fdcc3610173506b2646223e10bc3b1f74a86e0e08fc8a46f0f9befeed11dedb2b606f58b8b667398319e55f821d2d0f125ea2ebad687fa8c31422567c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cns (2.0.3)
+    cns (2.0.4)
       curb
       faraday
       faraday-retry

data/lib/cns/bitcoinde.rb

@@ -25,7 +25,7 @@ module Cns
     # @return [String] texto saldos & transacoes & ajuste dias
     def mresumo
       puts("\nBITCOINDE\ntipo              bitcoinde              bigquery")
-      ced[:sl].sort.each { |k, v| puts(fos(k, v)) }
+      exd[:sl].sort.each { |k, v| puts(fos(k, v)) }
       mtotais
 
       mtrades
@@ -39,8 +39,8 @@ module Cns
 
     # mosta contadores transacoes
     def mtotais
-      vtt, vnt = ced[:tt].count, bqd[:nt].count
-      vtl, vnl = ced[:tl].count, bqd[:nl].count
+      vtt, vnt = exd[:tt].count, bqd[:nt].count
+      vtl, vnl = exd[:tl].count, bqd[:nl].count
 
       puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: vtt, b: vnt, o: vtt == vnt ? 'OK' : 'NOK')}")
       puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: vtl, d: vnl, o: vtl == vnl ? 'OK' : 'NOK')}")
@@ -157,7 +157,7 @@ module Cns
     end
 
     # @return [Hash] dados exchange bitcoinde - saldos & trades & deposits & withdrawals
-    memoize def ced
+    memoize def exd
       {sl: pdea(api.account_de), tt: pdet(api.trades_de), tl: pdel(api.deposits_de + api.withdrawals_de)}
     end
 
@@ -172,23 +172,23 @@ module Cns
     end
 
     # @return [Array<String>] lista txid trades novos
-    memoize def cekyt
-      ced[:tt].map { |t| t[:trade_id] } - bqkyt
+    memoize def exkyt
+      exd[:tt].map { |t| t[:trade_id] } - bqkyt
     end
 
     # @return [Array<Integer>] lista nxid ledger novos
-    memoize def cekyl
-      ced[:tl].map { |t| t[:nxid] } - bqkyl
+    memoize def exkyl
+      exd[:tl].map { |t| t[:nxid] } - bqkyl
     end
 
     # @return [Array<Hash>] lista trades novos bitcoinde
     memoize def novxt
-      ced[:tt].select { |o| cekyt.include?(o[:trade_id]) }
+      exd[:tt].select { |o| exkyt.include?(o[:trade_id]) }
     end
 
     # @return [Array<Hash>] lista ledgers (deposits + withdrawals) novos bitcoinde
     memoize def novxl
-      ced[:tl].select { |o| cekyl.include?(o[:nxid]) }
+      exd[:tl].select { |o| exkyl.include?(o[:nxid]) }
     end
   end
 end

data/lib/cns/etherscan.rb

@@ -61,20 +61,20 @@ module Cns
 
     # mostra resumo carteiras & transacoes & ajuste dias
     def mresumo_simples
-      return unless dados.any?
+      return unless bqexd.any?
 
       puts("\nid     address                                        etherscan      bigquery")
-      dados.each { |o| puts(focs(o)) }
+      bqexd.each { |o| puts(focs(o)) }
       mtransacoes_novas
       mconfiguracao_ajuste_dias
     end
 
     # mostra resumo carteiras & transacoes & ajuste dias (com contadores)
     def mresumo
-      return unless dados.any?
+      return unless bqexd.any?
 
       puts("\nid     address      etherscan  tn ti tb tk   tw    bigquery  tn ti tb tk   tw")
-      dados.each { |o| puts(foct(o)) }
+      bqexd.each { |o| puts(foct(o)) }
       mtransacoes_novas
       mconfiguracao_ajuste_dias
     end
@@ -286,7 +286,7 @@ module Cns
     # Fetch Etherscan data for an account
     # @param [Hash] aes account etherscan
     # @return [Hash] dados etherscan - address, saldo & transacoes
-    def bses(aes)
+    def esd(aes)
       acc = aes[:account].downcase
       {
         ax: acc,
@@ -303,7 +303,7 @@ module Cns
     # @param [Hash] wbq wallet bigquery
     # @param [Hash] hes dados etherscan - address, saldo & transacoes
     # @return [Hash] dados juntos bigquery & etherscan
-    def bqes(wbq, hes)
+    def bqesd(wbq, hes)
       xbq = wbq[:ax]
       {
         id: wbq[:id],
@@ -323,12 +323,6 @@ module Cns
       }
     end
 
-    # Fetch all Etherscan data
-    # @return [Hash] saldos & transacoes, indexed by address
-    memoize def bcd
-      api.account_es(lax).map { |o| bses(o) }.to_h { |h| [h[:ax], h] }
-    end
-
     # Lazy Etherscan API Initialization
     # @return [Apibc] API instance
     memoize def api
@@ -340,90 +334,96 @@ module Cns
       bqd[:wb].map { |o| o[:ax] }
     end
 
+    # Fetch all Etherscan data
+    # @return [Hash] saldos & transacoes, indexed by address
+    memoize def exd
+      api.account_es(lax).map { |o| esd(o) }.to_h { |h| [h[:ax], h] }
+    end
+
     # Fetch combined data
     # @return [Array<Hash>] todos os dados juntos bigquery & etherscan
-    memoize def dados
-      bqd[:wb].map { |b| bqes(b, bcd[b[:ax]]) }
+    memoize def bqexd
+      bqd[:wb].map { |b| bqesd(b, exd[b[:ax]]) }
     end
 
     # @return [Array<Integer>] indices transacoes bigquery
-    memoize def bqidt
+    memoize def bqkyt
       show_all? ? [] : bqd[:nt].map { |i| i[:itx] }
     end
 
     # @return [Array<Integer>] indices transacoes bigquery
-    memoize def bqidi
+    memoize def bqkyi
       show_all? ? [] : bqd[:ni].map { |i| i[:itx] }
     end
 
     # @return [Array<Integer>] indices transacoes bigquery
-    memoize def bqidp
+    memoize def bqkyp
       show_all? ? [] : bqd[:np].map { |i| i[:itx] }
     end
 
     # @return [Array<Integer>] indices transacoes bigquery
-    memoize def bqidw
+    memoize def bqkyw
       show_all? ? [] : bqd[:nw].map { |i| i[:itx] }
     end
 
     # @return [Array<Integer>] indices transacoes bigquery
-    memoize def bqidk
+    memoize def bqkyk
       show_all? ? [] : bqd[:nk].map { |i| i[:itx] }
     end
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
-    memoize def bcidt
-      bcd.values.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
+    memoize def exkyt
+      exd.values.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqkyt
     end
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
-    memoize def bcidi
-      bcd.values.map { |o| o[:ix].map { |i| i[:itx] } }.flatten - bqidi
+    memoize def exkyi
+      exd.values.map { |o| o[:ix].map { |i| i[:itx] } }.flatten - bqkyi
     end
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
-    memoize def bcidp
-      bcd.values.map { |o| o[:px].map { |i| i[:itx] } }.flatten - bqidp
+    memoize def exkyp
+      exd.values.map { |o| o[:px].map { |i| i[:itx] } }.flatten - bqkyp
     end
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
-    memoize def bcidw
-      bcd.values.map { |o| o[:wx].map { |i| i[:itx] } }.flatten - bqidw
+    memoize def exkyw
+      exd.values.map { |o| o[:wx].map { |i| i[:itx] } }.flatten - bqkyw
     end
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
-    memoize def bcidk
-      bcd.values.map { |o| o[:kx].map { |i| i[:itx] } }.flatten - bqidk
+    memoize def exkyk
+      exd.values.map { |o| o[:kx].map { |i| i[:itx] } }.flatten - bqkyk
     end
 
     # Get new normal transactions
     # @return [Array<Hash>] List of new transactions
     memoize def novxt
-      bcd.values.map { |o| o[:tx].select { |t| bcidt.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      exd.values.map { |o| o[:tx].select { |t| exkyt.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
     # Get new internal transactions
     # @return [Array<Hash>] List of new transactions
     memoize def novxi
-      bcd.values.map { |o| o[:ix].select { |t| bcidi.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      exd.values.map { |o| o[:ix].select { |t| exkyi.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
     # Get new produced block transactions
     # @return [Array<Hash>] List of new transactions
     memoize def novxp
-      bcd.values.map { |o| o[:px].select { |t| bcidp.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      exd.values.map { |o| o[:px].select { |t| exkyp.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
     # Get new withdrawal transactions
     # @return [Array<Hash>] List of new transactions
     memoize def novxw
-      bcd.values.map { |o| o[:wx].select { |t| bcidw.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      exd.values.map { |o| o[:wx].select { |t| exkyw.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
     # Get new token transactions
     # @return [Array<Hash>] List of new transactions
     memoize def novxk
-      bcd.values.map { |o| o[:kx].select { |t| bcidk.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      exd.values.map { |o| o[:kx].select { |t| exkyk.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
   end
 end

data/lib/cns/greymass.rb

@@ -26,10 +26,10 @@ module Cns
 
     # Display summary of wallets, transactions, and adjustment days configuration
     def mresumo
-      return unless dados.any?
+      return unless bqexd.any?
 
       puts("\naddress            greymass  ntx       bigquery  ntx")
-      dados.each { |e| puts(foct(e)) }
+      bqexd.each { |e| puts(foct(e)) }
       mtransacoes_novas
       mconfiguracao_ajuste_dias
     end
@@ -131,16 +131,16 @@ module Cns
     # Fetch Greymass data for a wallet
     # @param [Hash] wbq wallet bigquery
     # @return [Hash] dados greymass - address, saldo & transacoes
-    def bsgm(wbq)
+    def gmd(wbq)
       xbq = wbq[:ax]
       {ax: xbq, sl: peosa(xbq).reduce(:+), tx: peost(xbq, api.ledger_gm(xbq))}
     end
 
     # Combine BigQuery and Greymass data
-    # @param wbq (see bsgm)
+    # @param wbq (see gmd)
     # @param [Hash] hgm dados greymass - address, saldo & transacoes
     # @return [Hash] dados juntos bigquery & greymass
-    def bqgm(wbq, hgm)
+    def bqgmd(wbq, hgm)
       xbq = wbq[:ax]
       {
         id: wbq[:id],
@@ -160,30 +160,30 @@ module Cns
 
     # Fetch all Greymass data
     # @return [Hash] Hash of Greymass data indexed by address
-    memoize def bcd
-      bqd[:wb].map { |o| bsgm(o) }.to_h { |h| [h[:ax], h] }
+    memoize def exd
+      bqd[:wb].map { |o| gmd(o) }.to_h { |h| [h[:ax], h] }
     end
 
     # Fetch combined BigQuery and Greymass data
     # @return [Array<Hash>] Combined data list
-    memoize def dados
-      bqd[:wb].map { |b| bqgm(b, bcd[b[:ax]]) }
+    memoize def bqexd
+      bqd[:wb].map { |b| bqgmd(b, exd[b[:ax]]) }
     end
 
     # @return [Array<Integer>] indices transacoes bigquery
-    memoize def bqidt
+    memoize def bqkyt
       show_all? ? [] : bqd[:nt].map { |i| i[:itx] }
     end
 
     # @return [Array<Integer>] indices transacoes novas (greymass - bigquery)
-    memoize def bcidt
-      bcd.values.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
+    memoize def exkyt
+      exd.values.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqkyt
     end
 
     # Get new transactions
     # @return [Array<Hash>] List of new transactions
     memoize def novxt
-      bcd.values.map { |t| t[:tx].select { |o| bcidt.include?(o[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      exd.values.map { |t| t[:tx].select { |o| exkyt.include?(o[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
   end
 end

data/lib/cns/kraken.rb

@@ -25,7 +25,7 @@ module Cns
     # mosta resumo saldos & transacoes & ajuste dias
     def mresumo
       puts("\nKRAKEN\ntipo                 kraken              bigquery")
-      ced[:sl].sort.each { |key, val| puts(fos(key, val)) }
+      exd[:sl].sort.each { |key, val| puts(fos(key, val)) }
       mtotais
 
       mtrades
@@ -37,15 +37,15 @@ module Cns
 
     # @return [Hash] ledgers exchange kraken
     def uskl
-      ced[:kl]
+      exd[:kl]
     end
 
     private
 
     # mosta contadores transacoes
     def mtotais
-      vkt, vnt = ced[:kt].count, bqd[:nt].count
-      vkl, vnl = ced[:kl].count, bqd[:nl].count
+      vkt, vnt = exd[:kt].count, bqd[:nt].count
+      vkl, vnl = exd[:kl].count, 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')}")
@@ -147,7 +147,7 @@ module Cns
     end
 
     # @return [Hash] dados exchange kraken - saldos & transacoes trades e ledger
-    memoize def ced
+    memoize def exd
       {sl: pusa(api.account_us), kt: pust(api.trades_us), kl: pusl(api.ledger_us)}
     end
 
@@ -162,23 +162,23 @@ module Cns
     end
 
     # @return [Array<String>] lista txid trades novos
-    memoize def cekyt
-      ced[:kt].map { |t| t[:txid] } - bqkyt
+    memoize def exkyt
+      exd[:kt].map { |t| t[:txid] } - bqkyt
     end
 
     # @return [Array<String>] lista txid ledger novos
-    memoize def cekyl
-      ced[:kl].map { |t| t[:txid] } - bqkyl
+    memoize def exkyl
+      exd[:kl].map { |t| t[:txid] } - bqkyl
     end
 
     # @return [Array<Hash>] trades novos kraken
     memoize def novxt
-      ced[:kt].select { |o| cekyt.include?(o[:txid]) }
+      exd[:kt].select { |o| exkyt.include?(o[:txid]) }
     end
 
     # @return [Array<Hash>] ledgers novos kraken
     memoize def novxl
-      ced[:kl].select { |o| cekyl.include?(o[:txid]) }
+      exd[:kl].select { |o| exkyl.include?(o[:txid]) }
     end
   end
 end

data/lib/cns/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cns
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
 platform: ruby
 authors:
 - Hernâni Rodrigues Vaz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-21 00:00:00.000000000 Z
+date: 2025-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler