steem-ruby 0.9.0 → 0.9.5

data/lib/steem/transaction.rb

@@ -0,0 +1,96 @@
+module Steem
+  class Transaction
+    include JSONable
+    include Utils
+    
+    ATTRIBUTES = %i(id ref_block_num ref_block_prefix expiration operations
+      extensions signatures)
+    
+    attr_accessor *ATTRIBUTES
+    
+    def initialize(options = {})
+      if !!(hex = options.delete(:hex))
+        marshal = Marshal.new(hex: hex)
+        marshal.transaction(trx: self)
+      end
+      
+      options.each do |k, v|
+        raise Steem::ArgumentError, "Invalid option specified: #{k}" unless ATTRIBUTES.include?(k.to_sym)
+
+        send("#{k}=", v)
+      end
+      
+      self.operations ||= []
+      self.extensions ||= []
+      self.signatures ||= []
+      
+      self.expiration = case @expiration
+      when String then Time.parse(@expiration + 'Z')
+      else; @expiration
+      end
+    end
+    
+    def inspect
+      properties = 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 expiration
+      if @expiration.respond_to? :strftime
+        @expiration.strftime('%Y-%m-%dT%H:%M:%S')
+      else
+        @expiration
+      end
+    end
+    
+    def expired?
+      @expiration.nil? || @expiration < Time.now
+    end
+    
+    def [](key)
+      key = key.to_sym
+      send(key) if self.class.attributes.include?(key)
+    end
+
+    def []=(key, value)
+      key = key.to_sym
+      send("#{key}=", value) if self.class.attributes.include?(key)
+    end
+    
+    def ==(other_trx)
+      return true if self.equal? other_trx
+      return false unless self.class == other_trx.class
+      
+      begin
+        return false if self[:ref_block_num].to_i != other_trx[:ref_block_num].to_i
+        return false if self[:ref_block_prefix].to_i != other_trx[:ref_block_prefix].to_i
+        return false if self[:expiration].to_i != other_trx[:expiration].to_i
+        return false if self[:operations].size != other_trx[:operations].size
+        
+        op_values = self[:operations].map do |type, value|
+          [type.to_s, value.values.map{|v| v.to_s.gsub(/[^a-zA-Z0-9-]/, '')}]
+        end.flatten.sort
+        
+        other_op_values = other_trx[:operations].map do |type, value|
+          [type.to_s, value.values.map{|v| v.to_s.gsub(/[^a-zA-Z0-9-]/, '')}]
+        end.flatten.sort
+        # binding.pry unless op_values == other_op_values
+        op_values == other_op_values
+      rescue => e
+        # binding.pry
+        false
+      end
+    end
+  end
+end

data/lib/steem/transaction_builder.rb

@@ -1,3 +1,5 @@
+require 'pry'
+
 module Steem
   # {TransactionBuilder} can be used to create a transaction that the
   # {NetworkBroadcastApi} can broadcast to the rest of the platform.  The main
@@ -15,7 +17,7 @@ module Steem
   #     })
   #     
   #     trx = builder.transaction
-  #     network_broadcast_api = Steem::NetworkBroadcastApi.new
+  #     network_broadcast_api = Steem::CondenserApi.new
   #     network_broadcast_api.broadcast_transaction_synchronous(trx: trx)
   #
   #
@@ -26,15 +28,31 @@ module Steem
     include ChainConfig
     include Utils
     
-    attr_accessor :database_api, :block_api, :expiration, :operations
+    attr_accessor :app_base, :database_api, :block_api, :expiration, :operations
     attr_writer :wif
-    attr_reader :signed
+    attr_reader :signed, :testnet, :force_serialize
+    
+    alias app_base? app_base
+    alias testnet? testnet
+    alias force_serialize? force_serialize
     
     def initialize(options = {})
-      @database_api = options[:database_api] || Steem::DatabaseApi.new(options)
-      @block_api = options[:block_api] || Steem::BlockApi.new(options)
+      @app_base = true#!!options[:app_base] # default false
+      @database_api = options[:database_api]
+      @block_api = options[:block_api]
+      
+      if app_base?
+        @database_api ||= Steem::DatabaseApi.new(options)
+        @block_api ||= Steem::BlockApi.new(options)
+      else
+        @database_api ||= Steem::CondenserApi.new(options)
+        @block_api ||= Steem::CondenserApi.new(options)
+      end
+      
       @wif = [options[:wif]].flatten
       @signed = false
+      @testnet = true#!!options[:testnet]
+      @force_serialize = true#!!options[:force_serialize]
       
       if !!(trx = options[:trx])
         trx = case trx
@@ -42,44 +60,28 @@ module Steem
         else; trx
         end
         
-        trx_options = {
-          ref_block_num: trx['ref_block_num'],
-          ref_block_prefix: trx['ref_block_prefix'],
-          extensions: (trx['extensions']),
-          operations: trx['operations'],
-          signatures: (trx['signatures']),
-        }
-        
-        trx_options[:expiration] = case trx['expiration']
-        when String then Time.parse(trx['expiration'] + 'Z')
-        else; trx['expiration']
-        end
-        
-        options = options.merge(trx_options)
+        @trx = Transaction.new(trx)
       end
       
-      @ref_block_num = options[:ref_block_num]
-      @ref_block_prefix = options[:ref_block_prefix]
-      @operations = options[:operations] || []
-      @expiration = options[:expiration]
-      @extensions = options[:extensions] || []
-      @signatures = options[:signatures] || []
-      @chain = options[:chain] || :steem
+      @trx ||= Transaction.new
+      @chain = options[:chain] || :test
       @error_pipe = options[:error_pipe] || STDERR
-      @chain_id = case @chain
+      @chain_id = options[:chain_id]
+      @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
+      
+      # if testnet? && @chain_id == NETWORKS_STEEM_CHAIN_ID
+      #   raise UnsupportedChainError, "Unsupported testnet chain id: #{@chain_id}"
+      # end
     end
     
     def inspect
-      properties = %w(
-        ref_block_num ref_block_prefix expiration operations extensions
-        signatures
-      ).map do |prop|
+      properties = %w(trx).map do |prop|
         if !!(v = instance_variable_get("@#{prop}"))
-          "@#{prop}=#{v}" 
+          "@#{prop}=#{v.inspect}" 
         end
       end.compact.join(', ')
       
@@ -87,21 +89,12 @@ module Steem
     end
     
     def reset
-      @ref_block_num = nil
-      @ref_block_prefix = nil
-      @expiration = nil
-      @operations = []
-      @extensions = []
-      @signatures = []
+      @trx = Transaction.new
       @signed = false
       
       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.
@@ -110,17 +103,26 @@ module Steem
     #
     # @return {TransactionBuilder}
     def prepare
-      if expired?
+      if @trx.expired?
         catch :prepare_header do; begin
           @database_api.get_dynamic_global_properties do |properties|
             block_number = properties.last_irreversible_block_num
+            block_header_args = if app_base?
+              {block_num: block_number}
+            else
+              block_number
+            end
           
-            @block_api.get_block_header(block_num: block_number) do |result|
-              header = result.header
+            @block_api.get_block_header(block_header_args) do |result|
+              header = if app_base?
+                result.header
+              else
+                result
+              end
               
-              @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
+              @trx.ref_block_num = (block_number - 1) & 0xFFFF
+              @trx.ref_block_prefix = unhexlify(header.previous[8..-1]).unpack('V*')[0]
+              @trx.expiration ||= (Time.parse(properties.time + 'Z') + EXPIRE_IN_SECS).utc
             end
           end
         rescue => e
@@ -138,9 +140,9 @@ module Steem
     
     # Sets operations all at once, then prepares.
     def operations=(operations)
-      @operations = operations
+      @trx.operations = operations.map{ |op| normalize_operation(op) }
       prepare
-      @operations
+      @trx.operations
     end
     
     # A quick and flexible way to append a new operation to the transaction.
@@ -166,35 +168,9 @@ module Steem
     #     builder.put(vote: vote1).put(vote: vote2)
     # @return {TransactionBuilder}
     def put(type, op = nil)
-      @expiration = nil
-      
-      ## Saving this for later.  This block, or something like it, might replace
-      ## API broadcast operation structure.
-      # case type
-      # when Symbol, String
-      #   type_value = "#{type}_operation"
-      #   @operations << {type: type_value, value: op}
-      # when Hash
-      #   type_value = "#{type.keys.first}_operation"
-      #   @operations << {type: type_value, value: type.values.first}
-      # when Array
-      #   type_value = "#{type[0]}_operation"
-      #   @operations << {type: type_value, value: type[1]}
-      # else
-      #   # don't know what to do with it, skipped
-      # end
-      
-      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
-      
+      @trx.expiration = nil
+      @trx.operations << normalize_operation(type, op)
       prepare
-      
       self
     end
     
@@ -216,9 +192,17 @@ module Steem
     #             ]],
     #               :signatures => ["1c45b65740b4b2c17c4bcf6bcc3f8d90ddab827d50532729fc3b8f163f2c465a532b0112ae4bf388ccc97b7c2e0bc570caadda78af48cf3c261037e65eefcd941e"]
     #     }
-    def transaction
-      prepare
-      sign
+    def transaction(options = {prepare: true, sign: true})
+      options[:prepare] = true unless options.has_key? :prepare
+      options[:sign] = true unless options.has_key? :sign
+      
+      prepare if !!options[:prepare]
+      
+      if !!options[:sign]
+        sign
+      else
+        @trx
+      end
     end
     
     # Appends to the `signatures` array of the transaction, built from a
@@ -227,27 +211,42 @@ module Steem
     # @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 if @wif.empty?
-      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
-      }
+      return self if @trx.expired?
       
       unless @signed
         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?
+          transaction_hex.tap do |result|
+            hex = if app_base?
+              result
+            else
+              result
+            end
+
+            unless force_serialize?
+              derrived_trx = Transaction.new(hex: hex)
+              derrived_ops = derrived_trx.operations
+              derrived_trx.operations = derrived_ops.map do |op|
+                op_name = if app_base?
+                  op[:type].to_sym
+                else
+                  op[:type].to_s.sub(/_operation$/, '').to_sym
+                end
+                
+                normalize_operation op_name, JSON[op[:value].to_json]
+              end
+              
+              raise SerializationMismatchError unless @trx == derrived_trx
+            end
+            
+            hex = hex.to_s[0..-4] # drop empty signature array
+            @trx.id = Digest::SHA256.hexdigest(unhexlify(hex))[0..39]
+            
+            hex = @chain_id + hex
             digest = unhexlify(hex)
             digest_hex = Digest::SHA256.digest(digest)
             private_keys = @wif.map{ |wif| Bitcoin::Key.from_base58 wif }
             ec = Bitcoin::OpenSSL_EC
             count = 0
-            sigs = []
             
             private_keys.each do |private_key|
               sig = nil
@@ -262,11 +261,10 @@ module Steem
                 break if canonical? sig
               end
               
-              @signatures << hexlify(sig)
+              @trx.signatures << hexlify(sig)
             end
             
             @signed = true
-            trx[:signatures] = @signatures
           end
         rescue => e
           if can_retry? e
@@ -278,13 +276,41 @@ module Steem
         end; end
       end
         
-      Hashie::Mash.new trx
+      @trx
+    end
+    
+    def transaction_hex
+      trx = transaction(prepare: true, sign: false)
+      
+      transaction_hex_args = if app_base?
+        {trx: trx}
+      else
+        trx
+      end
+      
+      @database_api.get_transaction_hex(transaction_hex_args) do |result|
+        if app_base?
+          result[:hex]
+        else
+          result
+        end
+      end
     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]
+      potential_signatures_args = if app_base?
+        {trx: transaction}
+      else
+        transaction
+      end
+      
+      @database_api.get_potential_signatures(potential_signatures_args) do |result|
+        if app_base?
+          result[:keys]
+        else
+          result
+        end
       end
     end
     
@@ -294,15 +320,35 @@ module Steem
     #
     # @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]
+      required_signatures_args = if app_base?
+        {trx: transaction}
+      else
+        [transaction, []]
+      end
+      
+      @database_api.get_required_signatures(*required_signatures_args) do |result|
+        if app_base?
+          result[:keys]
+        else
+          result
+        end
       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
+      verify_authority_args = if app_base?
+        {trx: transaction}
+      else
+        transaction
+      end
+      
+      @database_api.verify_authority(verify_authority_args) do |result|
+        if app_base?
+          result.valid
+        else
+          result
+        end
       end
     end
   private
@@ -318,5 +364,32 @@ module Steem
         ((sig[33] & 0x80 ) != 0)
       )
     end
+    
+    def normalize_operation(type, op = nil)
+      if app_base?
+        case type
+        when Symbol, String
+          type_value = "#{type}_operation"
+          {type: type_value, value: op}
+        when Hash
+          type_value = "#{type.keys.first}_operation"
+          {type: type_value, value: type.values.first}
+        when Array
+          type_value = "#{type[0]}_operation"
+          {type: type_value, value: type[1]}
+        else
+          raise Steem::ArgumentError, "Don't know what to do with operation type #{type.class}: #{type} (#{op})"
+        end
+      else
+        case type
+        when Symbol then [type, op]
+        when String then [type.to_sym, op]
+        when Hash then [type.keys.first.to_sym, type.values.first]
+        when Array then type
+        else
+          raise Steem::ArgumentError, "Don't know what to do with operation type #{type.class}: #{type} (#{op})"
+        end
+      end
+    end
   end
 end