rubybear 0.0.2

data/lib/rubybear/chain.rb

@@ -0,0 +1,299 @@
+module Rubybear
+  # Examples ...
+  # 
+  # To vote on a post/comment:
+  # 
+  #     bears = Rubybear::Chain.new(chain: :bears, account_name: 'your account name', wif: 'your wif')
+  #     bears.vote!(10000, 'author', 'post-or-comment-permlink')
+  # 
+  # To post and vote in the same transaction:
+  # 
+  #     bears = Rubybear::Chain.new(chain: :bears, account_name: 'your account name', wif: 'your wif')
+  #     bears.post!(title: 'title of my post', body: 'body of my post', tags: ['tag'], self_upvote: 10000)
+  #
+  # To post and vote with declined payout:
+  #
+  #     bears = Rubybear::Chain.new(chain: :bears, account_name: 'your account name', wif: 'your wif')
+  #     
+  #     options = {
+  #       title: 'title of my post',
+  #       body: 'body of my post',
+  #       tags: ['tag'],
+  #       self_upvote: 10000,
+  #       percent_bears_dollars: 0
+  #     }
+  #     
+  #     bears.post!(options)
+  # 
+  class Chain
+    include Mixins::ActsAsPoster
+    include Mixins::ActsAsVoter
+    include Mixins::ActsAsWallet
+    
+    VALID_OPTIONS = %w(
+      chain account_name wif url failover_urls
+    ).map(&:to_sym)
+    VALID_OPTIONS.each { |option| attr_accessor option }
+    
+    def self.parse_slug(*args)
+      args = [args].flatten
+      
+      if args.size == 1
+        case args[0]
+        when String then split_slug(args[0])
+        when ::Hash then [args[0]['author'], args[0]['permlink']]
+        end
+      else
+        args
+      end
+    end
+    
+    def initialize(options = {})
+      options = options.dup
+      options.each do |k, v|
+        k = k.to_sym
+        if VALID_OPTIONS.include?(k.to_sym)
+          options.delete(k)
+          send("#{k}=", v)
+        end
+      end
+      
+      @account_name ||= ENV['ACCOUNT_NAME']
+      @wif ||= ENV['WIF']
+      
+      reset
+    end
+    
+    # Find a specific block by block number.
+    #
+    # Example:
+    #
+    #     bears = Rubybear::Chain.new(chain: :bears)
+    #     block = bears.find_block(12345678)
+    #     transactions = block.transactions
+    #
+    # @param block_number [Fixnum]
+    # @return [::Hash]
+    def find_block(block_number)
+      api.get_blocks(block_number).first
+    end
+    
+    # Find a specific account by name.
+    #
+    # Example:
+    #
+    #     bears = Rubybear::Chain.new(chain: :bears)
+    #     ned = bears.find_account('ned')
+    #     coining_shares = ned.coining_shares
+    #
+    # @param account_name [String] Name of the account to find.
+    # @return [::Hash]
+    def find_account(account_name)
+      api.get_accounts([account_name]) do |accounts, err|
+        raise ChainError, ErrorParser.new(err) if !!err
+        
+        accounts[0]
+      end
+    end
+    
+    # Find a specific comment by author and permlink or slug.
+    #
+    # Example:
+    #
+    #     bears = Rubybear::Chain.new(chain: :bears)
+    #     comment = bears.find_comment('inertia', 'kinda-spooky') # by account, permlink
+    #     active_votes = comment.active_votes
+    #
+    # ... or ...
+    #
+    #     comment = bears.find_comment('@inertia/kinda-spooky') # by slug
+    #
+    # @param args [String || ::Array<String>] Slug or author, permlink of comment.
+    # @return [::Hash]
+    def find_comment(*args)
+      author, permlink = Chain.parse_slug(args)
+      
+      api.get_content(author, permlink) do |comment, err|
+        raise ChainError, ErrorParser.new(err) if !!err
+        
+        comment unless comment.id == 0
+      end
+    end
+    
+    # Current dynamic global properties, cached for 3 seconds.  This is useful
+    # for reading properties without worrying about actually fetching it over
+    # rpc more than needed.
+    def properties
+      @properties ||= nil
+      
+      if !!@properties && Time.now.utc - Time.parse(@properties.time + 'Z') > 3
+        @properties = nil
+      end
+      
+      return @properties if !!@properties
+      
+      api.get_dynamic_global_properties do |properties|
+        @properties = properties
+      end
+    end
+    
+    def block_time
+      Time.parse(properties.time + 'Z')
+    end
+    
+    # Returns the current base (e.g. BEARS) price in the coin asset (e.g.
+    # COINS).
+    #
+    def base_per_mcoin
+      total_coining_fund_bears = properties.total_coining_fund_bears.to_f
+      total_coining_shares_mcoin = properties.total_coining_shares.to_f / 1e6
+    
+      total_coining_fund_bears / total_coining_shares_mcoin
+    end
+    
+    # Returns the current base (e.g. BEARS) price in the debt asset (e.g BSD).
+    #
+    def base_per_debt
+      api.get_feed_history do |feed_history|
+        current_median_history = feed_history.current_median_history
+        base = current_median_history.base
+        base = base.split(' ').first.to_f
+        quote = current_median_history.quote
+        quote = quote.split(' ').first.to_f
+        
+        (base / quote) * base_per_mcoin
+      end
+    end
+    
+    # List of accounts followed by account.
+    #
+    # @param account_name String Name of the account.
+    # @return [::Array<String>]
+    def followed_by(account_name)
+      return [] if account_name.nil?
+      
+      followers = []
+      count = -1
+
+      until count == followers.size
+        count = followers.size
+        follow_api.get_followers(account: account_name, start: followers.last, type: 'blog', limit: 1000) do |follows, err|
+          raise ChainError, ErrorParser.new(err) if !!err
+          
+          followers += follows.map(&:follower)
+          followers = followers.uniq
+        end
+      end
+      
+      followers
+    end
+    
+    # List of accounts following account.
+    #
+    # @param account_name String Name of the account.
+    # @return [::Array<String>]
+    def following(account_name)
+      return [] if account_name.nil?
+      
+      following = []
+      count = -1
+
+      until count == following.size
+        count = following.size
+        follow_api.get_following(account: account_name, start: following.last, type: 'blog', limit: 100) do |follows, err|
+          raise ChainError, ErrorParser.new(err) if !!err
+          
+          following += follows.map(&:following)
+          following = following.uniq
+        end
+      end
+
+      following
+    end
+    
+    # Clears out queued properties.
+    def reset_properties
+      @properties = nil
+    end
+    
+    # Clears out queued operations.
+    def reset_operations
+      @operations = []
+    end
+    
+    # Clears out all properties and operations.
+    def reset
+      reset_properties
+      reset_operations
+      
+      @api = @block_api = @follow_api = nil
+    end
+    
+    # Broadcast queued operations.
+    #
+    # @param auto_reset [boolean] clears operations no matter what, even if there's an error.
+    def broadcast!(auto_reset = false)
+      raise ChainError, "Required option: chain" if @chain.nil?
+      raise ChainError, "Required option: account_name, wif" if @account_name.nil? || @wif.nil?
+      
+      begin
+        transaction = Rubybear::Transaction.new(build_options)
+        transaction.operations = @operations
+        response = transaction.process(true)
+      rescue => e
+        reset if auto_reset
+        raise e
+      end
+      
+      if !!response.result
+        reset
+        response
+      else
+        reset if auto_reset
+        ErrorParser.new(response)
+      end
+    end
+  private
+    def self.split_slug(slug)
+      slug = slug.split('@').last
+      author = slug.split('/')[0]
+      permlink = slug.split('/')[1..-1].join('/')
+      permlink = permlink.split('#')[0]
+      
+      [author, permlink]
+    end
+    
+    def build_options
+      {
+        chain: chain,
+        wif: wif,
+        url: url,
+        failover_urls: failover_urls
+      }
+    end
+    
+    def api
+      @api ||= Api.new(build_options)
+    end
+    
+    def block_api
+      @block_api ||= BlockApi.new(build_options)
+    end
+    
+    def follow_api
+      @follow_api ||= FollowApi.new(build_options)
+    end
+    
+    def default_max_acepted_payout
+      "1000000.000 #{default_debt_asset}"
+    end
+    
+    def default_debt_asset
+      case chain
+      when :bears then ChainConfig::NETWORKS_BEARS_DEBT_ASSET
+      when :test then ChainConfig::NETWORKS_TEST_DEBT_ASSET
+      else; raise ChainError, "Unknown chain: #{chain}"
+      end
+    end
+  end
+end

data/lib/rubybear/chain_config.rb

@@ -0,0 +1,22 @@
+module Rubybear
+  module ChainConfig
+    EXPIRE_IN_SECS = 600
+    EXPIRE_IN_SECS_PROPOSAL = 24 * 60 * 60
+    
+    NETWORKS_BEARS_CHAIN_ID = 'b510834141c312c2aa8837040734605f2333f1ecc4f634576372f9c12dc7e8b2'
+    NETWORKS_BEARS_ADDRESS_PREFIX = 'SHR'
+    NETWORKS_BEARS_CORE_ASSET = 'BEARS'
+    NETWORKS_BEARS_DEBT_ASSET = 'BSD'
+    NETWORKS_BEARS_COIN_ASSET = 'COINS'
+    NETWORKS_BEARS_DEFAULT_NODE = 'https://api.bearshares.com'
+    
+    NETWORKS_TEST_CHAIN_ID = '18dcf0a285365fc58b71f18b3d3fec954aa0c141c44e4e5cb4cf777b9eab274e'
+    NETWORKS_TEST_ADDRESS_PREFIX = 'TST'
+    NETWORKS_TEST_CORE_ASSET = 'CORE'
+    NETWORKS_TEST_DEBT_ASSET = 'TEST'
+    NETWORKS_TEST_COIN_ASSET = 'CESTS'
+    NETWORKS_TEST_DEFAULT_NODE = 'https://test.bears.ws'
+    
+    NETWORK_CHAIN_IDS = [NETWORKS_BEARS_CHAIN_ID, NETWORKS_TEST_CHAIN_ID]
+  end
+end

data/lib/rubybear/chain_stats_api.rb

@@ -0,0 +1,15 @@
+module Rubybear
+  class ChainStatsApi < Api
+    def method_names
+      @method_names ||= [
+        :get_stats_for_time,
+        :get_stats_for_interval,
+        :get_lifetime_stats
+      ].freeze
+    end
+    
+    def api_name
+      :chain_stats_api
+    end
+  end
+end

data/lib/rubybear/condenser_api.rb

@@ -0,0 +1,99 @@
+module Rubybear
+  class CondenserApi < Api
+    METHOD_NAMES = [
+      :broadcast_block,
+      :broadcast_transaction,
+      :broadcast_transaction_synchronous,
+      :get_account_bandwidth,
+      :get_account_count,
+      :get_account_history,
+      :get_account_references,
+      :get_account_reputations,
+      :get_account_votes,
+      :get_accounts,
+      :get_active_votes,
+      :get_active_witnesses,
+      :get_block,
+      :get_block_header,
+      :get_blog,
+      :get_blog_authors,
+      :get_blog_entries,
+      :get_chain_properties,
+      :get_comment_discussions_by_payout,
+      :get_config,
+      :get_content,
+      :get_content_replies,
+      :get_conversion_requests,
+      :get_current_median_history_price,
+      :get_discussions_by_active,
+      :get_discussions_by_author_before_date,
+      :get_discussions_by_blog,
+      :get_discussions_by_cashout,
+      :get_discussions_by_children,
+      :get_discussions_by_comments,
+      :get_discussions_by_created,
+      :get_discussions_by_feed,
+      :get_discussions_by_hot,
+      :get_discussions_by_promoted,
+      :get_discussions_by_trending,
+      :get_discussions_by_votes,
+      :get_dynamic_global_properties,
+      :get_escrow,
+      :get_expiring_coining_delegations,
+      :get_feed,
+      :get_feed_entries,
+      :get_feed_history,
+      :get_follow_count,
+      :get_followers,
+      :get_following,
+      :get_hardfork_version,
+      :get_key_references,
+      :get_market_history,
+      :get_market_history_buckets,
+      :get_next_scheduled_hardfork,
+      :get_open_orders,
+      :get_ops_in_block,
+      :get_order_book,
+      :get_owner_history,
+      :get_post_discussions_by_payout,
+      :get_potential_signatures,
+      :get_reblogged_by,
+      :get_recent_trades,
+      :get_recovery_request,
+      :get_replies_by_last_update,
+      :get_required_signatures,
+      :get_reward_fund,
+      :get_savings_withdraw_from,
+      :get_savings_withdraw_to,
+      :get_state,
+      :get_tags_used_by_author,
+      :get_ticker,
+      :get_trade_history,
+      :get_transaction,
+      :get_transaction_hex,
+      :get_trending_tags,
+      :get_version,
+      :get_coining_delegations,
+      :get_volume,
+      :get_withdraw_routes,
+      :get_witness_by_account,
+      :get_witness_count,
+      :get_witness_schedule,
+      :get_witnesses,
+      :get_witnesses_by_vote,
+      :lookup_account_names,
+      :lookup_accounts,
+      :lookup_witness_accounts,
+      :verify_account_authority,
+      :verify_authority
+    ].freeze
+    
+    def method_names
+      METHOD_NAMES
+    end
+    
+    def api_name
+      :condenser_api
+    end
+  end
+end

data/lib/rubybear/database_api.rb

@@ -0,0 +1,5 @@
+module Rubybear
+  # @see Api
+  class DatabaseApi < Api
+  end
+end

data/lib/rubybear/error_parser.rb

@@ -0,0 +1,228 @@
+module Rubybear
+  class ErrorParser
+    include Utils
+    
+    attr_reader :response, :error, :error_code, :error_message,
+      :api_name, :api_method, :api_params,
+      :expiry, :can_retry, :can_reprepare, :node_degraded, :trx_id, :debug
+      
+    alias expiry? expiry
+    alias can_retry? can_retry
+    alias can_reprepare? can_reprepare
+    alias node_degraded? node_degraded
+    
+    REPREPARE_WHITELIST = [
+      'is_canonical( c ): signature is not canonical',
+      'now < trx.expiration: '
+    ]
+    
+    DUPECHECK = '(skip & skip_transaction_dupe_check) || trx_idx.indices().get<by_trx_id>().find(trx_id) == trx_idx.indices().get<by_trx_id>().end(): Duplicate transaction check failed'
+      
+    REPREPARE_BLACKLIST = [DUPECHECK]
+    
+    def initialize(response)
+      @response = response
+      
+      @error = nil
+      @error_code = nil
+      @error_message = nil
+      @api_name = nil
+      @api_method = nil
+      @api_params = nil
+      
+      @expiry = nil
+      @can_retry = nil
+      @can_reprepare = nil
+      @trx_id = nil
+      @debug = nil
+      
+      parse_error_response
+    end
+    
+    def parse_error_response
+      if response.nil?
+        @expiry = false
+        @can_retry = false
+        @can_reprepare = false
+        
+        return
+      end
+      
+      @response = JSON[response] if response.class == String
+
+      @error = if !!@response['error']
+        response['error']
+      else
+        response
+      end
+      
+      begin
+        if !!@error['data']
+          # These are, by far, the more interesting errors, so we try to pull
+          # them out first, if possible.
+          
+          @error_code = @error['data']['code']
+          stacks = @error['data']['stack']
+          stack_formats = nil
+          
+          @error_message = if !!stacks
+            stack_formats = stacks.map { |s| s['format'] }
+            stack_datum = stacks.map { |s| s['data'] }
+            data_call_method = stack_datum.find { |data| data['call.method'] == 'call' }
+            data_name = stack_datum.find { |data| !!data['name'] }
+            
+            # See if we can recover a transaction id out of this hot mess.
+            data_trx_ix = stack_datum.find { |data| !!data['trx_ix'] }
+            @trx_id = data_trx_ix['trx_ix'] if !!data_trx_ix
+            
+            stack_formats.reject(&:empty?).join('; ')
+          else
+            @error_code ||= @error['code']
+            @error['message']
+          end
+          
+          @api_name, @api_method, @api_params = if !!data_call_method
+            @api_name = data_call_method['call.params']
+          end
+        else
+          @error_code = @error['code']
+          @error_message = @error['message']
+          @expiry = false
+          @can_retry = false
+          @can_reprepare = false
+        end
+        
+        case @error_code
+        when -32603
+          if error_match?('Internal Error')
+            @expiry = false
+            @can_retry = true
+            @can_reprepare = true
+          end
+        when -32003
+          if error_match?('Unable to acquire database lock')
+            @expiry = false
+            @can_retry = true
+            @can_reprepare = true
+          end
+        when -32000
+          @expiry = false
+          @can_retry = coerce_backtrace
+          @can_reprepare = if @api_name == 'network_broadcast_api'
+            error_match(REPREPARE_WHITELIST)
+          else
+            false
+          end
+        when 10
+          @expiry = false
+          @can_retry = coerce_backtrace
+          @can_reprepare = !!stack_formats && (stack_formats & REPREPARE_WHITELIST).any?
+        when 13
+          @error_message = @error['data']['message']
+          @expiry = false
+          @can_retry = false
+          @can_reprepare = false
+        when 3030000
+          @error_message = @error['data']['message']
+          @expiry = false
+          @can_retry = false
+          @can_reprepare = false
+        when 4030100
+          # Code 4030100 is "transaction_expiration_exception: transaction
+          # expiration exception".  If we assume the expiration was valid, the
+          # node might be bad and needs to be dropped.
+          
+          @expiry = true
+          @can_retry = true
+          @can_reprepare = false
+        when 4030200
+          # Code 4030200 is "transaction tapos exception".  They are recoverable
+          # if the transaction hasn't expired yet.  A tapos exception can be
+          # retried in situations where the node is behind and the tapos is
+          # based on a block the node doesn't know about yet.
+          
+          @expiry = false
+          @can_retry = true
+          
+          # Allow fall back to reprepare if retry fails.
+          @can_reprepare = true
+        else
+          @expiry = false
+          @can_retry = false
+          @can_reprepare = false
+        end
+      rescue => e
+        if defined? ap
+          if ENV['DEBUG'] == 'true'
+            ap error_parser_exception: e, original_response: response, backtrace: e.backtrace
+          else
+            ap error_parser_exception: e, original_response: response
+          end
+        end
+        
+        @expiry = false
+        @can_retry = false
+        @can_reprepare = false
+      end
+    end
+    
+    def coerce_backtrace
+      can_retry = false
+      
+      case @error['code']
+      when -32003
+        any_of = [
+          'Internal Error"',
+          '_api_plugin not enabled.'
+        ]
+        
+        can_retry = error_match?('Unable to acquire database lock')
+        
+        if !can_retry && error_match?(any_of)
+          can_retry = true
+          @node_degraded = true
+        else
+          @node_degraded = false
+        end
+      when -32002
+        can_retry = @node_degraded = error_match?('Could not find API')
+      when 1
+        can_retry = @node_degraded = error_match?('no method with name \'condenser_api')
+      end
+        
+      can_retry
+    end
+    
+    def error_match?(matches)
+      matches = [matches].flatten
+      
+      any = matches.map do |match|
+        case match
+        when String
+          @error['message'] && @error['message'].include?(match)
+        when ::Array
+          if @error['message']
+            match.map { |m| m.include?(match) }.include? true
+          else
+            false
+          end
+        else; false
+        end
+      end
+      
+      any.include?(true)
+    end
+    
+    def to_s
+      if !!error_message && !error_message.empty?
+        "#{error_code}: #{error_message}"
+      else
+        error_code.to_s
+      end
+    end
+    
+    def inspect
+      "#<#{self.class.name} [#{to_s}]>"
+    end
+  end
+end