cns 0.1.0 → 0.1.5

data/lib/cns/bitcoinde.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require('bigdecimal/util')
+
+# @author Hernani Rodrigues Vaz
+module Cns
+  # 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 :bqd
+    # @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 = Apice.new
+      @bqd = dad
+      @ops = pop
+    end
+
+    # @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_de,
+        tt: api.trades_de,
+        tl: api.deposits_de + api.withdrawals_de
+      }
+    end
+
+    # @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] })
+    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] })
+    end
+
+    # @example (see Apice#account_de)
+    # @param [String] moe codigo bitcoinde da moeda
+    # @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
+      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 Apice#trades_de)
+    # @param (see Bigquery#det_val1)
+    # @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',
+        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 Apice#deposits_unif_de)
+    # @example (see Apice#withdrawals_unif_de)
+    # @param (see Bigquery#del_val)
+    # @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[:txid],
+        dt: hlx[:time],
+        ty: hlx[:tp],
+        mo: hlx[:moe].upcase,
+        pr: hlx[:qt].to_d,
+        vl: hlx[:fee].to_d
+      )
+    end
+
+    # @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
+
+      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.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)) }
+    end
+
+    # @return [String] texto transacoes ledger
+    def mostra_ledger
+      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)) }
+    end
+  end
+end

data/lib/cns/etherscan1.rb

@@ -0,0 +1,119 @@
+# 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 [Apibc] API blockchains
+    attr_reader :api
+    # @return [Array<Hash>] todos os dados bigquery
+    attr_reader :bqd
+    # @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 = 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 ||= bqd[:wb].map { |h| h[:ax] }
+    end
+
+    # @return [Array<Hash>] todos os dados etherscan - saldos & transacoes
+    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 ||= 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 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 idk
+      @idk ||= (bcd.map { |e| e[:kx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : bqd[:nk].map { |t| t[: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]
+      {
+        ax: 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] wbq wallet bigquery
+    # @param [Hash] hbc dados etherscan - address, saldo & transacoes
+    # @return [Hash] dados juntos bigquery & etherscan
+    def bq_bc(wbq, hbc)
+      {
+        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 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
+      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,112 @@
+# frozen_string_literal: true
+
+# @author Hernani Rodrigues Vaz
+module Cns
+  # classe para processar transacoes do etherscan
+  class Etherscan
+    # @return [String] texto carteiras & transacoes & ajuste dias
+    def mostra_resumo
+      return unless dados.count.positive?
+
+      puts("\nid     address                            etherscan nm tk     bigquery nm tk")
+      dados.each { |e| puts(formata_carteira(e)) }
+      mostra_transacao_norml
+      mostra_transacao_token
+      mostra_configuracao_ajuste_dias
+    end
+
+    # @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[:es],
+        n1: hjn[:et].count,
+        n3: hjn[:ek].count,
+        v2: hjn[:bs],
+        n2: hjn[:bt].count,
+        n4: hjn[:bk].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 ? bqd[:wb].select { |s| s[:ax] == add }.first : nil) || { id: add }
+      max < 7 ? 'erro' : "#{e[:id][0, i - 3]}..#{add[-i - 3..]}"
+    end
+
+    # @example (see Apibc#norml_es)
+    # @param [Hash] htx transacao normal etherscan
+    # @return [String] texto formatado transacao normal etherscan
+    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
+
+    # @example (see Apibc#token_es)
+    # @param [Hash] hkx transacao token etherscan
+    # @return [String] texto formatado transacao token etherscan
+    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 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

data/lib/cns/greymass1.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require('bigdecimal/util')
+
+# @author Hernani Rodrigues Vaz
+module Cns
+  # (see Greymass)
+  class Greymass
+    # @return [Apibc] API blockchains
+    attr_reader :api
+    # @return [Array<Hash>] todos os dados bigquery
+    attr_reader :bqd
+    # @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?
+    # @option pop [Boolean] :t (false) mostra transacoes todas ou somente novas?
+    # @return [Greymass] API greymass - processar transacoes
+    def initialize(dad, pop)
+      @api = Apibc.new
+      @bqd = dad
+      @ops = pop
+    end
+
+    # @return [Array<Hash>] lista transacoes novas
+    def novax
+      @novax ||= bcd.map { |e| e[:tx].select { |s| idt.include?(s[:itx]) } }.flatten
+    end
+
+    # @return [Array<String>] lista dos meus enderecos
+    def lax
+      @lax ||= bqd[:wb].map { |h| h[:ax] }
+    end
+
+    # @return [Array<Hash>] todos os dados greymass - saldos & transacoes
+    def bcd
+      @bcd ||= bqd[:wb].map { |e| base_bc(e) }
+    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) }
+    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] }))
+    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]
+      {
+        ax: a,
+        sl: greymass_sl(a).inject(:+),
+        tx: filtrar_tx(a, api.ledger_gm(a))
+      }
+    end
+
+    # @param wbq (see base_bc)
+    # @param [Hash] hbc dados greymass - address, saldo & transacoes
+    # @return [Hash] dados juntos bigquery & greymass
+    def bq_bc(wbq, hbc)
+      {
+        id: wbq[:id],
+        ax: wbq[:ax],
+        bs: wbq[:sl],
+        bt: bqd[:nt].select { |t| t[:iax] == wbq[:ax] },
+        es: hbc[:sl],
+        et: hbc[:tx]
+      }
+    end
+
+    # @param (see filtrar_tx)
+    # @return [Array<BigDecimal>] lista recursos - liquido, net, spu
+    def greymass_sl(add)
+      v = api.account_gm(add)
+      [
+        v[:core_liquid_balance].to_d,
+        v[:total_resources][:net_weight].to_d,
+        v[:total_resources][:cpu_weight].to_d
+      ]
+    end
+
+    # @param add (see Apibc#account_gm)
+    # @param [Array<Hash>] ary lista transacoes
+    # @return [Array<Hash>] lista transacoes filtrada
+    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) }
+    end
+
+    # @return [Array<Hash>] lista ordenada transacoes novas
+    def sorax
+      novax.sort { |a, b| b[:itx] <=> a[:itx] }
+    end
+  end
+end