cns 0.9.0 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fff5558da7a0b92a4511bf3f73b8330d3ad59d92d46c76b64a70bfd19e3dfd1e
-  data.tar.gz: eafa8884b41f68f83fa20b547474c7a0717281f8c47d0a948805e9d0a7ae19f4
+  metadata.gz: f54f4e0bf0d8e859722edf7c9a4430d625b3789ac50761b03061db0050956062
+  data.tar.gz: 7e2fbaa074c7cb51157849b8db9798271cf54f4b7b6404869278dd48ceedd55c
 SHA512:
-  metadata.gz: 8409acef5de4ce834e309710521c44cfe35414e3ec6c3d11b8dce9173720414d828fb320c6865c693867bdac1bf14c41e8f6ac5ac5172dc11253ff77683cd307
-  data.tar.gz: 072e66dc223d7c14c20248f25e2c5a72f5e918314881c60faf3b8377cb77d11534d9c5b6d0eaf8e2ab2c7966c4956414d3bfdf433b98e57eb3691fa0b46e78ac
+  metadata.gz: 917f7140253dbaa7e0619792c3912fb78533618640de779c473f86a1665e68ec5688d2f0d6624c0ed33678e698d19a5cadc47b5c20ce833d5273a8cbf7f87ff7
+  data.tar.gz: e56c3b51a6e0d539569b9deace1d491da55a63afaf44e3aaa08abb25807272c33164b55626f9de526b0660d27823514a6524c074b5449995c6d6161f0154a74f

data/.rubocop.yml

@@ -18,7 +18,7 @@ Metrics/AbcSize:
 
 # Formatting Rules
 Layout/LineLength:
-  Max: 180
+  Max: 185
   AllowHeredoc: true
   AllowURI: true
 
@@ -26,7 +26,7 @@ Layout/IndentationWidth:
   Width: 2
 
 Layout/SpaceInsideHashLiteralBraces:
-  EnforcedStyle: space
+  EnforcedStyle: no_space
 
 Layout/SingleLineBlockChain:
   Enabled: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cns (0.9.0)
+    cns (0.9.2)
       curb
       faraday
       google-cloud-bigquery
@@ -56,7 +56,7 @@ GEM
       logger
     faraday-net_http (3.4.0)
       net-http (>= 0.5.0)
-    google-apis-bigquery_v2 (0.83.0)
+    google-apis-bigquery_v2 (0.84.0)
       google-apis-core (>= 0.15.0, < 2.a)
     google-apis-core (0.16.0)
       addressable (~> 2.5, >= 2.5.1)

data/lib/cns/apibc.rb

@@ -7,12 +7,20 @@ require('json')
 module Cns
   # classe para acesso dados blockchains
   class Apibc
+    ESPS = 10_000
+    GMPS = 100
+
+    def initialize
+      @etherscan_conn = connection('https://api.etherscan.io')
+      @greymass_conn = connection('https://eos.greymass.com')
+    end
+
     # Get account balances for multiple ETH addresses
     # @param addresses [Array<String>] 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.fetch(:status, '0') == '1' ? response.fetch(:result, []) : []
+      response[:status] == '1' ? response[:result] || [] : []
     end
 
     # Get normal transactions for ETH address
@@ -55,7 +63,7 @@ module Cns
     # @return [Hash] Account details with resources
     def account_gm(address)
       response = greymass_req('/v1/chain/get_account', account_name: address)
-      response.dig(:core_liquid_balance).to_d > 0 ? response : gm_erro
+      response[:core_liquid_balance]&.to_d&.positive? ? response : gm_erro
     end
 
     # Get complete transaction history for EOS account
@@ -65,12 +73,12 @@ module Cns
       actions = []
       pos = 0
       loop do
-        response = greymass_req('/v1/history/get_actions', account_name: address, pos: pos, offset: 100)
-        batch = response.fetch(:actions, [])
-        actions += batch
-        break if batch.size < 100
+        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
 
-        pos += 100
+        pos += GMPS
       end
       actions
     end
@@ -80,17 +88,20 @@ module Cns
     # Reusable Faraday connection
     def connection(base_url)
       Faraday.new(base_url) do |conn|
-        conn.headers = { content_type: 'application/json', accept: 'application/json', user_agent: 'blockchain-api-client' }
+        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(connection('https://api.etherscan.io').get('/api', 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))
     rescue Faraday::Error
-      { status: '0' }
+      {status: '0'}
     end
 
     # Generic method for paginated Etherscan requests
@@ -103,11 +114,11 @@ module Cns
       page = 1
       loop do
         response = etherscan_req(action, address, page, params)
-        break unless response.fetch(:status, '0') == '1'
+        break unless response[:status] == '1'
 
-        batch = response.fetch(:result, [])
-        results += batch
-        break if batch.size < 10_000
+        batch = response[:result] || []
+        results.concat(batch)
+        break if batch.size < ESPS
 
         page += 1
       end
@@ -116,12 +127,12 @@ module Cns
 
     # Generic Greymass API error
     def gm_erro
-      { core_liquid_balance: 0, total_resources: { net_weight: 0, cpu_weight: 0 } }
+      {core_liquid_balance: 0, total_resources: {net_weight: 0, cpu_weight: 0}}
     end
 
     # Generic Greymass API request handler
     def greymass_req(endpoint, payload)
-      parse_json((connection('https://eos.greymass.com').post(endpoint) { |req| req.body = payload.to_json }))
+      parse_json(@greymass_conn.post(endpoint) { |req| req.body = payload })
     rescue Faraday::Error
       gm_erro
     end

data/lib/cns/apice.rb

@@ -7,137 +7,121 @@ require('json')
 
 # @author Hernani Rodrigues Vaz
 module Cns
-  API = { de: 'https://api.bitcoin.de/v4', us: 'https://api.kraken.com/0/private' }.freeze
+  API = {de: 'https://api.bitcoin.de/v4', us: 'https://api.kraken.com/0/private'}.freeze
 
   # classe para acesso dados centralized exchanges
   class Apice
+    def initialize
+      @curl = Curl::Easy.new
+      @curl.timeout = 30
+      @curl.connect_timeout = 10
+      @curl.follow_location = true
+      @curl.ssl_verify_peer = true
+    end
+
     # @return [Hash] saldos no bitcoinde
     def account_de
       uri = "#{API[:de]}/account"
-      parse_json(Curl.get(uri) { |obj| obj.headers = hde(uri) }).dig(:data, :balances) || {}
+      run_curl(@curl, uri, headers: hde(uri))
+      parse_json(@curl).dig(:data, :balances) || {}
     rescue Curl::Err::CurlError
       {}
     end
 
     # @return [Array<Hash>] trades bitcoinde
     def trades_de
-      pag = 1
-      ary = []
-      loop do
-        url = "#{API[:de]}/trades?#{URI.encode_www_form(state: 1, page: pag)}"
-        data = parse_json(Curl.get(url) { |obj| obj.headers = hde(url) })
-        ary += data.fetch(:trades, [])
-        break if data[:page][:current] >= data[:page][:last]
-
-        pag += 1
-      end
-      ary
+      pag_de_req("#{API[:de]}/trades", {state: 1}, :trades)
     rescue Curl::Err::CurlError
-      ary
+      []
     end
 
     # @return [Array<Hash>] depositos uniformizados bitcoinde
     def deposits_de
-      pag = 1
-      ary = []
-      loop do
-        url = "#{API[:de]}/btc/deposits?#{URI.encode_www_form(state: 2, page: pag)}"
-        data = parse_json(Curl.get(url) { |obj| obj.headers = hde(url) })
-        ary += data.fetch(:deposits, []).map { |has| deposit_unif(has) }
-        break if data[:page][:current] >= data[:page][:last]
-
-        pag += 1
-      end
-      ary
+      pag_de_req("#{API[:de]}/btc/deposits", {state: 2}, :deposits) { |i| i.map { |h| deposit_unif(h) } }
     rescue Curl::Err::CurlError
-      ary
-    end
-
-    # @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')
+      []
     end
 
     # @return [Array<Hash>] withdrawals uniformizadas bitcoinde
     def withdrawals_de
-      ary = []
-      pag = 1
-      loop do
-        url = "#{API[:de]}/btc/withdrawals?#{URI.encode_www_form(state: 1, page: pag)}"
-        data = parse_json(Curl.get(url) { |obj| obj.headers = hde(url) })
-        ary += data.fetch(:withdrawals, []).map { |has| withdrawal_unif(has) }
-        break if data[:page][:current] >= data[:page][:last]
-
-        pag += 1
-      end
-      ary
+      pag_de_req("#{API[:de]}/btc/withdrawals", {state: 1}, :withdrawals) { |i| i.map { |h| withdrawal_unif(h) } }
     rescue Curl::Err::CurlError
-      ary
-    end
-
-    # @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])
-      }.merge(tp: 'withdrawal', moe: 'btc')
+      []
     end
 
     # @return [Hash] saldos kraken
     def account_us
       uri = 'Balance'
-      ops = { nonce: nnc }
-      parse_json(Curl.post("#{API[:us]}/#{uri}", ops) { |hed| hed.headers = hus(uri, ops) }).fetch(:result, {})
+      ops = {nonce: nnc}
+      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
 
     # @return [Hash] trades kraken
     def trades_us
-      uri = 'TradesHistory'
-      has = {}
-      ofs = 0
-      loop do
-        sleep(1)
-        ops = { nonce: nnc, ofs: ofs }
-        result = parse_json(Curl.post("#{API[:us]}/#{uri}", ops) { |hed| hed.headers = hus(uri, ops) }).fetch(:result, {})
-        break if result.fetch(:trades, []).empty?
-
-        has.merge!(result[:trades])
-        ofs += result[:trades].size
-      end
-      has
+      pag_us_req('TradesHistory', :trades)
     rescue Curl::Err::CurlError
-      has
+      {}
     end
 
     # @return [Hash] ledger kraken
     def ledger_us
-      uri = 'Ledgers'
+      pag_us_req('Ledgers', :ledger)
+    rescue Curl::Err::CurlError
+      {}
+    end
+
+    private
+
+    # Generic paginated request handler for Kraken
+    def pag_us_req(uri, key)
       has = {}
       ofs = 0
       loop do
-        sleep(2)
-        ops = { nonce: nnc, ofs: ofs }
-        result = parse_json(Curl.post("#{API[:us]}/#{uri}", ops) { |hed| hed.headers = hus(uri, ops) }).fetch(:result, {})
-        break if result.fetch(:ledger, []).empty?
-
-        has.merge!(result[:ledger])
-        ofs += result[:ledger].size
+        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?
+
+        has.merge!(batch)
+        ofs += batch.size
       end
       has
-    rescue Curl::Err::CurlError
-      has
     end
 
-    private
+    # Generic paginated request handler for Bitcoin.de
+    def pag_de_req(base_url, params, key)
+      ary = []
+      pag = 1
+      loop do
+        url = "#{base_url}?#{URI.encode_www_form(params.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)
+
+        pag += 1
+      end
+      ary
+    end
+
+    # Configure Curl object for request
+    def run_curl(curl, url, method: :get, post_data: nil, headers: {})
+      curl.reset
+      curl.url = url
+      curl.http(method == :post ? 'POST' : 'GET')
+      curl.headers = headers
+      curl.post_body = URI.encode_www_form(post_data) if post_data
+      curl.perform
+    end
 
     # Safe JSON parsing with error handling
     def parse_json(res)
-      JSON.parse(res.body, symbolize_names: true) || {}
+      JSON.parse(res.body_str, symbolize_names: true)
     rescue JSON::ParserError
       {}
     end
@@ -147,6 +131,24 @@ module Cns
       Integer(Float(Time.now) * 1e6)
     end
 
+    # @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')
+    end
+
+    # @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]),
+        tp: 'withdrawal',
+        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
@@ -154,7 +156,7 @@ module Cns
       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 }
+      {'X-API-KEY': key, 'X-API-NONCE': non, 'X-API-SIGNATURE': mac}
     end
 
     # @param [String] qus query a incluir no pedido HTTP
@@ -165,7 +167,7 @@ module Cns
       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) }
+      {'api-key': key, 'api-sign': Base64.strict_encode64(mac)}
     end
   end
 end

data/lib/cns/bigquery.rb

@@ -9,16 +9,26 @@ module Cns
   FO = File.expand_path("~/#{File.basename($PROGRAM_NAME)}.log")
   EM = %i[EOS XETH ZEUR btc eth]
   TB = {
-    i: %w[blocknumber timestamp txhash axfrom axto iax value contractaddress input type gas gasused traceid iserror errcode dias],
-    p: %w[blocknumber timestamp blockreward iax dias],
-    w: %w[withdrawalindex validatorindex address amount blocknumber timestamp dias],
-    t: %w[blocknumber timestamp txhash nonce blockhash transactionindex axfrom axto iax value gas gasprice gasused iserror txreceipt_status input contractaddress dias],
-    k: %w[blocknumber timestamp txhash nonce blockhash transactionindex axfrom axto iax value tokenname tokensymbol tokendecimal gas gasprice gasused input contractaddress dias],
+    netht: %w[blocknumber timestamp txhash nonce blockhash transactionindex axfrom axto iax value gas gasprice gasused iserror txreceipt_status input contractaddress dias],
+    hetht: %i[blockNumber timeStamp hash nonce blockHash transactionIndex from to iax value gas gasPrice gasUsed isError txreceipt_status input contractAddress],
+    nethi: %w[blocknumber timestamp txhash axfrom axto iax value contractaddress input type gas gasused traceid iserror errcode dias],
+    hethi: %i[blockNumber timeStamp hash from to iax value contractAddress input type gas gasUsed traceId isError errCode],
+    nethp: %w[blocknumber timestamp blockreward iax dias],
+    hethp: %i[blockNumber timeStamp blockReward iax],
+    nethw: %w[withdrawalindex validatorindex address amount blocknumber timestamp dias],
+    hethw: %i[withdrawalIndex validatorIndex address amount blockNumber timeStamp],
+    nethk: %w[blocknumber timestamp txhash nonce blockhash transactionindex axfrom axto iax value tokenname tokensymbol tokendecimal gas gasprice gasused input contractaddress dias],
+    hethk: %i[blockNumber timeStamp hash nonce blockHash transactionIndex from to iax value tokenName tokenSymbol tokenDecimal gas gasPrice gasUsed input contractAddress],
     neost: %w[gseq aseq bnum time contract action acfrom acto iax amount moeda memo dias],
+    heost: %i[global_action_seq account_action_seq block_num block_time account name from to iax quantity moe memo],
     cdet: %w[txid time tp user btc eur dtc dias],
+    hdet: %i[trade_id successfully_finished_at type username btc eur trade_marked_as_paid_at],
     cdel: %w[txid time tp add moe qt fee],
+    hdel: %i[nxid time tp add moe qtd fee],
     cust: %w[txid ordertxid pair time type ordertype price cost fee vol margin misc ledgers dias],
-    cusl: %w[txid refid time type aclass asset amount fee]
+    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]
   }
 
   # classe para processar bigquery
@@ -65,93 +75,81 @@ module Cns
       Time.now.strftime('TRANSACOES  %Y-%m-%d %H:%M:%S')
     end
 
-    # insere (caso existam) dados novos kraken/bitcoinde/paymium/therock/etherscan/greymass no bigquery
+    # insere dados novos kraken/bitcoinde/etherscan/greymass no bigquery
     def ptudo
       puts("#{tct} #{pus}, #{pde}, #{peth}, #{peos}")
     end
 
-    # insere (caso existam) dados novos kraken/etherscan no bigquery
+    # insere dados novos kraken/etherscan no bigquery
     def pwkrk
       puts("#{tct} #{pus}, #{peth}")
     end
 
-    # insere (caso existam) dados novos etherscan no bigquery
+    # insere dados novos etherscan no bigquery
     def pweth
       puts("#{tct} #{peth}")
     end
 
-    # insere (caso existam) dados novos etherscan no bigquery (output to file)
+    # insere dados novos etherscan no bigquery (output to file)
     def pceth
-      File.open(FO, mode: 'a') { |out| out.puts("#{tct} #{pethc}") }
+      File.open(FO, mode: 'a') { |o| o.puts("#{tct} #{pethc}") }
     end
 
     private
 
-    # insere transacoes blockchain novas nas tabelas netht (norml), nethi (internas), nethp (block), nethw (withdrawals), nethk (token)
-    #
     # @return [String] linhas & tabelas afetadas
     def peth
-      tabelas_out(apies, %w[ETH], %i[t i p w k], 'neth')
+      dml_out(apies, %w[ETH], %i[netht nethi nethp nethw nethk])
     end
 
-    # insere transacoes blockchain novas nas tabelas netht (norml), nethi (internas), nethp (block), nethw (withdrawals), nethk (token)
-    #
     # @return [String] linhas & tabelas afetadas
     def pethc
-      tabelas_out(apiesc, %w[ETH], %i[t i p w k], 'neth')
+      dml_out(apiesc, %w[ETH], %i[netht nethi nethp nethw nethk])
     end
 
-    # insere transacoes exchange kraken novas nas tabelas ust (trades), usl (ledger)
-    #
     # @return [String] linhas & tabelas afetadas
     def pus
-      tabelas_cus(apius, %w[KRAKEN], %i[cust cusl])
+      dml_out(apius, %w[KRAKEN], %i[cust cusl])
     end
 
-    # insere transacoes exchange bitcoinde novas nas tabelas det (trades), del (ledger)
-    #
     # @return [String] linhas & tabelas afetadas
     def pde
-      tabelas_out(apide, %w[BITCOINDE], %i[cdet cdel])
+      dml_out(apide, %w[BITCOINDE], %i[cdet cdel])
     end
 
-    # insere transacoes blockchain novas na tabela eos
-    #
     # @return [String] linhas & tabelas afetadas
     def peos
-      tabelas_out(apigm, %w[EOS], %i[neost])
+      dml_out(apigm, %w[EOS], %i[neost])
     end
 
     # cria job bigquery & verifica execucao
-    #
     # @param cmd (see sql)
     # @return [Boolean] job ok?
     def job?(cmd)
-      @job = api.query_job(cmd)
+      @job = api.query_job(cmd, priority: 'BATCH')
       job.wait_until_done!
-      return false unless job.failed?
+      return true unless job.failed?
 
       puts("BigQuery Error: #{job.error['message']}")
-      true
+      false
     end
 
     # cria Structured Query Language (SQL) job bigquery
-    #
     # @param [String] cmd comando SQL a executar
     # @param [String] res resultado quando SQL tem erro
     # @return [Google::Cloud::Bigquery::Data] resultado do SQL
     def sql(cmd, res = [])
-      @sqr = job?(cmd) ? res : job.data
+      @sqr = job?(cmd) ? job.data : res
     end
 
     # cria Data Manipulation Language (DML) job bigquery
-    #
     # @param cmd (see sql)
     # @return [Integer] numero linhas afetadas
     def dml(cmd)
-      job?(cmd) ? 0 : job.num_dml_affected_rows
+      job?(cmd) ? job.num_dml_affected_rows : 0
     end
 
+    # @return [Etherscan] API blockchain ETH
     def apiesg(prx)
       Etherscan.new(
         {
@@ -171,270 +169,152 @@ module Cns
       @apies ||= apiesg('netb')
     end
 
-    # @return [Etherscan] API blockchain ETH
+    # @return [Etherscan] API blockchain ETH (cron)
     def apiesc
       @apiesc ||= apiesg('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") }, ops)
+      @apigm ||= Greymass.new({wb: sql("select * from #{BD}.weos ORDER BY ax"), nt: sql("select * from #{BD}.neosx")}, 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"), nl: sql("select * from #{BD}.cusl") }, ops)
+      @apius ||= Kraken.new({sl: sql("select * from #{BD}.cuss").first, nt: sql("select * from #{BD}.cust"), nl: sql("select * from #{BD}.cusl")}, 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"), nl: sql("select * from #{BD}.cdel") }, ops)
+      @apide ||= Bitcoinde.new({sl: sql("select * from #{BD}.cdes").first, nt: sql("select * from #{BD}.cdet"), nl: sql("select * from #{BD}.cdel")}, ops)
     end
 
-    def tabelas_cus(src, str, ltb, prx = '')
-      ltb.each do |itm|
-        novx = src.send("nov#{prx}#{itm}")
-        next if novx.empty?
-
-        # puts(insert_cus(prx, itm, novx))
-        str << format(' %<n>i %<t>s', n: dml(insert_cus(prx, itm, novx)), t: "#{prx}#{itm}")
-      end
-      str.join
+    # @return [String] comando insert SQL formatado
+    def ins_sql(tbl, lin)
+      "INSERT #{BD}.#{tbl} (#{TB[tbl].join(',')}) VALUES #{lin.map { |i| send("#{tbl}_val", i) }.join(',')}"
     end
 
-    def tabelas_out(src, str, ltb, prx = '')
-      ltb.each do |itm|
-        novx = src.send("nov#{prx}#{itm}")
-        next if novx.empty?
+    # @return [String] relatorio execucao dml
+    def dml_out(src, str, ltb)
+      str.concat(
+        ltb.filter_map do |itm|
+          novx = src.send("nov#{itm}")
+          next if novx.empty?
 
-        # puts(insert_out(prx, itm, novx))
-        str << format(' %<n>i %<t>s', n: dml(insert_out(prx, itm, novx)), t: "#{prx}#{itm}")
-      end
+          format(' %<n>i %<t>s', n: dml(ins_sql(itm, %i[cust cusl].include?(itm) ? novx.values : novx)), t: "#{itm}")
+        end
+      )
       str.join
     end
 
-    # @return [String] comando insert SQL formatado
-    def insert_cus(prx, tbl, lin)
-      "INSERT #{BD}.#{prx}#{tbl} (#{TB[tbl].join(',')}) VALUES #{lin.map { |key, val| send("#{prx}#{tbl}_val", key, val) }.join(',')}"
+    # @return [String] escapes SQL user input strings
+    def escape_sql(value)
+      value.gsub("'", "''").gsub('\\', '\\\\')
     end
 
-    # @return [String] comando insert SQL formatado
-    def insert_out(prx, tbl, lin)
-      "INSERT #{BD}.#{prx}#{tbl} (#{TB[tbl].join(',')}) VALUES #{lin.map { |itm| send("#{prx}#{tbl}_val", itm) }.join(',')}"
-    end
-
-    # SQL value formatting methods with improved safety
+    # @return [String] SQL string formatting
     def fqt(value)
       value.nil? || value.empty? ? 'null' : "'#{value}'"
     end
 
+    # @return [String] SQL string formatting with improved safety
+    def fqe(value)
+      value.to_s.empty? ? 'null' : "'#{escape_sql(value.to_s)}'"
+    end
+
+    # @return [String] SQL numeric formatting
     def fnm(value)
       "CAST(#{value.to_d} AS NUMERIC)"
     rescue StandardError
       'CAST(0 AS NUMERIC)'
     end
 
+    # @return [String] SQL integer formatting
     def fin(value)
-      Integer(value).to_s
+      Integer(value || 0).to_s
     rescue StandardError
       '0'
     end
 
-    def ftm(sec)
-      "PARSE_DATETIME('%s', '#{sec.round}')"
-    end
-
+    # @return [String] SQL timestamp formatting
     def fts(value)
-      "DATETIME(TIMESTAMP('#{value.iso8601}'))"
+      value.nil? ? 'null' : "DATETIME(TIMESTAMP('#{value.iso8601}'))"
+    end
+
+    # @return [String] formated SQL values for tables
+    def fvals(hsh, kys, idx = nil)
+      vls =
+        kys.map do |k|
+          case k
+          when :account_action_seq, :block_num, :blockNumber, :global_action_seq, :isError, :nonce, :timeStamp, :tokenDecimal, :transactionIndex, :nxid, :txreceipt_status, :validatorIndex, :withdrawalIndex then fin(hsh[k])
+          when :amount, :btc, :cost, :fee, :gas, :gasPrice, :gasUsed, :margin, :price, :quantity, :value, :vol, :eur, :blockReward, :qtd then fnm(hsh[k])
+          when :block_time, :successfully_finished_at, :time, :trade_marked_as_paid_at then fts(hsh[k])
+          when :memo, :input, :misc then fqe(hsh[k])
+          else fqt(hsh[k])
+          end
+        end
+      vls << fin(ops.dig(:h, hsh[idx].to_s)) if idx
+      "(#{vls.join(',')})"
     end
 
     # @param [Hash] htx transacao norml etherscan
-    # @return [String] valores formatados netht (norml parte1)
+    # @return [String] valores formatados netht
     def netht_val(htx)
-      vls = [
-        fin(htx[:blockNumber]),
-        fin(htx[:timeStamp]),
-        fqt(htx[:hash]),
-        fin(htx[:nonce]),
-        fqt(htx[:blockHash]),
-        fin(htx[:transactionIndex]),
-        fqt(htx[:from]),
-        fqt(htx[:to]),
-        fqt(htx[:iax]),
-        fnm(htx[:value]),
-        fnm(htx[:gas]),
-        fnm(htx[:gasPrice]),
-        fnm(htx[:gasUsed]),
-        fin(htx[:isError]),
-        fin(htx[:txreceipt_status]),
-        fqt(htx[:input]),
-        fqt(htx[:contractAddress]),
-        fin(ops.dig(:h, htx[:hash]))
-      ]
-      "(#{vls.join(',')})"
+      fvals(htx, TB[:hetht], :hash)
     end
 
     # @param [Hash] htx transacao internas etherscan
-    # @return [String] valores formatados nethi (internas parte1)
+    # @return [String] valores formatados nethi
     def nethi_val(htx)
-      vls = [
-        fin(htx[:blockNumber]),
-        fin(htx[:timeStamp]),
-        fqt(htx[:hash]),
-        fqt(htx[:from]),
-        fqt(htx[:to]),
-        fqt(htx[:iax]),
-        fnm(htx[:value]),
-        fqt(htx[:contractAddress]),
-        fqt(htx[:input]),
-        fqt(htx[:type]),
-        fnm(htx[:gas]),
-        fnm(htx[:gasUsed]),
-        fqt(htx[:traceId]),
-        fin(htx[:isError]),
-        fqt(htx[:errCode]),
-        fin(ops.dig(:h, htx[:hash]))
-      ]
-      "(#{vls.join(',')})"
+      fvals(htx, TB[:hethi], :hash)
     end
 
     # @param [Hash] htx transacao block etherscan
-    # @return [String] valores formatados nethi (block parte1)
+    # @return [String] valores formatados nethp
     def nethp_val(htx)
-      vls = [fin(htx[:blockNumber]), fin(htx[:timeStamp]), fnm(htx[:blockReward]), fqt(htx[:iax]), fin(ops.dig(:h, htx[:blockNumber]))]
-      "(#{vls.join(',')})"
+      fvals(htx, TB[:hethp], :blockNumber)
     end
 
     # @param [Hash] htx transacao withdrawals etherscan
-    # @return [String] valores formatados nethi (withdrawals parte1)
+    # @return [String] valores formatados nethw
     def nethw_val(htx)
-      vls = [
-        fin(htx[:withdrawalIndex]),
-        fin(htx[:validatorIndex]),
-        fqt(htx[:address]),
-        fnm(htx[:amount]),
-        fin(htx[:blockNumber]),
-        fin(htx[:timeStamp]),
-        fin(ops.dig(:h, htx[:withdrawalIndex]))
-      ]
-      "(#{vls.join(',')})"
+      fvals(htx, TB[:hethw], :withdrawalIndex)
     end
 
-    # @param [Hash] hkx token event etherscan
-    # @return [String] valores formatados nethk (token parte1)
+    # @param [Hash] htx token etherscan
+    # @return [String] valores formatados nethk
     def nethk_val(htx)
-      vls = [
-        fin(htx[:blockNumber]),
-        fin(htx[:timeStamp]),
-        fqt(htx[:hash]),
-        fin(htx[:nonce]),
-        fqt(htx[:blockHash]),
-        fin(htx[:transactionIndex]),
-        fqt(htx[:from]),
-        fqt(htx[:to]),
-        fqt(htx[:iax]),
-        fnm(htx[:value]),
-        fqt(htx[:tokenName]),
-        fqt(htx[:tokenSymbol]),
-        fin(htx[:tokenDecimal]),
-        fnm(htx[:gas]),
-        fnm(htx[:gasPrice]),
-        fnm(htx[:gasUsed]),
-        fqt(htx[:input]),
-        fqt(htx[:contractAddress]),
-        fin(ops.dig(:h, htx[:hash]))
-      ]
-      "(#{vls.join(',')})"
+      fvals(htx, TB[:hethk], :hash)
     end
 
-    # @example (see Apibc#ledger_gm)
-    # @param [Hash] hlx ledger greymass
-    # @return [String] valores formatados para insert eos (parte1)
+    # @param [Hash] htx ledger greymass
+    # @return [String] valores formatados neost
     def neost_val(htx)
-      # act = htx[:action_trace][:act]
-      # dat = act[:data]
-      # qtd = dat[:quantity].to_s
-      # str = dat[:memo].inspect
-      vls = [
-        fin(htx[:global_action_seq]),
-        fin(htx[:account_action_seq]),
-        fin(htx[:block_num]),
-        fts(htx[:block_time]),
-        fqt(htx[:account]),
-        fqt(htx[:name]),
-        fqt(htx[:from]),
-        fqt(htx[:to]),
-        fqt(htx[:iax]),
-        fnm(htx[:quantity]),
-        fqt(htx[:moe]),
-        fqt(htx[:memo]),
-        fin(ops.dig(:h, htx[:itx]))
-      ]
-      "(#{vls.join(',')})"
+      fvals(htx, TB[:heost], :itx)
     end
 
-    # @param [Hash] htx trade bitcoinde
-    # @return [String] valores formatados det (trades parte1)
+    # @param [Hash] htx trades bitcoinde
+    # @return [String] valores formatados cdet
     def cdet_val(htx)
-      vls = [
-        fqt(htx[:trade_id]),
-        fts(htx[:successfully_finished_at]),
-        fqt(htx[:type]),
-        fqt(htx[:trading_partner_information][:username]),
-        fnm(htx[:type] == 'buy' ? htx[:amount_currency_to_trade_after_fee] : "-#{htx[:amount_currency_to_trade]}"),
-        fnm(htx[:volume_currency_to_pay_after_fee]),
-        fts(htx[:trade_marked_as_paid_at]),
-        fin(ops.dig(:h, htx[:trade_id]))
-      ]
-      "(#{vls.join(',')})"
+      fvals(htx, TB[:hdet], :trade_id)
     end
 
-    # @param [Hash] hlx ledger (deposits + withdrawals) bitcoinde
-    # @return [String] valores formatados del (ledger)
+    # @param [Hash] htx ledger (deposits + withdrawals) bitcoinde
+    # @return [String] valores formatados cdel
     def cdel_val(htx)
-      vls = [
-        fin(htx[:txid]),
-        fts(htx[:time]),
-        fqt(htx[:tp]),
-        fqt(htx[:add]),
-        fqt(htx[:moe]),
-        fnm(htx[:tp] == 'withdrawal' ? "-#{htx[:qt]}" : "#{htx[:qt]}"),
-        fnm(htx[:fee])
-      ]
-      "(#{vls.join(',')})"
+      fvals(htx, TB[:hdel])
     end
 
-    # @param [String] idx identificador transacao
-    # @param [Hash] htx trade kraken
-    # @return [String] valores formatados ust (trades parte1)
-    def cust_val(idx, htx)
-      # gets ledgers related to this trade
-      ldg = apius.exd[:kl].select { |_, obj| obj[:refid] == idx.to_s }.keys.join(',')
-      vls = [
-        fqt(idx),
-        fqt(htx[:ordertxid]),
-        fqt(htx[:pair]),
-        fts(htx[:time]),
-        fqt(htx[:type]),
-        fqt(htx[:ordertype]),
-        fnm(htx[:price]),
-        fnm(htx[:cost]),
-        fnm(htx[:fee]),
-        fnm(htx[:vol]),
-        fnm(htx[:margin]),
-        fqt(htx[:misc]),
-        fqt(ldg),
-        fin(ops.dig(:h, idx))
-      ]
-      "(#{vls.join(',')})"
+    # @param [Hash] htx trades kraken
+    # @return [String] valores formatados cust
+    def cust_val(htx)
+      fvals(htx.merge(ledgers: apius.exd[:kl].select { |_, o| o[:refid] == htx[:txid] }.keys.join(',')), TB[:hust], :txid)
     end
 
-    # @param idx (see ust_val)
-    # @param [Hash] hlx ledger kraken
-    # @return [String] valores formatados usl (ledger)
-    def cusl_val(idx, hlx)
-      vls = [fqt(idx), fqt(hlx[:refid]), fts(hlx[:time]), fqt(hlx[:type]), fqt(hlx[:aclass]), fqt(hlx[:asset]), fnm(hlx[:amount]), fnm(hlx[:fee])]
-      "(#{vls.join(',')})"
+    # @param [Hash] htx ledger kraken
+    # @return [String] valores formatados cusl
+    def cusl_val(htx)
+      fvals(htx, TB[:husl])
     end
   end
 end

data/lib/cns/bitcoinde.rb

@@ -27,7 +27,7 @@ module Cns
 
     # @return [Hash] dados exchange bitcoinde - saldos & trades & deposits & withdrawals
     def exd
-      @exd ||= { sl: pdea(api.account_de), tt: pdet(api.trades_de), tl: pdel(api.deposits_de + api.withdrawals_de) }
+      @exd ||= {sl: pdea(api.account_de), tt: pdet(api.trades_de), tl: pdel(api.deposits_de + api.withdrawals_de)}
     end
 
     # @return [String] texto saldos & transacoes & ajuste dias
@@ -40,7 +40,7 @@ module Cns
       mledger
       return if novcdet.empty?
 
-      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |obj| "#{obj}:0" }.join(' ')}")
+      puts("\nstring ajuste dias dos trades\n-h=#{novcdet.sort_by { |i| -i[:srx] }.map { |o| "#{o[:trade_id]}:0" }.join(' ')}")
     end
 
     private
@@ -102,8 +102,8 @@ module Cns
         dp: htx[:trade_marked_as_paid_at].strftime('%F'),
         ty: htx[:type],
         mo: htx[:trading_pair],
-        vl: htx[:amount_currency_to_trade],
-        co: htx[:volume_currency_to_pay]
+        vl: htx[:btc],
+        co: htx[:eur]
       )
     end
 
@@ -116,7 +116,7 @@ module Cns
         dt: hlx[:time].strftime('%F %T'),
         ty: hlx[:tp],
         mo: hlx[:moe],
-        pr: hlx[:qt],
+        pr: hlx[:qtd],
         vl: hlx[:fee]
       )
     end
@@ -136,7 +136,7 @@ module Cns
     def mtrades
       return unless ops[:v] && novcdet.any?
 
-      puts("\ntrades data       hora     dt criacao tipo  par                     qtd      eur")
+      puts("\ntrades data       hora     dt criacao tipo  par                     btc      eur")
       novcdet.sort_by { |i| -i[:srx] }.each { |o| puts(formata_trades(o)) }
     end
 
@@ -168,16 +168,18 @@ module Cns
       itm.map do |t|
         pdes(:successfully_finished_at, t).merge(
           trade_marked_as_paid_at: ptm(t[:trade_marked_as_paid_at]),
-          amount_currency_to_trade: t[:amount_currency_to_trade].to_d,
-          volume_currency_to_pay: t[:volume_currency_to_pay].to_d,
+          username: t[:trading_partner_information][:username],
+          btc: t[:type] == 'buy' ? t[:amount_currency_to_trade_after_fee].to_d : -1 * t[:amount_currency_to_trade].to_d,
+          eur: t[:volume_currency_to_pay_after_fee].to_d,
           trading_pair: t[:trading_pair].upcase
         )
       end
     end
 
     # Processa os ledger entries para garantir que as datas estejam no formato correto
+
     def pdel(itm)
-      itm.map { |t| pdes(:time, t).merge(qt: t[:qt].to_d, fee: t[:fee].to_d, moe: t[:moe].upcase) }
+      itm.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) }
     end
   end
 end

data/lib/cns/etherscan.rb

@@ -19,38 +19,38 @@ module Cns
     TT = {
       normal: {
         new: :novnetht,
-        sort_key: :srx,
         format: :formata_tx_ti,
         header: "\ntx normal                     from            to              data         valor",
-        adjustment_key: :hash
+        sork: :srx,
+        adjk: :hash
       },
       internal: {
         new: :novnethi,
-        sort_key: :srx,
         format: :formata_tx_ti,
         header: "\ntx intern                     from            to              data         valor",
-        adjustment_key: :hash
+        sork: :srx,
+        adjk: :hash
       },
       block: {
         new: :novnethp,
-        sort_key: :itx,
         format: :formata_tx_block,
         header: "\ntx block  address                                   data                   valor",
-        adjustment_key: :blockNumber
+        sork: :itx,
+        adjk: :blockNumber
       },
       token: {
         new: :novnethk,
-        sort_key: :srx,
         format: :formata_tx_token,
         header: "\ntx token             from            to              data            valor moeda",
-        adjustment_key: :hash
+        sork: :srx,
+        adjk: :hash
       },
       withdrawal: {
         new: :novnethw,
-        sort_key: :itx,
         format: :formata_tx_withw,
         header: "\nwithdrawal validator data            valor",
-        adjustment_key: :withdrawalIndex
+        sork: :itx,
+        adjk: :withdrawalIndex
       }
     }
 
@@ -224,7 +224,7 @@ module Cns
         next unless ops[:v] && ntx.any?
 
         puts(cfg[:header])
-        ntx.sort_by { |s| -s[cfg[:sort_key]] }.each { |t| puts(send(cfg[:format], t)) }
+        ntx.sort_by { |s| -s[cfg[:sork]] }.each { |t| puts(send(cfg[:format], t)) }
       end
     end
 
@@ -234,7 +234,7 @@ module Cns
         ntx = send(cfg[:new])
         next unless ntx.any?
 
-        puts("\najuste dias transacoes #{typ}\n-h=#{ntx.map { |t| "#{t[cfg[:adjustment_key]]}:0" }.join(' ')}")
+        puts("\najuste dias transacoes #{typ}\n-h=#{ntx.sort_by { |s| -s[cfg[:sork]] }.map { |t| "#{t[cfg[:adjk]]}:0" }.join(' ')}")
       end
     end
 
@@ -366,31 +366,6 @@ module Cns
       @novnethk ||= bcd.map { |obc| obc[:kx].select { |obj| idk.include?(obj[:itx]) } }.flatten.uniq { |itm| itm[:itx] }
     end
 
-    # @return [Array<Hash>] lista ordenada transacoes normais novas
-    def sortx
-      novnetht.sort_by { |i| -i[:srx] }
-    end
-
-    # @return [Array<Hash>] lista ordenada transacoes internas novas
-    def sorix
-      novnethi.sort_by { |i| -i[:srx] }
-    end
-
-    # @return [Array<Hash>] lista ordenada transacoes block novas
-    def sorpx
-      novnethp.sort_by { |i| -i[:itx] }
-    end
-
-    # @return [Array<Hash>] lista ordenada transacoes withdrawals novas
-    def sorwx
-      novnethw.sort_by { |i| -i[:itx] }
-    end
-
-    # @return [Array<Hash>] lista ordenada transacoes token novas
-    def sorkx
-      novnethk.sort_by { |i| -i[:srx] }
-    end
-
     def pess(itm)
       tym = Integer(itm[:timeStamp])
       itm.merge(srx: tym, timeStamp: Time.at(tym))

data/lib/cns/greymass.rb

@@ -27,10 +27,10 @@ module Cns
 
     TT = {
       new: :novneost,
-      sort_key: :itx,
       format: :formata_ledger,
       header: "\nsequence num from         to           accao      data              valor moeda",
-      adjustment_key: :itx
+      sork: :itx,
+      adjk: :itx
     }
 
     # @return [String] texto carteiras & transacoes & ajuste dias
@@ -87,7 +87,7 @@ module Cns
       return unless ops[:v] && ntx.any?
 
       puts(TT[:header])
-      ntx.sort_by { |s| -s[TT[:sort_key]] }.each { |t| puts(send(TT[:format], t)) }
+      ntx.sort_by { |s| -s[TT[:sork]] }.each { |t| puts(send(TT[:format], t)) }
     end
 
     # @return [String] texto configuracao ajuste dias das transacoes
@@ -95,7 +95,7 @@ module Cns
       ntx = send(TT[:new])
       return unless ntx.any?
 
-      puts("\nstring ajuste dias\n-h=#{ntx.map { |t| "#{t[TT[:adjustment_key]]}:0" }.join(' ')}")
+      puts("\nstring ajuste dias\n-h=#{ntx.sort_by { |s| -s[TT[:sork]] }.map { |t| "#{t[TT[:adjk]]}:0" }.join(' ')}")
     end
 
     # @return [Array<Hash>] todos os dados greymass - saldos & transacoes
@@ -126,7 +126,7 @@ module Cns
     # @return [Hash] dados greymass - address, saldo & transacoes
     def base_bc(wbq)
       xbq = wbq[:ax]
-      { ax: xbq, sl: peosa(xbq).reduce(:+), tx: peost(xbq, api.ledger_gm(xbq)) }
+      {ax: xbq, sl: peosa(xbq).reduce(:+), tx: peost(xbq, api.ledger_gm(xbq))}
     end
 
     # @param wbq (see base_bc)
@@ -149,11 +149,6 @@ module Cns
       @novneost ||= bcd.map { |obc| obc[:tx].select { |obj| idt.include?(obj[:itx]) } }.flatten
     end
 
-    # @return [Array<Hash>] lista ordenada transacoes
-    def soreost
-      novneost.sort_by { |i| -i[:itx] }
-    end
-
     # @return [Array<BigDecimal>] lista recursos - liquido, net, spu
     def peosa(add)
       hac = api.account_gm(add)

data/lib/cns/kraken.rb

@@ -27,7 +27,7 @@ module Cns
 
     # @return [Hash] dados exchange kraken - saldos & transacoes trades e ledger
     def exd
-      @exd ||= { sl: pusa(api.account_us), kt: pust(api.trades_us), kl: pusl(api.ledger_us) }
+      @exd ||= {sl: pusa(api.account_us), kt: pust(api.trades_us), kl: pusl(api.ledger_us)}
     end
 
     # @return [String] texto saldos & transacoes & ajuste dias
@@ -40,7 +40,7 @@ module Cns
       mledger
       return if novcust.empty?
 
-      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |obj| "#{obj}:0" }.join(' ')}")
+      puts("\nstring ajuste dias dos trades\n-h=#{novcust.sort_by { |_, v| -v[:srx] }.map { |k, _v| "#{k}:0" }.join(' ')}")
     end
 
     private
@@ -139,7 +139,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 { |i, t| puts(formata_trades(i, t)) }
+      novcust.sort_by { |_, v| -v[:srx] }.each { |k, t| puts(formata_trades(k, t)) }
     end
 
     # @return [String] texto transacoes ledger
@@ -147,27 +147,30 @@ module Cns
       return unless ops[:v] && novcusl.any?
 
       puts("\nledger data       hora     tipo       moeda        quantidade              custo")
-      novcusl.sort_by { |_, v| -v[:srx] }.each { |i, t| puts(formata_ledger(i, t)) }
+      novcusl.sort_by { |_, v| -v[:srx] }.each { |k, t| puts(formata_ledger(k, t)) }
     end
 
-    # Processa os trades para garantir que as datas estejam no formato correto
+    # Processa accounts para garantir formato correto
     def pusa(itm)
       itm.select { |k, _| EM.include?(k) }.transform_values { |v| v.to_d }
     end
 
-    def puss(itm)
-      tym = Integer(itm[:time])
-      itm.merge(srx: tym, time: Time.at(tym))
+    # Processa campos comuns para garantir formato correto
+    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
 
-    # Processa os trades para garantir que as datas estejam no formato correto
+    # Processa trades para garantir formato correto
     def pust(itm)
-      itm.transform_values { |t| puss(t).merge(pair: t[:pair].upcase, price: t[:price].to_d, vol: t[:vol].to_d, cost: t[:cost].to_d) }
+      pusk(itm).transform_values { |t| t.merge(pair: t[:pair].upcase, price: t[:price].to_d, vol: t[:vol].to_d, cost: t[:cost].to_d) }
     end
 
-    # Processa os ledger entries para garantir que as datas estejam no formato correto
+    # Processa ledgers para garantir formato correto
     def pusl(itm)
-      itm.transform_values { |t| puss(t).merge(asset: t[:asset].upcase, amount: t[:amount].to_d, fee: t[:fee].to_d) }
+      pusk(itm).transform_values { |t| t.merge(asset: t[:asset].upcase, amount: t[:amount].to_d, fee: t[:fee].to_d) }
     end
   end
 end

data/lib/cns/version.rb

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

metadata

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