cns 0.1.1 → 0.1.2

data/lib/cns/bigquery4.rb

@@ -2,44 +2,65 @@
 
 # @author Hernani Rodrigues Vaz
 module Cns
-  # (see Bigquery)
+  # classe para processar bigquery
   class Bigquery
+    private
+
     # @return [String] comando insert SQL formatado det (trades)
     def det_ins
-      "insert #{BD}.det(tp,btc,eur,time,user,id,dtc,dias) VALUES#{apide.trades.map { |h| det_val1(h) }.join(',')}"
+      "insert #{BD}.det(txid,time,tp,user,btc,eur,dtc,dias) VALUES#{apide.trades.map { |h| det_val1(h) }.join(',')}"
     end
 
-    # @example (see Apide#trades)
-    # @param [Hash] htx transacao trade apide
+    # @example (see Apice#trades_de)
+    # @param [Hash] htx trade bitcoinde
     # @return [String] valores formatados det (trades parte1)
     def det_val1(htx)
-      "('#{htx[:type]}'," \
-      'cast(' \
-      "#{htx[:type] == 'buy' ? htx[:amount_currency_to_trade_after_fee] : "-#{htx[:amount_currency_to_trade]}"}" \
-      ' as numeric),' \
-      "cast(#{htx[:volume_currency_to_pay_after_fee]} as numeric)," \
+      "('#{htx[:trade_id]}'," \
       "DATETIME(TIMESTAMP('#{htx[:successfully_finished_at]}'))," \
+      "'#{htx[:type]}'," \
       "'#{htx[:trading_partner_information][:username]}'," \
       "#{det_val2(htx)}"
     end
 
-    # @param (see #det_val1)
+    # @param (see det_val1)
     # @return [String] valores formatados det (trades parte2)
     def det_val2(htx)
-      "'#{htx[:trade_id]}'," \
-        "DATETIME(TIMESTAMP('#{htx[:trade_marked_as_paid_at]}'))," \
+      'cast(' \
+      "#{htx[:type] == 'buy' ? htx[:amount_currency_to_trade_after_fee] : "-#{htx[:amount_currency_to_trade]}"}" \
+      ' as numeric),' \
+      "cast(#{htx[:volume_currency_to_pay_after_fee]} as numeric)," \
+      "DATETIME(TIMESTAMP('#{htx[:trade_marked_as_paid_at]}'))," \
       "#{Integer(ops[:h][htx[:trade_id]] || 0)})"
     end
 
+    # @return [String] comando insert SQL formatado del (ledger)
+    def del_ins
+      "insert #{BD}.del(txid,time,tp,add,moe,qt,fee) VALUES#{apide.ledger.map { |h| del_val(h) }.join(',')}"
+    end
+
+    # @example (see Apice#deposits_de)
+    # @example (see Apice#withdrawals_de)
+    # @param [Hash] hlx ledger (deposits + withdrawals) bitcoinde
+    # @return [String] valores formatados del (ledger)
+    def del_val(hlx)
+      "(#{hlx[:txid]}," \
+      "DATETIME(TIMESTAMP('#{hlx[:time].iso8601}'))," \
+      "'#{hlx[:tp]}'," \
+      "'#{hlx[:add]}'," \
+      "'#{hlx[:moe]}'," \
+      "cast(#{hlx[:tp] =='withdrawal' ? '-' : ''}#{hlx[:qt]} as numeric)," \
+      "cast(#{hlx[:fee]} as numeric))"
+    end
+
     # @return [String] comando insert SQL formatado ust (trades)
     def ust_ins
       "insert #{BD}.ust(txid,ordertxid,pair,time,type,ordertype,price,cost,fee,vol,margin,misc,ledgers,dias) " \
       "VALUES#{apius.trades.map { |k, v| ust_val1(k, v) }.join(',')}"
     end
 
-    # @example (see Apius#trades)
+    # @example (see Apice#trades_us)
     # @param [String] idx identificador transacao
-    # @param [Hash] htx transacao trade apius
+    # @param [Hash] htx trade kraken
     # @return [String] valores formatados ust (trades parte1)
     def ust_val1(idx, htx)
       "('#{idx}'," \
@@ -54,7 +75,7 @@ module Cns
       "#{ust_val2(idx, htx)}"
     end
 
-    # @param (see #ust_val1)
+    # @param (see ust_val1)
     # @return [String] valores formatados ust (trades parte2)
     def ust_val2(idx, htx)
       "cast(#{htx[:vol]} as numeric)," \
@@ -64,34 +85,15 @@ module Cns
       "#{Integer(ops[:h][idx] || 0)})"
     end
 
-    # @return [String] comando insert SQL formatado del (ledger)
-    def del_ins
-      "insert #{BD}.del(time,tp,qtxt,id,qt,fee,lgid) VALUES#{apide.ledger.map { |h| del_val(h) }.join(',')}"
-    end
-
-    # @example (see Apide#deposit_hash)
-    # @example (see Apide#withdrawal_hash)
-    # @param [Hash] hlx transacao uniformizada deposits + withdrawals apide
-    # @return [String] valores formatados del (ledger)
-    def del_val(hlx)
-      "(DATETIME(TIMESTAMP('#{hlx[:time].iso8601}'))," \
-      "'#{hlx[:tp]}'," \
-      "'#{hlx[:qtxt]}'," \
-      "'#{hlx[:id]}'," \
-      "cast(#{hlx[:tp] == 'out' ? '-' : ''}#{hlx[:qt]} as numeric)," \
-      "cast(#{hlx[:fee]} as numeric)," \
-      "#{hlx[:lgid]})"
-    end
-
     # @return [String] comando insert SQL formatado usl (ledger)
     def usl_ins
       "insert #{BD}.usl(txid,refid,time,type,aclass,asset,amount,fee) " \
       "VALUES#{apius.ledger.map { |k, v| usl_val(k, v) }.join(',')}"
     end
 
-    # @example (see Apius#ledger)
-    # @param idx (see #ust_val1)
-    # @param [Hash] hlx transacao ledger apius
+    # @example (see Apice#ledger_us)
+    # @param idx (see ust_val1)
+    # @param [Hash] hlx ledger kraken
     # @return [String] valores formatados usl (ledger)
     def usl_val(idx, hlx)
       "('#{idx}'," \
@@ -109,8 +111,8 @@ module Cns
       "insert #{BD}.fr(uuid,tipo,valor,moe,time,dias) VALUES#{apifr.ledger.map { |h| frl_val(h) }.join(',')}"
     end
 
-    # @example (see Apifr#ledger)
-    # @param [Hash] hlx transacao ledger apifr
+    # @example (see Apice#ledger_fr)
+    # @param [Hash] hlx ledger paymium
     # @return [String] valores formatados frl (ledger)
     def frl_val(hlx)
       "('#{hlx[:uuid]}'," \
@@ -127,8 +129,8 @@ module Cns
       "VALUES#{apimt.ledger.map { |h| mtl_val1(h) }.join(',')}"
     end
 
-    # @example (see Apimt#ledger)
-    # @param [Hash] hlx transacao ledger apimt
+    # @example (see Apice#ledger_mt)
+    # @param [Hash] hlx ledger therock
     # @return [String] valores formatados mtl (ledger parte1)
     def mtl_val1(hlx)
       "(#{hlx[:id]}," \
@@ -140,7 +142,7 @@ module Cns
       "#{mtl_val2(hlx)}"
     end
 
-    # @param hlx (see #mtl_val1)
+    # @param (see mtl_val1)
     # @return [String] valores formatados mtl (ledger parte2)
     def mtl_val2(hlx)
       "#{hlx[:note].to_s.empty? ? 'null' : "'#{hlx[:note]}'"}," \

data/lib/cns/bitcoinde.rb

@@ -4,12 +4,12 @@ require('bigdecimal/util')
 
 # @author Hernani Rodrigues Vaz
 module Cns
-  # classe para processar saldos & transacoes trades e ledger do bitcoinde
+  # classe para processar transacoes trades/ledger do bitcoinde
   class Bitcoinde
     # @return [Apius] API bitcoinde
     attr_reader :api
     # @return [Array<Hash>] todos os dados bigquery
-    attr_reader :dbq
+    attr_reader :bqd
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
     attr_reader :ops
 
@@ -20,47 +20,59 @@ module Cns
     # @option pop [Boolean] :t (false) mostra transacoes todas ou somente novas?
     # @return [Bitcoinde] API bitcoinde - obter saldos & transacoes trades e ledger
     def initialize(dad, pop)
-      # API bitcoinde base
-      @api = Apide.new
-      @dbq = dad
+      @api = Apice.new
+      @bqd = dad
       @ops = pop
     end
 
-    # @return [Hash] dados exchange bitcoinde - saldos & transacoes trades e ledger
+    # @return [Array<Hash>] lista trades bitcoinde novos
+    def trades
+      @trades ||= exd[:tt].select { |h| kyt.include?(h[:trade_id]) }
+    end
+
+    # @return [Array<Hash>] lista ledger (deposits + withdrawals) bitcoinde novos
+    def ledger
+      @ledger ||= exd[:tl].select { |h| kyl.include?(h[: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)) }
+      mostra_totais
+
+      mostra_trades
+      mostra_ledger
+      return if trades.empty?
+
+      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |e| "#{e}:0" }.join(' ')}")
+    end
+
+    # @return [Hash] dados exchange bitcoinde - saldos & trades & deposits & withdrawals
     def exd
       @exd ||= {
-        sl: api.account,
-        tt: api.trades,
-        tl: api.deposits + api.withdrawals
+        sl: api.account_de,
+        tt: api.trades_de,
+        tl: api.deposits_de + api.withdrawals_de
       }
     end
 
-    # @return [Array<String>] lista txid de transacoes trades
+    # @return [Array<String>] lista txid dos trades novos
     def kyt
-      @kyt ||= exd[:tt].map { |h| h[:trade_id] }.flatten - (ops[:t] ? [] : dbq[:nt].map { |e| e[:txid] })
+      @kyt ||= exd[:tt].map { |h| h[:trade_id] }.flatten - (ops[:t] ? [] : bqd[:nt].map { |e| e[:txid] })
     end
 
-    # @return [Array<Integer>] lista txid de transacoes ledger
+    # @return [Array<Integer>] lista txid dos ledger novos
     def kyl
-      @kyl ||= exd[:tl].map { |h| h[:lgid] }.flatten - (ops[:t] ? [] : dbq[:nl].map { |e| e[:txid] })
-    end
-
-    # @return [Hash] transacoes trades
-    def trades
-      @trades ||= exd[:tt].select { |h| kyt.include?(h[:trade_id]) }
-    end
-
-    # @return [Hash] transacoes ledger
-    def ledger
-      @ledger ||= exd[:tl].select { |h| kyl.include?(h[:lgid]) }
+      @kyl ||= exd[:tl].map { |h| h[:txid] }.flatten - (ops[:t] ? [] : bqd[:nl].map { |e| e[:txid] })
     end
 
-    # @example (see Apide#account)
+    # @example (see Apice#account_de)
     # @param [String] moe codigo bitcoinde da moeda
     # @param [Hash] hsx saldo bitcoinde da moeda
-    # @return [String] texto formatado saldos (bitcoinde)
+    # @return [String] texto formatado saldos
     def formata_saldos(moe, hsx)
-      b = dbq[:sl][moe.downcase.to_sym].to_d
+      b = bqd[:sl][moe.downcase.to_sym].to_d
       e = hsx[:total_amount].to_d
       format(
         '%<mo>-5.5s %<ex>21.9f %<bq>21.9f %<ok>3.3s',
@@ -71,9 +83,9 @@ module Cns
       )
     end
 
-    # @example (see Apide#trades)
+    # @example (see Apice#trades_de)
     # @param (see Bigquery#det_val1)
-    # @return [String] texto formatado transacao trade
+    # @return [String] texto formatado trade
     def formata_trades(htx)
       format(
         '%<ky>-6.6s %<dt>19.19s %<dp>10.10s %<ty>-5.5s %<mo>-8.8s %<vl>18.8f %<co>8.2f',
@@ -87,48 +99,47 @@ module Cns
       )
     end
 
-    # @example (see Apide#deposit_hash)
-    # @example (see Apide#withdrawal_hash)
+    # @example (see Apice#deposits_unif_de)
+    # @example (see Apice#withdrawals_unif_de)
     # @param (see Bigquery#del_val)
-    # @return [String] texto formatado transacao ledger
+    # @return [String] texto formatado ledger
     def formata_ledger(hlx)
       format(
         '%<ky>6i %<dt>19.19s %<ty>-10.10s %<mo>-3.3s %<pr>19.8f %<vl>18.8f',
-        ky: hlx[:lgid],
+        ky: hlx[:txid],
         dt: hlx[:time],
         ty: hlx[:tp],
-        mo: hlx[:qtxt].upcase,
+        mo: hlx[:moe].upcase,
         pr: hlx[:qt].to_d,
         vl: hlx[:fee].to_d
       )
     end
 
-    # @return [String] texto saldos & transacoes & ajuste dias
-    def mostra_resumo
-      puts("\nBITCOINDE\nmoeda       saldo bitcoinde        saldo bigquery")
-      exd[:sl].each { |k, v| puts(formata_saldos(k, v)) }
+    # @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
 
-      mostra_trades
-      mostra_ledger
-      return unless trades.count.positive?
-
-      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |e| "#{e}:0" }.join(' ')}")
+      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')}")
     end
 
     # @return [String] texto transacoes trades
     def mostra_trades
-      return unless ops[:v] && trades.count.positive?
+      return unless ops[:v] && !trades.empty?
 
-      puts("\ntrades data       hora     dt criacao tipo  par      ---------------qtd -----eur")
+      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)) }
     end
 
     # @return [String] texto transacoes ledger
     def mostra_ledger
-      return unless ops[:v] && ledger.count.positive?
+      return unless ops[:v] && !ledger.empty?
 
-      puts("\nledger data       hora     tipo       moe ---------quantidade -------------custo")
+      puts("\nledger data       hora     tipo       moe          quantidade              custo")
       ledger.sort { |a, b| b[:time] <=> a[:time] }.each { |h| puts(formata_ledger(h)) }
     end
   end

data/lib/cns/etherscan1.rb

@@ -9,10 +9,10 @@ module Cns
 
   # (see Etherscan)
   class Etherscan
-    # @return [Apies] API etherscan
+    # @return [Apibc] API blockchains
     attr_reader :api
     # @return [Array<Hash>] todos os dados bigquery
-    attr_reader :dbq
+    attr_reader :bqd
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
     attr_reader :ops
 
@@ -22,77 +22,78 @@ module Cns
     # @option pop [Boolean] :v (false) mostra dados transacoes normais & tokens?
     # @return [Etherscan] API etherscan - processar transacoes normais e tokens
     def initialize(dad, pop)
-      @api = Apies.new
-      @dbq = dad
+      @api = Apibc.new
+      @bqd = dad
       @ops = pop
     end
 
+    # @return [Array<Hash>] lista transacoes normais novas
+    def novtx
+      @novtx ||= bcd.map { |e| e[:tx].select { |n| idt.include?(n[: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
+    end
+
     # @return [Array<String>] lista dos meus enderecos
     def lax
-      @lax ||= dbq[:wb].map { |h| h[:ax] }
+      @lax ||= bqd[:wb].map { |h| h[:ax] }
     end
 
     # @return [Array<Hash>] todos os dados etherscan - saldos & transacoes
-    def dbc
-      @dbc ||= api.account(lax).map { |e| base_bc(e) }
+    def bcd
+      @bcd ||= api.account_es(lax).map { |e| base_bc(e) }
     end
 
     # @return [Array<Hash>] todos os dados juntos bigquery & etherscan
     def dados
-      @dados ||= dbq[:wb].map { |b| bq_bc(b, dbc.select { |s| b[:ax] == s[:ax] }.first) }
+      @dados ||= bqd[:wb].map { |b| bq_bc(b, bcd.select { |s| b[:ax] == s[:ax] }.first) }
     end
 
     # @return [Array<Integer>] lista indices transacoes normais novas
-    def bnt
-      @bnt ||= (dbc.map { |e| e[:tx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : dbq[:nt].map { |t| t[:itx] }))
+    def idt
+      @idt ||= (bcd.map { |e| e[:tx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : bqd[:nt].map { |t| t[:itx] }))
     end
 
     # @return [Array<Integer>] lista indices transacoes token novas
-    def bnk
-      @bnk ||= (dbc.map { |e| e[:kx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : dbq[:nk].map { |t| t[:itx] }))
-    end
-
-    # @return [Array<Hash>] lista transacoes normais novas
-    def novtx
-      @novtx ||= dbc.map { |e| e[:tx].select { |n| bnt.include?(n[:itx]) } }.flatten
-    end
-
-    # @return [Array<Hash>] lista transacoes token novas
-    def novkx
-      @novkx ||= dbc.map { |e| e[:kx].select { |n| bnk.include?(n[:itx]) } }.flatten
+    def idk
+      @idk ||= (bcd.map { |e| e[:kx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : bqd[:nk].map { |t| t[:itx] }))
     end
 
-    # @param [Hash] hbc dados etherscan
+    # @example (see Apibc#account_es)
+    # @param [Hash] abc account etherscan
     # @return [Hash] dados etherscan - address, saldo & transacoes
-    def base_bc(hbc)
-      a = hbc[:account]
+    def base_bc(abc)
+      a = abc[:account]
       {
         ax: a,
-        sl: (hbc[:balance].to_d / 10**18).round(10),
-        tx: filtrar_tx(a, api.norml_tx(a)),
-        kx: filtrar_tx(a, api.token_tx(a))
+        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))
       }
     end
 
-    # @param [Hash] hbq dados bigquery
-    # @param hbc (see base_bc)
+    # @param [Hash] wbq wallet bigquery
+    # @param [Hash] hbc dados etherscan - address, saldo & transacoes
     # @return [Hash] dados juntos bigquery & etherscan
-    def bq_bc(hbq, hbc)
+    def bq_bc(wbq, hbc)
       {
-        id: hbq[:id],
-        ax: hbq[:ax],
-        bs: hbq[:sl],
-        bt: dbq[:nt].select { |t| t[:iax] == hbq[:ax] },
-        bk: dbq[:nk].select { |t| t[:iax] == hbq[:ax] },
+        id: wbq[:id],
+        ax: wbq[:ax],
+        bs: wbq[:sl],
+        bt: bqd[:nt].select { |t| t[:iax] == wbq[:ax] },
+        bk: bqd[:nk].select { |t| t[:iax] == wbq[:ax] },
         es: hbc[:sl],
         et: hbc[:tx],
         ek: hbc[:kx]
       }
     end
 
-    # @param [String] add endereco carteira ETH
-    # @param [Array<Hash>] ary lista das transacoes
-    # @return [Array<Hash>] devolve lista de transacoes/token transfer events filtrada
+    # @param add (see Apibc#norml_es)
+    # @param [Array<Hash>] ary lista transacoes/token events
+    # @return [Array<Hash>] lista transacoes/token events filtrada
     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