cns 0.9.4 → 0.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d70ccf3bf3c61dccaf39f5fe5e34b3f629efd8182fbd036f1d1193e2e0d842e4
-  data.tar.gz: 969e4c7d275aa2b14a6e9b1324e007b84d9f61522b099fdbb6c6d8a9bc129708
+  metadata.gz: 60e46e5d964570303d66901fde56320d6102a12ff0f53495d420dc73fc5c5045
+  data.tar.gz: fbc9a980fe5be810ee82c541ecbd769feae8ea87e84a9a2d80c356e0e8b313a0
 SHA512:
-  metadata.gz: c406b44bacdf24f32dc6babc0c08d51cf5fe4f88724466e1af7d8770b08ae23da74c8811cc9f0bea0bdb11cf13ffb9fe3d8080de2626f8f3a0d6f22739e1e82f
-  data.tar.gz: 47e0b4e735ac2c3b11a11018ac5a9830ec1cf24c253b4cb7ab0b353bc2c262f55c572938668ccd00618bf367b5d1019381a30037789fecf13dd2a3b5e5a698b9
+  metadata.gz: 425413cbc19a0cbd77889e32a8cac2ba934cf32c9775e2c3bfd891d732f81c025b9f89b92e87211980b4f1e6a318a968fe369b46add18a3c133316b46ec64ceb
+  data.tar.gz: 3cd4b50b92b93d31abe4795d1887a24dd358ba4d7aee75edb0ff2329a0ff5b722217547dc77b2aaa944b002c3d22b3107b4a561eea4c8209e8a0a6936ad0448f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cns (0.9.4)
+    cns (0.9.6)
       curb
       faraday
       google-cloud-bigquery

data/lib/cns/apibc.rb

@@ -7,141 +7,159 @@ require('json')
 module Cns
   # classe para acesso dados blockchains
   class Apibc
-    ESPS = 10_000
-    GMPS = 100
+    ESPS = 10_000 # Etherscan maximum records per page
+    GMPS = 100    # Greymass maximum actions per request
 
     def initialize
-      @etherscan_conn = connection('https://api.etherscan.io')
-      @greymass_conn = connection('https://eos.greymass.com')
+      @escn = connection('https://api.etherscan.io')
+      @gmcn = connection('https://eos.greymass.com')
+      @esky = ENV.fetch('ETHERSCAN_API_KEY', nil)
     end
 
     # Get account balances for multiple ETH addresses
-    # @param addresses [Array<String>] List of ETH addresses (max 20)
+    # @param [Array<String>] addresses List of ETH addresses (max 20)
     # @return [Array<Hash>] List of addresses with balances
     def account_es(addresses)
-      response = etherscan_req('balancemulti', addresses.join(','), 1, tag: 'latest')
-      response[:status] == '1' ? response[:result] || [] : []
+      return [] if addresses.empty?
+
+      res = es_req('balancemulti', addresses.join(','), 1, tag: 'latest')
+      res[:status] == '1' ? res[:result] || [] : []
     end
 
     # Get normal transactions for ETH address
     # @param [String] address endereco ETH
     # @return [Array<Hash>] lista transacoes normais etherscan
     def norml_es(address)
-      pag_etherscan_req('txlist', address)
+      pag_es_req('txlist', address)
     end
 
     # Get internal transactions for ETH address
     # @param (see norml_es)
     # @return [Array<Hash>] lista transacoes internas etherscan
     def inter_es(address)
-      pag_etherscan_req('txlistinternal', address)
+      pag_es_req('txlistinternal', address)
     end
 
     # Get mined blocks for ETH address
     # @param (see norml_es)
     # @return [Array<Hash>] lista blocos etherscan
     def block_es(address)
-      pag_etherscan_req('getminedblocks', address, blocktype: 'blocks')
+      pag_es_req('getminedblocks', address, blocktype: 'blocks')
     end
 
     # Get withdrawals for ETH address
     # @param (see norml_es)
     # @return [Array<Hash>] lista blocos etherscan
     def withw_es(address)
-      pag_etherscan_req('txsBeaconWithdrawal', address)
+      pag_es_req('txsBeaconWithdrawal', address)
     end
 
     # Get token transfers for ETH address
     # @param (see norml_es)
     # @return [Array<Hash>] lista token transfer events etherscan
     def token_es(address)
-      pag_etherscan_req('tokentx', address)
+      pag_es_req('tokentx', address)
     end
 
     # Get EOS account information
-    # @param address [String] EOS account name
+    # @param [String] address EOS account name
     # @return [Hash] Account details with resources
     def account_gm(address)
-      response = greymass_req('/v1/chain/get_account', account_name: address)
-      response[:core_liquid_balance]&.to_d&.positive? ? response : gm_erro
+      res = gm_req('/v1/chain/get_account', account_name: address)
+      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)
-      actions = []
+      trx = []
       pos = 0
       loop do
-        response = greymass_req('/v1/history/get_actions', account_name: address, pos: pos, offset: GMPS)
-        batch = response[:actions] || []
-        actions.concat(batch)
-        break if batch.size < GMPS
+        res = gm_req('/v1/history/get_actions', account_name: address, pos: pos, offset: GMPS)
+        bth = res[:actions] || []
+        trx.concat(bth)
+        break if bth.size < GMPS
 
         pos += GMPS
       end
-      actions
+      trx
     end
 
     private
 
-    # Reusable Faraday connection
-    def connection(base_url)
-      Faraday.new(base_url) do |conn|
-        conn.request(:json) # Automatically encodes body as JSON
-        conn.headers = {content_type: 'application/json', accept: 'application/json', user_agent: 'blockchain-api-client'}
-        conn.options.timeout = 30
-        conn.options.open_timeout = 10
-        conn.adapter(Faraday.default_adapter)
-      end
-    end
-
-    # Generic Etherscan API request handler
-    def etherscan_req(action, address, page = 1, params = {})
-      params = {module: 'account', action: action, address: address, page: page, apikey: ENV.fetch('ETHERSCAN_API_KEY')}.merge(params)
-      parse_json(@etherscan_conn.get('/api', params))
+    # Make a request to the Etherscan API
+    # @param [String] act API action name
+    # @param [String] add Blockchain address
+    # @param [Integer] pag Page number for pagination
+    # @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)))
     rescue Faraday::Error
       {status: '0'}
     end
 
-    # Generic method for paginated Etherscan requests
-    # @param action [String] API action name
-    # @param address [String] Blockchain address
-    # @param params [Hash] Additional request parameters
+    # Fetch paginated results from Etherscan
+    # @param act [String] API action name
+    # @param add [String] Blockchain address
+    # @param prm [Hash] Additional request parameters
     # @return [Array<Hash>] Combined results from all pages
-    def pag_etherscan_req(action, address, params = {})
-      results = []
-      page = 1
+    def pag_es_req(act, add, prm = {})
+      prm = prm.merge(offset: ESPS)
+      trx = []
+      pag = 1
       loop do
-        response = etherscan_req(action, address, page, params)
-        break unless response[:status] == '1'
+        res = es_req(act, add, pag, prm)
+        break unless res[:status] == '1'
 
-        batch = response[:result] || []
-        results.concat(batch)
-        break if batch.size < ESPS
+        bth = res[:result] || []
+        trx.concat(bth)
+        break if bth.size < ESPS
 
-        page += 1
+        pag += 1
       end
-      results
-    end
-
-    # Generic Greymass API error
-    def gm_erro
-      {core_liquid_balance: 0, total_resources: {net_weight: 0, cpu_weight: 0}}
+      trx
     end
 
-    # Generic Greymass API request handler
-    def greymass_req(endpoint, payload)
-      parse_json(@greymass_conn.post(endpoint) { |req| req.body = payload })
+    # Make a request to the Greymass API
+    # @param [String] url API endpoint
+    # @param [Hash] pyl Request payload
+    # @return [Hash] Parsed API response
+    def gm_req(url, pyl)
+      parse_json(@gmcn.post(url) { |r| r.body = pyl })
     rescue Faraday::Error
       gm_erro
     end
 
-    # Safe JSON parsing with error handling
+    # Default error response for Greymass API
+    # @return [Hash] Error response with zeroed values
+    def gm_erro
+      {core_liquid_balance: 0, total_resources: {net_weight: 0, cpu_weight: 0}}
+    end
+
+    # Safely parse JSON response
+    # @param [Faraday::Response] res API response
+    # @return [Hash] Parsed JSON or empty hash on error
     def parse_json(res)
+      return {} if res.body.to_s.empty?
+
       JSON.parse(res.body, symbolize_names: true) || {}
     rescue JSON::ParserError
       {}
     end
+
+    # Create a Faraday connection with JSON configuration
+    # @param [String] url Base URL for the API
+    # @return [Faraday::Connection] Configured Faraday connection
+    def connection(url)
+      Faraday.new(url) do |c|
+        c.request(:json)
+        c.headers = {accept: 'application/json', user_agent: 'blockchain-api-client'}
+        c.options.timeout = 30
+        c.options.open_timeout = 10
+        c.adapter(Faraday.default_adapter)
+      end
+    end
   end
 end

data/lib/cns/apice.rb

@@ -17,8 +17,13 @@ module Cns
       @curl.connect_timeout = 10
       @curl.follow_location = true
       @curl.ssl_verify_peer = true
+      @deky = ENV.fetch('BITCOINDE_API_KEY', nil)
+      @desc = ENV.fetch('BITCOINDE_API_SECRET', nil)
+      @usky = ENV.fetch('KRAKEN_API_KEY', nil)
+      @ussc = ENV.fetch('KRAKEN_API_SECRET', nil)
     end
 
+    # Get account balances from Bitcoin.de
     # @return [Hash] saldos no bitcoinde
     def account_de
       uri = "#{API[:de]}/account"
@@ -28,6 +33,7 @@ module Cns
       {}
     end
 
+    # Get trades from Bitcoin.de
     # @return [Array<Hash>] trades bitcoinde
     def trades_de
       pag_de_req("#{API[:de]}/trades", {state: 1}, :trades)
@@ -35,6 +41,7 @@ module Cns
       []
     end
 
+    # Get deposits from Bitcoin.de, uniformly formatted
     # @return [Array<Hash>] depositos uniformizados bitcoinde
     def deposits_de
       pag_de_req("#{API[:de]}/btc/deposits", {state: 2}, :deposits) { |i| i.map { |h| deposit_unif(h) } }
@@ -42,6 +49,7 @@ module Cns
       []
     end
 
+    # Get withdrawals from Bitcoin.de, uniformly formatted
     # @return [Array<Hash>] withdrawals uniformizadas bitcoinde
     def withdrawals_de
       pag_de_req("#{API[:de]}/btc/withdrawals", {state: 1}, :withdrawals) { |i| i.map { |h| withdrawal_unif(h) } }
@@ -49,60 +57,83 @@ module Cns
       []
     end
 
+    # Get account balances from Kraken
     # @return [Hash] saldos kraken
     def account_us
       uri = 'Balance'
       ops = {nonce: nnc}
-      run_curl(@curl, "#{API[:us]}/#{uri}", method: :post, post_data: ops, headers: hus(uri, ops))
+      run_curl(@curl, "#{API[:us]}/#{uri}", method: 'POST', post_data: ops, headers: hus(uri, ops))
       parse_json(@curl).fetch(:result, {})
     rescue Curl::Err::CurlError
       {}
     end
 
+    # Get trades from Kraken
     # @return [Hash] trades kraken
     def trades_us
       pag_us_req('TradesHistory', :trades)
     rescue Curl::Err::CurlError
-      {}
+      []
     end
 
+    # Get ledger from Kraken
     # @return [Hash] ledger kraken
     def ledger_us
       pag_us_req('Ledgers', :ledger)
     rescue Curl::Err::CurlError
-      {}
+      []
     end
 
     private
 
+    # Uniformly format transacao kraken
+    # @param [Symbol] key id da transacao
+    # @param [Hash] trx transacao
+    # @return [Hash] transacao uniformizada
+    def us_unif(key, trx)
+      t = trx[:time].to_i
+      trx.merge(txid: key.to_s, srx: t, time: Time.at(t))
+    rescue ArgumentError
+      trx.merge(txid: key.to_s, srx: 0, time: Time.at(0))
+    end
+
     # Generic paginated request handler for Kraken
+    # @param [String] uri API endpoint URI
+    # @param [Symbol] key Key to extract from the result
+    # @yield [Array<Hash>] Block to process each batch of results
+    # @return [Array<Hash>] Combined results from all pages
     def pag_us_req(uri, key)
-      has = {}
+      ary = []
       ofs = 0
       loop do
         sleep(ofs.zero? ? 0 : 2)
         ops = {nonce: nnc, ofs: ofs}
-        run_curl(@curl, "#{API[:us]}/#{uri}", method: :post, post_data: ops, headers: hus(uri, ops))
-        batch = parse_json(@curl).fetch(:result, {}).fetch(key, [])
-        break if batch.empty?
+        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) }
+        break if bth.empty?
 
-        has.merge!(batch)
-        ofs += batch.size
+        ary.concat(bth)
+        ofs += bth.size
       end
-      has
+      ary
     end
 
     # Generic paginated request handler for Bitcoin.de
-    def pag_de_req(base_url, params, key)
+    # @param [String] uri Base URL for the API request
+    # @param [Hash] prm Additional parameters for the request
+    # @param [Symbol] key Key to extract from the result
+    # @yield [Array<Hash>] Optional block to process each batch of results
+    # @return [Array<Hash>] Combined results from all pages
+    def pag_de_req(uri, prm, key)
       ary = []
       pag = 1
       loop do
-        url = "#{base_url}?#{URI.encode_www_form(params.merge(page: pag))}"
+        url = "#{uri}?#{URI.encode_www_form(prm.merge(page: pag))}"
         run_curl(@curl, url, headers: hde(url))
-        result = parse_json(@curl)
-        batch = result.fetch(key, [])
-        ary.concat(block_given? ? yield(batch) : batch)
-        break if result[:page]&.[](:current)&.>= result[:page]&.[](:last)
+        res = parse_json(@curl)
+        bth = res.fetch(key, [])
+        ary.concat(block_given? ? yield(bth) : bth)
+        break if res[:page]&.[](:current)&.>= res[:page]&.[](:last)
 
         pag += 1
       end
@@ -110,64 +141,76 @@ module Cns
     end
 
     # Configure Curl object for request
-    def run_curl(curl, url, method: :get, post_data: nil, headers: {})
+    # @param [Curl::Easy] curl Curl object to configure
+    # @param [String] url URL for the request
+    # @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: {})
       curl.reset
       curl.url = url
-      curl.http(method == :post ? 'POST' : 'GET')
+      curl.http(method)
       curl.headers = headers
       curl.post_body = URI.encode_www_form(post_data) if post_data
       curl.perform
     end
 
     # 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)
     rescue JSON::ParserError
       {}
     end
 
-    # @return [Integer] continually-increasing unsigned integer nonce from the current Unix Time
+    # Generate a continually-increasing unsigned integer nonce from the current Unix Time
+    # @return [Integer] Nonce value
     def nnc
-      Integer(Float(Time.now) * 1e6)
+      Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond).to_i
     end
 
+    # Uniformly format a deposit from Bitcoin.de
+    # @param [Hash] has Deposit data from Bitcoin.de
     # @return [Hash] deposito uniformizado bitcoinde
     def deposit_unif(has)
-      {add: has[:address], time: Time.parse(has[:created_at]), qt: has[:amount], txid: Integer(has[:deposit_id])}.merge(tp: 'deposit', moe: 'btc', fee: '0')
+      {add: has[:address], time: Time.parse(has[:created_at]), qtd: has[:amount].to_d, nxid: has[:deposit_id].to_i}.merge(tp: 'deposit', moe: 'BTC', fee: 0.to_d)
     end
 
+    # Uniformly format a withdrawal from Bitcoin.de
+    # @param [Hash] has Withdrawal data from Bitcoin.de
     # @return [Hash] withdrawal uniformizada bitcoinde
     def withdrawal_unif(has)
       {
         add: has[:address],
         time: Time.parse(has[:transferred_at]),
-        qt: has[:amount],
-        fee: has[:network_fee],
-        txid: Integer(has[:withdrawal_id]),
+        qtd: -1 * has[:amount].to_d,
+        fee: has[:network_fee].to_d,
+        nxid: has[:withdrawal_id].to_i,
         tp: 'withdrawal',
-        moe: 'btc'
+        moe: 'BTC'
       }
     end
 
-    # @param [String] qde query a incluir no pedido HTTP
-    # @param [Integer] non continually-increasing unsigned integer
-    # @return [Hash] headers necessarios para pedido HTTP da exchange bitcoinde
+    # Generate headers for Bitcoin.de HTTP requests
+    # @param [String] qde Query string to include in the HTTP request
+    # @param [Integer] non Nonce value (default: generated from nnc)
+    # @return [Hash] Headers required for Bitcoin.de HTTP requests
     def hde(qde, non = nnc)
-      key = ENV.fetch('BITCOINDE_API_KEY', nil)
-      md5 = ['GET', qde, key, non, Digest::MD5.hexdigest('')].join('#')
-      mac = OpenSSL::HMAC.hexdigest('sha256', ENV.fetch('BITCOINDE_API_SECRET', nil), md5)
-      {'X-API-KEY': key, 'X-API-NONCE': non, 'X-API-SIGNATURE': mac}
+      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}
     end
 
+    # Generate headers for Kraken HTTP requests
     # @param [String] qus query a incluir no pedido HTTP
     # @param [Hash] ops opcoes trabalho
     # @option ops [Hash] :nonce continually-increasing unsigned integer
-    # @return [Hash] headers necessarios para pedido HTTP da exchange kraken
+    # @return [Hash] Headers required for Kraken HTTP requests
     def hus(qus, ops)
-      key = ENV.fetch('KRAKEN_API_KEY', nil)
       sha = ['/0/private/', qus, Digest::SHA256.digest("#{ops[:nonce]}#{URI.encode_www_form(ops)}")].join
-      mac = OpenSSL::HMAC.digest('sha512', Base64.decode64(ENV.fetch('KRAKEN_API_SECRET', nil)), sha)
-      {'api-key': key, 'api-sign': Base64.strict_encode64(mac)}
+      mac = OpenSSL::HMAC.digest('sha512', Base64.decode64(@ussc), sha)
+      {'api-key' => @usky, 'api-sign' => Base64.strict_encode64(mac)}
     end
   end
 end

data/lib/cns/bigquery.rb

@@ -29,7 +29,7 @@ module Cns
     hust: %i[txid ordertxid pair time type ordertype price cost fee vol margin misc ledgers],
     cusl: %w[txid refid time type aclass asset amount fee],
     husl: %i[txid refid time type aclass asset amount fee]
-  }
+  }.freeze
   # para testes bigquery
   TL = {
     ins: 'INSERT',
@@ -37,14 +37,14 @@ module Cns
     est: '', # ' limit 226',
     esi: '', # ' limit 22',
     esp: '', # ' limit 72',
-    esw: '', # ' limit 2299',
+    esw: '', # ' limit 2320',
     esk: '', # ' limit 20',
     gmt: '', # ' limit 1091',
     ust: '', # ' limit 182',
     usl: '', # ' limit 448',
     det: '', # ' limit 27',
     del: '' # ' limit 16'
-  }
+  }.freeze
 
   # classe para processar bigquery
   class Bigquery
@@ -223,7 +223,7 @@ module Cns
           novx = src.send("nov#{i}")
           next if novx.empty?
 
-          format(' %<n>i %<t>s', n: dml(ins_sql(i, %i[cust cusl].include?(i) ? novx.values : novx)), t: "#{i}")
+          format(' %<n>i %<t>s', n: dml(ins_sql(i, novx)), t: "#{i}")
         end
       )
       str.join
@@ -253,9 +253,7 @@ module Cns
 
     # @return [String] SQL integer formatting
     def fin(value)
-      Integer(value || 0).to_s
-    rescue StandardError
-      '0'
+      value.to_i.to_s
     end
 
     # @return [String] SQL timestamp formatting
@@ -330,7 +328,7 @@ module Cns
     # @param [Hash] htx trades kraken
     # @return [String] valores formatados cust
     def cust_val(htx)
-      fvals(htx.merge(ledgers: apius.uskl.select { |_, o| o[:refid] == htx[:txid] }.keys.join(',')), TB[:hust], :txid)
+      fvals(htx.merge(ledgers: apius.uskl.select { |o| o[:refid] == htx[:txid] }.map { |t| t[:txid] }.join(',')), TB[:hust], :txid)
     end
 
     # @param [Hash] htx ledger kraken

data/lib/cns/bitcoinde.rb

@@ -100,7 +100,7 @@ module Cns
     def fol(hlx)
       format(
         '%<ky>6i %<dt>19.19s %<ty>-10.10s %<mo>-3.3s %<pr>19.8f %<vl>18.8f',
-        ky: hlx[:txid],
+        ky: hlx[:nxid],
         dt: hlx[:time].strftime('%F %T'),
         ty: hlx[:tp],
         mo: hlx[:moe],
@@ -130,7 +130,7 @@ module Cns
     # @return [Hash] transaccao filtrada
     def pdes(key, itm)
       tym = ptm(itm[key])
-      itm.merge(srx: Integer(tym), key => tym)
+      itm.merge(srx: tym.to_i, key => tym)
     end
 
     # @param [Array<Hash>] htx trade bitcoinde
@@ -150,7 +150,7 @@ module Cns
     # @param [Array<Hash>] hlx ledger bitcoinde
     # @return [Array<Hash>] transaccao filtrada
     def pdel(hlx)
-      hlx.map { |t| pdes(:time, t).merge(qtd: (t[:tp] == 'withdrawal' ? -1 : 1) * t[:qt].to_d, nxid: t[:txid], fee: t[:fee].to_d, moe: t[:moe].upcase) }
+      hlx.map { |t| pdes(:time, t) }
     end
 
     # @return [Hash] dados exchange bitcoinde - saldos & trades & deposits & withdrawals
@@ -173,19 +173,19 @@ module Cns
       @kyt ||= ded[:tt].map { |t| t[:trade_id] } - bqkyt
     end
 
-    # @return [Array<Integer>] lista txid ledger novos
+    # @return [Array<Integer>] lista nxid ledger novos
     def kyl
-      @kyl ||= ded[:tl].map { |t| t[:txid] } - bqkyl
+      @kyl ||= ded[:tl].map { |t| t[:nxid] } - bqkyl
     end
 
-    # @return [Array<Hash>] lista trades bitcoinde novos
+    # @return [Array<Hash>] lista trades novos bitcoinde
     def novcdet
-      @novcdet ||= ded[:tt].select { |obj| kyt.include?(obj[:trade_id]) }
+      @novcdet ||= ded[:tt].select { |o| kyt.include?(o[:trade_id]) }
     end
 
-    # @return [Array<Hash>] lista ledger (deposits + withdrawals) bitcoinde novos
+    # @return [Array<Hash>] lista ledgers (deposits + withdrawals) novos bitcoinde
     def novcdel
-      @novcdel ||= ded[:tl].select { |obj| kyl.include?(obj[:txid]) }
+      @novcdel ||= ded[:tl].select { |o| kyl.include?(o[:nxid]) }
     end
   end
 end

data/lib/cns/etherscan.rb

@@ -18,36 +18,36 @@ module Cns
         header: "\ntx normal                     from            to              data         valor",
         sork: :srx,
         adjk: :hash
-      },
+      }.freeze,
       internal: {
         new: :novnethi,
         format: :foti,
         header: "\ntx intern                     from            to              data         valor",
         sork: :srx,
         adjk: :hash
-      },
+      }.freeze,
       block: {
         new: :novnethp,
         format: :fop,
         header: "\ntx block  address                                   data                   valor",
         sork: :itx,
         adjk: :blockNumber
-      },
+      }.freeze,
       token: {
         new: :novnethk,
         format: :fok,
         header: "\ntx token             from            to              data            valor moeda",
         sork: :srx,
         adjk: :hash
-      },
+      }.freeze,
       withdrawal: {
         new: :novnethw,
         format: :fow,
         header: "\nwithdrawal validator data            valor",
         sork: :itx,
         adjk: :withdrawalIndex
-      }
-    }
+      }.freeze
+    }.freeze
 
     # @param [Hash] dad todos os dados bigquery
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
@@ -166,7 +166,7 @@ module Cns
       return 'erro' if max < 7
 
       max -= 2
-      ini = Integer(max / 2) + 4
+      ini = (max / 2).to_i + 4
       inf = max % 2
       "#{add[0, ini - 3]}..#{add[-inf - ini + 5..]}"
     end
@@ -180,7 +180,7 @@ module Cns
       return 'erro' if max < 7
 
       max -= 2
-      ini = Integer(max / 2)
+      ini = (max / 2).to_i
       inf = max % 2
       hid = bqd[:wb].find { |o| o[:ax] == add }
       ndd = hid ? "#{hid[:id]}-#{add}" : add
@@ -234,29 +234,31 @@ module Cns
     # @param [Hash] htx transacao
     # @return [Hash] transaccao filtrada
     def pess(htx)
-      tym = Integer(htx[:timeStamp])
+      tym = htx[:timeStamp].to_i
       htx.merge(srx: tym, timeStamp: Time.at(tym))
+    rescue ArgumentError
+      htx.merge(srx: 0, timeStamp: Time.at(0))
     end
 
     # @param add (see foe1)
     # @param [Array<Hash>] ary lista transacoes normal(t)/(i)nternal/to(k)en
     # @return [Array<Hash>] lista transacoes filtrada
     def ftik(add, ary)
-      ary.map { |o| pess(o).merge(itx: String(o[:hash]), iax: add, value: o[:value].to_d) }
+      ary.map { |o| pess(o).merge(itx: o[:hash].to_s, iax: add, value: o[:value].to_d) }
     end
 
     # @param add (see foe1)
     # @param [Array<Hash>] ary lista transacoes (p)roduced blocks
     # @return [Array<Hash>] lista transacoes filtrada
     def fppp(add, ary)
-      ary.map { |o| o.merge(itx: Integer(o[:blockNumber]), iax: add, blockReward: o[:blockReward].to_d, timeStamp: Time.at(Integer(o[:timeStamp]))) }
+      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
 
     # @param add (see foe1)
     # @param [Array<Hash>] ary lista transacoes (w)ithdrawals
     # @return [Array<Hash>] lista transacoes filtrada
     def fwww(add, ary)
-      ary.map { |o| o.merge(itx: Integer(o[:withdrawalIndex]), iax: add, amount: o[:amount].to_d, timeStamp: Time.at(Integer(o[:timestamp]))) }
+      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
 
     # @param [Hash] aes account etherscan

data/lib/cns/greymass.rb

@@ -17,7 +17,7 @@ module Cns
       header: "\nsequence num from         to           accao      data              valor moeda",
       sork: :itx,
       adjk: :itx
-    }
+    }.freeze
 
     # @param [Hash] dad todos os dados bigquery
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
@@ -77,7 +77,7 @@ module Cns
     # @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
+      hjn[:bs].round(6) == hjn[:es].round(6) && hjn[:bt].count == hjn[:et].count
     end
 
     # @param [Hash] hlx ledger greymass
@@ -104,8 +104,8 @@ module Cns
     # @return [Array<BigDecimal>] lista recursos - liquido, net, spu
     def peosa(add)
       hac = api.account_gm(add)
-      htr = hac[:total_resources]
-      [hac[:core_liquid_balance].to_d, htr[:net_weight].to_d, htr[:cpu_weight].to_d]
+      htr = hac.fetch(:total_resources, {})
+      [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
 
     # @param add (see peosa)
@@ -122,7 +122,7 @@ module Cns
           quantity: qtd.to_d,
           account: act[:account],
           to: adt[:to],
-          memo: String(adt[:memo]).gsub(/\p{C}/, ''), # remove Non-Printable Characters
+          memo: adt[:memo].to_s.gsub(/\p{C}/, ''), # remove Non-Printable Characters
           moe: qtd[/[[:upper:]]+/],
           itx: t[:global_action_seq],
           iax: add,

data/lib/cns/kraken.rb

@@ -23,7 +23,7 @@ module Cns
       @ops = pop.transform_keys(&:to_sym)
     end
 
-    # @return [String] texto saldos & transacoes & ajuste dias
+    # mosta resumo saldos & transacoes & ajuste dias
     def mresumo
       puts("\nKRAKEN\ntipo                 kraken              bigquery")
       usd[:sl].sort.each { |key, val| puts(fos(key, val)) }
@@ -33,7 +33,7 @@ module Cns
       mledger
       return if novcust.empty?
 
-      puts("\nstring ajuste dias dos trades\n-h=#{novcust.sort_by { |_, v| -v[:srx] }.map { |k, _v| "#{k}:0" }.join(' ')}")
+      puts("\nstring ajuste dias dos trades\n-h=#{novcust.sort_by { |i| -i[:srx] }.map { |o| "#{o[:txid]}:0" }.join(' ')}")
     end
 
     # @return [Hash] ledgers exchange kraken
@@ -59,7 +59,7 @@ module Cns
       return unless ops[:v] && novcust.any?
 
       puts("\ntrade  data       hora     tipo       par         preco     volume         custo")
-      novcust.sort_by { |_, v| -v[:srx] }.each { |k, t| puts(fot(k, t)) }
+      novcust.sort_by { |i| -i[:srx] }.each { |o| puts(fot(o)) }
     end
 
     # mosta transacoes ledger
@@ -67,14 +67,14 @@ module Cns
       return unless ops[:v] && novcusl.any?
 
       puts("\nledger data       hora     tipo       moeda        quantidade              custo")
-      novcusl.sort_by { |_, v| -v[:srx] }.each { |k, t| puts(fol(k, t)) }
+      novcusl.sort_by { |i| -i[:srx] }.each { |o| puts(fol(o)) }
     end
 
     # @param [String] moe codigo kraken da moeda
     # @param [BigDecimal] sal saldo kraken da moeda
     # @return [String] texto formatado saldos
     def fos(moe, sal)
-      vbq = bqd[:sl][moe.downcase.to_sym].to_d
+      vbq = (bqd[:sl]&.fetch(moe.downcase.to_sym, nil) || 0).to_d
       format(
         '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
         mo: moe.upcase,
@@ -84,13 +84,12 @@ module Cns
       )
     end
 
-    # @param [Symbol] idx id da transacao
     # @param [Hash] htn trades kraken
     # @return [String] texto formatado trade
-    def fot(idx, htx)
+    def fot(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,
+        ky: htx[:txid],
         dt: htx[:time].strftime('%F %T'),
         ty: "#{htx[:type]}/#{htx[:ordertype]}",
         mo: htx[:pair],
@@ -100,13 +99,12 @@ module Cns
       )
     end
 
-    # @param idx (see fot)
     # @param [Hash] hln ledger kraken
     # @return [String] texto formatado ledger
-    def fol(idx, hlx)
+    def fol(hlx)
       format(
         '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-4.4s %<pr>18.7f %<vl>18.7f',
-        ky: idx,
+        ky: hlx[:txid],
         dt: hlx[:time].strftime('%F %T'),
         ty: hlx[:type],
         mo: hlx[:asset],
@@ -126,25 +124,16 @@ module Cns
       itm.select { |k, _| EM.include?(k) }.transform_values { |v| v.to_d }
     end
 
-    # @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
-
-    # @param [Hash] htx trade kraken
-    # @return [Hash] transaccao filtrada
+    # @param [Array<Hash>] htx trades kraken
+    # @return [Array<Hash>] transaccoes filtradas
     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) }
+      htx.map { |t| t.merge(pair: t[:pair].upcase, price: t[:price].to_d, vol: t[:vol].to_d, cost: t[:cost].to_d) }
     end
 
-    # @param [Hash] hlx ledger kraken
-    # @return [Hash] transaccao filtrada
+    # @param [Array<Hash>] hlx ledgers kraken
+    # @return [Array<Hash>] transaccoes filtradas
     def pusl(hlx)
-      pusk(hlx).transform_values { |t| t.merge(asset: t[:asset].upcase, amount: t[:amount].to_d, fee: t[:fee].to_d) }
+      hlx.map { |t| t.merge(asset: t[:asset].upcase, amount: t[:amount].to_d, fee: t[:fee].to_d) }
     end
 
     # @return [Hash] dados exchange kraken - saldos & transacoes trades e ledger
@@ -152,34 +141,34 @@ module Cns
       @usd ||= {sl: pusa(api.account_us), kt: pust(api.trades_us), kl: pusl(api.ledger_us)}
     end
 
-    # @return [Array<Symbol>] indices trades bigquery
+    # @return [Array<String>] indices trades bigquery
     def bqkyt
-      @bqkyt ||= show_all? ? [] : bqd[:nt].map { |t| t[:txid].to_sym }
+      @bqkyt ||= show_all? ? [] : bqd[:nt].map { |t| t[:txid] }
     end
 
-    # @return [Array<Symbol>] indices ledger bigquery
+    # @return [Array<String>] indices ledger bigquery
     def bqkyl
-      @bqkyl ||= show_all? ? [] : bqd[:nl].map { |l| l[:txid].to_sym }
+      @bqkyl ||= show_all? ? [] : bqd[:nl].map { |l| l[:txid] }
     end
 
-    # @return [Array<Symbol>] lista txid trades novos
+    # @return [Array<String>] lista txid trades novos
     def kyt
-      @kyt ||= usd[:kt].keys - bqkyt
+      @kyt ||= usd[:kt].map { |t| t[:txid] } - bqkyt
     end
 
-    # @return [Array<Symbol>] lista txid ledger novos
+    # @return [Array<String>] lista txid ledger novos
     def kyl
-      @kyl ||= usd[:kl].keys - bqkyl
+      @kyl ||= usd[:kl].map { |t| t[:txid] } - bqkyl
     end
 
-    # @return [Hash] trades kraken novos
+    # @return [Array<Hash>] trades novos kraken
     def novcust
-      @novcust ||= usd[:kt].slice(*kyt)
+      @novcust ||= usd[:kt].select { |o| kyt.include?(o[:txid]) }
     end
 
-    # @return [Hash] ledger kraken novos
+    # @return [Array<Hash>] ledgers novos kraken
     def novcusl
-      @novcusl ||= usd[:kl].slice(*kyl)
+      @novcusl ||= usd[:kl].select { |o| kyl.include?(o[:txid]) }
     end
   end
 end

data/lib/cns/version.rb

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

metadata

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