beowulf-ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3ef4850cb0d869fc8cdd9650b2eaa97e4c632685170515e98ab272bf1e427b8d
+  data.tar.gz: db9a7bc76541043e0aacb559088e1a4cbc30673ce1ef6ad8d44c4458f8b82d0c
+SHA512:
+  metadata.gz: f9dfd423d37d99eeb4af29e647a68ba949f7ba75122a652089ed31f05c33d87472226ad71c7535adb253a398e8a04b2235b4e52eaec2831547f2e7f3f1b14525
+  data.tar.gz: d5d2d7ea03c7d65b79079901fde8a86956db48fda59319bea17b070a5f58dde17d984b46b62024b3b224b2ffa1c3d8008e4d721cc2b7fd3c90445f961624a1c7

data/.gitignore

@@ -0,0 +1,58 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+hashie.log
+output.mp4
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 beowulf-foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,200 @@
+# beowulf-ruby
+
+beowulf-ruby is the official Beowulf library for Ruby.  
+
+### Quick Start
+
+Add the gem to your Gemfile:
+
+```ruby
+gem 'beowulf-ruby'
+```
+
+Then:
+
+```bash
+$ bundle install
+```
+
+If you don't have `bundler`, see the next section.
+    
+### Prerequisites
+
+`minimum ruby version: 2.2`
+
+#### Linux
+
+```bash
+$ sudo apt-get install ruby-full git openssl libssl1.0.0 libssl-dev
+$ gem install bundler
+```
+
+#### macOS
+
+```
+$ gem install bundler
+```
+
+### Usage
+
+```ruby
+require 'beowulf'
+
+api = Beowulf::Api.new
+api.get_dynamic_global_properties do |properties|
+  properties.head_block_number
+end
+=> 2307597
+```
+
+... or ...
+
+```ruby
+require 'beowulf'
+
+api = Beowulf::Api.new
+response = api.get_dynamic_global_properties
+response.result.head_block_number
+=> 2307597
+```
+
+### Example
+```ruby
+require 'beowulf'
+
+# 0. Init
+## MainNet: https://bw.beowulfchain.com/rpc
+## TestNet: https://testnet-bw.beowulfchain.com/rpc
+api = Beowulf::Api.new(url: 'http://localhost:8376/rpc') # Replace this url with your node url
+
+# 1. get_version
+version = api.get_version
+puts version.to_json
+
+# 2. get_block
+bk = api.get_blocks(1)
+puts bk.to_json
+
+# 3. get_config
+cfg = api.get_config
+puts cfg.to_json
+puts cfg.result.BEOWULF_INIT_SUPPLY
+
+# 4. get_accounts
+acc = api.get_accounts(["beowulf2", "beowulf3"])
+puts acc.to_json
+
+# 5. get_transaction
+gtx = api.get_transaction("e725f75544dbeea7a017250bd0186ca247b24724")
+puts gtx.to_json
+
+# 6. Transfer native coin
+## 6.1. Transfer BWF from alice to bob
+tx = Beowulf::Transaction.new(url: 'https://bw.beowulfchain.com/rpc', wif: 'alice Private-Key Here')
+transfer = {
+    type: :transfer,
+    from: 'alice',
+    to: 'bob',
+    amount: '100.00000 BWF',
+    fee: '0.01000 W',
+    memo: 'alice to bob'
+}
+tx.operations << transfer
+tx_resp = tx.process(true)
+puts tx_resp.to_json
+puts "tx_resp.result.id:", tx_resp.result.id
+
+## 6.2. Transfer W from alice to bob
+tx = Beowulf::Transaction.new(url: 'https://bw.beowulfchain.com/rpc', wif: 'alice Private-Key Here')
+transfer = {
+    type: :transfer,
+    from: 'alice',
+    to: 'bob',
+    amount: '1.00000 W',
+    fee: '0.01000 W',
+    memo: 'alice to bob'
+}
+tx.operations << transfer
+tx_resp = tx.process(true)
+puts tx_resp.to_json
+puts "tx_resp.result.id:", tx_resp.result.id
+
+# 7. Transfer token
+## Transfer token KNOW from alice to bob
+tx = Beowulf::Transaction.new(url: 'https://bw.beowulfchain.com/rpc', wif: 'alice Private-Key Here')
+transfer = {
+    type: :transfer,
+    from: 'alice',
+    to: 'bob',
+    amount: '100.00000 KNOW',
+    fee: '0.01000 W',
+    memo: 'alice to bob'
+}
+tx.operations << transfer
+tx_resp = tx.process(true)
+puts tx_resp.to_json
+puts "tx_resp.result.id:", tx_resp.result.id
+
+
+# 8. Create account
+## 8.1. GenKeys
+wl = Beowulf::Wallet.new(name: "new-account-name")
+wl.gen_keys
+puts "wl.private_key:", wl.private_key
+puts "wl.public_key:", wl.public_key
+
+## 8.2. AccountCreate
+tx = Beowulf::Transaction.new(url: 'https://bw.beowulfchain.com/rpc', wif: 'creator Private-Key Here')
+owner = {
+    weight_threshold: 1,
+    account_auths: [],
+    key_auths: [[wl.public_key, 1]]
+}
+account_create = {
+    type: :account_create,
+    fee: '0.10000 W',
+    creator: 'creator',
+    new_account_name: wl.name,
+    owner: owner,
+    json_metadata: ''
+}
+tx.operations << account_create
+tx_resp = tx.process(true)
+puts "tx_resp:", tx_resp.to_json
+puts "tx_resp.result.id:", tx_resp.result.id
+
+## 8.3. Write file wallet.
+wallet_path = "/path/to/folder/save/wallet"
+password = "your_password"
+wl.save_wallet_file(wallet_path, "", password)
+
+## 8.4. Load file wallet.
+sleep(2)
+wallet_path_file = File.join(wallet_path, "new-account-name-wallet.json")
+wl2 = Beowulf::Wallet.new
+wl2.read_wallet_file(wallet_path_file, password)
+puts "wl2.private_key:", wl2.private_key
+puts "wl2.public_key:", wl2.public_key
+```
+
+
+## Failover
+
+Beowulf supports failover for situations where a node has, for example, become unresponsive.  When creating a new instance of `::Api` and `::Transaction`, you may provide a list of alternative nodes, or leave them out to use the default list.  For example:
+
+```ruby
+options = {
+  url: 'https://api.yournodedomain.com',
+  failover_urls: [
+    'https://api.otherdomain1.com',
+    'https://api.otherdomain2.com'
+  ]
+}
+
+api = Beowulf::Api.new(options)
+```
+
+
+## License
+
+MIT, see the `LICENSE` file.  

data/Rakefile

@@ -0,0 +1,52 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'yard'
+require 'beowulf'
+require 'awesome_print'
+
+Rake::TestTask.new(:test) 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
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb']
+end
+
+task default: :test
+
+namespace :clean do
+  desc 'Deletes test/fixtures/vcr_cassettes/*.yml so they can be rebuilt fresh.'
+  task :vcr do |t|
+    exec 'rm -v test/fixtures/vcr_cassettes/*.yml'
+  end
+end
+
+desc 'Ruby console with beowulf already required.'
+task :console do
+  exec "irb -r beowulf -I ./lib"
+end
+
+desc 'Build a new version of the beowulf gem.'
+task :build do
+  exec 'gem build beowulf.gemspec'
+end
+
+desc 'Publish the current version of the beowulf gem.'
+task :push do
+  exec "gem push beowulf-ruby-#{Beowulf::VERSION}.gem"
+end
+
+# We're not going to yank on a regular basis, but this is how it's done if you
+# really want a task for that for some reason.
+
+# desc 'Yank the current version of the beowulf gem.'
+# task :yank do
+#   exec "gem yank beowulf -v #{Beowulf::VERSION}"
+# end

data/beowulf.gemspec

@@ -0,0 +1,43 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'beowulf/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'beowulf-ruby'
+  spec.version = Beowulf::VERSION
+  spec.authors = ['NghiaTC']
+  spec.email = ['contact@beowulfchain.com']
+
+  spec.summary = %q{Beowulf RPC Ruby Client}
+  spec.description = %q{Beowulf-ruby is the official Beowulf library for Ruby.}
+  spec.homepage = 'https://github.com/beowulf-foundation/beowulf-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', '~> 2.0', '>= 2.0.1'
+  spec.add_development_dependency 'rake', '~> 12.1', '>= 12.1.0'
+  spec.add_development_dependency 'minitest', '~> 5.10', '>= 5.10.3'
+  spec.add_development_dependency 'minitest-line', '~> 0.6.3'
+  spec.add_development_dependency 'minitest-proveit', '~> 1.0', '>= 1.0.0'
+  spec.add_development_dependency 'webmock', '~> 3.6', '>= 3.6.0'
+  spec.add_development_dependency 'simplecov', '~> 0.17.0'
+  spec.add_development_dependency 'vcr', '~> 5.0', '>= 5.0.0'
+  spec.add_development_dependency 'yard', '~> 0.9.20'
+  spec.add_development_dependency 'pry', '~> 0.11', '>= 0.11.3'
+  spec.add_development_dependency 'rb-readline', '~> 0.5', '>= 0.5.5'
+  spec.add_development_dependency 'irb', '~> 1.0', '>= 1.0.0'
+  
+  # net-http-persistent has an open-ended dependency because beowulf directly
+  # supports net-http-persistent-3.0.0 as well as net-http-persistent-2.5.2.
+  spec.add_dependency('net-http-persistent', '~> 2.5', '>= 2.5.2')
+  spec.add_dependency('json', '~> 2.0', '>= 2.0.2')
+  spec.add_dependency('logging', '~> 2.2', '>= 2.2.0')
+  spec.add_dependency('hashie', '~> 3.5', '>= 3.5.5')
+  spec.add_dependency('bitcoin-ruby', '~> 0.0', '>= 0.0.11')
+  spec.add_dependency('ffi', '~> 1.9', '>= 1.9.18')
+  spec.add_dependency('awesome_print', '~> 1.7', '>= 1.7.0')
+  spec.add_dependency 'base58', '~> 0.2', '>= 0.2.3'
+end

data/lib/beowulf.rb

@@ -0,0 +1,35 @@
+require 'beowulf/version'
+require 'json'
+require 'awesome_print' if ENV['USE_AWESOME_PRINT'] == 'true'
+
+module Beowulf
+  require 'beowulf/utils'
+  require 'beowulf/type/serializer'
+  require 'beowulf/type/amount'
+  require 'beowulf/type/u_int16'
+  require 'beowulf/type/u_int32'
+  require 'beowulf/type/point_in_time'
+  require 'beowulf/type/permission'
+  require 'beowulf/type/public_key'
+  require 'beowulf/type/array'
+  require 'beowulf/type/hash'
+  require 'beowulf/type/future'
+  require 'beowulf/type/authority'
+  require 'beowulf/type/authority_update'
+  require 'beowulf/logger'
+  require 'beowulf/chain_config'
+  require 'beowulf/api'
+  require 'beowulf/database_api'
+  require 'beowulf/network_broadcast_api'
+  require 'beowulf/account_history_api'
+  require 'beowulf/condenser_api'
+  require 'beowulf/block_api'
+  require 'beowulf/operation_ids'
+  require 'beowulf/operation_types'
+  require 'beowulf/operation'
+  require 'beowulf/transaction'
+  require 'beowulf/base_error'
+  require 'beowulf/error_parser'
+  require 'beowulf/wallet'
+  extend self
+end

data/lib/beowulf/account_history_api.rb

@@ -0,0 +1,15 @@
+module Beowulf
+  class AccountHistoryApi < Api
+    def method_names
+      @method_names ||= [
+        # :get_account_history,
+        # :get_ops_in_block,
+        :get_transaction
+      ].freeze
+    end
+    
+    def api_name
+      :account_history_api
+    end
+  end
+end

data/lib/beowulf/api.rb

@@ -0,0 +1,845 @@
+require 'uri'
+require 'base64'
+require 'hashie'
+require 'hashie/logger'
+require 'openssl'
+require 'open-uri'
+require 'net/http/persistent'
+
+module Beowulf
+  # Beowulf::Api allows you to call remote methods to interact with the Beowulf blockchain.
+  # The `Api` class is a shortened name for
+  # `Beowulf::CondenserApi`.
+  #
+  # Examples:
+  #
+  #   api = Beowulf::Api.new
+  #   response = api.get_dynamic_global_properties
+  #   virtual_supply = response.result.virtual_supply
+  #
+  # ... or ...
+  #
+  #   api = Beowulf::Api.new
+  #   virtual_supply = api.get_dynamic_global_properties do |prop|
+  #     prop.virtual_supply
+  #   end
+  #
+  # If you need access to the `error` property, they can be accessed as follows:
+  #
+  #   api = Beowulf::Api.new
+  #   response = api.get_dynamic_global_properties
+  #   if response.result.nil?
+  #     puts response.error
+  #     exit
+  #   end
+  #   
+  #   virtual_supply = response.result.virtual_supply
+  #
+  # ... or ...
+  #
+  #   api = Beowulf::Api.new
+  #   virtual_supply = api.get_dynamic_global_properties do |prop, error|
+  #     if prop.nil?
+  #       puts error
+  #       exis
+  #     end
+  #     
+  #     prop.virtual_supply
+  #   end
+  #
+  # List of remote methods:
+  #
+  #   get_version
+  #   get_block_header
+  #   get_block
+  #   get_config
+  #   get_dynamic_global_properties
+  #   get_supernode_schedule
+  #   get_hardfork_version
+  #   get_next_scheduled_hardfork
+  #   get_accounts
+  #   lookup_account_names
+  #   lookup_accounts
+  #   get_account_count
+  #   get_owner_history
+  #   get_transaction_hex
+  #   get_transaction
+  #   get_transaction_with_status
+  #   get_pending_transaction_count
+  #   get_required_signatures
+  #   get_potential_signatures
+  #   verify_authority
+  #   get_supernodes
+  #   get_supernode_by_accounts
+  #   get_supernodes_by_vote
+  #   lookup_supernode_accounts
+  #   get_supernode_count
+  #   get_active_supernodes
+  #
+  class Api
+    include Utils
+
+    DEFAULT_BEOWULF_URL = 'https://bw.beowulfchain.com/rpc'
+
+    DEFAULT_BEOWULF_FAILOVER_URLS = [
+        DEFAULT_BEOWULF_URL
+    ]
+
+    DEFAULT_RESTFUL_URL = 'https://bw.beowulfchain.com/rpc'
+
+    # @private
+    POST_HEADERS = {
+        'Content-Type' => 'application/json',
+        'User-Agent' => Beowulf::AGENT_ID
+    }
+
+    # @private
+    HEALTH_URI = '/health'
+
+    def self.default_url(chain)
+      case chain.to_sym
+      when :beowulf then DEFAULT_BEOWULF_URL
+      else; raise ApiError, "Unsupported chain: #{chain}"
+      end
+    end
+
+    def self.default_restful_url(chain)
+      case chain.to_sym
+      when :beowulf then DEFAULT_RESTFUL_URL
+      else; raise ApiError, "Unsupported chain: #{chain}"
+      end
+    end
+
+    def self.default_failover_urls(chain)
+      case chain.to_sym
+      when :beowulf then DEFAULT_BEOWULF_FAILOVER_URLS
+      else; raise ApiError, "Unsupported chain: #{chain}"
+      end
+    end
+
+    # Create a new instance of Beowulf::Api.
+    #
+    # Examples:
+    #
+    #   api = Beowulf::Api.new(url: 'https://api.example.com')
+    #
+    # @param options [::Hash] The attributes to initialize the Beowulf::Api with.
+    # @option options [String] :url URL that points at a full node, like `https://bw.beowulfchain.com/rpc`.  Default from DEFAULT_URL.
+    # @option options [::Array<String>] :failover_urls An array that contains one or more full nodes to fall back on.  Default from DEFAULT_FAILOVER_URLS.
+    # @option options [Logger] :logger An instance of `Logger` to send debug messages to.
+    # @option options [Boolean] :recover_transactions_on_error Have Beowulf try to recover transactions that are accepted but could not be confirmed due to an error like network timeout.  Default: `true`
+    # @option options [Integer] :max_requests Maximum number of requests on a connection before it is considered expired and automatically closed.
+    # @option options [Integer] :pool_size Maximum number of connections allowed.
+    # @option options [Boolean] :reuse_ssl_sessions Reuse a previously opened SSL session for a new connection.  There's a slight performance improvement by enabling this, but at the expense of reliability during long execution.  Default false.
+    # @option options [Boolean] :persist Enable or disable Persistent HTTP.  Using Persistent HTTP keeps the connection alive between API calls.  Default: `true`
+    def initialize(options = {})
+      @user = options[:user]
+      @password = options[:password]
+      @chain = options[:chain] || :beowulf
+      @url = options[:url] || Api::default_url(@chain)
+      @restful_url = options[:restful_url] || Api::default_restful_url(@chain)
+      @preferred_url = @url.dup
+      @failover_urls = options[:failover_urls]
+      @debug = !!options[:debug]
+      @max_requests = options[:max_requests] || 30
+      @ssl_verify_mode = options[:ssl_verify_mode] || OpenSSL::SSL::VERIFY_PEER
+      @ssl_version = options[:ssl_version]
+
+      @self_logger = false
+      @logger = if options[:logger].nil?
+                  @self_logger = true
+                  Beowulf.logger
+                else
+                  options[:logger]
+                end
+
+      @self_hashie_logger = false
+      @hashie_logger = if options[:hashie_logger].nil?
+                         @self_hashie_logger = true
+                         Logger.new(nil)
+                       else
+                         options[:hashie_logger]
+                       end
+
+      if @failover_urls.nil?
+        @failover_urls = Api::default_failover_urls(@chain) - [@url]
+      end
+
+      @failover_urls = [@failover_urls].flatten.compact
+      @preferred_failover_urls = @failover_urls.dup
+
+      unless @hashie_logger.respond_to? :warn
+        @hashie_logger = Logger.new(@hashie_logger)
+      end
+
+      @recover_transactions_on_error = if options.keys.include? :recover_transactions_on_error
+                                         options[:recover_transactions_on_error]
+                                       else
+                                         true
+                                       end
+
+      @persist_error_count = 0
+      @persist = if options.keys.include? :persist
+                   options[:persist]
+                 else
+                   true
+                 end
+
+      @reuse_ssl_sessions = if options.keys.include? :reuse_ssl_sessions
+                              options[:reuse_ssl_sessions]
+                            else
+                              true
+                            end
+
+      @use_condenser_namespace = if options.keys.include? :use_condenser_namespace
+                                   options[:use_condenser_namespace]
+                                 else
+                                   true
+                                 end
+
+      if defined? Net::HTTP::Persistent::DEFAULT_POOL_SIZE
+        @pool_size = options[:pool_size] || Net::HTTP::Persistent::DEFAULT_POOL_SIZE
+      end
+
+      Hashie.logger = @hashie_logger
+      @method_names = nil
+      @uri = nil
+      @http_id = nil
+      @http_memo = {}
+      @api_options = options.dup.merge(chain: @chain)
+      @api = nil
+      @block_api = nil
+      @backoff_at = nil
+      @jussi_supported = []
+    end
+
+    # Get a specific block or range of blocks.
+    #
+    # Example:
+    #
+    #   api = Beowulf::Api.new
+    #   blocks = api.get_blocks(10..20)
+    #   transactions = blocks.flat_map(&:transactions)
+    #
+    # ... or ...
+    #
+    #   api = Beowulf::Api.new
+    #   transactions = []
+    #   api.get_blocks(10..20) do |block|
+    #     transactions += block.transactions
+    #   end
+    #
+    # @param block_number [Fixnum || ::Array<Fixnum>]
+    # @param block the block to execute for each result, optional.
+    # @return [::Array]
+    def get_blocks(block_number, &block)
+      block_number = [*(block_number)].flatten
+
+      if !!block
+        block_number.each do |i|
+          if use_condenser_namespace?
+            yield api.get_block(i)
+          else
+            yield block_api.get_block(block_num: i).result, i
+          end
+        end
+      else
+        block_number.map do |i|
+          if use_condenser_namespace?
+            api.get_block(i)
+          else
+            block_api.get_block(block_num: i).result
+          end
+        end
+      end
+    end
+
+    # Stops the persistent http connections.
+    #
+    def shutdown
+      @uri = nil
+      @http_id = nil
+      @http_memo.each do |k|
+        v = @http_memo.delete(k)
+        if defined?(v.shutdown)
+          debug "Shutting down instance #{k} (#{v})"
+          v.shutdown
+        end
+      end
+      @api.shutdown if !!@api && @api != self
+      @api = nil
+      @block_api.shutdown if !!@block_api && @block_api != self
+      @block_api = nil
+
+      if @self_logger
+        if !!@logger && defined?(@logger.close)
+          if defined?(@logger.closed?)
+            @logger.close unless @logger.closed?
+          end
+        end
+      end
+
+      if @self_hashie_logger
+        if !!@hashie_logger && defined?(@hashie_logger.close)
+          if defined?(@hashie_logger.closed?)
+            @hashie_logger.close unless @hashie_logger.closed?
+          end
+        end
+      end
+    end
+
+    # @private
+    def method_names
+      return @method_names if !!@method_names
+      return CondenserApi::METHOD_NAMES if api_name == :condenser_api
+
+      @method_names = Beowulf::Api.methods(api_name).map do |e|
+        e['method'].to_sym
+      end
+    end
+
+    # @private
+    def api_name
+      :condenser_api
+    end
+
+    # @private
+    def respond_to_missing?(m, include_private = false)
+      method_names.nil? ? false : method_names.include?(m.to_sym)
+    end
+
+    # @private
+    def method_missing(m, *args, &block)
+      super unless respond_to_missing?(m)
+
+      current_rpc_id = rpc_id
+      method_name = [api_name, m].join('.')
+      response = nil
+      options = if api_name == :condenser_api
+                  {
+                      jsonrpc: "2.0",
+                      method: method_name,
+                      params: args,
+                      id: current_rpc_id,
+                  }
+                else
+                  rpc_args = if args.empty?
+                               {}
+                             else
+                               args.first
+                             end
+                  {
+                      jsonrpc: "2.0",
+                      method: method_name,
+                      params: rpc_args,
+                      id: current_rpc_id,
+                  }
+                end
+
+      tries = 0
+      timestamp = Time.now.utc
+
+      loop do
+        tries += 1
+
+        if tries > 5 && flappy? && !check_file_open?
+          raise ApiError, 'PANIC: Out of file resources'
+        end
+
+        begin
+          if tries > 1 && @recover_transactions_on_error && api_name == :network_broadcast_api
+            signatures, exp = extract_signatures(options)
+
+            if !!signatures && signatures.any?
+              offset = [(exp - timestamp).abs, 30].min
+
+              if !!(response = recover_transaction(signatures, current_rpc_id, timestamp - offset))
+                response = Hashie::Mash.new(response)
+              end
+            end
+          end
+
+          if response.nil?
+            response = request(options)
+
+            response = if response.nil?
+                         error "No response, retrying ...", method_name
+                       elsif !response.kind_of? Net::HTTPSuccess
+                         warning "Unexpected response (code: #{response.code}): #{response.inspect}, retrying ...", method_name, true
+                       else
+                         detect_jussi(response)
+
+                         case response.code
+                         when '200'
+                           body = response.body
+                           response = JSON[body]
+
+                           if response['id'] != options[:id]
+                             debug_payload(options, body) if ENV['DEBUG'] == 'true'
+
+                             if !!response['id']
+                               warning "Unexpected rpc_id (expected: #{options[:id]}, got: #{response['id']}), retrying ...", method_name, true
+                             else
+                               # The node has broken the jsonrpc spec.
+                               warning "Node did not provide jsonrpc id (expected: #{options[:id]}, got: nothing), retrying ...", method_name, true
+                             end
+
+                             if response.keys.include?('error')
+                               handle_error(response, options, method_name, tries)
+                             end
+                           elsif response.keys.include?('error')
+                             handle_error(response, options, method_name, tries)
+                           else
+                             Hashie::Mash.new(response)
+                           end
+                         when '400' then warning 'Code 400: Bad Request, retrying ...', method_name, true
+                         when '429' then warning 'Code 429: Too Many Requests, retrying ...', method_name, true
+                         when '502' then warning 'Code 502: Bad Gateway, retrying ...', method_name, true
+                         when '503' then warning 'Code 503: Service Unavailable, retrying ...', method_name, true
+                         when '504' then warning 'Code 504: Gateway Timeout, retrying ...', method_name, true
+                         else
+                           warning "Unknown code #{response.code}, retrying ...", method_name, true
+                           warning response
+                         end
+                       end
+          end
+        rescue Net::HTTP::Persistent::Error => e
+          warning "Unable to perform request: #{e} :: #{!!e.cause ? "cause: #{e.cause.message}" : ''}, retrying ...", method_name, true
+          if e.cause.class == Net::HTTPMethodNotAllowed
+            warning 'Node upstream is misconfigured.'
+            drop_current_failover_url method_name
+          end
+
+          @persist_error_count += 1
+        rescue ConnectionPool::Error => e
+          warning "Connection Pool Error (#{e.message}), retrying ...", method_name, true
+        rescue Errno::ECONNREFUSED => e
+          warning 'Connection refused, retrying ...', method_name, true
+        rescue Errno::EADDRNOTAVAIL => e
+          warning 'Node not available, retrying ...', method_name, true
+        rescue Errno::ECONNRESET => e
+          warning "Connection Reset (#{e.message}), retrying ...", method_name, true
+        rescue Errno::EBUSY => e
+          warning "Resource busy (#{e.message}), retrying ...", method_name, true
+        rescue Errno::ENETDOWN => e
+          warning "Network down (#{e.message}), retrying ...", method_name, true
+        rescue Net::ReadTimeout => e
+          warning 'Node read timeout, retrying ...', method_name, true
+        rescue Net::OpenTimeout => e
+          warning 'Node timeout, retrying ...', method_name, true
+        rescue RangeError => e
+          warning 'Range Error, retrying ...', method_name, true
+        rescue OpenSSL::SSL::SSLError => e
+          warning "SSL Error (#{e.message}), retrying ...", method_name, true
+        rescue SocketError => e
+          warning "Socket Error (#{e.message}), retrying ...", method_name, true
+        rescue JSON::ParserError => e
+          warning "JSON Parse Error (#{e.message}), retrying ...", method_name, true
+          drop_current_failover_url method_name if tries > 5
+          response = nil
+        rescue ApiError => e
+          warning "ApiError (#{e.message}), retrying ...", method_name, true
+          # rescue => e
+          #   warning "Unknown exception from request, retrying ...", method_name, true
+          #   warning e
+        end
+
+        if !!response
+          @persist_error_count = 0
+
+          if !!block
+            if api_name == :condenser_api
+              return yield(response.result, response.error, response.id)
+            else
+              if defined?(response.result.size) && response.result.size == 0
+                return yield(nil, response.error, response.id)
+              elsif (defined?(response.result.size) && response.result.size == 1 && defined?(response.result.values))
+                return yield(response.result.values.first, response.error, response.id)
+              else
+                return yield(response.result, response.error, response.id)
+              end
+            end
+          else
+            return response
+          end
+        end
+
+        backoff
+      end # loop
+    end
+
+    def inspect
+      properties = %w(
+        chain url backoff_at max_requests ssl_verify_mode ssl_version persist
+        recover_transactions_on_error reuse_ssl_sessions pool_size
+        use_condenser_namespace
+      ).map do |prop|
+        if !!(v = instance_variable_get("@#{prop}"))
+          "@#{prop}=#{v}"
+        end
+      end.compact.join(', ')
+
+      "#<#{self.class.name} [#{properties}]>"
+    end
+
+    def stopped?
+      http_active = if @http_memo.nil?
+                      false
+                    else
+                      @http_memo.values.map do |http|
+                        if defined?(http.active?)
+                          http.active?
+                        else
+                          false
+                        end
+                      end.include?(true)
+                    end
+
+      @uri.nil? && @http_id.nil? && !http_active && @api.nil? && @block_api.nil?
+    end
+
+    def use_condenser_namespace?
+      @use_condenser_namespace
+    end
+    private
+    def self.methods_json_path
+      @methods_json_path ||= "#{File.dirname(__FILE__)}/methods.json"
+    end
+
+    def self.methods(api_name)
+      @methods ||= {}
+      @methods[api_name] ||= JSON[File.read methods_json_path].map do |e|
+        e if e['api'].to_sym == api_name
+      end.compact.freeze
+    end
+
+    def self.apply_http_defaults(http, ssl_verify_mode)
+      http.read_timeout = 10
+      http.open_timeout = 10
+      http.verify_mode = ssl_verify_mode
+      http.ssl_timeout = 30 if defined? http.ssl_timeout
+      http
+    end
+
+    def api_options
+      @api_options.merge(failover_urls: @failover_urls, logger: @logger, hashie_logger: @hashie_logger)
+    end
+
+    def api
+      @api ||= self.class == Api ? self : Api.new(api_options)
+    end
+
+    def block_api
+      @block_api ||= self.class == BlockApi ? self : BlockApi.new(api_options)
+    end
+
+    def rpc_id
+      @rpc_id ||= 0
+      @rpc_id = @rpc_id + 1
+    end
+
+    def uri
+      @uri ||= URI.parse(@url)
+    end
+
+    def http_id
+      @http_id ||= "beowulf-#{Beowulf::VERSION}-#{api_name}-#{SecureRandom.uuid}"
+    end
+
+    def http
+      return @http_memo[http_id] if @http_memo.keys.include? http_id
+
+      @http_memo[http_id] = if @persist && @persist_error_count < 10
+                              idempotent = api_name != :network_broadcast_api
+
+                              http = if defined? Net::HTTP::Persistent::DEFAULT_POOL_SIZE
+                                       Net::HTTP::Persistent.new(name: http_id, pool_size: @pool_size)
+                                     else
+                                       # net-http-persistent < 3.0
+                                       Net::HTTP::Persistent.new(http_id)
+                                     end
+
+                              http.keep_alive = 30
+                              http.idle_timeout = idempotent ? 10 : nil
+                              http.max_requests = @max_requests
+                              http.retry_change_requests = idempotent
+                              http.reuse_ssl_sessions = @reuse_ssl_sessions
+
+                              http
+                            else
+                              http = Net::HTTP.new(uri.host, uri.port)
+                              http.use_ssl = uri.scheme == 'https'
+                              http
+                            end
+
+      Api::apply_http_defaults(@http_memo[http_id], @ssl_verify_mode)
+    end
+
+    def post_request
+      Net::HTTP::Post.new uri.request_uri, POST_HEADERS
+    end
+
+    def request(options)
+      request = post_request
+      request.body = JSON[options]
+
+      case http
+      when Net::HTTP::Persistent then http.request(uri, request)
+      when Net::HTTP then http.request(request)
+      else; raise ApiError, "Unsuppored scheme: #{http.inspect}"
+      end
+    end
+
+    def jussi_supported?(url = @url)
+      @jussi_supported.include? url
+    end
+
+    def detect_jussi(response)
+      return if jussi_supported?(@url)
+
+      jussi_response_id = response['x-jussi-response-id']
+
+      if !!jussi_response_id
+        debug "Found a node that supports jussi: #{@url}"
+        @jussi_supported << @url
+      end
+    end
+
+    def recover_transaction(signatures, expected_rpc_id, after)
+      debug "Looking for signatures: #{signatures.map{|s| s[0..5]}} since: #{after}"
+
+      count = 0
+      start = Time.now.utc
+      block_range = api.get_dynamic_global_properties do |properties|
+        high = properties.head_block_number
+        low = high - 100
+        [*(low..(high))].reverse
+      end
+
+      # At most, we read 100 blocks
+      # but we also give up once the block time is before the `after` argument.
+      api.get_blocks(block_range) do |block, block_num|
+        unless defined? block.transaction_ids
+          error "Blockchain does not provide transaction ids in blocks, giving up."
+          return nil
+        end
+
+        count += 1
+        raise ApiError, "Race condition detected on remote node at: #{block_num}" if block.nil?
+
+        # In the future, it would be better to decode the operation and signature
+        # into the transaction id.
+        unless defined? block.transaction_ids
+          @recover_transactions_on_error = false
+          return
+        end
+
+        timestamp = Time.parse(block.timestamp + 'Z')
+        break if timestamp < after
+
+        block.transactions.each_with_index do |tx, index|
+          next unless ((tx['signatures'] || []) & signatures).any?
+
+          debug "Found transaction #{count} block(s) ago; took #{(Time.now.utc - start)} seconds to scan."
+
+          return {
+              id: expected_rpc_id,
+              recovered_by: http_id,
+              result: {
+                  id: block.transaction_ids[index],
+                  block_num: block_num,
+                  trx_num: index,
+                  expired: false
+              }
+          }
+        end
+      end
+
+      debug "Could not find transaction in #{count} block(s); took #{(Time.now.utc - start)} seconds to scan."
+
+      return nil
+    end
+
+    def reset_failover
+      @url = @preferred_url.dup
+      @failover_urls = @preferred_failover_urls.dup
+      warning "Failover reset, going back to #{@url} ..."
+    end
+
+    def pop_failover_url
+      reset_failover if @failover_urls.none?
+
+      until @failover_urls.none? || healthy?(url = @failover_urls.sample)
+        @failover_urls.delete(url)
+      end
+
+      url || (uri || @url).to_s
+    end
+
+    def bump_failover
+      @uri = nil
+      @url = pop_failover_url
+      warning "Failing over to #{@url} ..."
+    end
+
+    def flappy?
+      !!@backoff_at && Time.now.utc - @backoff_at < 300
+    end
+
+    # Note, this methods only removes the uri.to_s if present but it does not
+    # call bump_failover, in order to avoid a race condition.
+    def drop_current_failover_url(prefix)
+      if @preferred_failover_urls.size == 1
+        warning "Node #{uri} appears to be misconfigured but no other node is available, retrying ...", prefix
+      else
+        warning "Removing misconfigured node from failover urls: #{uri}, retrying ...", prefix
+        @preferred_failover_urls.delete(uri.to_s)
+        @failover_urls.delete(uri.to_s)
+      end
+    end
+
+    def handle_error(response, request_options, method_name, tries)
+      parser = ErrorParser.new(response)
+      _signatures, exp = extract_signatures(request_options)
+
+      if (!!exp && exp < Time.now.utc) || (tries > 2 && !parser.node_degraded?)
+        # Whatever the error was, it is already expired or tried too much.  No need to try to recover.
+        debug "Error code #{parser} but transaction already expired or too many tries, giving up (attempt: #{tries})."
+      elsif parser.can_retry?
+        drop_current_failover_url method_name if !!exp && parser.expiry?
+        drop_current_failover_url method_name if parser.node_degraded?
+        debug "Error code #{parser} (attempt: #{tries}), retrying ..."
+        return nil
+      end
+
+      if !!parser.trx_id
+        # Turns out, the ErrorParser found a transaction id.  It might come in
+        # handy, so let's append this to the result along with the error.
+
+        response[:result] = {
+            id: parser.trx_id,
+            block_num: -1,
+            trx_num: -1,
+            expired: false
+        }
+
+        if @recover_transactions_on_error
+          begin
+            if !!@restful_url
+              JSON[open("#{@restful_url}/account_history_api/get_transaction?id=#{parser.trx_id}").read].tap do |tx|
+                response[:result][:block_num] = tx['block_num']
+                response[:result][:trx_num] = tx['transaction_num']
+              end
+            else
+              # Node operators often disable this operation.
+              api.get_transaction(parser.trx_id) do |tx|
+                if !!tx
+                  response[:result][:block_num] = tx.block_num
+                  response[:result][:trx_num] = tx.transaction_num
+                end
+              end
+            end
+
+            response[:recovered_by] = http_id
+            response.delete('error') # no need for this, now
+          rescue
+            debug "Couldn't find block for trx_id: #{parser.trx_id}, giving up."
+          end
+        end
+      end
+
+      Hashie::Mash.new(response)
+    end
+
+    def healthy?(url)
+      begin
+        # Note, not all nodes support the /health uri.  But even if they don't,
+        # they'll respond status code 200 OK, even if the body shows an error.
+        #
+        # But if the node supports the /health uri, it will do additional
+        # verifications on the block height.
+        #
+        # Also note, this check is done **without** net-http-persistent.
+
+        response = open(url + HEALTH_URI)
+        response = JSON[response.read]
+
+        if !!response['error']
+          if !!response['error']['data']
+            if !!response['error']['data']['message']
+              error "#{url} error: #{response['error']['data']['message']}"
+            end
+          elsif !!response['error']['message']
+            error "#{url} error: #{response['error']['message']}"
+          else
+            error "#{url} error: #{response['error']}"
+          end
+
+          false
+        elsif response['status'] == 'OK'
+          true
+        else
+          error "#{url} status: #{response['status']}"
+
+          false
+        end
+      rescue JSON::ParserError
+        # No JSON, but also no HTTP error code, so we're OK.
+
+        true
+      rescue => e
+        error "Health check failure for #{url}: #{e.inspect}"
+        sleep 0.2
+        false
+      end
+    end
+
+    def check_file_open?
+      File.exists?('.')
+    rescue
+      false
+    end
+
+    def debug_payload(request, response)
+      request = JSON.pretty_generate(request)
+      response = JSON.parse(response) rescue response
+      response = JSON.pretty_generate(response) rescue response
+
+      puts '=' * 80
+      puts "Request:"
+      puts request
+      puts '=' * 80
+      puts "Response:"
+      puts response
+      puts '=' * 80
+    end
+
+    def backoff
+      shutdown
+      bump_failover if flappy? || !healthy?(uri)
+      @backoff_at ||= Time.now.utc
+      @backoff_sleep ||= 0.01
+
+      @backoff_sleep *= 2
+      GC.start
+      sleep @backoff_sleep
+    ensure
+      if !!@backoff_at && Time.now.utc - @backoff_at > 300
+        @backoff_at = nil
+        @backoff_sleep = nil
+      end
+    end
+
+    def self.finalize(logger, hashie_logger)
+      proc {
+        if !!logger && defined?(logger.close) && !logger.closed?
+          logger.close
+        end
+
+        if !!hashie_logger && defined?(hashie_logger.close) && !hashie_logger.closed?
+          hashie_logger.close
+        end
+      }
+    end
+  end
+end