dpay-ruby 0.1.1

data/Rakefile

@@ -0,0 +1,332 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'yard'
+require 'dpay'
+
+Rake::TestTask.new(test: ['clean:vcr', 'test:threads']) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.ruby_opts << if ENV['HELL_ENABLED']
+    '-W2'
+  else
+    '-W1'
+  end
+end
+
+namespace :test do
+  Rake::TestTask.new(static: 'clean:vcr') do |t|
+    t.description = <<-EOD
+      Run static tests, which are those that have static request/responses.
+      These are tests that are typically read-only and do not require heavy
+      matches on the json-rpc request body.  Often, the only difference between
+      one execution and another is the json-rpc-id.
+    EOD
+    t.libs << 'test'
+    t.libs << 'lib'
+    t.test_files = [
+      'test/dpay/account_by_key_api_test.rb',
+      'test/dpay/account_history_api_test.rb',
+      'test/dpay/block_api_test.rb',
+      'test/dpay/database_api_test.rb',
+      'test/dpay/follow_api_test.rb',
+      'test/dpay/jsonrpc_test.rb',
+      'test/dpay/market_history_api_test.rb',
+      'test/dpay/tags_api_test.rb',
+      'test/dpay/witness_api_test.rb'
+    ]
+    t.ruby_opts << if ENV['HELL_ENABLED']
+      '-W2'
+    else
+      '-W1'
+    end
+  end
+
+  Rake::TestTask.new(broadcast: 'clean:vcr') do |t|
+    t.description = <<-EOD
+      Run broadcast tests, which are those that only use network_broadcast_api
+      and/or database_api.verify_authority (pretend: true).
+    EOD
+    t.libs << 'test'
+    t.libs << 'lib'
+    t.test_files = [
+      'test/dpay/broadcast_test.rb',
+      'test/dpay/transaction_builder_test.rb'
+    ]
+    t.ruby_opts << if ENV['HELL_ENABLED']
+      '-W2'
+    else
+      '-W1'
+    end
+  end
+
+  Rake::TestTask.new(testnet: 'clean:vcr') do |t|
+    t.description = <<-EOD
+      Run testnet tests, which are those that use network_broadcast_api to do
+      actual broadcast operations, on a specified (or default) testnet.
+    EOD
+    t.libs << 'test'
+    t.libs << 'lib'
+    t.test_files = [
+      'test/dpay/testnet_test.rb'
+    ]
+    t.ruby_opts << if ENV['HELL_ENABLED']
+      '-W2'
+    else
+      '-W1'
+    end
+  end
+
+  desc 'Tests the API using multiple threads.'
+  task :threads do
+    next if !!ENV['TEST']
+
+    threads = []
+    api = DPay::Api.new(url: ENV['TEST_NODE'])
+    database_api = DPay::DatabaseApi.new(url: ENV['TEST_NODE'])
+    witnesses = {}
+    keys = %i(created url total_missed props running_version
+      hardfork_version_vote hardfork_time_vote)
+
+    if defined? Thread.report_on_exception
+      Thread.report_on_exception = true
+    end
+
+    database_api.get_active_witnesses do |result|
+      print "Found #{result.witnesses.size} witnesses ..."
+
+      result.witnesses.each do |witness_name|
+        threads << Thread.new do
+          api.get_witness_by_account(witness_name) do |witness|
+            witnesses[witness.owner] = witness.map do |k, v|
+              [k, v] if keys.include? k.to_sym
+            end.compact.to_h
+
+            bbd_exchange_rate = witness[:bbd_exchange_rate]
+            base = bbd_exchange_rate[:base].to_f
+
+            if (quote = bbd_exchange_rate[:quote].to_f) > 0
+              rate = (base / quote).round(3)
+              witnesses[witness.owner][:bbd_exchange_rate] = rate
+            else
+              witnesses[witness.owner][:bbd_exchange_rate] = nil
+            end
+
+            last_bbd_exchange_update = witness[:last_bbd_exchange_update]
+            last_bbd_exchange_update = Time.parse(last_bbd_exchange_update + 'Z')
+            last_bbd_exchange_elapsed = '%.2f hours ago' % ((Time.now.utc - last_bbd_exchange_update) / 60)
+            witnesses[witness.owner][:last_bbd_exchange_elapsed] = last_bbd_exchange_elapsed
+          end
+        end
+      end
+    end
+
+    threads.each do |thread|
+      print '.'
+      thread.join
+    end
+
+    puts ' done!'
+
+    if threads.size != witnesses.size
+      puts "Bug: expected #{threads.size} witnesses, only found #{witnesses.size}."
+    else
+      puts JSON.pretty_generate witnesses rescue puts witnesses
+    end
+  end
+end
+
+namespace :stream do
+  desc 'Test the ability to stream a block range.'
+  task :block_range, [:mode, :at_block_num] do |t, args|
+    mode = (args[:mode] || 'irreversible').to_sym
+    first_block_num = args[:at_block_num].to_i if !!args[:at_block_num]
+    stream = DPay::Stream.new(url: ENV['TEST_NODE'], mode: mode)
+    api = DPay::Api.new(url: ENV['TEST_NODE'])
+    last_block_num = nil
+    last_timestamp = nil
+    range_complete = false
+
+    api.get_dynamic_global_properties do |properties|
+      current_block_num = if mode == :head
+        properties.head_block_number
+      else
+        properties.last_irreversible_block_num
+      end
+
+      # First pass replays latest a random number of blocks to test chunking.
+      first_block_num ||= current_block_num - (rand * 200).to_i
+
+      range = first_block_num..current_block_num
+      puts "Initial block range: #{range.size}"
+
+      stream.blocks(at_block_num: range.first) do |block, block_num|
+        current_timestamp = Time.parse(block.timestamp + 'Z')
+
+        if !range_complete && block_num > range.last
+          puts 'Done with initial range.'
+          range_complete = true
+        end
+
+        if !!last_timestamp && block_num != last_block_num + 1
+          puts "Bug: Last block number was #{last_block_num} then jumped to: #{block_num}"
+          exit
+        end
+
+        if !!last_timestamp && current_timestamp < last_timestamp
+          puts "Bug: Went back in time.  Last timestamp was #{last_timestamp}, then jumped back to #{current_timestamp}"
+          exit
+        end
+
+        puts "\t#{block_num} Timestamp: #{current_timestamp}, witness: #{block.witness}"
+        last_block_num = block_num
+        last_timestamp = current_timestamp
+      end
+    end
+  end
+
+  desc 'Test the ability to stream a block range of transactions.'
+  task :trx_range, [:mode, :at_block_num] do |t, args|
+    mode = (args[:mode] || 'irreversible').to_sym
+    first_block_num = args[:at_block_num].to_i if !!args[:at_block_num]
+    stream = DPay::Stream.new(url: ENV['TEST_NODE'], mode: mode)
+    api = DPay::Api.new(url: ENV['TEST_NODE'])
+
+    api.get_dynamic_global_properties do |properties|
+      current_block_num = if mode == :head
+        properties.head_block_number
+      else
+        properties.last_irreversible_block_num
+      end
+
+      # First pass replays latest a random number of blocks to test chunking.
+      first_block_num ||= current_block_num - (rand * 200).to_i
+
+      stream.transactions(at_block_num: first_block_num) do |trx, trx_id, block_num|
+        puts "#{block_num} :: #{trx_id}; ops: #{trx.operations.map(&:type).join(', ')}"
+      end
+    end
+  end
+
+  desc 'Test the ability to stream a block range of operations.'
+  task :op_range, [:mode, :at_block_num] do |t, args|
+    mode = (args[:mode] || 'irreversible').to_sym
+    first_block_num = args[:at_block_num].to_i if !!args[:at_block_num]
+    stream = DPay::Stream.new(url: ENV['TEST_NODE'], mode: mode)
+    api = DPay::Api.new(url: ENV['TEST_NODE'])
+
+    api.get_dynamic_global_properties do |properties|
+      current_block_num = if mode == :head
+        properties.head_block_number
+      else
+        properties.last_irreversible_block_num
+      end
+
+      # First pass replays latest a random number of blocks to test chunking.
+      first_block_num ||= current_block_num - (rand * 200).to_i
+
+      stream.operations(at_block_num: first_block_num) do |op, trx_id, block_num|
+        puts "#{block_num} :: #{trx_id}; op: #{op.type}"
+      end
+    end
+  end
+
+  desc 'Test the ability to stream a block range of virtual operations.'
+  task :vop_range, [:mode, :at_block_num] do |t, args|
+    mode = (args[:mode] || 'irreversible').to_sym
+    first_block_num = args[:at_block_num].to_i if !!args[:at_block_num]
+    stream = DPay::Stream.new(url: ENV['TEST_NODE'], mode: mode)
+    api = DPay::Api.new(url: ENV['TEST_NODE'])
+
+    api.get_dynamic_global_properties do |properties|
+      current_block_num = if mode == :head
+        properties.head_block_number
+      else
+        properties.last_irreversible_block_num
+      end
+
+      # First pass replays latest a random number of blocks to test chunking.
+      first_block_num ||= current_block_num - (rand * 200).to_i
+
+      stream.operations(at_block_num: first_block_num, only_virtual: true) do |op, trx_id, block_num|
+        puts "#{block_num} :: #{trx_id}; op: #{op.type}"
+      end
+    end
+  end
+
+  desc 'Test the ability to stream a block range of all operations (including virtual).'
+  task :all_op_range, [:mode, :at_block_num] do |t, args|
+    mode = (args[:mode] || 'irreversible').to_sym
+    first_block_num = args[:at_block_num].to_i if !!args[:at_block_num]
+    stream = DPay::Stream.new(url: ENV['TEST_NODE'], mode: mode)
+    api = DPay::Api.new(url: ENV['TEST_NODE'])
+
+    api.get_dynamic_global_properties do |properties|
+      current_block_num = if mode == :head
+        properties.head_block_number
+      else
+        properties.last_irreversible_block_num
+      end
+
+      # First pass replays latest a random number of blocks to test chunking.
+      first_block_num ||= current_block_num - (rand * 200).to_i
+
+      stream.operations(at_block_num: first_block_num, include_virtual: true) do |op, trx_id, block_num|
+        puts "#{block_num} :: #{trx_id}; op: #{op.type}"
+      end
+    end
+  end
+end
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb']
+end
+
+task default: :test
+
+desc 'Ruby console with dpay already required.'
+task :console do
+  exec 'irb -r dpay -I ./lib'
+end
+
+namespace :clean do
+  desc 'Remove test/fixtures/vcr_cassettes/*.yml so they can be rebuilt fresh.'
+  task :vcr do |t|
+    cmd = 'echo Cleaned cassettes: $(rm -v test/fixtures/vcr_cassettes/*.yml | wc -l)'
+    system cmd
+  end
+end
+
+namespace :show do
+  desc 'Shows known API names.'
+  task :apis do
+    url = ENV['URL']
+    jsonrpc = DPay::Jsonrpc.new(url: url)
+    api_methods = jsonrpc.get_api_methods
+    puts api_methods.keys
+  end
+
+  desc 'Shows known method names for specified API.'
+  task :methods, [:api] do |t, args|
+    url = ENV['URL']
+    jsonrpc = DPay::Jsonrpc.new(url: url)
+    api_methods = jsonrpc.get_api_methods
+    api_methods[args[:api]].each do |method|
+      jsonrpc.get_signature(method: "#{args[:api]}.#{method}") do |signature|
+        print "#{method} "
+        params = signature.args.map do |k, v|
+          if v =~ /\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2]\d|3[0-1])T(2[0-3]|[01]\d):[0-5]\d:[0-5]\d/
+            "#{k}: Time"
+          elsif v.class == Hashie::Array
+            "#{k}: []"
+          elsif v.class == Hashie::Mash
+            "#{k}: {}"
+          else
+            "#{k}: #{v.class}"
+          end
+        end
+        puts params.join(', ')
+      end
+    end
+  end
+end

data/dpay-ruby.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dpay/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'dpay-ruby'
+  spec.version = DPay::VERSION
+  spec.authors = ['dPay, DAO']
+  spec.email = ['labs@dpays.io']
+
+  spec.summary = %q{dPay Ruby Client}
+  spec.description = %q{Client for accessing the dPay blockchain.}
+  spec.homepage = 'https://github.com/dpays/dpay-ruby'
+  spec.license = 'MIT'
+
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test)/}) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.16', '>= 1.16.1'
+  spec.add_development_dependency 'rake', '~> 12.3', '>= 12.3.0'
+  spec.add_development_dependency 'minitest', '~> 5.10', '>= 5.10.3'
+  spec.add_development_dependency 'minitest-line', '~> 0.6', '>= 0.6.4'
+  spec.add_development_dependency 'minitest-proveit', '~> 1.0', '>= 1.0.0'
+  spec.add_development_dependency 'webmock', '~> 3.3', '>= 3.3.0'
+  spec.add_development_dependency 'simplecov', '~> 0.15', '>= 0.15.1'
+  spec.add_development_dependency 'vcr', '~> 4.0', '>= 4.0.0'
+  spec.add_development_dependency 'yard', '~> 0.9', '>= 0.9.12'
+  spec.add_development_dependency 'pry', '~> 0.11', '>= 0.11.3'
+  spec.add_development_dependency 'awesome_print', '~> 1.8', '>= 1.8.0'
+
+  spec.add_dependency 'json', '~> 2.1', '>= 2.1.0'
+  spec.add_dependency 'logging', '~> 2.2', '>= 2.2.0'
+  spec.add_dependency 'hashie', '~> 3.5', '>= 3.5.7'
+  spec.add_dependency 'bitcoin-ruby', '~> 0.0', '>= 0.0.18'
+  spec.add_dependency 'ffi', '~> 1.9', '>= 1.9.23'
+end

data/gource.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+gource ./ --user-image-dir images --hide usernames -s 0.5 -b 000000 \
+  -1280x720 --output-ppm-stream - |\
+  ffmpeg -y -r 28 -f image2pipe -vcodec ppm -i - -vcodec libx264 -preset slow \
+  -crf 28 -threads 0 output.mp4

data/lib/dpay.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+require 'json' unless defined?(JSON)
+require 'net/https'
+
+require 'hashie'
+require 'dpay/version'
+require 'dpay/utils'
+require 'dpay/base_error'
+require 'dpay/mixins/retriable'
+require 'dpay/chain_config'
+require 'dpay/type/base_type'
+require 'dpay/type/amount'
+require 'dpay/transaction_builder'
+require 'dpay/rpc/base_client'
+require 'dpay/rpc/http_client'
+require 'dpay/rpc/thread_safe_http_client'
+require 'dpay/api'
+require 'dpay/jsonrpc'
+require 'dpay/block_api'
+require 'dpay/formatter'
+require 'dpay/broadcast'
+require 'dpay/stream'
+
+module DPay
+  def self.api_classes
+    @api_classes ||= {}
+  end
+  
+  def self.const_missing(api_name)
+    api = api_classes[api_name]
+    api ||= Api.clone(freeze: true) rescue Api.clone
+    api.api_name = api_name
+    api_classes[api_name] = api
+  end
+end
+
+Hashie.logger = Logger.new(ENV['HASHIE_LOGGER'])

data/lib/dpay/api.rb

@@ -0,0 +1,229 @@
+module DPay
+  # This ruby API works with
+  # {https://github.com/dpays/dpay/releases dpayd-0.19.10} and other AppBase
+  # compatible upstreams.  To access different API namespaces, use the
+  # following:
+  #
+  #     api = DPay::Api.new
+  #     api.get_dynamic_global_properties
+  #
+  # The above example will make an instance that can access the
+  # {https://developers.dpays.io/apidefinitions/condenser-api condenser_api}
+  # namespace.  Alternatively, you may also create a direct instances with its
+  # full name, if you prefer:
+  #
+  #     api = DPay::CondenserApi.new
+  #     api.get_dynamic_global_properties
+  #
+  # If you know the name of another API that is supported by the remote node,
+  # you can create an instance to that instead, for example:
+  #
+  #     api = DPay::MarketHistoryApi.new
+  #     api.get_volume
+  #
+  # All known API by namespace:
+  #
+  # * {AccountByKeyApi}
+  # * {AccountHistoryApi}
+  # * {BlockApi}
+  # * {DatabaseApi}
+  # * {FollowApi}
+  # * {Jsonrpc}
+  # * {MarketHistoryApi}
+  # * {NetworkBroadcastApi}
+  # * {TagsApi}
+  # * {WitnessApi}
+  #
+  # Also see: {https://developers.dpays.io/apidefinitions/ Complete API Definitions}
+  class Api
+    attr_accessor :chain, :methods, :rpc_client
+
+    # Use this for debugging naive thread handler.
+    # DEFAULT_RPC_CLIENT_CLASS = RPC::HttpClient
+    DEFAULT_RPC_CLIENT_CLASS = RPC::ThreadSafeHttpClient
+
+    def self.api_name=(api_name)
+      @api_name = api_name.to_s.
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr('-', '_').downcase.to_sym
+    end
+
+    def self.api_name
+      @api_name
+    end
+
+    def self.api_class_name
+      @api_name.to_s.split('_').map(&:capitalize).join
+    end
+
+    def self.jsonrpc=(jsonrpc, url = nil)
+      @jsonrpc ||= {}
+      @jsonrpc[url || jsonrpc.rpc_client.uri.to_s] = jsonrpc
+    end
+
+    def self.jsonrpc(url = nil)
+      if @jsonrpc.size < 2 && url.nil?
+        @jsonrpc.values.first
+      else
+        @jsonrpc[url]
+      end
+    end
+
+    # Override this if you want to just use your own client.  Otherwise, inject
+    # the default using:
+    #
+    #     DPay::Api.register default_rpc_client_class: MyClient
+    def self.default_rpc_client_class
+      if !!@injected_dependencies && !!@injected_dependencies[:default_rpc_client_class]
+        @injected_dependencies[:default_rpc_client_class]
+      else
+        DEFAULT_RPC_CLIENT_CLASS
+      end
+    end
+
+    # Used for dependency injection.  Currently, the only key supported is:
+    #
+    # `default_rpc_client_class`
+    def self.register(register)
+      @injected_dependencies ||= {}
+      @injected_dependencies = @injected_dependencies.merge register
+    end
+
+    def initialize(options = {})
+      @chain = options[:chain] || :dpay
+      @error_pipe = options[:error_pipe] || STDERR
+      @api_name = self.class.api_name ||= :condenser_api
+
+      @rpc_client = if !!options[:rpc_client]
+        options[:rpc_client]
+      else
+        rpc_client_class = self.class.default_rpc_client_class
+        rpc_client_class.new(options.merge(api_name: @api_name))
+      end
+
+      if @api_name == :jsonrpc
+        Api::jsonrpc = self
+      else
+        # Note, we have to wait until initialize to check this because we don't
+        # have access to instance options until now.
+
+        Api::jsonrpc = Jsonrpc.new(options)
+        @methods = Api::jsonrpc(rpc_client.uri.to_s).get_api_methods
+
+        unless !!@methods[@api_name]
+          raise UnknownApiError, "#{@api_name} (known APIs: #{@methods.keys.join(' ')})"
+        end
+
+        @methods = @methods[@api_name]
+      end
+
+      @try_count = 0
+    end
+
+    def inspect
+      properties = %w(chain methods).map do |prop|
+        if !!(v = instance_variable_get("@#{prop}"))
+          case v
+          when Array then "@#{prop}=<#{v.size} #{v.size == 1 ? 'element' : 'elements'}>"
+          else; "@#{prop}=#{v}"
+          end
+        end
+      end.compact.join(', ')
+
+      "#<#{self.class.api_class_name} [#{properties}]>"
+    end
+  private
+    # @private
+    def args_keys_to_s(rpc_method_name)
+      args = signature(rpc_method_name).args
+      args_keys = JSON[args.to_json]
+    end
+
+    # @private
+    def signature(rpc_method_name)
+      url = rpc_client.uri.to_s
+
+      @@signatures ||= {}
+      @@signatures[url] ||= {}
+      @@signatures[url][rpc_method_name] ||= Api::jsonrpc(url).get_signature(method: rpc_method_name).result
+    end
+
+    # @private
+    def raise_error_response(rpc_method_name, rpc_args, response)
+      raise UnknownError, "#{rpc_method_name}: #{response}" if response.error.nil?
+
+      error = response.error
+
+      if error.message == 'Invalid Request'
+        raise DPay::ArgumentError, "Unexpected arguments: #{rpc_args.inspect}.  Expected: #{rpc_method_name} (#{args_keys_to_s(rpc_method_name)})"
+      end
+
+      BaseError.build_error(error, rpc_method_name)
+    end
+
+    # @private
+    def respond_to_missing?(m, include_private = false)
+      methods.nil? ? false : methods.include?(m.to_sym)
+    end
+
+    # @private
+    def method_missing(m, *args, &block)
+      super unless respond_to_missing?(m)
+
+      rpc_method_name = "#{@api_name}.#{m}"
+      rpc_args = case @api_name
+      when :condenser_api then args
+      when :jsonrpc then args.first
+      else
+        expected_args = signature(rpc_method_name).args || []
+        expected_args_key_string = if expected_args.size > 0
+          " (#{args_keys_to_s(rpc_method_name)})"
+        end
+        expected_args_size = expected_args.size
+
+        begin
+          args = args.first.to_h
+          args_size = args.size
+
+          # Some argument are optional, but if the arguments passed are greater
+          # than the expected arguments size, we can warn.
+          if args_size > expected_args_size
+            @error_pipe.puts "Warning #{rpc_method_name} expects arguments: #{expected_args_size}, got: #{args_size}"
+          end
+        rescue NoMethodError => e
+          error = DPay::ArgumentError.new("#{rpc_method_name} expects arguments: #{expected_args_size}", e)
+          raise error
+        rescue => e
+          raise UnknownError.new("#{rpc_method_name} unknown error.", e)
+        end
+
+        args
+      end
+
+      response = rpc_client.rpc_execute(@api_name, m, rpc_args)
+
+      if defined?(response.error) && !!response.error
+        if !!response.error.message
+          raise_error_response rpc_method_name, rpc_args, response
+        else
+          raise DPay::ArgumentError, response.error.inspect
+        end
+      end
+
+      if !!block
+        case response
+        when Hashie::Mash then yield response.result, response.error, response.id
+        when Hashie::Array
+          response.each do |r|
+            r = Hashie::Mash.new(r)
+            yield r.result, r.error, r.id
+          end
+        else; yield response
+        end
+      else
+        return response
+      end
+    end
+  end
+end