radiator 0.2.0a

data/lib/radiator/operation_types.rb

@@ -0,0 +1,113 @@
+module Radiator
+  
+  # See: https://github.com/steemit/steem-js/blob/766746adb5ded86380be982c844f4c269f7800ae/src/auth/serializer/src/operations.js
+  module OperationTypes
+    TYPES = {
+      transfer: {
+        amount: Type::Amount
+      },
+      transfer_to_vesting: {
+        amount: Type::Amount
+      },
+      withdraw_vesting: {
+        vesting_shares: Type::Amount
+      },
+      limit_order_create: {
+        orderid: Type::Uint32,
+        amount_to_sell: Type::Amount,
+        min_to_receive: Type::Amount,
+        expiration: Type::PointInTime
+      },
+      limit_order_cancel: {
+        orderid: Type::Uint32
+      },
+      convert: {
+        requestid: Type::Uint32,
+        amount: Type::Amount
+      },
+      account_create: {
+        fee: Type::Amount,
+        owner: Type::Permission,
+        active: Type::Permission,
+        posting: Type::Permission,
+        memo: Type::Permission
+      },
+      account_update: {
+        owner: Type::Permission,
+        active: Type::Permission,
+        posting: Type::Permission,
+        memo: Type::PublicKey
+      },
+      custom: {
+        id: Type::Uint16
+      },
+      comment_options: {
+        max_accepted_payout: Type::Amount
+      },
+      set_withdraw_vesting_route: {
+        percent: Type::Uint16
+      },
+      request_account_recovery: {
+        new_owner_Permission: Type::Permission
+      },
+      recover_account: {
+        new_owner_Permission: Type::Permission,
+        recent_owner_Permission: Type::Permission
+      },
+      escrow_transfer: {
+        sbd_amount: Type::Amount,
+        steem_amount: Type::Amount,
+        escrow_id: Type::Uint32,
+        fee: Type::Amount,
+        ratification_deadline: Type::PointInTime,
+        escrow_expiration: Type::PointInTime
+      },
+      escrow_dispute: {
+        escrow_id: Type::Uint32
+      },
+      escrow_release: {
+        escrow_id: Type::Uint32,
+        sbd_amount: Type::Amount,
+        steem_amount: Type::Amount
+      },
+      escrow_approve: {
+        escrow_id: Type::Uint32
+      },
+      transfer_to_savings: {
+        amount: Type::Amount
+      },
+      transfer_from_savings: {
+        request_id: Type::Uint32,
+        amount: Type::Amount
+      },
+      cancel_transfer_from_savings: {
+        request_id: Type::Uint32
+      },
+      reset_account: {
+        new_owner_Permission: Type::Amount
+      },
+      set_reset_account: {
+        reward_steem: Type::Amount,
+        reward_sbd: Type::Amount,
+        reward_vests: Type::Amount
+      },
+      claim_reward_balance: {
+        reward_steem: Type::Amount,
+        reward_sbd: Type::Amount,
+        reward_vests: Type::Amount
+      },
+      delegate_vesting_shares: {
+        vesting_shares: Type::Amount
+      }
+    }
+    
+    def type(key, param, value)
+      return if value.nil?
+      
+      t = TYPES[key] or return value
+      p = t[param] or return value
+      
+      p.new(value)
+    end
+  end
+end

data/lib/radiator/stream.rb

@@ -0,0 +1,260 @@
+module Radiator
+  # Radiator::Stream allows a live view of the STEEM blockchain.
+  # 
+  # All values returned by `get_dynamic_global_properties` can be streamed.
+  # 
+  # For example, if you want to know which witness is currently signing blocks,
+  # use the following:
+  # 
+  #   stream = Radiator::Stream.new
+  #   stream.current_witness do |witness|
+  #     puts witness
+  #   end
+  class Stream < Api
+    INITIAL_TIMEOUT = 0.0200
+    MAX_TIMEOUT = 80
+    MAX_BLOCKS_PER_NODE = 100
+    
+    def initialize(options = {})
+      @api_options = options
+      @logger = @api_options[:logger] || Radiator.logger
+    end
+    
+    def api
+      @api ||= Api.new(@api_options)
+    end
+    
+    def method_names
+      @method_names ||= [
+        :head_block_number,
+        :head_block_id,
+        :time,
+        :current_witness,
+        :total_pow,
+        :num_pow_witnesses,
+        :virtual_supply,
+        :current_supply,
+        :confidential_supply,
+        :current_sbd_supply,
+        :confidential_sbd_supply,
+        :total_vesting_fund_steem,
+        :total_vesting_shares,
+        :total_reward_fund_steem,
+        :total_reward_shares2,
+        :total_activity_fund_steem,
+        :total_activity_fund_shares,
+        :sbd_interest_rate,
+        :average_block_size,
+        :maximum_block_size,
+        :current_aslot,
+        :recent_slots_filled,
+        :participation_count,
+        :last_irreversible_block_num,
+        :max_virtual_bandwidth,
+        :current_reserve_ratio,
+        :block_numbers,
+        :blocks
+      ].freeze
+    end
+    
+    def method_params(method)
+      case method
+      when :block_numbers then {head_block_number: nil}
+      when :blocks then {get_block: :head_block_number}
+      else; nil
+      end
+    end
+    
+    # Returns the latest operations from the blockchain.
+    # 
+    # If symbol are passed, then only that operation is returned.  Expected
+    # symbols are:
+    #
+    #   transfer_to_vesting
+    #   withdraw_vesting
+    #   interest
+    #   transfer
+    #   liquidity_reward
+    #   author_reward
+    #   curation_reward
+    #   transfer_to_savings
+    #   transfer_from_savings
+    #   cancel_transfer_from_savings
+    #   escrow_transfer
+    #   escrow_approve
+    #   escrow_dispute
+    #   escrow_release
+    #   comment
+    #   limit_order_create
+    #   limit_order_cancel
+    #   fill_convert_request
+    #   fill_order
+    #   vote
+    #   account_witness_vote
+    #   account_witness_proxy
+    #   account_create
+    #   account_update
+    #   witness_update
+    #   pow
+    #   custom
+    #
+    # @param type [symbol || Array<symbol>] the type(s) of operation, optional.
+    # @param start starting block
+    # @param mode we have the choice between
+    #   * :head the last block
+    #   * :irreversible the block that is confirmed by 2/3 of all block producers and is thus irreversible!
+    # @param block the block to execute for each result, optional.
+    # @return [Hash]
+    def operations(type = nil, start = nil, mode = :irreversible, &block)
+      transactions(start, mode) do |transaction|
+        ops = transaction.operations.map do |t, op|
+          t = t.to_sym
+          if type == t
+            op
+          elsif type.nil? || [type].flatten.include?(t)
+            {t => op}
+          end
+        end.compact
+        
+        next if ops.none?
+        
+        return ops unless !!block
+        
+        ops.each do |op|
+          yield op
+        end
+      end
+    end
+    
+    # Returns the latest transactions from the blockchain.
+    # 
+    # @param start starting block
+    # @param mode we have the choice between
+    #   * :head the last block
+    #   * :irreversible the block that is confirmed by 2/3 of all block producers and is thus irreversible!
+    # @param block the block to execute for each result, optional.
+    # @return [Hash]
+    def transactions(start = nil, mode = :irreversible, &block)
+      blocks(start, mode) do |b|
+        next if (_transactions = b.transactions).nil?
+        return _transactions unless !!block
+        
+        _transactions.each.each do |transaction|
+          yield transaction
+        end
+      end
+    end
+    
+    # Returns the latest blocks from the blockchain.
+    # 
+    # @param start starting block
+    # @param mode we have the choice between
+    #   * :head the last block
+    #   * :irreversible the block that is confirmed by 2/3 of all block producers and is thus irreversible!
+    #   * :max_blocks_per_node the number of blocks to read before trying a new node
+    # @param block the block to execute for each result, optional.
+    # @return [Hash]
+    def blocks(start = nil, mode = :irreversible, max_blocks_per_node = MAX_BLOCKS_PER_NODE, &block)
+      counter = 0
+      
+      if start.nil?
+        properties = api.get_dynamic_global_properties.result
+        start = case mode.to_sym
+        when :head then properties.head_block_number
+        when :irreversible then properties.last_irreversible_block_num
+        else; raise StreamError, '"mode" has to be "head" or "irreversible"'
+        end
+      end
+      
+      loop do
+        properties = api.get_dynamic_global_properties.result
+        
+        head_block = case mode.to_sym
+        when :head then properties.head_block_number
+        when :irreversible then properties.last_irreversible_block_num
+        else; raise StreamError, '"mode" has to be "head" or "irreversible"'
+        end
+        
+        [*(start..(head_block))].each do |n|
+          if (counter += 1) > max_blocks_per_node
+            shutdown
+            counter = 0
+          end
+
+          response = api.send(:get_block, n)
+          raise StreamError, JSON[response.error] if !!response.error
+          result = response.result
+        
+          if !!block
+            yield result
+          else
+            return result
+          end
+        end
+        
+        start = head_block + 1
+        sleep 3
+      end
+    end
+    
+    def method_missing(m, *args, &block)
+      super unless respond_to_missing?(m)
+      
+      @latest_values ||= []
+      @latest_values.shift(5) if @latest_values.size > 20
+      loop do
+        value = if (n = method_params(m)).nil?
+          key_value = api.get_dynamic_global_properties.result[m]
+        else
+          key = n.keys.first
+          if !!n[key]
+            r = api.get_dynamic_global_properties.result
+            key_value = param = r[n[key]]
+            result = nil
+            loop do
+              response = api.send(key, param)
+              raise StreamError, JSON[response.error] if !!response.error
+              result = response.result
+              break if !!result
+              @logger.warn "#{key}: #{param} result missing, retrying with timeout: #{@timeout || INITIAL_TIMEOUT} seconds"
+              shutdown
+              sleep timeout
+            end
+            @timeout = INITIAL_TIMEOUT
+            result
+          else
+            key_value = api.get_dynamic_global_properties.result[key]
+          end
+        end
+        unless @latest_values.include? key_value
+          @latest_values << key_value
+          if !!block
+            yield value
+          else
+            return value
+          end
+        end
+        sleep 0.0200
+      end
+    end
+    
+    def timeout
+      @timeout ||= INITIAL_TIMEOUT
+      @timeout *= 2
+      @timeout = INITIAL_TIMEOUT if @timeout > MAX_TIMEOUT
+      @timeout
+    end
+    
+    # Stops the persistant http connections.
+    #
+    def shutdown
+      begin
+        @api.shutdown
+      rescue => e
+        @logger.warn("Unable to shut down: #{e}")
+      end
+      
+      @api = nil
+    end
+  end
+end

data/lib/radiator/tag_api.rb

@@ -0,0 +1,11 @@
+module Radiator
+  class TagApi < Api
+    def method_names
+      @method_names ||= [:get_tags].freeze
+    end
+    
+    def api_name
+      :tag_api
+    end
+  end
+end

data/lib/radiator/transaction.rb

@@ -0,0 +1,150 @@
+require 'bitcoin'
+require 'digest'
+require 'time'
+
+module Radiator
+  #   * graphenej:
+  #     * https://github.com/kenCode-de/graphenej/blob/master/graphenej/src/main/java/de/bitsharesmunich/graphenej/Transaction.java#L142
+  class Transaction
+    include ChainConfig
+    include Utils
+    
+    VALID_OPTIONS = %w(
+      wif private_key ref_block_num ref_block_prefix expiration operations
+      chain
+    ).map(&:to_sym)
+    VALID_OPTIONS.each { |option| attr_accessor option }
+    
+    def initialize(options = {})
+      options.each do |k, v|
+        k = k.to_sym
+        if VALID_OPTIONS.include?(k.to_sym)
+          options.delete(k)
+          send("#{k}=", v)
+        end
+      end
+      
+      @logger = options[:logger] || Radiator.logger
+      @chain ||= :steem
+      @chain_id = chain_id options[:chain_id]
+      @url = options[:url] || url
+      @operations ||= []
+      
+      unless NETWORK_CHAIN_IDS.include? @chain_id
+        @logger.warn "Unknown chain id: #{@chain_id}"
+      end
+      
+      if !!wif && !!private_key
+        raise TransactionError, "Do not pass both wif and private_key.  That's confusing."
+      end
+      
+      if !!wif
+        @private_key = Bitcoin::Key.from_base58 wif
+      end
+      
+      options = options.merge(url: @url)
+      @api = Api.new(options)
+      @network_broadcast_api = NetworkBroadcastApi.new(options)
+    end
+    
+    def chain_id(chain_id = nil)
+      return chain_id if !!chain_id
+      
+      case chain.to_s.downcase.to_sym
+      when :steem then NETWORKS_STEEM_CHAIN_ID
+      when :golos then NETWORKS_GOLOS_CHAIN_ID
+      when :test then NETWORKS_TEST_CHAIN_ID
+      end
+    end
+    
+    def url
+      case chain.to_s.downcase.to_sym
+      when :steem then NETWORKS_STEEM_DEFAULT_NODE
+      when :golos then NETWORKS_GOLOS_DEFAULT_NODE
+      when :test then NETWORKS_TEST_DEFAULT_NODE
+      end
+    end
+    
+    def process(broadcast = false)
+      prepare
+      
+      if broadcast
+        @network_broadcast_api.broadcast_transaction_synchronous(payload)
+      else
+        self
+      end
+    end
+  private
+    def payload
+      {
+        expiration: @expiration.strftime('%Y-%m-%dT%H:%M:%S'),
+        ref_block_num: @ref_block_num,
+        ref_block_prefix: @ref_block_prefix,
+        operations: @operations.map { |op| op.payload },
+        extensions: [],
+        signatures: [hexlify(signature)]
+      }
+    end
+  
+    def prepare
+      raise TransactionError, "No wif or private key." unless !!@wif || !!@private_key
+      
+      @properties = @api.get_dynamic_global_properties.result
+      @ref_block_num = @properties.head_block_number & 0xFFFF
+      @ref_block_prefix = unhexlify(@properties.head_block_id[8..-1]).unpack('V*')[0]
+      
+      # The expiration allows for transactions to expire if they are not
+      # included into a block by that time.  Always update it to the current
+      # time + EXPIRE_IN_SECS.
+      @expiration = Time.parse(@properties.time + 'Z') + EXPIRE_IN_SECS
+      
+      self
+    end
+    
+    def to_bytes
+      bytes = unhexlify(@chain_id)
+      bytes << pakS(@ref_block_num)
+      bytes << pakI(@ref_block_prefix)
+      bytes << pakI(@expiration.to_i)
+      bytes << pakC(@operations.size)
+      
+      @operations.each do |op|
+        bytes << op.to_bytes
+      end
+      
+      bytes << 0x00 # extensions
+      
+      bytes
+    end
+    
+    def digest
+      Digest::SHA256.digest(to_bytes)
+    end
+    
+    def signature
+      public_key_hex = @private_key.pub
+      ec = Bitcoin::OpenSSL_EC
+      digest_hex = digest.freeze
+
+      loop do
+        @expiration += 1
+        sig = ec.sign_compact(digest_hex, @private_key.priv, public_key_hex)
+        
+        next if public_key_hex != ec.recover_compact(digest_hex, sig)
+        
+        return sig if canonical? sig
+      end
+    end
+    
+    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

data/lib/radiator/type/amount.rb

@@ -0,0 +1,36 @@
+module Radiator
+  module Type
+    
+    # See: https://github.com/xeroc/piston-lib/blob/34a7525cee119ec9b24a99577ede2d54466fca0e/steembase/operations.py
+    class Amount
+      def initialize(value)
+        @amount, @asset = value.strip.split(' ')
+        @precision = case @asset
+        when 'STEEM' then 3
+        when 'VESTS' then 6
+        when 'SBD' then 3
+        when 'GOLOS' then 3
+        when 'GESTS' then 6
+        when 'GBG' then 3
+        when 'CORE' then 3
+        when 'CESTS' then 6
+        when 'TEST' then 3
+        else; raise TypeError, "Asset #{@asset} unknown."
+        end
+      end
+      
+      def to_bytes
+        asset = @asset.ljust(7, "\x00")
+        amount = (@amount.to_f * 10 ** @precision).round
+        
+        [amount].pack('q') +
+        [@precision].pack('c') +
+        asset
+      end
+      
+      def to_s
+        "#{@amount} #{@asset}"
+      end
+    end
+  end
+end

data/lib/radiator/type/permission.rb

@@ -0,0 +1,17 @@
+module Radiator
+  module Type
+    
+    # See: https://github.com/xeroc/piston-lib/blob/34a7525cee119ec9b24a99577ede2d54466fca0e/steembase/operations.py
+    class Permission
+      def initialize()
+        raise NotImplementedError, 'stub'
+      end
+      
+      def to_bytes
+      end
+      
+      def to_s
+      end
+    end
+  end
+end

data/lib/radiator/type/point_in_time.rb

@@ -0,0 +1,19 @@
+module Radiator
+  module Type
+  
+    # See: https://github.com/xeroc/python-graphenelib/blob/98de98e219264d45fe04b3c28f3aabd1a9f58b71/graphenebase/types.py
+    class PointInTime
+      def initialize(value)
+        @value = value
+      end
+      
+      def to_bytes
+        [Time.parse(@value + 'Z').to_i].pack('I')
+      end
+      
+      def to_s
+        @value
+      end
+    end
+  end
+end

data/lib/radiator/type/public_key.rb

@@ -0,0 +1,17 @@
+module Radiator
+  module Type
+  
+    # See: https://github.com/xeroc/piston-lib/blob/34a7525cee119ec9b24a99577ede2d54466fca0e/steembase/operations.py
+    class PublicKey
+      def initialize()
+        raise NotImplementedError, 'stub'
+      end
+      
+      def to_bytes
+      end
+      
+      def to_s
+      end
+    end
+  end
+end

data/lib/radiator/type/u_int16.rb

@@ -0,0 +1,19 @@
+module Radiator
+  module Type
+  
+    # See: https://github.com/xeroc/piston-lib/blob/34a7525cee119ec9b24a99577ede2d54466fca0e/steembase/operations.py
+    class Uint16
+      def initialize(value)
+        @value = value.to_i
+      end
+      
+      def to_bytes
+        [@value].pack('S')
+      end
+      
+      def to_s
+        @value.to_s
+      end
+    end
+  end
+end

data/lib/radiator/type/u_int32.rb

@@ -0,0 +1,19 @@
+module Radiator
+  module Type
+  
+    # See: https://github.com/xeroc/piston-lib/blob/34a7525cee119ec9b24a99577ede2d54466fca0e/steembase/operations.py
+    class Uint32
+      def initialize(value)
+        @value = value.to_i
+      end
+      
+      def to_bytes
+        [@value].pack('L')
+      end
+      
+      def to_s
+        @value.to_s
+      end
+    end
+  end
+end