cns 0.1.0 → 0.1.1

data/lib/cns/greymass1.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require('bigdecimal/util')
+
+# @author Hernani Rodrigues Vaz
+module Cns
+  # (see Greymass)
+  class Greymass
+    # @return [Apigm] API greymass
+    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?
+    # @option pop [Boolean] :t (false) mostra transacoes todas ou somente novas?
+    # @return [Greymass] API greymass - processar transacoes
+    def initialize(dad, pop)
+      @api = Apigm.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 greymass - saldos & transacoes
+    def dbc
+      @dbc ||= dbq[:wb].map { |e| base_bc(e) }
+    end
+
+    # @return [Array<Hash>] todos os dados juntos bigquery & greymass
+    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 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<Hash>] lista transacoes novas
+    def novax
+      @novax ||= dbc.map { |e| e[:tx].select { |s| bnt.include?(s[:itx]) } }.flatten
+    end
+
+    # @param [Hash] hbq dados bigquery wallet
+    # @return [Hash] dados greymass - address, saldo & transacoes
+    def base_bc(hbq)
+      a = hbq[:ax]
+      {
+        ax: a,
+        sl: greymass_sl(a).inject(:+),
+        tx: filtrar_tx(a, api.all_tx(a))
+      }
+    end
+
+    # @param hbq (see base_bc)
+    # @param [Hash] hbc dados greymass
+    # @return [Hash] dados juntos bigquery & greymass
+    def bq_bc(hbq, hbc)
+      {
+        id: hbq[:id],
+        ax: hbq[:ax],
+        bs: hbq[:sl],
+        bt: dbq[:nt].select { |t| t[:iax] == hbq[: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(account_name: add)
+      [
+        v[:core_liquid_balance].to_d,
+        v[:total_resources][:net_weight].to_d,
+        v[:total_resources][:cpu_weight].to_d
+      ]
+    end
+
+    # @param [String] add endereco carteira EOS
+    # @param [Array<Hash>] ary lista das transacoes
+    # @return [Array<Hash>] lista transacoes ligadas a uma carteira 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

data/lib/cns/greymass2.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# @author Hernani Rodrigues Vaz
+module Cns
+  # classe para processar carteiras & transacoes
+  class Greymass
+    # @param [Hash] hjn dados juntos bigquery & greymass
+    # @return [String] texto formatado duma carteira
+    def formata_carteira(hjn)
+      format(
+        '%<s1>-12.12s %<v1>14.4f %<n1>4i %<v2>14.4f %<n2>4i %<ok>-3s',
+        s1: hjn[:ax],
+        v1: hjn[:bs],
+        n1: hjn[:bt].count,
+        v2: hjn[:es],
+        n2: hjn[:et].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
+    end
+
+    # @param [Hash] htx transacao
+    # @return [String] texto formatado transacao
+    def formata_transacao(htx)
+      format(
+        '%<bn>12i %<fr>-12.12s %<to>-12.12s %<ac>-10.10s %<dt>10.10s %<vl>12.4f %<sy>-6.6s',
+        bn: htx[:itx],
+        fr: act_data(htx)[:from],
+        to: act_data(htx)[:to],
+        ac: act(htx)[:name],
+        dt: Date.parse(htx[:block_time]),
+        vl: act_data_quantity(htx).to_d,
+        sy: act_data_quantity(htx)[/[[:upper:]]+/]
+      )
+    end
+
+    # @param (see formata_transacao)
+    # @return [Hash] dados da acao
+    def act(htx)
+      htx[:action_trace][:act]
+    end
+
+    # @param (see formata_transacao)
+    # @return [Hash] dados da acao
+    def act_data(htx)
+      act(htx)[:data]
+    end
+
+    # @param (see formata_transacao)
+    # @return [String] dados da quantidade
+    def act_data_quantity(htx)
+      act_data(htx)[:quantity].to_s
+    end
+
+    # @return [String] texto carteiras & transacoes & ajuste dias
+    def mostra_resumo
+      return unless dados.count.positive?
+
+      puts("\naddress            bigquery  ntx       greymass  ntx")
+      dados.each { |e| puts(formata_carteira(e)) }
+      mostra_transacoes_novas
+      mostra_configuracao_ajuste_dias
+    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_transacao(e)) }
+    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(' ')}")
+    end
+  end
+end

data/lib/cns/kraken.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require('bigdecimal/util')
+
+# @author Hernani Rodrigues Vaz
+module Cns
+  # classe para processar saldos & transacoes trades e ledger
+  class Kraken
+    # @return [Apius] API kraken
+    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 [Kraken] API kraken - obter saldos & transacoes trades e ledger
+    def initialize(dad, pop)
+      # API kraken base
+      @api = Apius.new
+      @dbq = dad
+      @ops = pop
+    end
+
+    # @return [Hash] dados exchange kraken - saldos & transacoes trades e ledger
+    def exd
+      @exd ||= {
+        sl: api.account,
+        kt: api.trades,
+        kl: api.ledger
+      }
+    end
+
+    # @return [Array<String>] lista txid de transacoes trades
+    def kyt
+      @kyt ||= exd[:kt].keys - (ops[:t] ? [] : dbq[:nt].map { |e| e[:txid].to_sym })
+    end
+
+    # @return [Array<String>] lista txid de transacoes ledger
+    def kyl
+      @kyl ||= exd[:kl].keys - (ops[:t] ? [] : dbq[:nl].map { |e| e[:txid].to_sym })
+    end
+
+    # @return [Hash] transacoes trades
+    def trades
+      @trades ||= exd[:kt].select { |k, _| kyt.include?(k) }
+    end
+
+    # @return [Hash] transacoes ledger
+    def ledger
+      @ledger ||= exd[:kl].select { |k, _| kyl.include?(k) }
+    end
+
+    # @example (see Apius#account)
+    # @param [String] moe codigo kraken da moeda
+    # @param [BigDecimal] sal saldo kraken da moeda
+    # @return [String] texto formatado saldos (kraken/bigquery) & iguais/ok/nok?
+    def formata_saldos(moe, sal)
+      t = dbq[:sl][moe.downcase.to_sym].to_d
+      format(
+        '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
+        mo: moe.upcase,
+        kr: sal,
+        bq: t,
+        ok: t == sal ? 'OK' : 'NOK'
+      )
+    end
+
+    # @example (see Apius#trades)
+    # @param (see Bigquery#ust_val1)
+    # @return [String] texto formatado transacao trade
+    def formata_trades(idx, htx)
+      format(
+        '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-8.8s %<pr>8.2f %<vl>15.7f %<co>8.2f',
+        ky: idx,
+        dt: Time.at(htx[:time]),
+        ty: "#{htx[:type]}/#{htx[:ordertype]}",
+        mo: htx[:pair].upcase,
+        pr: htx[:price].to_d,
+        vl: htx[:vol].to_d,
+        co: htx[:cost].to_d
+      )
+    end
+
+    # @example (see Apius#ledger)
+    # @param (see Bigquery#usl_val)
+    # @return [String] texto formatado transacao ledger
+    def formata_ledger(idx, hlx)
+      format(
+        '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-4.4s %<pr>18.7f %<vl>18.7f',
+        ky: idx,
+        dt: Time.at(hlx[:time]),
+        ty: hlx[:type],
+        mo: hlx[:asset].upcase,
+        pr: hlx[:amount].to_d,
+        vl: hlx[:fee].to_d
+      )
+    end
+
+    # @return [String] texto saldos & transacoes & ajuste dias
+    def mostra_resumo
+      puts("\nKRAKEN\nmoeda          saldo kraken        saldo bigquery")
+      exd[:sl].each { |k, v| puts(formata_saldos(k, v.to_d)) }
+
+      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("\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)) }
+    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)) }
+    end
+  end
+end

data/lib/cns/paymium.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require('bigdecimal/util')
+
+# @author Hernani Rodrigues Vaz
+module Cns
+  # classe para processar saldos & transacoes ledger
+  class Paymium
+    # @return [Apius] API paymium
+    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 [Paymium] API paymium - obter saldos & transacoes ledger
+    def initialize(dad, pop)
+      # API paymium base
+      @api = Apifr.new
+      @dbq = dad
+      @ops = pop
+    end
+
+    # @return [Hash] dados exchange paymium - saldos & transacoes ledger
+    def exd
+      @exd ||= {
+        sl: api.account,
+        kl: api.ledger
+      }
+    end
+
+    # @return [Array<String>] lista txid de transacoes ledger
+    def kyl
+      @kyl ||= exd[:kl].map { |h| h[:account_operations].map { |o| o[:uuid] } }.flatten -
+               (ops[:t] ? [] : dbq[:nl].map { |e| e[:txid] })
+    end
+
+    # @return [Hash] transacoes ledger
+    def ledger
+      @ledger ||= exd[:kl].map { |h| h[:account_operations].select { |o| kyl.include?(o[:uuid]) } }.flatten
+    end
+
+    # @example (see Apifr#account)
+    # @param [Symbol] bqm symbol paymium da moeda
+    # @return [String] texto formatado saldos (paymium/bigquery) & iguais/ok/nok?
+    def formata_saldos(bqm)
+      b = dbq[:sl][bqm].to_d
+      t = exd[:sl]["balance_#{bqm}".to_sym].to_d
+      format(
+        '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
+        mo: bqm.upcase,
+        kr: t,
+        bq: b,
+        ok: t == b ? 'OK' : 'NOK'
+      )
+    end
+
+    # @example (see Apifr#ledger)
+    # @param (see Bigquery#frl_val)
+    # @return [String] texto formatado transacao ledger
+    def formata_ledger(hlx)
+      format(
+        '%<ky>-18.18s %<dt>19.19s %<ty>-17.17s %<mo>-4.4s %<vl>18.7f',
+        ky: formata_uuid(hlx[:uuid], 18),
+        dt: Time.at(hlx[:created_at_int]),
+        ty: hlx[:name],
+        mo: hlx[:currency].upcase,
+        vl: hlx[:amount].to_d
+      )
+    end
+
+    # @example (see Apifr#ledger)
+    # @param [String] uid identificacor da ledger apifr
+    # @param [Integer] max chars a mostrar
+    # @return [String] texto formatado identificacor da ledger apifr
+    def formata_uuid(uid, max)
+      i = Integer(max / 2)
+      max < 7 ? 'erro' : "#{uid[0, i]}#{uid[-i..]}"
+    end
+
+    # @return [String] texto saldos & transacoes & ajuste dias
+    def mostra_resumo
+      puts("\nPAYMIUM\nmoeda         saldo paymium        saldo bigquery")
+      puts(formata_saldos(:btc))
+      puts(formata_saldos(:eur))
+
+      mostra_ledger
+      return unless ledger.count.positive?
+
+      puts("\nstring ajuste dias da ledger\n-h=#{kyl.map { |e| "#{e}:0" }.join(' ')}")
+    end
+
+    # @return [String] texto transacoes ledger
+    def mostra_ledger
+      return unless ops[:v] && ledger.count.positive?
+
+      puts("\nledger             data       hora     tipo              moeda -------quantidade")
+      ledger.sort { |a, b| b[:created_at_int] <=> a[:created_at_int] }.each { |o| puts(formata_ledger(o)) }
+    end
+  end
+end

data/lib/cns/therock.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require('bigdecimal/util')
+
+# @author Hernani Rodrigues Vaz
+module Cns
+  # classe para processar saldos & transacoes ledger
+  class TheRock
+    # @return [Apius] API therock
+    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 [TheRock] API therock - obter saldos & transacoes ledger
+    def initialize(dad, pop)
+      # API therock base
+      @api = Apimt.new
+      @dbq = dad
+      @ops = pop
+    end
+
+    # @return [Hash] dados exchange therock - saldos & transacoes ledger
+    def exd
+      @exd ||= {
+        sl: api.account,
+        kl: api.ledger
+      }
+    end
+
+    # @return [Array<String>] lista txid de transacoes ledger
+    def kyl
+      @kyl ||= exd[:kl].map { |h| h[:id] } - (ops[:t] ? [] : dbq[:nl].map { |e| e[:txid] })
+    end
+
+    # @return [Hash] transacoes ledger
+    def ledger
+      @ledger ||= exd[:kl].select { |o| kyl.include?(o[:id]) }
+    end
+
+    # @example (see Apimt#account)
+    # @param [Hash] hsl saldo therock da moeda
+    # @return [String] texto formatado saldos (therock/bigquery) & iguais/ok/nok?
+    def formata_saldos(hsl)
+      b = dbq[:sl][hsl[:currency].downcase.to_sym].to_d
+      k = hsl[:balance].to_d
+      format(
+        '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
+        mo: hsl[:currency].upcase,
+        kr: k,
+        bq: b,
+        ok: k == b ? 'OK' : 'NOK'
+      )
+    end
+
+    # @example (see Apimt#ledger)
+    # @param (see Bigquery#mtl_val1)
+    # @return [String] texto formatado transacao ledger
+    def formata_ledger(hlx)
+      format(
+        '%<ky>6i %<dt>19.19s %<ty>-27.27s %<mo>-4.4s %<vl>20.7f',
+        ky: hlx[:id],
+        dt: Time.parse(hlx[:date]),
+        ty: hlx[:type],
+        mo: hlx[:currency].upcase,
+        vl: hlx[:price].to_d
+      )
+    end
+
+    # @return [String] texto saldos & transacoes & ajuste dias
+    def mostra_resumo
+      puts("\nTHEROCK\nmoeda         saldo therock        saldo bigquery")
+      exd[:sl].each { |h| puts(formata_saldos(h)) }
+
+      mostra_ledger
+      return unless ledger.count.positive?
+
+      puts("\nstring ajuste dias da ledger\n-h=#{kyl.map { |e| "#{e}:0" }.join(' ')}")
+    end
+
+    # @return [String] texto transacoes ledger
+    def mostra_ledger
+      return unless ops[:v] && ledger.count.positive?
+
+      puts("\nledger data       hora     tipo                        moeda ---------quantidade")
+      ledger.sort { |a, b| b[:id] <=> a[:id] }.each { |o| puts(formata_ledger(o)) }
+    end
+  end
+end