hive-ruby 1.0.0.pre.1

data/lib/hive/marshal.rb

@@ -0,0 +1,231 @@
+require 'bindata'
+require 'base58'
+
+module Hive
+  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] || :hive
+      @prefix ||= case @chain
+      when :hive then NETWORKS_HIVE_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)
+
+      Hive::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 Hive::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"] = Hive::Type::Amount.new(rate["base"])
+            rate["quote"] = Hive::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 = "Hive::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

data/lib/hive/mixins/jsonable.rb

@@ -0,0 +1,37 @@
+module Hive
+  module JSONable
+    module ClassMethods
+      attr_accessor :attributes
+
+      def attr_accessor *attrs
+        self.attributes = Array attrs
+        
+        super
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def as_json options = {}
+      serialized = Hash.new
+      
+      self.class.attributes.each do |attribute|
+        unless (value = self.public_send attribute).nil?
+          serialized[attribute] = if value.respond_to? :strftime
+            value.strftime('%Y-%m-%dT%H:%M:%S')
+          else
+            value
+          end
+        end
+      end
+      
+      serialized
+    end
+
+    def to_json *a
+      as_json.to_json *a
+    end
+  end
+end

data/lib/hive/mixins/retriable.rb

@@ -0,0 +1,58 @@
+module Hive
+  module Retriable
+    # @private
+    MAX_RETRY_COUNT = 30
+    
+    MAX_RETRY_ELAPSE = 60
+    
+    # @private
+    MAX_BACKOFF = MAX_RETRY_ELAPSE / 4
+    
+    RETRYABLE_EXCEPTIONS = [
+      NonCanonicalSignatureError, IncorrectRequestIdError,
+      IncorrectResponseIdError, RemoteDatabaseLockError
+    ]
+    
+    def can_retry?(e = nil)
+      @retry_count ||= 0
+      
+      return false if @retry_count >= MAX_RETRY_COUNT
+      
+      @retry_count = if retry_reset?
+        @first_retry_at = nil
+      else
+        @retry_count + 1
+      end
+      
+      can_retry = case e
+      when *RETRYABLE_EXCEPTIONS then true
+      else; false
+      end
+      
+      backoff if can_retry
+      
+      can_retry
+    end
+  private
+    # @private
+    def first_retry_at
+      @first_retry_at ||= Time.now.utc
+    end
+    
+    # @private
+    def retry_reset?
+      Time.now.utc - first_retry_at > MAX_RETRY_ELAPSE
+    end
+    
+    # Expontential backoff.
+    #
+    # @private
+    def backoff
+      @backoff ||= 0.1
+      @backoff *= 2
+      @backoff = 0.1 if @backoff > MAX_BACKOFF
+      
+      sleep @backoff
+    end
+  end
+end

data/lib/hive/mixins/serializable.rb

@@ -0,0 +1,45 @@
+module Hive
+  module Serializable
+    NUMERIC_TYPES = %i(unsigned_char uint16 uint32 uint64 signed_char int16 int32
+      int64 varint)
+    
+    KNOWN_TYPES = NUMERIC_TYPES + %i(boolean string raw_bytes point_in_time
+      public_key amount price authority optional_authority
+      comment_options_extensions beneficiaries chain_properties required_auths
+      witness_properties empty_array lambda)
+    
+    module ClassMethods
+      def def_attr key_pair
+        name = key_pair.keys.first.to_sym
+        type = key_pair.values.first.to_sym
+        
+        self.attributes ||= []
+        self.attributes << name
+        
+        attr_accessor *attributes
+        add_type name, type
+      end
+      
+      def add_type name, type
+        name = name.to_sym
+        type = type.to_sym
+        raise "Unknown type: #{type}" unless KNOWN_TYPES.include? type
+        
+        @serializable_types ||= {}
+        @serializable_types[name] = type
+      end
+      
+      def numeric?(name)
+        NUMERIC_TYPES.include? @serializable_types[name.to_sym]
+      end
+      
+      def serializable_types
+        @serializable_types
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/hive/operation.rb

@@ -0,0 +1,141 @@
+module Hive
+  class Operation
+    include JSONable
+    include Serializable
+    include Utils
+    
+    # IDs derrived from:
+    # https://github.com/openhive-network/hive/blob/127a441fbac2f06804359968bda83b66e602c891/libraries/protocol/include/steem/protocol/operations.hpp
+    
+    IDS = [
+      :vote_operation,
+      :comment_operation,
+      
+      :transfer_operation,
+      :transfer_to_vesting_operation,
+      :withdraw_vesting_operation,
+      
+      :limit_order_create_operation,
+      :limit_order_cancel_operation,
+      
+      :feed_publish_operation,
+      :convert_operation,
+      
+      :account_create_operation,
+      :account_update_operation,
+      
+      :witness_update_operation,
+      :account_witness_vote_operation,
+      :account_witness_proxy_operation,
+      
+      :pow_operation,
+      
+      :custom_operation,
+      
+      :report_over_production_operation,
+      
+      :delete_comment_operation,
+      :custom_json_operation,
+      :comment_options_operation,
+      :set_withdraw_vesting_route_operation,
+      :limit_order_create2_operation,
+      :claim_account_operation,
+      :create_claimed_account_operation,
+      :request_account_recovery_operation,
+      :recover_account_operation,
+      :change_recovery_account_operation,
+      :escrow_transfer_operation,
+      :escrow_dispute_operation,
+      :escrow_release_operation,
+      :pow2_operation,
+      :escrow_approve_operation,
+      :transfer_to_savings_operation,
+      :transfer_from_savings_operation,
+      :cancel_transfer_from_savings_operation,
+      :custom_binary_operation,
+      :decline_voting_rights_operation,
+      :reset_account_operation,
+      :set_reset_account_operation,
+      :claim_reward_balance_operation,
+      :delegate_vesting_shares_operation,
+      :account_create_with_delegation_operation,
+      :witness_set_properties_operation,
+      
+      # SMT operations
+      :claim_reward_balance2_operation,
+      
+      :smt_setup_operation,
+      :smt_cap_reveal_operation,
+      :smt_refund_operation,
+      :smt_setup_emissions_operation,
+      :smt_set_setup_parameters_operation,
+      :smt_set_runtime_parameters_operation,
+      :smt_create_operation,
+      
+      # virtual operations below this point
+      :fill_convert_request_operation,
+      :author_reward_operation,
+      :curation_reward_operation,
+      :comment_reward_operation,
+      :liquidity_reward_operation,
+      :interest_operation,
+      :fill_vesting_withdraw_operation,
+      :fill_order_operation,
+      :shutdown_witness_operation,
+      :fill_transfer_from_savings_operation,
+      :hardfork_operation,
+      :comment_payout_update_operation,
+      :return_vesting_delegation_operation,
+      :comment_benefactor_reward_operation,
+      :producer_reward_operation,
+      :clear_null_account_balance_operation
+    ]
+    
+    def self.op_id(op)
+      IDS.find_index op
+    end
+
+    def inspect
+      properties = self.class.attributes.map do |prop|
+        unless (v = instance_variable_get("@#{prop}")).nil?
+          v = if v.respond_to? :strftime
+            v.strftime('%Y-%m-%dT%H:%M:%S')
+          else
+            v
+          end
+          
+          "@#{prop}=#{v}"
+        end
+      end.compact.join(', ')
+      
+      "#<#{self.class.name} [#{properties}]>"
+    end
+    
+    def [](key)
+      key = key.to_sym
+      send(key) if self.class.attributes.include?(key)
+    end
+
+    def []=(key, value)
+      key = key.to_sym
+      
+      if self.class.attributes.include?(key)
+        if self.class.numeric? key
+          send("#{key}=", value.to_i)
+        else
+          send("#{key}=", value)
+        end
+      end
+    end
+    
+    def ==(other_op)
+      return false if self.class != other_op.class
+      
+      self.class.attributes.each do |prop|
+        return false if self[prop] != other_op[prop]
+      end
+      
+      true
+    end
+  end
+end