cns 0.1.5 → 0.1.6

data/lib/cns/bitcoinde.rb

@@ -27,25 +27,25 @@ module Cns
 
     # @return [Array<Hash>] lista trades bitcoinde novos
     def trades
-      @trades ||= exd[:tt].select { |h| kyt.include?(h[:trade_id]) }
+      @trades ||= exd[:tt].select { |obj| kyt.include?(obj[:trade_id]) }
     end
 
     # @return [Array<Hash>] lista ledger (deposits + withdrawals) bitcoinde novos
     def ledger
-      @ledger ||= exd[:tl].select { |h| kyl.include?(h[:txid]) }
+      @ledger ||= exd[:tl].select { |obj| kyl.include?(obj[:txid]) }
     end
 
     # @return [String] texto saldos & transacoes & ajuste dias
     def mostra_resumo
       puts("\nBITCOINDE\ntipo              bitcoinde              bigquery")
-      exd[:sl].each { |k, v| puts(formata_saldos(k, v)) }
+      exd[:sl].each { |key, val| puts(formata_saldos(key, val)) }
       mostra_totais
 
       mostra_trades
       mostra_ledger
       return if trades.empty?
 
-      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |e| "#{e}:0" }.join(' ')}")
+      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |obj| "#{obj}:0" }.join(' ')}")
     end
 
     # @return [Hash] dados exchange bitcoinde - saldos & trades & deposits & withdrawals
@@ -59,12 +59,12 @@ module Cns
 
     # @return [Array<String>] lista txid dos trades novos
     def kyt
-      @kyt ||= exd[:tt].map { |h| h[:trade_id] }.flatten - (ops[:t] ? [] : bqd[:nt].map { |e| e[:txid] })
+      @kyt ||= exd[:tt].map { |oex| oex[:trade_id] }.flatten - (ops[:t] ? [] : bqd[:nt].map { |obq| obq[:txid] })
     end
 
     # @return [Array<Integer>] lista txid dos ledger novos
     def kyl
-      @kyl ||= exd[:tl].map { |h| h[:txid] }.flatten - (ops[:t] ? [] : bqd[:nl].map { |e| e[:txid] })
+      @kyl ||= exd[:tl].map { |oex| oex[:txid] }.flatten - (ops[:t] ? [] : bqd[:nl].map { |obq| obq[:txid] })
     end
 
     # @example (see Apice#account_de)
@@ -72,14 +72,14 @@ module Cns
     # @param [Hash] hsx saldo bitcoinde da moeda
     # @return [String] texto formatado saldos
     def formata_saldos(moe, hsx)
-      b = bqd[:sl][moe.downcase.to_sym].to_d
-      e = hsx[:total_amount].to_d
+      vbq = bqd[:sl][moe.downcase.to_sym].to_d
+      vex = hsx[:total_amount].to_d
       format(
         '%<mo>-5.5s %<ex>21.9f %<bq>21.9f %<ok>3.3s',
         mo: moe.upcase,
-        ex: e,
-        bq: b,
-        ok: e == b ? 'OK' : 'NOK'
+        ex: vex,
+        bq: vbq,
+        ok: vex == vbq ? 'OK' : 'NOK'
       )
     end
 
@@ -117,13 +117,13 @@ module Cns
 
     # @return [String] texto numero de transacoes
     def mostra_totais
-      a = exd[:tt].count
-      b = bqd[:nt].count
-      c = exd[:tl].count
-      d = bqd[:nl].count
+      vtt = exd[:tt].count
+      vnt = bqd[:nt].count
+      vtl = exd[:tl].count
+      vnl = bqd[:nl].count
 
-      puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: a, b: b, o: a == b ? 'OK' : 'NOK')}")
-      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: c, d: d, o: c == d ? 'OK' : 'NOK')}")
+      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')}")
     end
 
     # @return [String] texto transacoes trades
@@ -131,8 +131,9 @@ module Cns
       return unless ops[:v] && !trades.empty?
 
       puts("\ntrades data       hora     dt criacao tipo  par                     qtd      eur")
-      trades.sort { |a, b| Time.parse(b[:successfully_finished_at]) <=> Time.parse(a[:successfully_finished_at]) }
-            .each { |h| puts(formata_trades(h)) }
+      trades
+        .sort { |ant, prx| Time.parse(prx[:successfully_finished_at]) <=> Time.parse(ant[:successfully_finished_at]) }
+        .each { |obj| puts(formata_trades(obj)) }
     end
 
     # @return [String] texto transacoes ledger
@@ -140,7 +141,7 @@ module Cns
       return unless ops[:v] && !ledger.empty?
 
       puts("\nledger data       hora     tipo       moe          quantidade              custo")
-      ledger.sort { |a, b| b[:time] <=> a[:time] }.each { |h| puts(formata_ledger(h)) }
+      ledger.sort { |ant, prx| prx[:time] <=> ant[:time] }.each { |obj| puts(formata_ledger(obj)) }
     end
   end
 end

data/lib/cns/etherscan1.rb

@@ -29,49 +29,51 @@ module Cns
 
     # @return [Array<Hash>] lista transacoes normais novas
     def novtx
-      @novtx ||= bcd.map { |e| e[:tx].select { |n| idt.include?(n[:itx]) } }.flatten
+      @novtx ||= bcd.map { |obc| obc[:tx].select { |obj| idt.include?(obj[:itx]) } }.flatten
     end
 
     # @return [Array<Hash>] lista transacoes token novas
     def novkx
-      @novkx ||= bcd.map { |e| e[:kx].select { |n| idk.include?(n[:itx]) } }.flatten
+      @novkx ||= bcd.map { |obc| obc[:kx].select { |obj| idk.include?(obj[:itx]) } }.flatten
     end
 
     # @return [Array<String>] lista dos meus enderecos
     def lax
-      @lax ||= bqd[:wb].map { |h| h[:ax] }
+      @lax ||= bqd[:wb].map { |obj| obj[:ax] }
     end
 
     # @return [Array<Hash>] todos os dados etherscan - saldos & transacoes
     def bcd
-      @bcd ||= api.account_es(lax).map { |e| base_bc(e) }
+      @bcd ||= api.account_es(lax).map { |obj| base_bc(obj) }
     end
 
     # @return [Array<Hash>] todos os dados juntos bigquery & etherscan
     def dados
-      @dados ||= bqd[:wb].map { |b| bq_bc(b, bcd.select { |s| b[:ax] == s[:ax] }.first) }
+      @dados ||= bqd[:wb].map { |obq| bq_bc(obq, bcd.select { |obc| obq[:ax] == obc[:ax] }.first) }
     end
 
     # @return [Array<Integer>] lista indices transacoes normais novas
     def idt
-      @idt ||= (bcd.map { |e| e[:tx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : bqd[:nt].map { |t| t[:itx] }))
+      @idt ||= bcd.map { |obc| obc[:tx].map { |obj| obj[:itx] } }.flatten -
+               (ops[:t] ? [] : bqd[:nt].map { |obq| obq[:itx] })
     end
 
     # @return [Array<Integer>] lista indices transacoes token novas
     def idk
-      @idk ||= (bcd.map { |e| e[:kx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : bqd[:nk].map { |t| t[:itx] }))
+      @idk ||= bcd.map { |obc| obc[:kx].map { |obj| obj[:itx] } }.flatten -
+               (ops[:t] ? [] : bqd[:nk].map { |obq| obq[:itx] })
     end
 
     # @example (see Apibc#account_es)
     # @param [Hash] abc account etherscan
     # @return [Hash] dados etherscan - address, saldo & transacoes
     def base_bc(abc)
-      a = abc[:account]
+      acc = abc[:account]
       {
-        ax: a,
+        ax: acc,
         sl: (abc[:balance].to_d / 10**18).round(10),
-        tx: filtrar_tx(a, api.norml_es(a)),
-        kx: filtrar_tx(a, api.token_es(a))
+        tx: filtrar_tx(acc, api.norml_es(acc)),
+        kx: filtrar_tx(acc, api.token_es(acc))
       }
     end
 
@@ -81,10 +83,10 @@ module Cns
     def bq_bc(wbq, hbc)
       {
         id: wbq[:id],
-        ax: wbq[:ax],
+        ax: xbq = wbq[:ax],
         bs: wbq[:sl],
-        bt: bqd[:nt].select { |t| t[:iax] == wbq[:ax] },
-        bk: bqd[:nk].select { |t| t[:iax] == wbq[:ax] },
+        bt: bqd[:nt].select { |ont| ont[:iax] == xbq },
+        bk: bqd[:nk].select { |onk| onk[:iax] == xbq },
         es: hbc[:sl],
         et: hbc[:tx],
         ek: hbc[:kx]
@@ -97,23 +99,23 @@ module Cns
     def filtrar_tx(add, ary)
       # elimina transferencia from: (lax) to: (add) - esta transferencia aparece em from: (add) to: (lax)
       # elimina chaves irrelevantes (DL) & adiciona chave indice itx & adiciona identificador da carteira iax
-      ary.delete_if { |h| h[:to] == add && lax.include?(h[:from]) }
-         .map { |h| h.delete_if { |k, _| DL.include?(k) }.merge(itx: Integer(h[:blockNumber]), iax: add) }
+      ary.delete_if { |odl| odl[:to] == add && lax.include?(odl[:from]) }
+         .map { |omp| omp.delete_if { |key, _| DL.include?(key) }.merge(itx: Integer(omp[:blockNumber]), iax: add) }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes normais novas
     def sortx
-      novtx.sort { |a, b| a[:itx] <=> b[:itx] }
+      novtx.sort { |ant, prx| ant[:itx] <=> prx[:itx] }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes token novas
     def sorkx
-      novkx.sort { |a, b| a[:itx] <=> b[:itx] }
+      novkx.sort { |ant, prx| ant[:itx] <=> prx[:itx] }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes (normais & token) novas
     def sorax
-      (novtx + novkx).sort { |a, b| a[:itx] <=> b[:itx] }
+      (novtx + novkx).sort { |ant, prx| ant[:itx] <=> prx[:itx] }
     end
   end
 end

data/lib/cns/etherscan2.rb

@@ -9,7 +9,7 @@ module Cns
       return unless dados.count.positive?
 
       puts("\nid     address                            etherscan nm tk     bigquery nm tk")
-      dados.each { |e| puts(formata_carteira(e)) }
+      dados.each { |obj| puts(formata_carteira(obj)) }
       mostra_transacao_norml
       mostra_transacao_token
       mostra_configuracao_ajuste_dias
@@ -52,9 +52,9 @@ module Cns
     # @param [Integer] max chars a mostrar
     # @return [String] endereco formatado
     def formata_endereco(add, max)
-      i = Integer((max - 2) / 2)
-      e = (max <= 20 ? bqd[:wb].select { |s| s[:ax] == add }.first : nil) || { id: add }
-      max < 7 ? 'erro' : "#{e[:id][0, i - 3]}..#{add[-i - 3..]}"
+      int = Integer((max - 2) / 2)
+      hid = (max <= 20 ? bqd[:wb].select { |obj| obj[:ax] == add }.first : nil) || { id: add }
+      max < 7 ? 'erro' : "#{hid[:id][0, int - 3]}..#{add[-int - 3..]}"
     end
 
     # @example (see Apibc#norml_es)
@@ -91,7 +91,7 @@ module Cns
       return unless ops[:v] && novtx.count.positive?
 
       puts("\ntx normal from                 to                   data                   valor")
-      sortx.each { |e| puts(formata_transacao_norml(e)) }
+      sortx.each { |obj| puts(formata_transacao_norml(obj)) }
     end
 
     # @return [String] texto transacoes token
@@ -99,14 +99,14 @@ module Cns
       return unless ops[:v] && novkx.count.positive?
 
       puts("\ntx token  from                 to                   data             valor")
-      sorkx.each { |e| puts(formata_transacao_token(e)) }
+      sorkx.each { |obj| puts(formata_transacao_token(obj)) }
     end
 
     # @return [String] texto configuracao ajuste dias das transacoes (normais & token)
     def mostra_configuracao_ajuste_dias
       return unless (novtx.count + novkx.count).positive?
 
-      puts("\nstring ajuste dias\n-h=#{sorax.map { |e| "#{e[:blockNumber]}:0" }.join(' ')}")
+      puts("\nstring ajuste dias\n-h=#{sorax.map { |obj| "#{obj[:blockNumber]}:0" }.join(' ')}")
     end
   end
 end

data/lib/cns/greymass1.rb

@@ -27,38 +27,39 @@ module Cns
 
     # @return [Array<Hash>] lista transacoes novas
     def novax
-      @novax ||= bcd.map { |e| e[:tx].select { |s| idt.include?(s[:itx]) } }.flatten
+      @novax ||= bcd.map { |obc| obc[:tx].select { |obj| idt.include?(obj[:itx]) } }.flatten
     end
 
     # @return [Array<String>] lista dos meus enderecos
     def lax
-      @lax ||= bqd[:wb].map { |h| h[:ax] }
+      @lax ||= bqd[:wb].map { |obj| obj[:ax] }
     end
 
     # @return [Array<Hash>] todos os dados greymass - saldos & transacoes
     def bcd
-      @bcd ||= bqd[:wb].map { |e| base_bc(e) }
+      @bcd ||= bqd[:wb].map { |obj| base_bc(obj) }
     end
 
     # @return [Array<Hash>] todos os dados juntos bigquery & greymass
     def dados
-      @dados ||= bqd[:wb].map { |b| bq_bc(b, bcd.select { |s| b[:ax] == s[:ax] }.first) }
+      @dados ||= bqd[:wb].map { |obq| bq_bc(obq, bcd.select { |obj| obq[:ax] == obj[:ax] }.first) }
     end
 
     # @return [Array<Integer>] lista indices transacoes novas
     def idt
-      @idt ||= (bcd.map { |e| e[:tx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : bqd[:nt].map { |t| t[:itx] }))
+      @idt ||= bcd.map { |obc| obc[:tx].map { |obj| obj[:itx] } }.flatten -
+               (ops[:t] ? [] : bqd[:nt].map { |obq| obq[:itx] })
     end
 
     # @example (see Apibc#account_gm)
     # @param [Hash] wbq wallet bigquery
     # @return [Hash] dados greymass - address, saldo & transacoes
     def base_bc(wbq)
-      a = wbq[:ax]
+      xbq = wbq[:ax]
       {
-        ax: a,
-        sl: greymass_sl(a).inject(:+),
-        tx: filtrar_tx(a, api.ledger_gm(a))
+        ax: xbq,
+        sl: greymass_sl(xbq).inject(:+),
+        tx: filtrar_tx(xbq, api.ledger_gm(xbq))
       }
     end
 
@@ -66,11 +67,12 @@ module Cns
     # @param [Hash] hbc dados greymass - address, saldo & transacoes
     # @return [Hash] dados juntos bigquery & greymass
     def bq_bc(wbq, hbc)
+      xbq = wbq[:ax]
       {
         id: wbq[:id],
-        ax: wbq[:ax],
+        ax: xbq,
         bs: wbq[:sl],
-        bt: bqd[:nt].select { |t| t[:iax] == wbq[:ax] },
+        bt: bqd[:nt].select { |obj| obj[:iax] == xbq },
         es: hbc[:sl],
         et: hbc[:tx]
       }
@@ -79,11 +81,12 @@ module Cns
     # @param (see filtrar_tx)
     # @return [Array<BigDecimal>] lista recursos - liquido, net, spu
     def greymass_sl(add)
-      v = api.account_gm(add)
+      hac = api.account_gm(add)
+      htr = hac[:total_resources]
       [
-        v[:core_liquid_balance].to_d,
-        v[:total_resources][:net_weight].to_d,
-        v[:total_resources][:cpu_weight].to_d
+        hac[:core_liquid_balance].to_d,
+        htr[:net_weight].to_d,
+        htr[:cpu_weight].to_d
       ]
     end
 
@@ -93,13 +96,15 @@ module Cns
     def filtrar_tx(add, ary)
       # elimina transferencia from: (lax) to: (add) - esta transferencia aparece em from: (add) to: (lax)
       # adiciona chave indice itx & adiciona identificador da carteira iax
-      ary.delete_if { |h| act_data(h)[:to] == add && lax.include?(act_data(h)[:from]) }
-         .map { |h| h.merge(itx: h[:global_action_seq], iax: add) }
+      (ary.delete_if do |odl|
+        adt = odl[:action_trace][:act][:data]
+        adt[:to] == add && lax.include?(adt[:from])
+      end).map { |omp| omp.merge(itx: omp[:global_action_seq], iax: add) }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes novas
     def sorax
-      novax.sort { |a, b| b[:itx] <=> a[:itx] }
+      novax.sort { |ant, prx| prx[:itx] <=> ant[:itx] }
     end
   end
 end

data/lib/cns/greymass2.rb

@@ -9,7 +9,7 @@ module Cns
       return unless dados.count.positive?
 
       puts("\naddress            greymass  ntx       bigquery  ntx")
-      dados.each { |e| puts(formata_carteira(e)) }
+      dados.each { |obj| puts(formata_carteira(obj)) }
       mostra_transacoes_novas
       mostra_configuracao_ajuste_dias
     end
@@ -40,47 +40,29 @@ module Cns
     def formata_ledger(hlx)
       format(
         '%<bn>12i %<fr>-12.12s %<to>-12.12s %<ac>-10.10s %<dt>10.10s %<vl>12.4f %<sy>-6.6s',
+        ac: (act = hlx[:action_trace][:act])[:name],
+        fr: (adt = act[:data])[:from],
+        vl: (aqt = adt[:quantity].to_s).to_d,
         bn: hlx[:itx],
-        fr: act_data(hlx)[:from],
-        to: act_data(hlx)[:to],
-        ac: act(hlx)[:name],
+        to: adt[:to],
         dt: Date.parse(hlx[:block_time]),
-        vl: act_data_quantity(hlx).to_d,
-        sy: act_data_quantity(hlx)[/[[:upper:]]+/]
+        sy: aqt[/[[:upper:]]+/]
       )
     end
 
-    # @param (see formata_ledger)
-    # @return [Hash] dados da acao
-    def act(hlx)
-      hlx[:action_trace][:act]
-    end
-
-    # @param (see formata_ledger)
-    # @return [Hash] dados da acao
-    def act_data(hlx)
-      act(hlx)[:data]
-    end
-
-    # @param (see formata_ledger)
-    # @return [String] dados da quantidade
-    def act_data_quantity(hlx)
-      act_data(hlx)[:quantity].to_s
-    end
-
     # @return [String] texto transacoes
     def mostra_transacoes_novas
       return unless ops[:v] && novax.count.positive?
 
       puts("\nsequence num from         to           accao      data              valor moeda")
-      sorax.each { |e| puts(formata_ledger(e)) }
+      sorax.each { |obj| puts(formata_ledger(obj)) }
     end
 
     # @return [String] texto configuracao ajuste dias das transacoes
     def mostra_configuracao_ajuste_dias
       return unless novax.count.positive?
 
-      puts("\nstring ajuste dias\n-h=#{sorax.map { |e| "#{e[:itx]}:0" }.join(' ')}")
+      puts("\nstring ajuste dias\n-h=#{sorax.map { |obj| "#{obj[:itx]}:0" }.join(' ')}")
     end
   end
 end

data/lib/cns/kraken.rb

@@ -27,25 +27,25 @@ module Cns
 
     # @return [Hash] trades kraken novos
     def trades
-      @trades ||= exd[:kt].select { |k, _| kyt.include?(k) }
+      @trades ||= exd[:kt].select { |key, _| kyt.include?(key) }
     end
 
     # @return [Hash] ledger kraken novos
     def ledger
-      @ledger ||= exd[:kl].select { |k, _| kyl.include?(k) }
+      @ledger ||= exd[:kl].select { |key, _| kyl.include?(key) }
     end
 
     # @return [String] texto saldos & transacoes & ajuste dias
     def mostra_resumo
       puts("\nKRAKEN\ntipo                 kraken              bigquery")
-      exd[:sl].each { |k, v| puts(formata_saldos(k, v)) }
+      exd[:sl].each { |key, val| puts(formata_saldos(key, val)) }
       mostra_totais
 
       mostra_trades
       mostra_ledger
       return if trades.empty?
 
-      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |e| "#{e}:0" }.join(' ')}")
+      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |obj| "#{obj}:0" }.join(' ')}")
     end
 
     # @return [Hash] dados exchange kraken - saldos & transacoes trades e ledger
@@ -59,12 +59,12 @@ module Cns
 
     # @return [Array<String>] lista txid dos trades novos
     def kyt
-      @kyt ||= exd[:kt].keys - (ops[:t] ? [] : bqd[:nt].map { |e| e[:txid].to_sym })
+      @kyt ||= exd[:kt].keys - (ops[:t] ? [] : bqd[:nt].map { |obj| obj[:txid].to_sym })
     end
 
     # @return [Array<String>] lista txid dos ledger novos
     def kyl
-      @kyl ||= exd[:kl].keys - (ops[:t] ? [] : bqd[:nl].map { |e| e[:txid].to_sym })
+      @kyl ||= exd[:kl].keys - (ops[:t] ? [] : bqd[:nl].map { |obj| obj[:txid].to_sym })
     end
 
     # @example (see Apice#account_us)
@@ -72,13 +72,14 @@ module Cns
     # @param [BigDecimal] sal saldo kraken da moeda
     # @return [String] texto formatado saldos
     def formata_saldos(moe, sal)
-      t = bqd[:sl][moe.downcase.to_sym].to_d
+      vbq = bqd[:sl][moe.downcase.to_sym].to_d
+      vsl = sal.to_d
       format(
         '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
         mo: moe.upcase,
-        kr: sal.to_d,
-        bq: t,
-        ok: t == sal.to_d ? 'OK' : 'NOK'
+        kr: vsl,
+        bq: vbq,
+        ok: vbq == vsl ? 'OK' : 'NOK'
       )
     end
 
@@ -115,29 +116,29 @@ module Cns
 
     # @return [String] texto totais numero de transacoes
     def mostra_totais
-      a = exd[:kt].count
-      b = bqd[:nt].count
-      c = exd[:kl].count
-      d = bqd[:nl].count
+      vkt = exd[:kt].count
+      vnt = bqd[:nt].count
+      vkl = exd[:kl].count
+      vnl = bqd[:nl].count
 
-      puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: a, b: b, o: a == b ? 'OK' : 'NOK')}")
-      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: c, d: d, o: c == d ? 'OK' : 'NOK')}")
+      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')}")
     end
 
     # @return [String] texto transacoes trades
     def mostra_trades
       return unless ops[:v] && trades.count.positive?
 
-      puts("\ntrade  data       hora     tipo       par      ---preco ---------volume ---custo")
-      trades.sort { |a, b| b[1][:time] <=> a[1][:time] }.each { |k, v| puts(formata_trades(k, v)) }
+      puts("\ntrade  data       hora     tipo       par         preco          volume    custo")
+      trades.sort { |ant, prx| prx[1][:time] <=> ant[1][:time] }.each { |key, val| puts(formata_trades(key, val)) }
     end
 
     # @return [String] texto transacoes ledger
     def mostra_ledger
       return unless ops[:v] && ledger.count.positive?
 
-      puts("\nledger data       hora     tipo       moeda -------quantidade -------------custo")
-      ledger.sort { |a, b| b[1][:time] <=> a[1][:time] }.each { |k, v| puts(formata_ledger(k, v)) }
+      puts("\nledger data       hora     tipo       moeda        quantidade              custo")
+      ledger.sort { |ant, prx| prx[1][:time] <=> ant[1][:time] }.each { |key, val| puts(formata_ledger(key, val)) }
     end
   end
 end