steem-ruby 0.1.0

data/lib/steem/chain_config.rb

@@ -0,0 +1,36 @@
+module Steem
+  module ChainConfig
+    EXPIRE_IN_SECS = 600
+    EXPIRE_IN_SECS_PROPOSAL = 24 * 60 * 60
+    
+    NETWORKS_STEEM_CHAIN_ID = '0000000000000000000000000000000000000000000000000000000000000000'
+    NETWORKS_STEEM_ADDRESS_PREFIX = 'STM'
+    NETWORKS_STEEM_CORE_ASSET = ["0", 3, "@@000000021"] # STEEM
+    NETWORKS_STEEM_DEBT_ASSET = ["0", 3, "@@000000013"] # SBD
+    NETWORKS_STEEM_VEST_ASSET = ["0", 6, "@@000000037"] # VESTS
+    NETWORKS_STEEM_DEFAULT_NODE = 'https://api.steemit.com' # √
+    # NETWORKS_STEEM_DEFAULT_NODE = 'https://api.steemitstage.com' # √
+    # NETWORKS_STEEM_DEFAULT_NODE = 'https://api.steemitdev.com' # √
+    # NETWORKS_STEEM_DEFAULT_NODE = 'https://appbasetest.timcliff.com'
+    # NETWORKS_STEEM_DEFAULT_NODE = 'https://gtg.steem.house:8090'
+    # NETWORKS_STEEM_DEFAULT_NODE = 'https://api.steem.house' # √?
+    # NETWORKS_STEEM_DEFAULT_NODE = 'https://seed.bitcoiner.me'
+    # NETWORKS_STEEM_DEFAULT_NODE = 'https://steemd.minnowsupportproject.org'
+    # NETWORKS_STEEM_DEFAULT_NODE = 'https://steemd.privex.io'
+    # NETWORKS_STEEM_DEFAULT_NODE = 'https://rpc.steemliberator.com'
+    # NETWORKS_STEEM_DEFAULT_NODE = 'https://rpc.curiesteem.com'
+    # NETWORKS_STEEM_DEFAULT_NODE = 'https://rpc.buildteam.io'
+    # NETWORKS_STEEM_DEFAULT_NODE = 'https://steemd.pevo.science'
+    # NETWORKS_STEEM_DEFAULT_NODE = 'https://rpc.steemviz.com'
+    # NETWORKS_STEEM_DEFAULT_NODE = 'https://steemd.steemgigs.org'
+    
+    NETWORKS_TEST_CHAIN_ID = '46d82ab7d8db682eb1959aed0ada039a6d49afa1602491f93dde9cac3e8e6c32'
+    NETWORKS_TEST_ADDRESS_PREFIX = 'TST'
+    NETWORKS_TEST_CORE_ASSET = ["0", 3, "@@000000021"] # TESTS
+    NETWORKS_TEST_DEBT_ASSET = ["0", 3, "@@000000013"] # TBD
+    NETWORKS_TEST_VEST_ASSET = ["0", 6, "@@000000037"] # VESTS
+    NETWORKS_TEST_DEFAULT_NODE = 'https://testnet.steemitdev.com'
+    
+    NETWORK_CHAIN_IDS = [NETWORKS_STEEM_CHAIN_ID, NETWORKS_TEST_CHAIN_ID]
+  end
+end

data/lib/steem/formatter.rb

@@ -0,0 +1,14 @@
+module Steem
+  class Formatter
+    def self.reputation(raw)
+      raw = raw.to_i
+      neg = raw < 0
+      level = Math.log10(raw.abs)
+      level = [level - 9, 0].max
+      level = (neg ? -1 : 1) * level
+      level = (level * 9) + 25
+      
+      level.round(1)
+    end
+  end
+end

data/lib/steem/jsonrpc.rb

@@ -0,0 +1,98 @@
+module Steem
+  # {Jsonrpc} allows you to inspect the available methods offered by a node.
+  # If a node runs a plugin you want, then all of the API methods it can exposes
+  # will automatically be available.  This API is used internally to determine
+  # which APIs and methods are available on the node you specify.
+  #
+  # In theory, if a new plugin is created and enabled by the node, it will be
+  # available by this library without needing an update to its code.
+  class Jsonrpc < Api
+    API_METHODS = %i(get_signature get_methods)
+    
+    def self.api_methods
+      @api_methods ||= {}
+    end
+    
+    # Might help diagnose a cluster that has asymmetric plugin definitions.
+    def self.reset_api_methods
+      @api_methods = nil
+    end
+    
+    def initialize(options = {})
+      self.class.api_name = :jsonrpc
+      @methods = API_METHODS
+      super
+    end
+    
+    def get_api_methods(&block)
+      api_methods = self.class.api_methods[@rpc_client.uri.to_s]
+      
+      if api_methods.nil?
+        get_methods do |result, error, rpc_id|
+          methods = result.map do |method|
+            method.split('.').map(&:to_sym)
+          end
+          
+          api_methods = Hashie::Mash.new
+          
+          methods.each do |api, method|
+            api_methods[api] ||= []
+            api_methods[api] << method
+          end
+          
+          self.class.api_methods[@rpc_client.uri.to_s] = api_methods
+        end
+      end
+      
+      if !!block
+        api_methods.each do |api, methods|
+          yield api, methods
+        end
+      else
+        return api_methods
+      end
+    end
+    
+    def get_all_signatures(&block)
+      request_body = []
+      method_names = []
+      method_map = {}
+      signatures = {}
+      offset = 0
+      
+      get_api_methods do |api, methods|
+        request_body += methods.map do |method|
+          method_name = "#{api}.#{method}"
+          method_names << method_name
+          current_rpc_id = @rpc_client.rpc_id
+          offset += 1
+          method_map[current_rpc_id] = [api, method]
+          
+          {
+            jsonrpc: '2.0',
+            id: current_rpc_id,
+            method: 'jsonrpc.get_signature',
+            params: {method: method_name}
+          }
+        end
+      end
+      
+      @rpc_client.rpc_post(nil, nil, {request_body: request_body}) do |result, error, id|
+        api, method = method_map[id]
+        api = api.to_sym
+        method = method.to_sym
+        
+        signatures[api] ||= {}
+        signatures[api][method] = result
+      end
+      
+      if !!block
+        signatures.each do |api, methods|
+          yield api, methods
+        end
+      else
+        return signatures
+      end
+    end
+  end
+end

data/lib/steem/mixins/retriable.rb

@@ -0,0 +1,56 @@
+module Steem
+  module Retriable
+    # @private
+    MAX_RETRY_COUNT = 100
+    
+    # @private
+    MAX_BACKOFF = 30
+    
+    MAX_RETRY_ELAPSE = 300
+    
+    RETRYABLE_EXCEPTIONS = [
+      NonCanonicalSignatureError, IncorrectRequestIdError,
+      IncorrectResponseIdError, Errno::EBADF, Errno::ECONNREFUSED,
+      JSON::ParserError, IOError, Net::OpenTimeout
+    ]
+    
+    # Expontential backoff.
+    #
+    # @private
+    def backoff
+      @backoff ||= 0.1
+      @backoff *= 2
+      if @backoff > MAX_BACKOFF
+        @backoff = 0.1
+        
+        if Time.now.utc - @first_retry_at > MAX_RETRY_ELAPSE
+          @retry_count = nil
+          @first_retry_at = nil
+        end
+      end
+      
+      sleep @backoff
+    end
+    
+    def can_retry?(e = nil)
+      @retry_count ||= 0
+      @first_retry_at ||= Time.now.utc
+      
+      return false if @retry_count >= MAX_RETRY_COUNT
+      
+      @retry_count += 1
+      
+      can_retry = case e
+      when *RETRYABLE_EXCEPTIONS
+        true
+      when RemoteNodeError
+        e.inspect.include?('Unable to acquire database lock')
+      else; false
+      end
+      
+      backoff if can_retry
+      
+      can_retry
+    end
+  end
+end

data/lib/steem/rpc/base_client.rb

@@ -0,0 +1,154 @@
+module Steem
+  module RPC
+    class BaseClient
+      include ChainConfig
+      
+      attr_accessor :chain, :error_pipe
+      
+      # @private
+      POST_HEADERS = {
+        'Content-Type' => 'application/json; charset=utf-8',
+        'User-Agent' => Steem::AGENT_ID
+      }
+      
+      def initialize(options = {})
+        @chain = options[:chain] || :steem
+        @error_pipe = options[:error_pipe] || STDERR
+        @api_name = options[:api_name]
+        @url = case @chain
+        when :steem then options[:url] || NETWORKS_STEEM_DEFAULT_NODE
+        when :test then options[:url] || NETWORKS_TEST_DEFAULT_NODE
+        else; raise UnsupportedChainError, "Unsupported chain: #{@chain}"
+        end
+      end
+      
+      def uri
+        @uri ||= URI.parse(@url)
+      end
+      
+      def http
+        @http ||= Net::HTTP.new(uri.host, uri.port).tap do |http|
+          http.use_ssl = true
+          http.keep_alive_timeout = 2 # seconds
+          
+          # WARNING This method opens a serious security hole. Never use this
+          # method in production code.
+          # http.set_debug_output(STDOUT) if !!ENV['DEBUG']
+        end
+      end
+      
+      def http_post
+        @http_post ||= Net::HTTP::Post.new(uri.request_uri, POST_HEADERS)
+      end
+      
+      def put(api_name = @api_name, api_method = nil, options = {})
+        current_rpc_id = rpc_id
+        rpc_method_name = "#{api_name}.#{api_method}"
+        options ||= {}
+        request_body = defined?(options.delete) ? options.delete(:request_body) : []
+        request_body ||= []
+        
+        request_body << {
+          jsonrpc: '2.0',
+          id: current_rpc_id,
+          method: rpc_method_name,
+          params: options
+        }
+        
+        request_body
+      end
+
+      def evaluate_id(options = {})
+        debug = options[:debug] || ENV['DEBUG'] == 'true'
+        request = options[:request]
+        response = options[:response]
+        api_method = options[:api_method]
+        req_id = request[:id].to_i
+        res_id = !!response['id'] ? response['id'].to_i : nil
+        method = [@api_name, api_method].join('.')
+        
+        if debug
+          req = JSON.pretty_generate(request)
+          res = JSON.parse(response) rescue response
+          res = JSON.pretty_generate(response) rescue response
+          
+          error_pipe.puts '=' * 80
+          error_pipe.puts "Request:"
+          error_pipe.puts req
+          error_pipe.puts '=' * 80
+          error_pipe.puts "Response:"
+          error_pipe.puts res
+          error_pipe.puts '=' * 80
+          error_pipe.puts Thread.current.backtrace.join("\n")
+        end
+        
+        error = response['error'].to_json if !!response['error']
+              
+        if req_id != res_id
+          raise IncorrectResponseIdError, "#{method}: The json-rpc id did not match.  Request was: #{req_id}, got: #{res_id.inspect}", error.nil? ? nil : error.to_json
+        end
+      end
+      
+      def http_request(request)
+        http.request(request)
+      end
+      
+      def rpc_post(api_name = @api_name, api_method = nil, options = {}, &block)
+        request = http_post
+        
+        request_body = if !!api_name && !!api_method
+          put(api_name, api_method, options)
+        elsif !!options && defined?(options.delete)
+          options.delete(:request_body)
+        end
+        
+        request.body = if request_body.size == 1
+          request_body.first.to_json
+        else
+          request_body.to_json
+        end
+        
+        response = http_request(request)
+        
+        case response.code
+        when '200'
+          response = JSON[response.body]
+          response = case response
+          when Hash
+            Hashie::Mash.new(response).tap do |r|
+              evaluate_id(request: request_body.first, response: r, api_method: api_method)
+            end
+          when Array
+            Hashie::Array.new(response).tap do |r|
+              request_body.each_with_index do |req, index|
+                evaluate_id(request: req, response: r[index], api_method: api_method)
+              end
+            end
+          else; response
+          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
+        else
+          raise UnknownError, "#{api_name}.#{api_method}: #{response.body}"
+        end
+      end
+      
+      def rpc_id
+        @rpc_id ||= 0
+        @rpc_id += 1
+      end
+    end
+  end
+end

data/lib/steem/rpc/thread_safe_client.rb

@@ -0,0 +1,23 @@
+module Steem
+  module RPC
+    # {ThreadSafeClient} is the default RPC Client used by `steem-ruby.`  It's
+    # perfect for simple requests.  But for higher performance, it's better to
+    # override {BaseClient} and implement something other than {Net::HTTP}.
+    class ThreadSafeClient < BaseClient
+      SEMAPHORE = Mutex.new.freeze
+      
+      def http_request(request)
+        response = SEMAPHORE.synchronize do
+          http.request(request)
+        end
+      end
+      
+      def rpc_id
+        SEMAPHORE.synchronize do
+          @rpc_id ||= 0
+          @rpc_id += 1
+        end
+      end
+    end
+  end
+end

data/lib/steem/transaction_builder.rb

@@ -0,0 +1,266 @@
+module Steem
+  # {TransactionBuilder} can be used to create a transaction that the
+  # {NetworkBroadcastApi} can broadcast to the rest of the platform.  The main
+  # feature of this class is the ability to cryptographically sign the
+  # transaction so that it conforms to the consensus rules that are required by
+  # the blockchain.
+  #
+  #     wif = '5JrvPrQeBBvCRdjv29iDvkwn3EQYZ9jqfAHzrCyUvfbEbRkrYFC'
+  #     builder = Steem::TransactionBuilder.new(wif: wif)
+  #     builder.put(vote: {
+  #       voter: 'alice',
+  #       author: 'bob',
+  #       permlink: 'my-burgers',
+  #       weight: 10000
+  #     })
+  #     
+  #     trx = builder.transaction
+  #     network_broadcast_api = Steem::NetworkBroadcastApi.new
+  #     network_broadcast_api.broadcast_transaction_synchronous(trx: trx)
+  #
+  class TransactionBuilder
+    include Retriable
+    include ChainConfig
+    include Utils
+    
+    attr_accessor :database_api, :block_api, :wif, :expiration, :operations
+    
+    def initialize(options = {})
+      @database_api = options[:database_api] || Steem::DatabaseApi.new(options)
+      @block_api = options[:block_api] || Steem::BlockApi.new(options)
+      @wif = options[:wif]
+      @ref_block_num = options[:ref_block_num]
+      @ref_block_prefix = options[:ref_block_prefix]
+      @expiration = nil
+      @operations = options[:operations] || []
+      @extensions = []
+      @signatures = []
+      @chain = options[:chain] || :steem
+      @error_pipe = options[:error_pipe] || STDERR
+      @chain_id = case @chain
+      when :steem then NETWORKS_STEEM_CHAIN_ID
+      when :test then NETWORKS_TEST_CHAIN_ID
+      else; raise UnsupportedChainError, "Unsupported chain: #{@chain}"
+      end
+    end
+    
+    def inspect
+      properties = %w(
+        ref_block_num ref_block_prefix expiration operations
+        extensions signatures
+      ).map do |prop|
+        if !!(v = instance_variable_get("@#{prop}"))
+          "@#{prop}=#{v}" 
+        end
+      end.compact.join(', ')
+      
+      "#<#{self.class.name} [#{properties}]>"
+    end
+    
+    def reset
+      @ref_block_num = nil
+      @ref_block_prefix = nil
+      @expiration = nil
+      @operations = []
+      @extensions = []
+      @signatures = []
+      
+      self
+    end
+    
+    def expired?
+      @expiration.nil? || @expiration < Time.now
+    end
+    
+    # If the transaction can be prepared, this method will do so and set the
+    # expiration.  Once the expiration is set, it will not re-prepare.  If you
+    # call {#put}, the expiration is set {::Nil} so that it can be re-prepared.
+    #
+    # Usually, this method is called automatically by {#put} and/or {#transaction}.
+    #
+    # @return {TransactionBuilder}
+    def prepare
+      if expired?
+        catch :prepare_header do; begin
+          @database_api.get_dynamic_global_properties do |properties|
+            block_number = properties.last_irreversible_block_num
+          
+            @block_api.get_block_header(block_num: block_number) do |result|
+              header = result.header
+              
+              @ref_block_num = (block_number - 1) & 0xFFFF
+              @ref_block_prefix = unhexlify(header.previous[8..-1]).unpack('V*')[0]
+              @expiration = (Time.parse(properties.time + 'Z') + EXPIRE_IN_SECS).utc
+            end
+          end
+        rescue => e
+          if can_retry? e
+            @error_pipe.puts "#{e} ... retrying."
+            throw :prepare_header
+          else
+            raise e
+          end
+        end; end
+      end
+      
+      self
+    end
+    
+    # Sets operations all at once, then prepares.
+    def operations=(operations)
+      @operations = operations
+      prepare
+      @operations
+    end
+    
+    # A quick and flexible way to append a new operation to the transaction.
+    # This method uses ducktyping to figure out how to form the operation.
+    #
+    # There are three main ways you can call this method.  These assume that
+    # `op_type` is a {::Symbol} (or {::String}) representing the type of operation and `op` is the
+    # operation {::Hash}.
+    #
+    #     put(op_type, op)
+    #
+    # ... or ...
+    #
+    #     put(op_type => op)
+    #
+    # ... or ...
+    #
+    #     put([op_type, op])
+    #
+    # You can also chain multiple operations:
+    #
+    #     builder = Steem::TransactionBuilder.new
+    #     builder.put(vote: vote1).put(vote: vote2)
+    # @return {TransactionBuilder}
+    def put(type, op = nil)
+      @expiration = nil
+      
+      case type
+      when Symbol then @operations << [type, op]
+      when String then @operations << [type.to_sym, op]
+      when Hash then @operations << [type.keys.first.to_sym, type.values.first]
+      when Array then @operations << type
+      else
+        # don't know what to do with it, skipped
+      end
+      
+      prepare
+      
+      self
+    end
+    
+    # If all of the required values are set, this returns a fully formed
+    # transaction that is ready to broadcast.
+    # 
+    # @return
+    #     {
+    #            :ref_block_num => 18912,
+    #         :ref_block_prefix => 575781536,
+    #               :expiration => "2018-04-26T15:26:12",
+    #               :extensions => [],
+    #               :operations => [[:vote, {
+    #                    :voter => "alice",
+    #                   :author => "bob",
+    #                 :permlink => "my-burgers",
+    #                   :weight => 10000
+    #                 }
+    #             ]],
+    #               :signatures => ["1c45b65740b4b2c17c4bcf6bcc3f8d90ddab827d50532729fc3b8f163f2c465a532b0112ae4bf388ccc97b7c2e0bc570caadda78af48cf3c261037e65eefcd941e"]
+    #     }
+    def transaction
+      prepare
+      sign
+    end
+    
+    # Appends to the `signatures` array of the transaction, built from a
+    # serialized digest.
+    #
+    # @return {Hash | TransactionBuilder} The fully signed transaction if a `wif` is provided or the instance of the {TransactionBuilder} if a `wif` has not yet been provided.
+    def sign
+      return self unless !!@wif
+      return self if expired?
+      
+      trx = {
+        ref_block_num: @ref_block_num,
+        ref_block_prefix: @ref_block_prefix, 
+        expiration: @expiration.strftime('%Y-%m-%dT%H:%M:%S'),
+        operations: @operations,
+        extensions: @extensions,
+        signatures: @signatures
+      }
+      
+      catch :serialize do; begin
+        @database_api.get_transaction_hex(trx: trx) do |result|
+          hex = @chain_id + result.hex[0..-4] # Why do we have to chop the last two bytes?
+          digest = unhexlify(hex)
+          digest_hex = Digest::SHA256.digest(digest)
+          private_key = Bitcoin::Key.from_base58 @wif
+          public_key_hex = private_key.pub
+          ec = Bitcoin::OpenSSL_EC
+          count = 0
+          sig = nil
+          
+          loop do
+            count += 1
+            @error_pipe.puts "#{count} attempts to find canonical signature" if count % 40 == 0
+            sig = ec.sign_compact(digest_hex, private_key.priv, public_key_hex, false)
+            
+            next if public_key_hex != ec.recover_compact(digest_hex, sig)
+            break if canonical? sig
+          end
+          
+          trx[:signatures] = @signatures = [hexlify(sig)]
+        end
+      rescue => e
+        if can_retry? e
+          @error_pipe.puts "#{e} ... retrying."
+          throw :serialize
+        else
+          raise e
+        end
+      end; end
+      
+      trx
+    end
+    
+    # @return [Array] All public keys that could possibly sign for a given transaction.
+    def potential_signatures
+      @database_api.get_potential_signatures(trx: transaction) do |result|
+        result[:keys]
+      end
+    end
+    
+    # This API will take a partially signed transaction and a set of public keys
+    # that the owner has the ability to sign for and return the minimal subset
+    # of public keys that should add signatures to the transaction.
+    #
+    # @return [Array] The minimal subset of public keys that should add signatures to the transaction.
+    def required_signatures
+      @database_api.get_required_signatures(trx: transaction) do |result|
+        result[:keys]
+      end
+    end
+    
+    # @return [Boolean] True if the transaction has all of the required signatures.
+    def valid?
+      @database_api.verify_authority(trx: transaction) do |result|
+        result.valid
+      end
+    end
+  private
+    # See: https://github.com/steemit/steem/issues/1944
+    def canonical?(sig)
+      sig = sig.unpack('C*')
+      
+      !(
+        ((sig[0] & 0x80 ) != 0) || ( sig[0] == 0 ) ||
+        ((sig[1] & 0x80 ) != 0) ||
+        ((sig[32] & 0x80 ) != 0) || ( sig[32] == 0 ) ||
+        ((sig[33] & 0x80 ) != 0)
+      )
+    end
+  end
+end