steem-ruby 0.9.1 → 0.9.6

data/lib/steem/base_error.rb

@@ -1,16 +1,16 @@
 module Steem
   class BaseError < StandardError
-    def initialize(error, cause = nil)
+    def initialize(error = nil, cause = nil)
       @error = error
       @cause = cause
     end
     
     def to_s
-      if !!@cause
-        JSON[error: @error, cause: @cause] rescue {error: @error, cause: @cause}.to_s
-      else
-        JSON[@error] rescue @error.to_s
-      end
+      detail = {}
+      detail[:error] = @error if !!@error
+      detail[:cause] = @cause if !!@cause
+      
+      JSON[detail] rescue detail.to_s
     end
     
     def self.build_error(error, context)
@@ -19,7 +19,11 @@ module Steem
       end
       
       if error.message.include? 'Internal Error'
-        raise Steem::RemoteNodeError.new, error.message, build_backtrace(error)
+        raise Steem::RemoteNodeError, error.message, build_backtrace(error)
+      end
+      
+      if error.message.include? 'Server error'
+        raise Steem::RemoteNodeError, error.message, build_backtrace(error)
       end
       
       if error.message.include? 'plugin not enabled'
@@ -30,6 +34,10 @@ module Steem
         raise Steem::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
+      if error.message.include? 'Invalid params'
+        raise Steem::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
       if error.message.start_with? 'Bad Cast:'
         raise Steem::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
       end
@@ -110,6 +118,10 @@ module Steem
         raise Steem::MissingOtherAuthorityError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
+      if error.message.include? 'Upstream response error'
+        raise Steem::UpstreamResponseError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
       if error.message.include? 'Bad or missing upstream response'
         raise Steem::BadOrMissingUpstreamResponseError, "#{context}: #{error.message}", build_backtrace(error)
       end
@@ -122,6 +134,10 @@ module Steem
         raise Steem::InvalidAccountError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
+      if error.message.include?('Method') && error.message.include?(' does not exist.')
+        raise Steem::UnknownMethodError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
       if error.message.include? 'Invalid operation name'
         raise Steem::UnknownOperationError, "#{context}: #{error.message}", build_backtrace(error)
       end
@@ -160,11 +176,10 @@ module Steem
     end
   end
   
+  class DeserializationError < BaseError; end
+  class SerializationMismatchError < BaseError; end
   class UnsupportedChainError < BaseError; end
   class ArgumentError < BaseError; end
-  class RemoteNodeError < BaseError; end
-  class RemoteDatabaseLockError < RemoteNodeError; end
-  class PluginNotEnabledError < RemoteNodeError; end
   class TypeError < BaseError; end
   class EmptyTransactionError < ArgumentError; end
   class InvalidAccountError < ArgumentError; end
@@ -186,12 +201,18 @@ module Steem
   class MissingOtherAuthorityError < MissingAuthorityError; end
   class IncorrectRequestIdError < BaseError; end
   class IncorrectResponseIdError < BaseError; end
-  class BadOrMissingUpstreamResponseError < BaseError; end
+  class RemoteNodeError < BaseError; end
+  class UpstreamResponseError < RemoteNodeError; end
+  class RemoteDatabaseLockError < UpstreamResponseError; end
+  class PluginNotEnabledError < UpstreamResponseError; end
+  class BadOrMissingUpstreamResponseError < UpstreamResponseError; end
   class TransactionIndexDisabledError < BaseError; end
   class NotAppBaseError < BaseError; end
   class UnknownApiError < BaseError; end
+  class UnknownMethodError < BaseError; end
   class UnknownOperationError < BaseError; end
   class JsonRpcBatchMaximumSizeExceededError < BaseError; end
   class TooManyTimeoutsError < BaseError; end
+  class TooManyRetriesError < BaseError; end
   class UnknownError < BaseError; end
 end

data/lib/steem/block_api.rb

@@ -12,11 +12,25 @@ module Steem
       super
     end
     
+    # Uses a batched requst on a range of block headers.
+    #
+    # @param options [Hash] The attributes to get a block range with.
+    # @option options [Range] :block_range starting on one block number and ending on an higher block number.
+    def get_block_headers(options = {block_range: (0..0)}, &block)
+      get_block_objects(options.merge(object: :block_header), block)
+    end
+    
     # Uses a batched requst on a range of blocks.
     #
     # @param options [Hash] The attributes to get a block range with.
     # @option options [Range] :block_range starting on one block number and ending on an higher block number.
     def get_blocks(options = {block_range: (0..0)}, &block)
+      get_block_objects(options.merge(object: :block), block)
+    end
+  private
+    def get_block_objects(options = {block_range: (0..0)}, block = nil)
+      object = options[:object]
+      object_method = "get_#{object}".to_sym
       block_range = options[:block_range] || (0..0)
       
       if (start = block_range.first) < 1
@@ -33,15 +47,21 @@ module Steem
         request_object = []
         
         for i in sub_range do
-          @rpc_client.put(self.class.api_name, :get_block, block_num: i, request_object: request_object)
+          @rpc_client.put(self.class.api_name, object_method, block_num: i, request_object: request_object)
         end
         
         if !!block
           index = 0
           @rpc_client.rpc_batch_execute(request_object: request_object) do |result, error, id|
             block_num = sub_range.to_a[index]
-            index = index += 1
-            yield(result.nil? ? nil : result.block, block_num)
+            index = index + 1
+            
+            case object
+            when :block_header
+              block.call(result.nil? ? nil : result[:header], block_num)
+            else
+              block.call(result.nil? ? nil : result[object], block_num)
+            end
           end
         else
           blocks = []

data/lib/steem/broadcast.rb

@@ -31,6 +31,7 @@ module Steem
   # For details on what to pass to these methods, check out the {https://developers.steem.io/apidefinitions/broadcast-ops Steem Developer Portal Broadcast Operations} page.
   class Broadcast
     extend Retriable
+    extend Utils
     
     DEFAULT_MAX_ACCEPTED_PAYOUT = Type::Amount.new(amount: '1000000000', precision: 3, nai: '@@000000013')
     
@@ -196,13 +197,17 @@ module Steem
         permlink: params[:permlink],
         max_accepted_payout: max_accepted_payout,
         percent_steem_dollars: params[:percent_steem_dollars] || 10000,
+        # allow_replies: allow_replies,
         allow_votes: allow_votes,
         allow_curation_rewards: allow_curation_rewards,
         extensions: []
       }
       
       if !!params[:beneficiaries]
-        comment_options[:extensions] << [0, {beneficiaries: params[:beneficiaries]}]
+        comment_options[:extensions] << [
+          comment_options[:extensions].size,
+          normalize_beneficiaries(options.merge(beneficiaries: params[:beneficiaries]))
+        ]
       end
       
       ops << [:comment_options, comment_options]
@@ -509,6 +514,68 @@ module Steem
       process(options.merge(ops: ops), &block)
     end
     
+    # Create a claimed account.
+    #     options = {
+    #       wif: wif,
+    #       params: {
+    #         creator: creator_account_name,
+    #         new_account_name: new_account_name,
+    #         owner: {
+    #           weight_threshold: 1,
+    #           account_auths: [],
+    #           key_auths: [[owner_public_key, 1]],
+    #         },
+    #         active: {
+    #           weight_threshold: 1,
+    #           account_auths: [],
+    #           key_auths: [[active_public_key, 1]],
+    #         },
+    #         posting: {
+    #           weight_threshold: 1,
+    #           account_auths: [],
+    #           key_auths: [[posting_public_key, 1]],
+    #         },
+    #         memo_key: memo_public_key,
+    #         json_metadata: '{}'
+    #       }
+    #     }
+    # 
+    #     Steem::Broadcast.create_claimed_account(options)
+    # 
+    # @param options [Hash] options
+    # @option options [String] :wif Active wif
+    # @option options [Hash] :params
+    #   * :creator (String)
+    #   * :new_account_name (String)
+    #   * :owner (Hash)
+    #   * :active (Hash)
+    #   * :posting (Hash)
+    #   * :memo_key (String)
+    #   * :metadata (Hash) Metadata of the account, becomes `json_metadata`.
+    #   * :json_metadata (String) String version of `metadata` (use one or the other).
+    #   * :extensions (Array) (optional)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_create_claimed_account
+    def self.create_claimed_account(options, &block)
+      required_fields = %i(creator new_account_name owner active posting memo_key json_metadata)
+      params = options[:params]
+      
+      if !!params[:metadata] && !!params[:json_metadata]
+        raise Steem::ArgumentError, 'Assign either metadata or json_metadata, not both.'
+      end
+      
+      metadata = params.delete(:metadata) || {}
+      metadata ||= (JSON[params[:json_metadata]] || nil) || {}
+      params[:json_metadata] = metadata.to_json
+      
+      check_required_fields(params, *required_fields)
+      
+      params[:extensions] ||= []
+      ops = [[:create_claimed_account, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+    
     # Update an account.
     #     options = {
     #       wif: wif,
@@ -611,6 +678,73 @@ module Steem
       process(options.merge(ops: ops), &block)
     end
     
+    # Extensible replacement for #witness_update that supports additional
+    # properties added since HF20 and beyond.
+    #
+    #     options = {
+    #       wif: wif,
+    #       params: {
+    #         owner: witness_account_name,
+    #         props: {
+    #           account_creation_fee: '0.000 STEEM',
+    #           maximum_block_size: 131072,
+    #           sbd_interest_rate: 1000,
+    #           account_subsidy_budget: 50000,
+    #           account_subsidy_decay: 330782,
+    #           sbd_exchange_rate: '1.000 STEEM',
+    #           url: "https://steemit.com",
+    #           new_signing_key: 'STM8LoQjQqJHvotqBo7HjnqmUbFW9oJ2theyqonzUd9DdJ7YYHsvD'
+    #         }
+    #       }
+    #     }
+    # 
+    #     Steem::Broadcast.witness_set_properties(options)
+    #
+    # @param options [Hash] options
+    # @option options [String] :wif Active wif
+    # @option options [Hash] :params
+    #   * :owner (String)
+    #   * :props (String)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_witness_set_properties
+    # @see https://github.com/steemit/steem/blob/master/doc/witness_parameters.md
+    def self.witness_set_properties(options, &block)
+      required_fields = %i(owner props)
+      params = options[:params]
+      check_required_fields(params, *required_fields)
+      
+      if !!(account_creation_fee = params[:props][:account_creation_fee] rescue nil)
+        params[:props][:account_creation_fee] = normalize_amount(options.merge amount: account_creation_fee, serialize: true)
+      end
+      
+      if !!(sbd_exchange_rate = params[:props][:sbd_exchange_rate] rescue nil)
+        params[:props][:sbd_exchange_rate][:base] = normalize_amount(options.merge amount: sbd_exchange_rate[:base], serialize: true)
+        params[:props][:sbd_exchange_rate][:quote] = normalize_amount(options.merge amount: sbd_exchange_rate[:quote], serialize: true)
+        params[:props][:sbd_exchange_rate] = params[:props][:sbd_exchange_rate].to_json
+      end
+      
+      %i(key new_signing_key).each do |key|
+        if !!params[key] && params[key].size == 53
+          params[key] = params[key][3..-1]
+        end
+      end
+      
+      %i(account_creation_fee sbd_exchange_rate url new_signing_key).each do |key|
+        next unless !!params[:props][key]
+        
+        val = params[:props][key].to_s
+          
+        params[:props][key] = hexlify val unless val =~ /^[0-9A-F]+$/i
+      end
+      
+      params[:props] = params[:props].to_a
+      
+      params[:extensions] ||= []
+      ops = [[:witness_set_properties, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+    
     # All accounts with a VFS (Vesting Fund Shares) can vote for or against any
     # witness.
     # 
@@ -1084,6 +1218,28 @@ module Steem
       process(options.merge(ops: ops), &block)
     end
     
+    # @param options [Hash] options
+    # @option options [String] :wif Active wif
+    # @option options [Hash] :params
+    #   * :creator (String)
+    #   * :fee (String)
+    #   * :extensions (Array)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_claim_account
+    def self.claim_account(options, &block)
+      required_fields = %i(creator fee)
+      params = options[:params]
+      
+      check_required_fields(params, *required_fields)
+      
+      params[:fee] = normalize_amount(options.merge amount: params[:fee])
+      params[:extensions] ||= []
+      
+      ops = [[:claim_account, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+        
     # @param options [Hash] options
     # @option options [Array<Array<Hash>] :ops Operations to process.
     # @option options [Boolean] :pretend Just validate, do not broadcast.
@@ -1131,12 +1287,19 @@ module Steem
     def self.normalize_amount(options)
       if !!options[:app_base]
         Type::Amount.to_h(options[:amount])
+      elsif !!options[:serialize]
+        Type::Amount.to_s(options[:amount])
       else
         Type::Amount.to_s(options[:amount])
       end
     end
     
-    # @privats
+    def self.normalize_beneficiaries(options)
+      # Type::Beneficiaries.new(options[:beneficiaries])
+      {beneficiaries: options[:beneficiaries]}
+    end
+    
+    # @private
     def self.database_api(options)
       options[:database_api] ||= if !!options[:app_base]
         Steem::DatabaseApi.new(options)

data/lib/steem/marshal.rb

@@ -0,0 +1,231 @@
+require 'bindata'
+require 'base58'
+
+module Steem
+  class Marshal
+    include Utils
+    include ChainConfig
+    
+    PUBLIC_KEY_DISABLED = '1111111111111111111111111111111114T1Anm'
+    
+    attr_reader :bytes, :cursor
+
+    def initialize(options = {})
+      @bytes = if !!(hex = options[:hex])
+        unhexlify hex
+      else
+        options[:bytes]
+      end
+      
+      @chain = options[:chain] || :steem
+      @prefix ||= case @chain
+      when :steem then NETWORKS_STEEM_ADDRESS_PREFIX
+      when :test then NETWORKS_TEST_ADDRESS_PREFIX
+      else; raise UnsupportedChainError, "Unsupported chain: #{@chain}"
+      end
+      @cursor = 0
+    end
+    
+    def hex
+      hexlify bytes
+    end
+    
+    def rewind!
+      @cursor = 0
+    end
+    
+    def step(n = 0)
+      @cursor += n
+    end
+    
+    def scan(len)
+      bytes.slice(@cursor..(@cursor - 1) + len).tap { |_| @cursor += len }
+    end
+    
+    def operation_type
+      Operation::IDS[unsigned_char]
+    end
+    
+    def unsigned_char; BinData::Uint8le.read(scan(1)); end # 8-bit unsigned 
+    def uint16; BinData::Uint16le.read(scan(2)); end # 16-bit unsigned, VAX (little-endian) byte order
+    def uint32; BinData::Uint32le.read(scan(4)); end # 32-bit unsigned, VAX (little-endian) byte order
+    def uint64; BinData::Uint64le.read(scan(8)); end # 64-bit unsigned, little-endian
+
+    def signed_char; BinData::Int8le.read(scan(1)); end # 8-bit signed 
+    def int16; BinData::Int16le.read(scan(2)); end # 16-bit signed, little-endian
+    def int32; BinData::Int32le.read(scan(4)); end # 32-bit signed, little-endian
+    def int64; BinData::Int64le.read(scan(8)); end # 64-bit signed, little-endian
+
+    def boolean; scan(1) == "\x01"; end
+    
+    def varint
+      shift = 0
+      result = 0
+      bytes = []
+      
+      while (n = unsigned_char) >> 7 == 1
+        bytes << n
+      end
+      
+      bytes << n
+      
+      bytes.each do |b|
+        result += ((b & 0x7f) << shift)
+        break unless (b & 0x80)
+        shift += 7
+      end
+      
+      result
+    end
+    
+    def string(len = nil); scan(len || varint); end
+    
+    def raw_bytes(len = nil); scan(len || varint).force_encoding('BINARY'); end
+  
+    def point_in_time
+      if (time = uint32) == 2**32-1
+        Time.at -1
+      else
+        Time.at time
+      end.utc
+    end
+    
+    def public_key(prefix = @prefix)
+      raw_public_key = raw_bytes(33)
+      checksum = OpenSSL::Digest::RIPEMD160.digest(raw_public_key)
+      key = Base58.binary_to_base58(raw_public_key + checksum.slice(0, 4), :bitcoin)
+      
+      prefix + key unless key == PUBLIC_KEY_DISABLED
+    end
+    
+    def amount
+      amount = uint64.to_f
+      precision = signed_char
+      asset = scan(7).strip
+      
+      amount = "%.#{precision}f #{asset}" % (amount / 10 ** precision)
+
+      Steem::Type::Amount.new(amount)
+    end
+    
+    def price
+      {base: amount, quote: amount}
+    end
+    
+    def authority(options = {optional: false})
+      return if !!options[:optional] && unsigned_char == 0
+      
+      {
+        weight_threshold: uint32,
+        account_auths: varint.times.map { [string, uint16] },
+        key_auths: varint.times.map { [public_key, uint16] }
+      }
+    end
+    
+    def optional_authority
+      authority(optional: true)
+    end
+    
+    def comment_options_extensions
+      if scan(1) == "\x01"
+        beneficiaries
+      else
+        []
+      end
+    end
+    
+    def beneficiaries
+      if scan(1) == "\x00"
+        varint.times.map {{account: string, weight: uint16}}
+      end
+    end
+    
+    def chain_properties
+      {
+        account_creation_fee: amount,
+        maximum_block_size: uint32,
+        sbd_interest_rate: uint16
+      }
+    end
+    
+    def required_auths
+      varint.times.map { string }
+    end
+    
+    def witness_properties
+      properties = {}
+      
+      varint.times do
+        key = string.to_sym
+        properties[key] = case key
+        when :account_creation_fee then Steem::Type::Amount.new(string)
+        when :account_subsidy_budget then scan(3)
+        when :account_subsidy_decay, :maximum_block_size then uint32
+        when :url then string
+        when :sbd_exchange_rate
+          JSON[string].tap do |rate|
+            rate["base"] = Steem::Type::Amount.new(rate["base"])
+            rate["quote"] = Steem::Type::Amount.new(rate["quote"])
+          end
+        when :sbd_interest_rate then uint16
+        when :key, :new_signing_key then @prefix + scan(50)
+        else; raise "Unknown witness property: #{key}"
+        end
+      end
+      
+      properties
+    end
+    
+    def empty_array
+      unsigned_char == 0 and [] or raise "Found non-empty array."
+    end
+    
+    def transaction(options = {})
+      trx = options[:trx] || Transaction.new
+      
+      trx.ref_block_num = uint16
+      trx.ref_block_prefix = uint32
+      trx.expiration = point_in_time
+      
+      trx.operations = operations
+      
+      trx
+    rescue => e
+      raise DeserializationError.new("Transaction failed\nOriginal serialized bytes:\n[#{hex[0..(@cursor * 2) - 1]}]#{hex[((@cursor) * 2)..-1]}", e)
+    end
+
+    def operations
+      operations_len = signed_char
+      operations = []
+      
+      while operations.size < operations_len do
+        begin
+          type = operation_type
+          break if type.nil?
+          
+          op_class_name = type.to_s.sub!(/_operation$/, '')
+          op_class_name = "Steem::Operation::" + op_class_name.split('_').map(&:capitalize).join
+          op_class = Object::const_get(op_class_name)
+          op = op_class.new
+          
+          op_class::serializable_types.each do |k, v|
+            begin
+              # binding.pry if v == :comment_options_extensions
+              op.send("#{k}=", send(v))
+            rescue => e
+              raise DeserializationError.new("#{type}.#{k} (#{v}) failed", e)
+            end
+          end
+          
+          operations << {type: type, value: op}
+        rescue => e
+          raise DeserializationError.new("#{type} failed", e)
+        end
+      end
+      
+      operations
+    rescue => e
+      raise DeserializationError.new("Operations failed", e)
+    end
+  end
+end