cns 0.9.6 → 0.9.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60e46e5d964570303d66901fde56320d6102a12ff0f53495d420dc73fc5c5045
-  data.tar.gz: fbc9a980fe5be810ee82c541ecbd769feae8ea87e84a9a2d80c356e0e8b313a0
+  metadata.gz: f44706093bb37569dad944e52da3becb0d1bb8ab34e48c9dd30c2f2cd6599f3c
+  data.tar.gz: 1cb9e471623d4abbf526a77278e5ff27614e52093d3a79a56229a9c9bf39783f
 SHA512:
-  metadata.gz: 425413cbc19a0cbd77889e32a8cac2ba934cf32c9775e2c3bfd891d732f81c025b9f89b92e87211980b4f1e6a318a968fe369b46add18a3c133316b46ec64ceb
-  data.tar.gz: 3cd4b50b92b93d31abe4795d1887a24dd358ba4d7aee75edb0ff2329a0ff5b722217547dc77b2aaa944b002c3d22b3107b4a561eea4c8209e8a0a6936ad0448f
+  metadata.gz: 99c1e87bc81a61b9c8e572807b133daf02e54b42bbdea7b2d1997711fc4a98984eae1320ebc6764ce15cd586dee29f88716fa49bc07bb91f136f9a4dd4bf3d55
+  data.tar.gz: 0ed7c0a9c0b40fcb5d18cf7271a5208ddd62e2e0643c0ae2134d74538fb6993c6756ba962e7de754751feae71873e2cb22644c74d5e6b999f78bda6336714e94

data/Gemfile.lock

@@ -1,9 +1,10 @@
 PATH
   remote: .
   specs:
-    cns (0.9.6)
+    cns (0.9.8)
       curb
       faraday
+      faraday-retry
       google-cloud-bigquery
       thor
 
@@ -56,6 +57,8 @@ GEM
       logger
     faraday-net_http (3.4.0)
       net-http (>= 0.5.0)
+    faraday-retry (2.2.1)
+      faraday (~> 2.0)
     google-apis-bigquery_v2 (0.84.0)
       google-apis-core (>= 0.15.0, < 2.a)
     google-apis-core (0.16.0)

data/cns.gemspec

@@ -36,6 +36,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency('curb')
   spec.add_dependency('faraday')
+  spec.add_dependency('faraday-retry')
   spec.add_dependency('google-cloud-bigquery')
   spec.add_dependency('thor')
   spec.metadata['rubygems_mfa_required'] = 'true'

data/lib/cns/apibc.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require('faraday')
+require 'faraday/retry'
 require('json')
 
 # @author Hernani Rodrigues Vaz
@@ -22,8 +23,11 @@ module Cns
     def account_es(addresses)
       return [] if addresses.empty?
 
-      res = es_req('balancemulti', addresses.join(','), 1, tag: 'latest')
-      res[:status] == '1' ? res[:result] || [] : []
+      # Batch addresses into groups of 20 (Etherscan limit) and fetch balances
+      addresses.each_slice(20).flat_map do |b|
+        res = es_req('balancemulti', b.join(','), 1, tag: 'latest')
+        res[:status] == '1' ? res[:result] || [] : []
+      end
     end
 
     # Get normal transactions for ETH address
@@ -149,7 +153,7 @@ module Cns
       {}
     end
 
-    # Create a Faraday connection with JSON configuration
+    # Create a Faraday connection with JSON configuration and retry logic
     # @param [String] url Base URL for the API
     # @return [Faraday::Connection] Configured Faraday connection
     def connection(url)
@@ -158,6 +162,7 @@ module Cns
         c.headers = {accept: 'application/json', user_agent: 'blockchain-api-client'}
         c.options.timeout = 30
         c.options.open_timeout = 10
+        c.use(Faraday::Retry::Middleware, max: 3, interval: 1)
         c.adapter(Faraday.default_adapter)
       end
     end

data/lib/cns/apice.rb

@@ -106,7 +106,8 @@ module Cns
       ary = []
       ofs = 0
       loop do
-        sleep(ofs.zero? ? 0 : 2)
+        # Rate limiting for page requests (2s in Kraken)
+        sleep(@lpag - Time.now + 2) if @lpag && Time.now - @lpag < 2
         ops = {nonce: nnc, ofs: ofs}
         run_curl(@curl, "#{API[:us]}/#{uri}", method: 'POST', post_data: ops, headers: hus(uri, ops))
         bth = parse_json(@curl).fetch(:result, {}).fetch(key, []).map { |k, v| us_unif(k, v) }
@@ -114,6 +115,7 @@ module Cns
 
         ary.concat(bth)
         ofs += bth.size
+        @lpag = Time.now
       end
       ary
     end
@@ -200,6 +202,8 @@ module Cns
       md5 = ['GET', qde, @deky, non, Digest::MD5.hexdigest('')].join('#')
       mac = OpenSSL::HMAC.hexdigest('sha256', @desc, md5)
       {'X-API-KEY' => @deky, 'X-API-NONCE' => non.to_s, 'X-API-SIGNATURE' => mac}
+    rescue OpenSSL::HMACError => e
+      raise("HMAC bitcoinde generation failed: #{e.message}")
     end
 
     # Generate headers for Kraken HTTP requests
@@ -211,6 +215,8 @@ module Cns
       sha = ['/0/private/', qus, Digest::SHA256.digest("#{ops[:nonce]}#{URI.encode_www_form(ops)}")].join
       mac = OpenSSL::HMAC.digest('sha512', Base64.decode64(@ussc), sha)
       {'api-key' => @usky, 'api-sign' => Base64.strict_encode64(mac)}
+    rescue OpenSSL::HMACError => e
+      raise("HMAC kraken generation failed: #{e.message}")
     end
   end
 end

data/lib/cns/bitcoinde.rb

@@ -16,9 +16,7 @@ module Cns
     # @option pop [Hash] :h ({}) configuracao dias ajuste reposicionamento temporal
     # @option pop [Boolean] :v (false) mostra dados transacoes trades & ledger?
     # @option pop [Boolean] :t (false) mostra transacoes todas ou somente novas?
-    # @return [Bitcoinde] API bitcoinde - obter saldos & transacoes trades e ledger
     def initialize(dad, pop)
-      @api = Apice.new
       @bqd = dad
       @ops = pop.transform_keys(&:to_sym)
     end
@@ -153,6 +151,12 @@ module Cns
       hlx.map { |t| pdes(:time, t) }
     end
 
+    # Lazy Bitcoinde API Initialization
+    # @return [Bitcoinde] API - obter saldos & transacoes trades e ledger
+    def api
+      @api ||= Apice.new
+    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)}

data/lib/cns/etherscan.rb

@@ -53,9 +53,7 @@ module Cns
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
     # @option pop [Hash] :h ({}) configuracao dias ajuste reposicionamento temporal
     # @option pop [Boolean] :v (false) mostra dados transacoes
-    # @return [Etherscan] API etherscan - processar transacoes
     def initialize(dad, pop)
-      @api = Apibc.new
       @bqd = dad
       @ops = pop.transform_keys(&:to_sym)
     end
@@ -103,42 +101,45 @@ module Cns
       end
     end
 
+    # Format simple wallet summary
     # @param [Hash] hjn dados juntos bigquery & etherscan
     # @return [String] texto formatado duma carteira
     def focs(hjn)
       format(
-        '%<s1>-6.6s %<s2>-42.42s %<v1>13.6f %<v2>13.6f %<ok>-3s',
-        s1: hjn[:id],
-        s2: hjn[:ax],
-        v1: hjn[:es],
-        v2: hjn[:bs],
-        ok: ok?(hjn) ? 'OK' : 'NOK'
+        '%<id>-6.6s %<address>-42.42s %<etherscan_value>13.6f %<bigquery_value>13.6f %<status>-3s',
+        id: hjn[:id],
+        address: hjn[:ax],
+        etherscan_value: hjn[:es],
+        bigquery_value: hjn[:bs],
+        status: ok?(hjn) ? 'OK' : 'NOK'
       )
     end
 
+    # Format detailed wallet summary with counters
     # @param (see focs)
     # @return [String] texto formatado duma carteira (com contadores)
     def foct(hjn)
       format(
-        '%<s1>-6.6s %<s2>-10.10s %<v1>11.4f %<n1>3i %<n2>2i %<n3>2i %<n4>2i %<w1>4i %<v2>11.4f %<n5>3i %<n6>2i %<n7>2i %<n8>2i %<w2>4i %<ok>-3s',
-        s1: hjn[:id],
-        s2: foe1(hjn[:ax], 10),
-        v1: hjn[:es],
-        n1: hjn[:et].count,
-        n2: hjn[:ei].count,
-        n3: hjn[:ep].count,
-        n4: hjn[:ek].count,
-        w1: hjn[:ew].count,
-        v2: hjn[:bs],
-        n5: hjn[:bt].count,
-        n6: hjn[:bi].count,
-        n7: hjn[:bp].count,
-        n8: hjn[:bk].count,
-        w2: hjn[:bw].count,
+        '%<id>-6.6s %<ax>-10.10s %<es>11.4f %<et>3i %<ei>2i %<ep>2i %<ek>2i %<ew>4i %<bs>11.4f %<bt>3i %<bi>2i %<bp>2i %<bk>2i %<bw>4i %<ok>-3s',
+        id: hjn[:id],
+        ax: foe1(hjn[:ax], 10),
+        es: hjn[:es],
+        et: hjn[:et].count,
+        ei: hjn[:ei].count,
+        ep: hjn[:ep].count,
+        ek: hjn[:ek].count,
+        ew: hjn[:ew].count,
+        bs: hjn[:bs],
+        bt: hjn[:bt].count,
+        bi: hjn[:bi].count,
+        bp: hjn[:bp].count,
+        bk: hjn[:bk].count,
+        bw: hjn[:bw].count,
         ok: ok?(hjn) ? 'OK' : 'NOK'
       )
     end
 
+    # Check if wallet has new transactions
     # @param (see focs)
     # @return [Boolean] check saldo & contadores ipwtk
     def ok?(hjn)
@@ -187,50 +188,68 @@ module Cns
       "#{ndd[0, ini]}..#{ndd[-inf - ini..]}"
     end
 
-    # @param [Hash] htx transacao etherscan normal(t)/(i)nternal
+    # Format normal(t)/(i)nternal transaction
+    # @param [Hash] htx transacao etherscan
     # @return [String] texto formatado
     def foti(htx)
       format(
-        '%<hx>-29.29s %<fr>-15.15s %<to>-15.15s %<dt>10.10s %<vl>7.3f',
-        hx: foe1(htx[:hash], 29),
-        fr: foe2(htx[:from], 15),
+        '%<hash>-29.29s %<from>-15.15s %<to>-15.15s %<date>10.10s %<value>7.3f',
+        hash: foe1(htx[:hash], 29),
+        from: foe2(htx[:from], 15),
         to: foe2(htx[:to], 15),
-        dt: htx[:timeStamp].strftime('%F'),
-        vl: htx[:value] / (10**18)
+        date: htx[:timeStamp].strftime('%F'),
+        value: htx[:value] / (10**18)
       )
     end
 
-    # @param [Hash] hkx transacao etherscan to(k)en
+    # Format to(k)en transaction
+    # @param [Hash] hkx transacao etherscan
     # @return [String] texto formatado
     def fok(hkx)
       format(
-        '%<hx>-20.20s %<fr>-15.15s %<to>-15.15s %<dt>10.10s %<vl>10.3f %<sy>-5.5s',
-        hx: foe1(hkx[:hash], 20),
-        fr: foe2(hkx[:from], 15),
+        '%<hash>-20.20s %<from>-15.15s %<to>-15.15s %<date>10.10s %<value>10.3f %<symbol>-5.5s',
+        hash: foe1(hkx[:hash], 20),
+        from: foe2(hkx[:from], 15),
         to: foe2(hkx[:to], 15),
-        dt: hkx[:timeStamp].strftime('%F'),
-        vl: hkx[:value] / (10**18),
-        sy: hkx[:tokenSymbol]
+        date: hkx[:timeStamp].strftime('%F'),
+        value: hkx[:value] / (10**18),
+        symbol: hkx[:tokenSymbol]
       )
     end
 
-    # @param [Hash] hpx transacao etherscan (p)roduced blocks
+    # Format (p)roduced block transaction
+    # @param [Hash] hpx transacao etherscan
     # @return [String] texto formatado
     def fop(hpx)
-      format('%<bn>9i %<fr>-41.41s %<dt>10.10s %<vl>17.6f', bn: hpx[:blockNumber], fr: foe2(hpx[:iax], 41), dt: hpx[:timeStamp].strftime('%F'), vl: hpx[:blockReward] / (10**18))
+      format(
+        '%<block_number>9i %<address>-41.41s %<date>10.10s %<reward>17.6f',
+        block_number: hpx[:blockNumber],
+        address: foe2(hpx[:iax], 41),
+        date: hpx[:timeStamp].strftime('%F'),
+        reward: hpx[:blockReward] / (10**18)
+      )
     end
 
-    # @param [Hash] hwx transacao etherscan (w)ithdrawals
-    # @return [String] texto formatado transacao withdrawals etherscan
+    # Format (w)ithdrawal transaction
+    # @param [Hash] hwx transacao etherscan
+    # @return [String] texto formatado
     def fow(hwx)
-      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))
+      format(
+        '%<index>10i %<validator>9i %<date>10.10s %<amount>10.6f',
+        index: hwx[:withdrawalIndex],
+        validator: hwx[:validatorIndex],
+        date: hwx[:timeStamp].strftime('%F'),
+        amount: hwx[:amount] / (10**9)
+      )
     end
 
+    # Determine if all transactions should be shown
     # @return [Boolean] mostra todas/novas transacoes
     def show_all?
       ops[:t] || false
     end
 
+    # Process timestamp
     # @param [Hash] htx transacao
     # @return [Hash] transaccao filtrada
     def pess(htx)
@@ -240,27 +259,31 @@ module Cns
       htx.merge(srx: 0, timeStamp: Time.at(0))
     end
 
+    # Filter normal(t)/(i)nternal/to(k)en transactions
     # @param add (see foe1)
-    # @param [Array<Hash>] ary lista transacoes normal(t)/(i)nternal/to(k)en
+    # @param [Array<Hash>] ary lista transacoes
     # @return [Array<Hash>] lista transacoes filtrada
     def ftik(add, ary)
       ary.map { |o| pess(o).merge(itx: o[:hash].to_s, iax: add, value: o[:value].to_d) }
     end
 
+    # Filter (p)roduced blocks transactions
     # @param add (see foe1)
-    # @param [Array<Hash>] ary lista transacoes (p)roduced blocks
+    # @param [Array<Hash>] ary lista transacoes
     # @return [Array<Hash>] lista transacoes filtrada
     def fppp(add, ary)
       ary.map { |o| o.merge(itx: o[:blockNumber].to_i, iax: add, blockReward: o[:blockReward].to_d, timeStamp: Time.at(o[:timeStamp].to_i)) }
     end
 
+    # Filter (w)ithdrawals transactions
     # @param add (see foe1)
-    # @param [Array<Hash>] ary lista transacoes (w)ithdrawals
+    # @param [Array<Hash>] ary lista transacoes
     # @return [Array<Hash>] lista transacoes filtrada
     def fwww(add, ary)
       ary.map { |o| o.merge(itx: o[:withdrawalIndex].to_i, iax: add, amount: o[:amount].to_d, timeStamp: Time.at(o[:timestamp].to_i)) }
     end
 
+    # Fetch Etherscan data for an account
     # @param [Hash] aes account etherscan
     # @return [Hash] dados etherscan - address, saldo & transacoes
     def bses(aes)
@@ -276,6 +299,7 @@ module Cns
       }
     end
 
+    # Combine BigQuery and Etherscan data
     # @param [Hash] wbq wallet bigquery
     # @param [Hash] hes dados etherscan - address, saldo & transacoes
     # @return [Hash] dados juntos bigquery & etherscan
@@ -299,19 +323,27 @@ module Cns
       }
     end
 
+    # Lazy Etherscan API Initialization
+    # @return [Apibc] API instance
+    def api
+      @api ||= Apibc.new
+    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
+    # Fetch all Etherscan data
+    # @return [Hash] saldos & transacoes, indexed by address
     def esd
-      @esd ||= api.account_es(lax).map { |o| bses(o) }
+      @esd ||= api.account_es(lax).map { |o| bses(o) }.each_with_object({}) { |h, a| a[h[:ax]] = h }
     end
 
+    # Fetch combined data
     # @return [Array<Hash>] todos os dados juntos bigquery & etherscan
     def dados
-      @dados ||= bqd[:wb].map { |b| bqes(b, esd.find { |e| b[:ax] == e[:ax] }) }
+      @dados ||= bqd[:wb].map { |b| bqes(b, esd[b[:ax]]) }
     end
 
     # @return [Array<Integer>] indices transacoes bigquery
@@ -341,52 +373,57 @@ module Cns
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
     def idt
-      @idt ||= esd.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
+      @idt ||= esd.values.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
     end
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
     def idi
-      @idi ||= esd.map { |o| o[:ix].map { |i| i[:itx] } }.flatten - bqidi
+      @idi ||= esd.values.map { |o| o[:ix].map { |i| i[:itx] } }.flatten - bqidi
     end
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
     def idp
-      @idp ||= esd.map { |o| o[:px].map { |i| i[:itx] } }.flatten - bqidp
+      @idp ||= esd.values.map { |o| o[:px].map { |i| i[:itx] } }.flatten - bqidp
     end
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
     def idw
-      @idw ||= esd.map { |o| o[:wx].map { |i| i[:itx] } }.flatten - bqidw
+      @idw ||= esd.values.map { |o| o[:wx].map { |i| i[:itx] } }.flatten - bqidw
     end
 
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
     def idk
-      @idk ||= esd.map { |o| o[:kx].map { |i| i[:itx] } }.flatten - bqidk
+      @idk ||= esd.values.map { |o| o[:kx].map { |i| i[:itx] } }.flatten - bqidk
     end
 
-    # @return [Array<Hash>] lista transacoes normais novas
+    # Get new normal transactions
+    # @return [Array<Hash>] List of new transactions
     def novnetht
-      @novnetht ||= esd.map { |o| o[:tx].select { |t| idt.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      @novnetht ||= esd.values.map { |o| o[:tx].select { |t| idt.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
-    # @return [Array<Hash>] lista transacoes internas novas
+    # Get new internal transactions
+    # @return [Array<Hash>] List of new transactions
     def novnethi
-      @novnethi ||= esd.map { |o| o[:ix].select { |t| idi.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      @novnethi ||= esd.values.map { |o| o[:ix].select { |t| idi.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
-    # @return [Array<Hash>] lista transacoes block novas
+    # Get new produced block transactions
+    # @return [Array<Hash>] List of new transactions
     def novnethp
-      @novnethp ||= esd.map { |o| o[:px].select { |t| idp.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      @novnethp ||= esd.values.map { |o| o[:px].select { |t| idp.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
-    # @return [Array<Hash>] lista transacoes withdrawals novas
+    # Get new withdrawal transactions
+    # @return [Array<Hash>] List of new transactions
     def novnethw
-      @novnethw ||= esd.map { |o| o[:wx].select { |t| idw.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      @novnethw ||= esd.values.map { |o| o[:wx].select { |t| idw.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
 
-    # @return [Array<Hash>] lista transacoes token novas
+    # Get new token transactions
+    # @return [Array<Hash>] List of new transactions
     def novnethk
-      @novnethk ||= esd.map { |o| o[:kx].select { |t| idk.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      @novnethk ||= esd.values.map { |o| o[:kx].select { |t| idk.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
   end
 end

data/lib/cns/greymass.rb

@@ -11,32 +11,24 @@ module Cns
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
     attr_reader :api, :bqd, :ops
 
-    TT = {
-      new: :novneost,
-      format: :fol,
-      header: "\nsequence num from         to           accao      data              valor moeda",
-      sork: :itx,
-      adjk: :itx
-    }.freeze
+    TT = {sork: :itx, adjk: :itx}.freeze
 
     # @param [Hash] dad todos os dados bigquery
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
     # @option pop [Hash] :h ({}) configuracao dias ajuste reposicionamento temporal
     # @option pop [Boolean] :v (false) mostra dados transacoes?
     # @option pop [Boolean] :t (false) mostra transacoes todas ou somente novas?
-    # @return [Greymass] API greymass - processar transacoes
     def initialize(dad, pop)
-      @api = Apibc.new
       @bqd = dad
       @ops = pop.transform_keys(&:to_sym)
     end
 
-    # @return [String] texto carteiras & transacoes & ajuste dias
+    # Display summary of wallets, transactions, and adjustment days configuration
     def mresumo
       return unless dados.any?
 
       puts("\naddress            greymass  ntx       bigquery  ntx")
-      dados.each { |o| puts(foct(o)) }
+      dados.each { |e| puts(foct(e)) }
       mtransacoes_novas
       mconfiguracao_ajuste_dias
     end
@@ -45,61 +37,64 @@ module Cns
 
     # mosta transacoes novas
     def mtransacoes_novas
-      ntx = send(TT[:new])
-      return unless ops[:v] && ntx.any?
+      return unless ops[:v] && novneost.any?
 
-      puts(TT[:header])
-      ntx.sort_by { |s| -s[TT[:sork]] }.each { |t| puts(send(TT[:format], t)) }
+      puts("\nsequence num from         to           accao      data              valor moeda")
+      novneost.sort_by { |s| -s[TT[:sork]] }.each { |t| puts(fol(t)) }
     end
 
     # mostra configuration text for adjusting days
     def mconfiguracao_ajuste_dias
-      ntx = send(TT[:new])
-      return unless ntx.any?
+      return unless novneost.any?
 
-      puts("\nstring ajuste dias\n-h=#{ntx.sort_by { |s| -s[TT[:sork]] }.map { |t| "#{t[TT[:adjk]]}:0" }.join(' ')}")
+      puts("\nstring ajuste dias\n-h=#{novneost.sort_by { |s| -s[TT[:sork]] }.map { |t| "#{t[TT[:adjk]]}:0" }.join(' ')}")
     end
 
+    # Format wallet summary text
     # @param [Hash] hjn dados juntos bigquery & greymass
     # @return [String] texto formatado duma carteira
     def foct(hjn)
       format(
-        '%<s1>-12.12s %<v1>14.4f %<n1>4i %<v2>14.4f %<n2>4i %<ok>-3s',
-        s1: hjn[:ax],
-        v1: hjn[:es],
-        n1: hjn[:et].count,
-        v2: hjn[:bs],
-        n2: hjn[:bt].count,
-        ok: ok?(hjn) ? 'OK' : 'NOK'
+        '%<address>-12.12s %<greymass_value>14.4f %<greymass_tx_count>4i %<bigquery_value>14.4f %<bigquery_tx_count>4i %<status>-3s',
+        address: hjn[:ax],
+        greymass_value: hjn[:es],
+        greymass_tx_count: hjn[:et].count,
+        bigquery_value: hjn[:bs],
+        bigquery_tx_count: hjn[:bt].count,
+        status: ok?(hjn) ? 'OK' : 'NOK'
       )
     end
 
+    # Check if wallet has new transactions
     # @param (see foct)
     # @return [Boolean] carteira tem transacoes novas(sim=NOK, nao=OK)?
     def ok?(hjn)
       hjn[:bs].round(6) == hjn[:es].round(6) && hjn[:bt].count == hjn[:et].count
     end
 
+    # Format transaction text
     # @param [Hash] hlx ledger greymass
     # @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],
-        fr: hlx[:from],
-        vl: hlx[:quantity],
-        bn: hlx[:itx],
+        '%<sequence>12i %<from>-12.12s %<to>-12.12s %<action>-10.10s %<date>10.10s %<value>12.4f %<symbol>-6.6s',
+        sequence: hlx[:itx],
+        from: hlx[:from],
         to: hlx[:to],
-        dt: hlx[:block_time].strftime('%F'),
-        sy: hlx[:moe]
+        action: hlx[:name],
+        date: hlx[:block_time].strftime('%F'),
+        value: hlx[:quantity],
+        symbol: hlx[:moe]
       )
     end
 
+    # Determine if all transactions should be shown
     # @return [Boolean] mostra todas/novas transacoes
     def show_all?
       ops[:t] || false
     end
 
+    # Fetch EOS account resources
     # @param [String] add EOS account name
     # @return [Array<BigDecimal>] lista recursos - liquido, net, spu
     def peosa(add)
@@ -108,6 +103,7 @@ module Cns
       [hac[:core_liquid_balance]&.to_d || 0.to_d, htr[:net_weight]&.to_d || 0.to_d, htr[:cpu_weight]&.to_d || 0.to_d]
     end
 
+    # Process and filter EOS transactions
     # @param add (see peosa)
     # @param [Array<Hash>] ary lista transacoes
     # @return [Array<Hash>] lista transacoes filtrada
@@ -131,6 +127,7 @@ module Cns
       end
     end
 
+    # Fetch Greymass data for a wallet
     # @param [Hash] wbq wallet bigquery
     # @return [Hash] dados greymass - address, saldo & transacoes
     def bsgm(wbq)
@@ -138,6 +135,7 @@ module Cns
       {ax: xbq, sl: peosa(xbq).reduce(:+), tx: peost(xbq, api.ledger_gm(xbq))}
     end
 
+    # Combine BigQuery and Greymass data
     # @param wbq (see bsgm)
     # @param [Hash] hgm dados greymass - address, saldo & transacoes
     # @return [Hash] dados juntos bigquery & greymass
@@ -153,14 +151,22 @@ module Cns
       }
     end
 
-    # @return [Array<Hash>] todos os dados greymass - saldos & transacoes
+    # Lazy Greymass API Initialization
+    # @return [Apibc] API instance
+    def api
+      @api ||= Apibc.new
+    end
+
+    # Fetch all Greymass data
+    # @return [Hash] Hash of Greymass data indexed by address
     def gmd
-      @gmd ||= bqd[:wb].map { |o| bsgm(o) }
+      @gmd ||= bqd[:wb].map { |o| bsgm(o) }.each_with_object({}) { |h, a| a[h[:ax]] = h }
     end
 
-    # @return [Array<Hash>] todos os dados juntos bigquery & greymass
+    # Fetch combined BigQuery and Greymass data
+    # @return [Array<Hash>] Combined data list
     def dados
-      @dados ||= bqd[:wb].map { |b| bqgm(b, gmd.find { |g| b[:ax] == g[:ax] }) }
+      @dados ||= bqd[:wb].map { |b| bqgm(b, gmd[b[:ax]]) }
     end
 
     # @return [Array<Integer>] indices transacoes bigquery
@@ -170,12 +176,13 @@ module Cns
 
     # @return [Array<Integer>] indices transacoes novas (greymass - bigquery)
     def idt
-      @idt ||= gmd.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
+      @idt ||= gmd.values.map { |o| o[:tx].map { |i| i[:itx] } }.flatten - bqidt
     end
 
-    # @return [Array<Hash>] lista transacoes novas
+    # Get new transactions
+    # @return [Array<Hash>] List of new transactions
     def novneost
-      @novneost ||= gmd.map { |t| t[:tx].select { |o| idt.include?(o[:itx]) } }.flatten.uniq { |i| i[:itx] }
+      @novneost ||= gmd.values.map { |t| t[:tx].select { |o| idt.include?(o[:itx]) } }.flatten.uniq { |i| i[:itx] }
     end
   end
 end

data/lib/cns/kraken.rb

@@ -16,9 +16,7 @@ module Cns
     # @option pop [Hash] :h ({}) configuracao dias ajuste reposicionamento temporal
     # @option pop [Boolean] :v (false) mostra dados transacoes trades & ledger?
     # @option pop [Boolean] :t (false) mostra transacoes todas ou somente novas?
-    # @return [Kraken] API kraken - obter saldos & transacoes trades e ledger
     def initialize(dad, pop)
-      @api = Apice.new
       @bqd = dad
       @ops = pop.transform_keys(&:to_sym)
     end
@@ -136,6 +134,22 @@ module Cns
       hlx.map { |t| t.merge(asset: t[:asset].upcase, amount: t[:amount].to_d, fee: t[:fee].to_d) }
     end
 
+    # Lazy kraken API Initialization decorated with rate limiting logic
+    # @return [Kraken] API - obter saldos & transacoes trades e ledger
+    def api
+      @api ||=
+        begin
+          t = Apice.new
+          # Rate limiting to this specific instance (0.5s in Kraken)
+          t.define_singleton_method(:run_curl) do |curl, url, **options|
+            sleep(@lapi - Time.now + 0.5) if @lapi && Time.now - @lapi < 0.5
+            super(curl, url, **options)
+            @lapi = Time.now
+          end
+          t
+        end
+    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)}

data/lib/cns/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: cns
 version: !ruby/object:Gem::Version
-  version: 0.9.6
+  version: 0.9.8
 platform: ruby
 authors:
 - Hernâni Rodrigues Vaz
 bindir: exe
 cert_chain: []
-date: 2025-03-06 00:00:00.000000000 Z
+date: 2025-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -135,6 +135,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday-retry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: google-cloud-bigquery
   requirement: !ruby/object:Gem::Requirement