cns 0.1.0 → 0.1.1

data/lib/cns/bigquery4.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+# @author Hernani Rodrigues Vaz
+module Cns
+  # (see Bigquery)
+  class Bigquery
+    # @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(',')}"
+    end
+
+    # @example (see Apide#trades)
+    # @param [Hash] htx transacao trade apide
+    # @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)," \
+      "DATETIME(TIMESTAMP('#{htx[:successfully_finished_at]}'))," \
+      "'#{htx[:trading_partner_information][:username]}'," \
+      "#{det_val2(htx)}"
+    end
+
+    # @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]}'))," \
+      "#{Integer(ops[:h][htx[:trade_id]] || 0)})"
+    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)
+    # @param [String] idx identificador transacao
+    # @param [Hash] htx transacao trade apius
+    # @return [String] valores formatados ust (trades parte1)
+    def ust_val1(idx, htx)
+      "('#{idx}'," \
+      "'#{htx[:ordertxid]}'," \
+      "'#{htx[:pair]}'," \
+      "PARSE_DATETIME('%s', '#{String(htx[:time].round)}')," \
+      "'#{htx[:type]}'," \
+      "'#{htx[:ordertype]}'," \
+      "cast(#{htx[:price]} as numeric)," \
+      "cast(#{htx[:cost]} as numeric)," \
+      "cast(#{htx[:fee]} as numeric)," \
+      "#{ust_val2(idx, htx)}"
+    end
+
+    # @param (see #ust_val1)
+    # @return [String] valores formatados ust (trades parte2)
+    def ust_val2(idx, htx)
+      "cast(#{htx[:vol]} as numeric)," \
+      "cast(#{htx[:margin]} as numeric)," \
+      "#{htx[:misc].to_s.empty? ? 'null' : "'#{htx[:misc]}'"}," \
+      "'#{apius.ledger.select { |_, v| v[:refid] == idx }.keys.join(',') || ''}'," \
+      "#{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
+    # @return [String] valores formatados usl (ledger)
+    def usl_val(idx, hlx)
+      "('#{idx}'," \
+      "'#{hlx[:refid]}'," \
+      "PARSE_DATETIME('%s', '#{String(hlx[:time].round)}')," \
+      "'#{hlx[:type]}'," \
+      "#{hlx[:aclass].to_s.empty? ? 'null' : "'#{hlx[:aclass]}'"}," \
+      "'#{hlx[:asset]}'," \
+      "cast(#{hlx[:amount]} as numeric)," \
+      "cast(#{hlx[:fee]} as numeric))"
+    end
+
+    # @return [String] comando insert SQL formatado fr (ledger)
+    def frl_ins
+      "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
+    # @return [String] valores formatados frl (ledger)
+    def frl_val(hlx)
+      "('#{hlx[:uuid]}'," \
+      "'#{hlx[:name]}'," \
+      "cast(#{hlx[:amount]} as numeric)," \
+      "'#{hlx[:currency]}'," \
+      "PARSE_DATETIME('%s', '#{hlx[:created_at_int]}')," \
+      "#{Integer(ops[:h][hlx[:uuid]] || 0)})"
+    end
+
+    # @return [String] comando insert SQL formatado fr (ledger)
+    def mtl_ins
+      "insert #{BD}.mt(id,time,type,valor,moe,pair,note,trade_id,dias) " \
+      "VALUES#{apimt.ledger.map { |h| mtl_val1(h) }.join(',')}"
+    end
+
+    # @example (see Apimt#ledger)
+    # @param [Hash] hlx transacao ledger apimt
+    # @return [String] valores formatados mtl (ledger parte1)
+    def mtl_val1(hlx)
+      "(#{hlx[:id]}," \
+      "DATETIME(TIMESTAMP('#{hlx[:date]}'))," \
+      "'#{hlx[:type]}'," \
+      "cast(#{hlx[:price]} as numeric)," \
+      "'#{hlx[:currency]}'," \
+      "#{hlx[:fund_id].to_s.empty? ? 'null' : "'#{hlx[:fund_id]}'"}," \
+      "#{mtl_val2(hlx)}"
+    end
+
+    # @param hlx (see #mtl_val1)
+    # @return [String] valores formatados mtl (ledger parte2)
+    def mtl_val2(hlx)
+      "#{hlx[:note].to_s.empty? ? 'null' : "'#{hlx[:note]}'"}," \
+      "#{hlx[:trade_id].to_s.empty? ? 'null' : (hlx[:trade_id]).to_s}," \
+      "#{Integer(ops[:h][String(hlx[:id])] || 0)})"
+    end
+  end
+end

data/lib/cns/bitcoinde.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require('bigdecimal/util')
+
+# @author Hernani Rodrigues Vaz
+module Cns
+  # classe para processar saldos & transacoes trades e ledger do bitcoinde
+  class Bitcoinde
+    # @return [Apius] API bitcoinde
+    attr_reader :api
+    # @return [Array<Hash>] todos os dados bigquery
+    attr_reader :dbq
+    # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
+    attr_reader :ops
+
+    # @param [Hash] dad todos os dados bigquery
+    # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
+    # @option pop [Hash] :h ({}) configuracao dias ajuste reposicionamento temporal
+    # @option pop [Boolean] :v (false) mostra dados transacoes trades & ledger?
+    # @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
+      @ops = pop
+    end
+
+    # @return [Hash] dados exchange bitcoinde - saldos & transacoes trades e ledger
+    def exd
+      @exd ||= {
+        sl: api.account,
+        tt: api.trades,
+        tl: api.deposits + api.withdrawals
+      }
+    end
+
+    # @return [Array<String>] lista txid de transacoes trades
+    def kyt
+      @kyt ||= exd[:tt].map { |h| h[:trade_id] }.flatten - (ops[:t] ? [] : dbq[:nt].map { |e| e[:txid] })
+    end
+
+    # @return [Array<Integer>] lista txid de transacoes ledger
+    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]) }
+    end
+
+    # @example (see Apide#account)
+    # @param [String] moe codigo bitcoinde da moeda
+    # @param [Hash] hsx saldo bitcoinde da moeda
+    # @return [String] texto formatado saldos (bitcoinde)
+    def formata_saldos(moe, hsx)
+      b = dbq[: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',
+        mo: moe.upcase,
+        ex: e,
+        bq: b,
+        ok: e == b ? 'OK' : 'NOK'
+      )
+    end
+
+    # @example (see Apide#trades)
+    # @param (see Bigquery#det_val1)
+    # @return [String] texto formatado transacao 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',
+        ky: htx[:trade_id],
+        dt: Time.parse(htx[:successfully_finished_at]),
+        dp: Time.parse(htx[:trade_marked_as_paid_at]),
+        ty: htx[:type],
+        mo: htx[:trading_pair].upcase,
+        vl: htx[:amount_currency_to_trade].to_d,
+        co: htx[:volume_currency_to_pay].to_d
+      )
+    end
+
+    # @example (see Apide#deposit_hash)
+    # @example (see Apide#withdrawal_hash)
+    # @param (see Bigquery#del_val)
+    # @return [String] texto formatado transacao 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],
+        dt: hlx[:time],
+        ty: hlx[:tp],
+        mo: hlx[:qtxt].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)) }
+
+      mostra_trades
+      mostra_ledger
+      return unless trades.count.positive?
+
+      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |e| "#{e}:0" }.join(' ')}")
+    end
+
+    # @return [String] texto transacoes trades
+    def mostra_trades
+      return unless ops[:v] && trades.count.positive?
+
+      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?
+
+      puts("\nledger data       hora     tipo       moe ---------quantidade -------------custo")
+      ledger.sort { |a, b| b[:time] <=> a[:time] }.each { |h| puts(formata_ledger(h)) }
+    end
+  end
+end

data/lib/cns/etherscan1.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require('bigdecimal/util')
+
+# @author Hernani Rodrigues Vaz
+module Cns
+  # chaves a eliminar da API - resultado deve ser ignirado pois muda a cada pedido API feito
+  DL = %i[cumulativeGasUsed confirmations].freeze
+
+  # (see Etherscan)
+  class Etherscan
+    # @return [Apies] API etherscan
+    attr_reader :api
+    # @return [Array<Hash>] todos os dados bigquery
+    attr_reader :dbq
+    # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
+    attr_reader :ops
+
+    # @param [Hash] dad todos os dados bigquery
+    # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
+    # @option pop [Hash] :h ({}) configuracao dias ajuste reposicionamento temporal
+    # @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
+      @ops = pop
+    end
+
+    # @return [Array<String>] lista dos meus enderecos
+    def lax
+      @lax ||= dbq[: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) }
+    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) }
+    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] }))
+    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
+    end
+
+    # @param [Hash] hbc dados etherscan
+    # @return [Hash] dados etherscan - address, saldo & transacoes
+    def base_bc(hbc)
+      a = hbc[: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))
+      }
+    end
+
+    # @param [Hash] hbq dados bigquery
+    # @param hbc (see base_bc)
+    # @return [Hash] dados juntos bigquery & etherscan
+    def bq_bc(hbq, 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] },
+        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
+    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) }
+    end
+
+    # @return [Array<Hash>] lista ordenada transacoes normais novas
+    def sortx
+      novtx.sort { |a, b| a[:itx] <=> b[:itx] }
+    end
+
+    # @return [Array<Hash>] lista ordenada transacoes token novas
+    def sorkx
+      novkx.sort { |a, b| a[:itx] <=> b[:itx] }
+    end
+
+    # @return [Array<Hash>] lista ordenada transacoes (normais & token) novas
+    def sorax
+      (novtx + novkx).sort { |a, b| a[:itx] <=> b[:itx] }
+    end
+  end
+end

data/lib/cns/etherscan2.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+# @author Hernani Rodrigues Vaz
+module Cns
+  # classe para processar carteiras & transacoes normais e tokens
+  class Etherscan
+    # @param [Hash] hjn dados juntos bigquery & etherscan
+    # @return [String] texto formatado duma carteira
+    def formata_carteira(hjn)
+      format(
+        '%<s1>-6.6s %<s2>-32.32s ',
+        s1: hjn[:id],
+        s2: formata_endereco(hjn[:ax], 32)
+      ) + formata_valores(hjn)
+    end
+
+    # @param (see formata_carteira)
+    # @return [String] texto formatado valores duma carteira
+    def formata_valores(hjn)
+      format(
+        '%<v1>11.6f %<n1>2i %<n3>2i %<v2>12.6f %<n2>2i %<n4>2i %<ok>-3s',
+        v1: hjn[:bs],
+        n1: hjn[:bt].count,
+        n3: hjn[:bk].count,
+        v2: hjn[:es],
+        n2: hjn[:et].count,
+        n4: hjn[:ek].count,
+        ok: ok?(hjn) ? 'OK' : 'NOK'
+      )
+    end
+
+    # @param (see formata_carteira)
+    # @return [Boolean] carteira tem transacoes novas(sim=NOK, nao=OK)?
+    def ok?(hjn)
+      hjn[:bs] == hjn[:es] && hjn[:bt].count == hjn[:et].count && hjn[:bk].count == hjn[:ek].count
+    end
+
+    # @example ether address inicio..fim
+    #  0x10f3a0cf0b534c..c033cf32e8a03586
+    # @param add (see filtrar_tx)
+    # @param [Integer] max chars a mostrar
+    # @return [String] endereco formatado
+    def formata_endereco(add, max)
+      i = Integer((max - 2) / 2)
+      e = (max <= 20 ? dbq[:wb].select { |s| s[:ax] == add }.first : nil) || { id: add }
+      max < 7 ? 'erro' : "#{e[:id][0, i - 3]}..#{add[-i - 3..]}"
+    end
+
+    # @param [Hash] htx transacao normal
+    # @return [String] texto formatado transacao normal
+    def formata_transacao_norml(htx)
+      format(
+        '%<bn>9i %<fr>-20.20s %<to>-20.20s %<dt>10.10s %<vl>17.6f',
+        bn: htx[:blockNumber],
+        fr: formata_endereco(htx[:from], 20),
+        to: formata_endereco(htx[:to], 20),
+        dt: Time.at(Integer(htx[:timeStamp])),
+        vl: (htx[:value].to_d / 10**18).round(10)
+      )
+    end
+
+    # @param [Hash] hkx transacao token
+    # @return [String] texto formatado transacao token
+    def formata_transacao_token(hkx)
+      format(
+        '%<bn>9i %<fr>-20.20s %<to>-20.20s %<dt>10.10s %<vl>11.3f %<sy>-5.5s',
+        bn: hkx[:blockNumber],
+        fr: formata_endereco(hkx[:from], 20),
+        to: formata_endereco(hkx[:to], 20),
+        dt: Time.at(Integer(hkx[:timeStamp])),
+        vl: (hkx[:value].to_d / 10**18).round(10),
+        sy: hkx[:tokenSymbol]
+      )
+    end
+
+    # @return [String] texto carteiras & transacoes & ajuste dias
+    def mostra_resumo
+      return unless dados.count.positive?
+
+      puts("\nid     address                             bigquery nm tk    etherscan nm tk")
+      dados.each { |e| puts(formata_carteira(e)) }
+      mostra_transacao_norml
+      mostra_transacao_token
+      mostra_configuracao_ajuste_dias
+    end
+
+    # @return [String] texto transacoes normais
+    def mostra_transacao_norml
+      return unless ops[:v] && novtx.count.positive?
+
+      puts("\ntx normal from                 to                   data                   valor")
+      sortx.each { |e| puts(formata_transacao_norml(e)) }
+    end
+
+    # @return [String] texto transacoes token
+    def mostra_transacao_token
+      return unless ops[:v] && novkx.count.positive?
+
+      puts("\ntx token  from                 to                   data             valor")
+      sorkx.each { |e| puts(formata_transacao_token(e)) }
+    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(' ')}")
+    end
+  end
+end