RubyGems - cns - Versions diffs - 2.0.2 → 2.0.4 - Mend

cns 2.0.2 → 2.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba101a6a6bbdbb1272e8cc61fe00f03b779b907066dd3c2ac6c29ee2543c8ec5
-  data.tar.gz: fdb6a8433f4e738851490b07baae241b524326f6917f07e260039ac19d6b5df6
+  metadata.gz: d694cb783e1251f3f407be238aab038991afc5fb59ff3aedd47c9e7b916b5c82
+  data.tar.gz: 5fcc7fd02541ab31d788d04a83cac269bddc05bdd18c63308159c88062434e59
 SHA512:
-  metadata.gz: 6070637e17f7176b2bb28be217c0a7b1ad1f88066a9fa8befe312a2f687237cfe503f744c14652d2654ad0dfd8b878358286b097a7fd3a966e87fdb37410029c
-  data.tar.gz: d5de5d4806a1cfd64f349f120532557d3c161f5ddfec78a8972062c181f644906b0f3c8d85287bd9d879d1b2ed4131fcb2d76fde225569a51ca803e3e176a544
+  metadata.gz: a1a7d81e1fa81a8b843a17473644f0762b0d144cf97f267ffdb63bf160a5c84fac4eb105e05d11516aaf7f5985a6b075280aa8115bfb40f0535f6fa8d619d1ae
+  data.tar.gz: d02c614fdcc3610173506b2646223e10bc3b1f74a86e0e08fc8a46f0f9befeed11dedb2b606f58b8b667398319e55f821d2d0f125ea2ebad687fa8c31422567c

data/.rubocop.yml CHANGED Viewed

@@ -56,6 +56,9 @@ Style/StringLiterals:
 Style/NumericLiterals:
   MinDigits: 5
+Style/ParallelAssignment:
+  Enabled: false
 # Linting
 Lint/UselessAssignment:
   Enabled: true

data/Gemfile.lock CHANGED Viewed

@@ -1,11 +1,12 @@
 PATH
   remote: .
   specs:
-    cns (2.0.2)
+    cns (2.0.4)
       curb
       faraday
       faraday-retry
       google-cloud-bigquery
+      memoist
       thor
 GEM
@@ -13,7 +14,7 @@ GEM
   specs:
     addressable (2.8.7)
       public_suffix (>= 2.0.2, < 7.0)
-    ast (2.4.2)
+    ast (2.4.3)
     backport (1.2.0)
     base64 (0.2.0)
     benchmark (0.4.0)
@@ -106,18 +107,19 @@ GEM
     language_server-protocol (3.17.0.4)
     lint_roller (1.1.0)
     logger (1.6.6)
+    memoist (0.16.2)
     mini_mime (1.1.5)
     multi_json (1.15.0)
     mutex_m (0.3.0)
     net-http (0.6.0)
       uri
-    nokogiri (1.18.4-x86_64-linux-gnu)
+    nokogiri (1.18.5-x86_64-linux-gnu)
       racc (~> 1.4)
     observer (0.1.2)
     os (1.1.4)
     ostruct (0.6.1)
     parallel (1.26.3)
-    parser (3.3.7.1)
+    parser (3.3.7.2)
       ast (~> 2.4.1)
       racc
     public_suffix (6.0.1)
@@ -152,8 +154,8 @@ GEM
       rubocop-ast (>= 1.38.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 4.0)
-    rubocop-ast (1.39.0)
-      parser (>= 3.3.1.0)
+    rubocop-ast (1.41.0)
+      parser (>= 3.3.7.2)
     rubocop-rake (0.7.1)
       lint_roller (~> 1.1)
       rubocop (>= 1.72.1)

data/cns.gemspec CHANGED Viewed

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

data/lib/cns/apibc.rb CHANGED Viewed

@@ -12,82 +12,86 @@ module Cns
     GMPS = 100    # Greymass maximum actions per request
     def initialize
-      @escn = connection('https://api.etherscan.io')
-      @gmcn = connection('https://eos.greymass.com')
+      @escn = bccn('https://api.etherscan.io')
+      @gmcn = bccn('https://eos.greymass.com')
       @esky = ENV.fetch('ETHERSCAN_API_KEY', nil)
     end
     # Get account balances for multiple ETH addresses
-    # @param [Array<String>] addresses List of ETH addresses (max 20)
+    # @param [Array<String>] ads List of ETH addresses (max 20)
     # @return [Array<Hash>] List of addresses with balances
-    def account_es(addresses)
-      return [] if addresses.nil? || addresses.empty?
+    def account_es(ads)
+      return [] if ads.nil? || ads.empty?
       # Batch addresses into groups of 20 (Etherscan limit) and fetch balances
-      addresses.each_slice(20).flat_map do |b|
+      ads.each_slice(20).flat_map do |b|
         res = es_req('balancemulti', b.join(','), 1, tag: 'latest')
-        res[:status] == '1' ? res[:result] || [] : []
+        res[:status] == '1' ? Array(res[:result]) : []
       end
+    rescue StandardError
+      []
     end
     # Get normal transactions for ETH address
-    # @param [String] address endereco ETH
+    # @param [String] add endereco ETH
     # @return [Array<Hash>] lista transacoes normais etherscan
-    def norml_es(address)
-      pag_es_req('txlist', address)
+    def norml_es(add)
+      pag_es_req('txlist', add)
     end
     # Get internal transactions for ETH address
     # @param (see norml_es)
     # @return [Array<Hash>] lista transacoes internas etherscan
-    def inter_es(address)
-      pag_es_req('txlistinternal', address)
+    def inter_es(add)
+      pag_es_req('txlistinternal', add)
     end
     # Get mined blocks for ETH address
     # @param (see norml_es)
     # @return [Array<Hash>] lista blocos etherscan
-    def block_es(address)
-      pag_es_req('getminedblocks', address, blocktype: 'blocks')
+    def block_es(add)
+      pag_es_req('getminedblocks', add, blocktype: 'blocks')
     end
     # Get withdrawals for ETH address
     # @param (see norml_es)
     # @return [Array<Hash>] lista blocos etherscan
-    def withw_es(address)
-      pag_es_req('txsBeaconWithdrawal', address)
+    def withw_es(add)
+      pag_es_req('txsBeaconWithdrawal', add)
     end
     # Get token transfers for ETH address
     # @param (see norml_es)
     # @return [Array<Hash>] lista token transfer events etherscan
-    def token_es(address)
-      pag_es_req('tokentx', address)
+    def token_es(add)
+      pag_es_req('tokentx', add)
     end
     # Get EOS account information
-    # @param [String] address EOS account name
+    # @param [String] add EOS account name
     # @return [Hash] Account details with resources
-    def account_gm(address)
-      res = gm_req('/v1/chain/get_account', account_name: address)
+    def account_gm(add)
+      res = gm_req('/v1/chain/get_account', account_name: add)
       res[:core_liquid_balance]&.to_d&.positive? ? res : gm_erro
     end
     # Get complete transaction history for EOS account
     # @param (see account_gm)
     # @return [Array<Hash>] lista completa transacoes greymass
-    def ledger_gm(address)
+    def ledger_gm(add)
       trx = []
       pos = 0
       loop do
-        res = gm_req('/v1/history/get_actions', account_name: address, pos: pos, offset: GMPS)
-        bth = res[:actions] || []
+        res = gm_req('/v1/history/get_actions', account_name: add, pos: pos, offset: GMPS)
+        bth = Array(res[:actions])
         trx.concat(bth)
         break if bth.size < GMPS
         pos += GMPS
       end
       trx
+    rescue StandardError
+      trx
     end
     private
@@ -99,7 +103,7 @@ module Cns
     # @param [Hash] prm Additional request parameters
     # @return [Hash] Parsed API response
     def es_req(act, add, pag = 1, prm = {})
-      parse_json(@escn.get('/api', prm.merge(module: 'account', action: act, address: add, page: pag, apikey: @esky)))
+      pjsn(@escn.get('/api', prm.merge(module: 'account', action: act, address: add, page: pag, apikey: @esky)))
     rescue Faraday::Error
       {status: '0'}
     end
@@ -117,13 +121,15 @@ module Cns
         res = es_req(act, add, pag, prm)
         break unless res[:status] == '1'
-        bth = res[:result] || []
+        bth = Array(res[:result])
         trx.concat(bth)
         break if bth.size < ESPS
         pag += 1
       end
       trx
+    rescue StandardError
+      trx
     end
     # Make a request to the Greymass API
@@ -131,7 +137,7 @@ module Cns
     # @param [Hash] pyl Request payload
     # @return [Hash] Parsed API response
     def gm_req(url, pyl)
-      parse_json(@gmcn.post(url) { |r| r.body = pyl })
+      pjsn(@gmcn.post(url) { |r| r.body = pyl })
     rescue Faraday::Error
       gm_erro
     end
@@ -145,7 +151,7 @@ module Cns
     # Safely parse JSON response
     # @param [Faraday::Response] res API response
     # @return [Hash] Parsed JSON or empty hash on error
-    def parse_json(res)
+    def pjsn(res)
       return {} if res.nil? || res.body.to_s.empty?
       JSON.parse(res.body, symbolize_names: true) || {}
@@ -156,7 +162,7 @@ module Cns
     # 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)
+    def bccn(url)
       Faraday.new(url) do |c|
         c.request(:json)
         c.headers = {accept: 'application/json', user_agent: 'blockchain-api-client'}

data/lib/cns/apice.rb CHANGED Viewed

@@ -12,11 +12,13 @@ module Cns
     API = {de: 'https://api.bitcoin.de/v4', us: 'https://api.kraken.com/0/private'}.freeze
     def initialize
-      @curl = Curl::Easy.new
-      @curl.timeout = 30
-      @curl.connect_timeout = 10
-      @curl.follow_location = true
-      @curl.ssl_verify_peer = true
+      @curl =
+        Curl::Easy.new.tap do |c|
+          c.timeout = 30
+          c.connect_timeout = 10
+          c.follow_location = true
+          c.ssl_verify_peer = true
+        end
       @deky = ENV.fetch('BITCOINDE_API_KEY', nil)
       @desc = ENV.fetch('BITCOINDE_API_SECRET', nil)
       @usky = ENV.fetch('KRAKEN_API_KEY', nil)
@@ -27,8 +29,8 @@ module Cns
     # @return [Hash] saldos no bitcoinde
     def account_de
       uri = "#{API[:de]}/account"
-      run_curl(@curl, uri, headers: hde(uri))
-      parse_json(@curl).dig(:data, :balances) || {}
+      rcrl(@curl, uri, headers: hde(uri))
+      pjsn(@curl).dig(:data, :balances) || {}
     rescue Curl::Err::CurlError
       {}
     end
@@ -62,8 +64,8 @@ module Cns
     def account_us
       uri = 'Balance'
       ops = {nonce: nnc}
-      run_curl(@curl, "#{API[:us]}/#{uri}", method: 'POST', post_data: ops, headers: hus(uri, ops))
-      parse_json(@curl).fetch(:result, {})
+      rcrl(@curl, "#{API[:us]}/#{uri}", method: 'POST', post_data: ops, headers: hus(uri, ops))
+      pjsn(@curl).fetch(:result, {})
     rescue Curl::Err::CurlError
       {}
     end
@@ -109,8 +111,8 @@ module Cns
         # 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) }
+        rcrl(@curl, "#{API[:us]}/#{uri}", method: 'POST', post_data: ops, headers: hus(uri, ops))
+        bth = pjsn(@curl).fetch(:result, {}).fetch(key, []).map { |k, v| us_unif(k, v) }
         break if bth.empty?
         ary.concat(bth)
@@ -131,11 +133,11 @@ module Cns
       pag = 1
       loop do
         url = "#{uri}?#{URI.encode_www_form(prm.merge(page: pag))}"
-        run_curl(@curl, url, headers: hde(url))
-        res = parse_json(@curl)
+        rcrl(@curl, url, headers: hde(url))
+        res = pjsn(@curl)
         bth = res.fetch(key, [])
         ary.concat(block_given? ? yield(bth) : bth)
-        break if res[:page]&.[](:current)&.>= res[:page]&.[](:last)
+        break if res[:page]&.fetch(:current, 0)&.>= res[:page]&.fetch(:last, 0)
         pag += 1
       end
@@ -148,7 +150,7 @@ module Cns
     # @param [String] method HTTP method (GET or POST)
     # @param [Hash] post_data Data to send in POST requests
     # @param [Hash] headers HTTP headers for the request
-    def run_curl(curl, url, method: 'GET', post_data: nil, headers: {})
+    def rcrl(curl, url, method: 'GET', post_data: nil, headers: {})
       curl.reset
       curl.url = url
       curl.http(method)
@@ -160,8 +162,10 @@ module Cns
     # Safe JSON parsing with error handling
     # @param [Curl::Easy] res Curl response object
     # @return [Hash] Parsed JSON or empty hash on error
-    def parse_json(res)
-      JSON.parse(res.body_str, symbolize_names: true)
+    def pjsn(res)
+      return {} if res.nil? || res.body_str.to_s.empty?
+      JSON.parse(res.body_str, symbolize_names: true) || {}
     rescue JSON::ParserError
       {}
     end

data/lib/cns/bigquery.rb CHANGED Viewed

@@ -2,11 +2,13 @@
 require('google/cloud/bigquery')
 require('bigdecimal/util')
+require('memoist')
 # @author Hernani Rodrigues Vaz
 module Cns
   # classe para processar bigquery
   class Bigquery
+    extend Memoist
     BD = 'hernanirvaz.coins'
     FO = File.expand_path("~/#{File.basename($PROGRAM_NAME)}.log")
     TB = {
@@ -35,16 +37,16 @@ module Cns
     TL = {
       ins: 'INSERT',
       exo: false,
-      est: '', # ' limit 226',
-      esi: '', # ' limit 22',
-      esp: '', # ' limit 72',
-      esw: '', # ' limit 2320',
-      esk: '', # ' limit 20',
-      gmt: '', # ' limit 1091',
-      ust: '', # ' limit 182',
-      usl: '', # ' limit 448',
-      det: '', # ' limit 27',
-      del: '' # ' limit 16'
+      est: '', # limit 228',
+      esi: '', # limit 22',
+      esp: '', # limit 72',
+      esw: '', # limit 2350',
+      esk: '', # limit 20',
+      gmt: '', # limit 1091',
+      ust: '', # limit 182',
+      usl: '', # limit 448',
+      det: '', # limit 27',
+      del: '' # limit 16'
     }.freeze
     # @return [Google::Cloud::Bigquery] API bigquery
@@ -67,16 +69,12 @@ module Cns
     # mostra situacao completa entre kraken/bitcoinde/paymium/therock/etherscan/greymass & bigquery
     def mtudo
-      apius.mresumo
-      apide.mresumo
-      apies.mresumo
-      apigm.mresumo
+      [apius, apide, apies, apigm].each(&:mresumo)
     end
     # mostra situacao completa entre kraken/etherscan & bigquery
     def mskrk
-      apius.mresumo
-      apies.mresumo
+      [apius, apies].each(&:mresumo)
     end
     # mostra situacao completa entre etherscan & bigquery
@@ -91,34 +89,30 @@ module Cns
     # insere dados novos kraken/bitcoinde/etherscan/greymass no bigquery
     def ptudo
-      puts("#{tct} #{pus}, #{pde}, #{peth}, #{peos}")
+      puts("#{tct} #{pus}, #{pde}, #{peth(apies)}, #{peos}")
     end
     # insere dados novos kraken/etherscan no bigquery
     def pwkrk
-      puts("#{tct} #{pus}, #{peth}")
+      puts("#{tct} #{pus}, #{peth(apies)}")
     end
     # insere dados novos etherscan no bigquery
     def pweth
-      puts("#{tct} #{peth}")
+      puts("#{tct} #{peth(apies)}")
     end
     # insere dados novos etherscan no bigquery (output to file)
     def pceth
-      File.open(FO, mode: 'a') { |o| o.puts("#{tct} #{pethc}") }
+      File.open(FO, mode: 'a') { |o| o.puts("#{tct} #{peth(apiec)}") }
     end
     private
+    # @param [Etherscan] API blockchain ETH
     # @return [String] linhas & tabelas afetadas
-    def peth
-      dmo(apies, %w[ETH], %i[netht nethi nethp nethw nethk])
-    end
-    # @return [String] linhas & tabelas afetadas
-    def pethc
-      dmo(apiesc, %w[ETH], %i[netht nethi nethp nethw nethk])
+    def peth(api)
+      dmo(api, %w[ETH], %i[netht nethi nethp nethw nethk])
     end
     # @return [String] linhas & tabelas afetadas
@@ -137,7 +131,7 @@ module Cns
     end
     # @return [Etherscan] API blockchain ETH
-    def apiesg(prx)
+    def apieg(prx)
       Etherscan.new(
         {
           wb: sql("SELECT * FROM #{BD}.wet#{prx[-1]} ORDER BY ax"),
@@ -152,28 +146,28 @@ module Cns
     end
     # @return [Etherscan] API blockchain ETH
-    def apies
-      @apies ||= apiesg('netb')
+    memoize def apies
+      apieg('netb')
     end
     # @return [Etherscan] API blockchain ETH (cron)
-    def apiesc
-      @apiesc ||= apiesg('netc')
+    memoize def apiec
+      apieg('netc')
     end
     # @return [Greymass] API blockchain EOS
-    def apigm
-      @apigm ||= Greymass.new({wb: sql("select * from #{BD}.weos ORDER BY ax"), nt: sql("select * from #{BD}.neosx#{TL[:gmt]}")}, ops)
+    memoize def apigm
+      Greymass.new({wb: sql("SELECT * FROM #{BD}.weos ORDER BY ax"), nt: sql("SELECT * FROM #{BD}.neosx#{TL[:gmt]}")}, ops)
     end
     # @return [Kraken] API exchange kraken
-    def apius
-      @apius ||= Kraken.new({sl: sql("select * from #{BD}.cuss").first, nt: sql("select * from #{BD}.cust#{TL[:ust]}"), nl: sql("select * from #{BD}.cusl#{TL[:usl]}")}, ops)
+    memoize def apius
+      Kraken.new({sl: sql("SELECT * FROM #{BD}.cuss").first, nt: sql("SELECT * FROM #{BD}.cust#{TL[:ust]}"), nl: sql("SELECT * FROM #{BD}.cusl#{TL[:usl]}")}, ops)
     end
     # @return [Bitcoinde] API exchange bitcoinde
-    def apide
-      @apide ||= Bitcoinde.new({sl: sql("select * from #{BD}.cdes").first, nt: sql("select * from #{BD}.cdet#{TL[:det]}"), nl: sql("select * from #{BD}.cdel#{TL[:del]}")}, ops)
+    memoize def apide
+      Bitcoinde.new({sl: sql("SELECT * FROM #{BD}.cdes").first, nt: sql("SELECT * FROM #{BD}.cdet#{TL[:det]}"), nl: sql("SELECT * FROM #{BD}.cdel#{TL[:del]}")}, ops)
     end
     # cria job bigquery & verifica execucao
@@ -211,7 +205,7 @@ module Cns
     def dmo(api, ini, ltb)
       ini.concat(
         ltb.filter_map do |i|
-          n = api.send("nov#{i}")
+          n = api.send("novx#{i[-1]}")
           next if n.empty?
           format(' %<n>i %<t>s', n: dml(ins_sql(i, n)), t: "#{i}")

data/lib/cns/bitcoinde.rb CHANGED Viewed

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 require('bigdecimal/util')
+require('memoist')
 # @author Hernani Rodrigues Vaz
 module Cns
   # classe para processar transacoes trades/ledger do bitcoinde
   class Bitcoinde
-    # @return [Apius] API bitcoinde
+    extend Memoist
     # @return [Array<Hash>] todos os dados bigquery
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
-    attr_reader :api, :bqd, :ops
+    attr_reader :bqd, :ops
     # @param [Hash] dad todos os dados bigquery
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
@@ -24,24 +25,22 @@ module Cns
     # @return [String] texto saldos & transacoes & ajuste dias
     def mresumo
       puts("\nBITCOINDE\ntipo              bitcoinde              bigquery")
-      ded[:sl].sort.each { |k, v| puts(fos(k, v)) }
+      exd[:sl].sort.each { |k, v| puts(fos(k, v)) }
       mtotais
       mtrades
       mledger
-      return if novcdet.empty?
+      return if novxt.empty?
-      puts("\nstring ajuste dias dos trades\n-h=#{novcdet.sort_by { |i| -i[:srx] }.map { |o| "#{o[:trade_id]}:0" }.join(' ')}")
+      puts("\nstring ajuste dias dos trades\n-h=#{novxt.sort_by { |i| -i[:srx] }.map { |o| "#{o[:trade_id]}:0" }.join(' ')}")
     end
     private
     # mosta contadores transacoes
     def mtotais
-      vtt = ded[:tt].count
-      vnt = bqd[:nt].count
-      vtl = ded[:tl].count
-      vnl = 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')}")
@@ -49,18 +48,18 @@ module Cns
     # mosta transacoes trades
     def mtrades
-      return unless ops[:v] && novcdet.any?
+      return unless ops[:v] && novxt.any?
       puts("\ntrades data       hora     dt criacao tipo  par                     btc      eur")
-      novcdet.sort_by { |i| -i[:srx] }.each { |o| puts(fot(o)) }
+      novxt.sort_by { |i| -i[:srx] }.each { |o| puts(fot(o)) }
     end
     # mosta transacoes ledger
     def mledger
-      return unless ops[:v] && novcdel.any?
+      return unless ops[:v] && novxl.any?
       puts("\nledger data       hora     tipo       moe          quantidade              custo")
-      novcdel.sort_by { |i| -i[:srx] }.each { |o| puts(fol(o)) }
+      novxl.sort_by { |i| -i[:srx] }.each { |o| puts(fol(o)) }
     end
     # @param [String] moe codigo bitcoinde da moeda
@@ -153,43 +152,43 @@ module Cns
     # Lazy Bitcoinde API Initialization
     # @return [Bitcoinde] API - obter saldos & transacoes trades e ledger
-    def api
-      @api ||= Apice.new
+    memoize def 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)}
+    memoize def exd
+      {sl: pdea(api.account_de), tt: pdet(api.trades_de), tl: pdel(api.deposits_de + api.withdrawals_de)}
     end
     # @return [Array<String>] indices trades bigquery
-    def bqkyt
-      @bqkyt ||= show_all? ? [] : bqd[:nt].map { |t| t[:txid] }
+    memoize def bqkyt
+      show_all? ? [] : bqd[:nt].map { |t| t[:txid] }
     end
     # @return [Array<Integer>] indices ledger bigquery
-    def bqkyl
-      @bqkyl ||= show_all? ? [] : bqd[:nl].map { |l| l[:txid] }
+    memoize def bqkyl
+      show_all? ? [] : bqd[:nl].map { |l| l[:txid] }
     end
     # @return [Array<String>] lista txid trades novos
-    def kyt
-      @kyt ||= ded[: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
-    def kyl
-      @kyl ||= ded[:tl].map { |t| t[:nxid] } - bqkyl
+    memoize def exkyl
+      exd[:tl].map { |t| t[:nxid] } - bqkyl
     end
     # @return [Array<Hash>] lista trades novos bitcoinde
-    def novcdet
-      @novcdet ||= ded[:tt].select { |o| kyt.include?(o[:trade_id]) }
+    memoize def novxt
+      exd[:tt].select { |o| exkyt.include?(o[:trade_id]) }
     end
     # @return [Array<Hash>] lista ledgers (deposits + withdrawals) novos bitcoinde
-    def novcdel
-      @novcdel ||= ded[:tl].select { |o| kyl.include?(o[:nxid]) }
+    memoize def novxl
+      exd[:tl].select { |o| exkyl.include?(o[:nxid]) }
     end
   end
 end

data/lib/cns/etherscan.rb CHANGED Viewed

@@ -1,47 +1,48 @@
 # frozen_string_literal: true
 require('bigdecimal/util')
+require('memoist')
 # @author Hernani Rodrigues Vaz
 module Cns
   # classe para processar transacoes do etherscan
   class Etherscan
-    # @return [Apibc] API blockchains
+    extend Memoist
     # @return [Array<Hash>] todos os dados bigquery
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
-    attr_reader :api, :bqd, :ops
+    attr_reader :bqd, :ops
     TT = {
       normal: {
-        new: :novnetht,
+        new: :novxt,
         format: :foti,
         header: "\ntx normal                     from            to              data         valor",
         sork: :srx,
         adjk: :hash
       }.freeze,
       internal: {
-        new: :novnethi,
+        new: :novxi,
         format: :foti,
         header: "\ntx intern                     from            to              data         valor",
         sork: :srx,
         adjk: :hash
       }.freeze,
       block: {
-        new: :novnethp,
+        new: :novxp,
         format: :fop,
         header: "\ntx block  address                                   data                   valor",
         sork: :itx,
         adjk: :blockNumber
       }.freeze,
       token: {
-        new: :novnethk,
+        new: :novxk,
         format: :fok,
         header: "\ntx token             from            to              data            valor moeda",
         sork: :srx,
         adjk: :hash
       }.freeze,
       withdrawal: {
-        new: :novnethw,
+        new: :novxw,
         format: :fow,
         header: "\nwithdrawal validator data            valor",
         sork: :itx,
@@ -60,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
@@ -82,9 +83,8 @@ module Cns
     # mosta transacoes novas
     def mtransacoes_novas
-      TT.each do |_, c|
-        ntx = send(c[:new])
-        next unless ops[:v] && ntx.any?
+      TT.each_value do |c|
+        next unless ops[:v] && (ntx = send(c[:new])).any?
         puts(c[:header])
         ntx.sort_by { |s| -s[c[:sork]] }.each { |t| puts(send(c[:format], t)) }
@@ -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],
@@ -325,105 +325,105 @@ module Cns
     # Lazy Etherscan API Initialization
     # @return [Apibc] API instance
-    def api
-      @api ||= Apibc.new
+    memoize def api
+      Apibc.new
     end
     # @return [Array<String>] lista enderecos
-    def lax
-      @lax ||= bqd[:wb].map { |o| o[:ax] }
+    memoize def lax
+      bqd[:wb].map { |o| o[:ax] }
     end
     # Fetch all Etherscan data
     # @return [Hash] saldos & transacoes, indexed by address
-    def esd
-      @esd ||= api.account_es(lax).map { |o| bses(o) }.each_with_object({}) { |h, a| a[h[:ax]] = h }
+    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
-    def dados
-      @dados ||= bqd[:wb].map { |b| bqes(b, esd[b[:ax]]) }
+    memoize def bqexd
+      bqd[:wb].map { |b| bqesd(b, exd[b[:ax]]) }
     end
     # @return [Array<Integer>] indices transacoes bigquery
-    def bqidt
-      @bqidt ||= show_all? ? [] : bqd[:nt].map { |i| i[:itx] }
+    memoize def bqkyt
+      show_all? ? [] : bqd[:nt].map { |i| i[:itx] }
     end
     # @return [Array<Integer>] indices transacoes bigquery
-    def bqidi
-      @bqidi ||= show_all? ? [] : bqd[:ni].map { |i| i[:itx] }
+    memoize def bqkyi
+      show_all? ? [] : bqd[:ni].map { |i| i[:itx] }
     end
     # @return [Array<Integer>] indices transacoes bigquery
-    def bqidp
-      @bqidp ||= show_all? ? [] : bqd[:np].map { |i| i[:itx] }
+    memoize def bqkyp
+      show_all? ? [] : bqd[:np].map { |i| i[:itx] }
     end
     # @return [Array<Integer>] indices transacoes bigquery
-    def bqidw
-      @bqidw ||= show_all? ? [] : bqd[:nw].map { |i| i[:itx] }
+    memoize def bqkyw
+      show_all? ? [] : bqd[:nw].map { |i| i[:itx] }
     end
     # @return [Array<Integer>] indices transacoes bigquery
-    def bqidk
-      @bqidk ||= show_all? ? [] : bqd[:nk].map { |i| i[:itx] }
+    memoize def bqkyk
+      show_all? ? [] : bqd[:nk].map { |i| i[:itx] }
     end
     # @return [Array<Integer>] indices transacoes novas (etherscan - bigquery)
-    def idt
-      @idt ||= esd.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)
-    def idi
-      @idi ||= esd.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)
-    def idp
-      @idp ||= esd.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)
-    def idw
-      @idw ||= esd.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)
-    def idk
-      @idk ||= esd.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
-    def novnetht
-      @novnetht ||= esd.values.map { |o| o[:tx].select { |t| idt.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+    memoize def novxt
+      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
-    def novnethi
-      @novnethi ||= esd.values.map { |o| o[:ix].select { |t| idi.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+    memoize def novxi
+      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
-    def novnethp
-      @novnethp ||= esd.values.map { |o| o[:px].select { |t| idp.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+    memoize def novxp
+      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
-    def novnethw
-      @novnethw ||= esd.values.map { |o| o[:wx].select { |t| idw.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+    memoize def novxw
+      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
-    def novnethk
-      @novnethk ||= esd.values.map { |o| o[:kx].select { |t| idk.include?(t[:itx]) } }.flatten.uniq { |i| i[:itx] }
+    memoize def novxk
+      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 CHANGED Viewed

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 require('bigdecimal/util')
+require('memoist')
 # @author Hernani Rodrigues Vaz
 module Cns
   # classe para processar transacoes do greymass
   class Greymass
-    # @return [Apibc] API blockchains
+    extend Memoist
     # @return [Array<Hash>] todos os dados bigquery
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
-    attr_reader :api, :bqd, :ops
+    attr_reader :bqd, :ops
     TT = {sork: :itx, adjk: :itx}.freeze
@@ -25,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
@@ -37,17 +38,17 @@ module Cns
     # mosta transacoes novas
     def mtransacoes_novas
-      return unless ops[:v] && novneost.any?
+      return unless ops[:v] && novxt.any?
       puts("\nsequence num from         to           accao      data              valor moeda")
-      novneost.sort_by { |s| -s[TT[:sork]] }.each { |t| puts(fol(t)) }
+      novxt.sort_by { |s| -s[TT[:sork]] }.each { |t| puts(fol(t)) }
     end
     # mostra configuration text for adjusting days
     def mconfiguracao_ajuste_dias
-      return unless novneost.any?
+      return unless novxt.any?
-      puts("\nstring ajuste dias\n-h=#{novneost.sort_by { |s| -s[TT[:sork]] }.map { |t| "#{t[TT[:adjk]]}:0" }.join(' ')}")
+      puts("\nstring ajuste dias\n-h=#{novxt.sort_by { |s| -s[TT[:sork]] }.map { |t| "#{t[TT[:adjk]]}:0" }.join(' ')}")
     end
     # Format wallet summary text
@@ -130,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],
@@ -153,36 +154,36 @@ module Cns
     # Lazy Greymass API Initialization
     # @return [Apibc] API instance
-    def api
-      @api ||= Apibc.new
+    memoize def 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) }.each_with_object({}) { |h, a| a[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
-    def dados
-      @dados ||= bqd[:wb].map { |b| bqgm(b, gmd[b[:ax]]) }
+    memoize def bqexd
+      bqd[:wb].map { |b| bqgmd(b, exd[b[:ax]]) }
     end
     # @return [Array<Integer>] indices transacoes bigquery
-    def bqidt
-      @bqidt ||= show_all? ? [] : bqd[:nt].map { |i| i[:itx] }
+    memoize def bqkyt
+      show_all? ? [] : bqd[:nt].map { |i| i[:itx] }
     end
     # @return [Array<Integer>] indices transacoes novas (greymass - bigquery)
-    def idt
-      @idt ||= gmd.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
-    def novneost
-      @novneost ||= gmd.values.map { |t| t[:tx].select { |o| idt.include?(o[:itx]) } }.flatten.uniq { |i| i[:itx] }
+    memoize def novxt
+      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 CHANGED Viewed

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 require('bigdecimal/util')
+require('memoist')
 # @author Hernani Rodrigues Vaz
 module Cns
   # classe para processar transacoes trades/ledger do kraken
   class Kraken
-    # @return [Apius] API kraken
+    extend Memoist
     # @return [Array<Hash>] todos os dados bigquery
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
-    attr_reader :api, :bqd, :ops
+    attr_reader :bqd, :ops
     # @param [Hash] dad todos os dados bigquery
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
@@ -24,29 +25,27 @@ module Cns
     # mosta resumo saldos & transacoes & ajuste dias
     def mresumo
       puts("\nKRAKEN\ntipo                 kraken              bigquery")
-      usd[:sl].sort.each { |key, val| puts(fos(key, val)) }
+      exd[:sl].sort.each { |key, val| puts(fos(key, val)) }
       mtotais
       mtrades
       mledger
-      return if novcust.empty?
+      return if novxt.empty?
-      puts("\nstring ajuste dias dos trades\n-h=#{novcust.sort_by { |i| -i[:srx] }.map { |o| "#{o[:txid]}:0" }.join(' ')}")
+      puts("\nstring ajuste dias dos trades\n-h=#{novxt.sort_by { |i| -i[:srx] }.map { |o| "#{o[:txid]}:0" }.join(' ')}")
     end
     # @return [Hash] ledgers exchange kraken
     def uskl
-      usd[:kl]
+      exd[:kl]
     end
     private
     # mosta contadores transacoes
     def mtotais
-      vkt = usd[:kt].count
-      vnt = bqd[:nt].count
-      vkl = usd[:kl].count
-      vnl = 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')}")
@@ -54,18 +53,18 @@ module Cns
     # mosta transacoes trades
     def mtrades
-      return unless ops[:v] && novcust.any?
+      return unless ops[:v] && novxt.any?
       puts("\ntrade  data       hora     tipo       par         preco     volume         custo")
-      novcust.sort_by { |i| -i[:srx] }.each { |o| puts(fot(o)) }
+      novxt.sort_by { |i| -i[:srx] }.each { |o| puts(fot(o)) }
     end
     # mosta transacoes ledger
     def mledger
-      return unless ops[:v] && novcusl.any?
+      return unless ops[:v] && novxl.any?
       puts("\nledger data       hora     tipo       moeda        quantidade              custo")
-      novcusl.sort_by { |i| -i[:srx] }.each { |o| puts(fol(o)) }
+      novxl.sort_by { |i| -i[:srx] }.each { |o| puts(fol(o)) }
     end
     # @param [String] moe codigo kraken da moeda
@@ -136,53 +135,50 @@ module Cns
     # 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
+    memoize def api
+      Apice.new.tap do |t|
+        # Rate limiting to this specific instance (0.5s in Kraken)
+        t.define_singleton_method(:rcrl) do |c, u, **o|
+          sleep(@lapi - Time.now + 0.5) if @lapi && Time.now - @lapi < 0.5
+          super(c, u, **o)
+          @lapi = Time.now
         end
+      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)}
+    memoize def exd
+      {sl: pusa(api.account_us), kt: pust(api.trades_us), kl: pusl(api.ledger_us)}
     end
     # @return [Array<String>] indices trades bigquery
-    def bqkyt
-      @bqkyt ||= show_all? ? [] : bqd[:nt].map { |t| t[:txid] }
+    memoize def bqkyt
+      show_all? ? [] : bqd[:nt].map { |t| t[:txid] }
     end
-    # @return [Array<String>] indices ledger bigquery
-    def bqkyl
-      @bqkyl ||= show_all? ? [] : bqd[:nl].map { |l| l[:txid] }
+    # @return [Array<Integer>] indices ledger bigquery
+    memoize def bqkyl
+      show_all? ? [] : bqd[:nl].map { |l| l[:txid] }
     end
     # @return [Array<String>] lista txid trades novos
-    def kyt
-      @kyt ||= usd[:kt].map { |t| t[:txid] } - bqkyt
+    memoize def exkyt
+      exd[:kt].map { |t| t[:txid] } - bqkyt
     end
     # @return [Array<String>] lista txid ledger novos
-    def kyl
-      @kyl ||= usd[:kl].map { |t| t[:txid] } - bqkyl
+    memoize def exkyl
+      exd[:kl].map { |t| t[:txid] } - bqkyl
     end
     # @return [Array<Hash>] trades novos kraken
-    def novcust
-      @novcust ||= usd[:kt].select { |o| kyt.include?(o[:txid]) }
+    memoize def novxt
+      exd[:kt].select { |o| exkyt.include?(o[:txid]) }
     end
     # @return [Array<Hash>] ledgers novos kraken
-    def novcusl
-      @novcusl ||= usd[:kl].select { |o| kyl.include?(o[:txid]) }
+    memoize def novxl
+      exd[:kl].select { |o| exkyl.include?(o[:txid]) }
     end
   end
 end

data/lib/cns/version.rb CHANGED Viewed

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

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cns
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.4
 platform: ruby
 authors:
 - Hernâni Rodrigues Vaz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-18 00:00:00.000000000 Z
+date: 2025-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -164,6 +164,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: memoist
+  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: thor
   requirement: !ruby/object:Gem::Requirement