mastercoin-ruby 0.0.4 → 0.0.5

data/Gemfile

@@ -9,6 +9,7 @@ source "http://rubygems.org"
 gem 'bitcoin-ruby', '~> 0.0.1', git: "https://github.com/maran/bitcoin-ruby.git"
 gem 'sequel', '~> 4.1.1'
 gem 'thor'
+gem 'activesupport', '>= 3.0.0'
 
 group :development do
   gem "rdoc", "~> 3.12"

data/Gemfile.lock

@@ -7,7 +7,14 @@ GIT
 GEM
   remote: http://rubygems.org/
   specs:
+    activesupport (4.0.0)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
     addressable (2.3.5)
+    atomic (1.1.14)
     builder (3.2.2)
     diff-lcs (1.2.4)
     faraday (0.8.8)
@@ -23,6 +30,7 @@ GEM
     hashie (2.0.5)
     highline (1.6.19)
     httpauth (0.2.0)
+    i18n (0.6.5)
     jeweler (1.8.7)
       builder
       bundler (~> 1.0)
@@ -35,6 +43,7 @@ GEM
     json (1.8.0)
     jwt (0.1.8)
       multi_json (>= 1.5)
+    minitest (4.7.5)
     multi_json (1.8.0)
     multi_xml (0.5.5)
     multipart-post (1.2.0)
@@ -60,11 +69,15 @@ GEM
     rspec-mocks (2.14.3)
     sequel (4.1.1)
     thor (0.18.1)
+    thread_safe (0.1.3)
+      atomic
+    tzinfo (0.3.37)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  activesupport (>= 3.0.0)
   bitcoin-ruby (~> 0.0.1)!
   bundler (~> 1.0)
   jeweler (~> 1.8.7)

data/TODO

@@ -0,0 +1,4 @@
+If all outputs are the same, then look at sequence numbers:
+If there is a broken sequence (i.e. 3,4,8), then the odd-man-out is the change address (8 in this example)
+If there is an ambiguous sequence (i.e. 3,4,4), then the transaction is invalid!
+If there is a perfect sequence (i.e. 3,4,5), then the transaction is invalid!

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+$:.unshift( File.expand_path("../../lib", __FILE__) )
+require 'mastercoin-ruby'
+include Mastercoin
+
+require 'irb'
+require 'irb/completion'
+def reload(require_regex)
+  $".grep(/^#{require_regex}/).each {|e| $".delete(e) && require(e) }
+end
+def reload!
+  $".grep(/mastercoin/).each {|e| $".delete(e) && require(e) }
+end
+IRB.start

data/lib/mastercoin-ruby.rb

@@ -1,21 +1,25 @@
 require 'bitcoin'
 require 'logger'
+require 'active_support/core_ext'
 
 module Mastercoin
   class TransactionNotFoundException < StandardError;end
   autoload :SimpleSend, 'mastercoin-ruby/simple_send'
+  autoload :SellingOffer, 'mastercoin-ruby/selling_offer'
   autoload :ExodusPayment, 'mastercoin-ruby/exodus_payment'
   autoload :Transaction, 'mastercoin-ruby/transaction'
+  autoload :Message, 'mastercoin-ruby/message'
   autoload :Util, 'mastercoin-ruby/util'
   autoload :BitcoinWrapper, 'mastercoin-ruby/bitcoin_wrapper'
 
   TRANSACTION_SIMPLE_SEND = "0"
+  TRANSACTION_SELL_FOR_BITCOIN = 20
 
   TRANSACTION_TYPES = {
     TRANSACTION_SIMPLE_SEND => "Simple transfer",
     "10" => "Mark saving",
     "11" => "Mark compromised",
-    "20" => "Currency trade offer bitcoins",
+    TRANSACTION_SELL_FOR_BITCOIN => "Currency trade offer bitcoins",
     "21" => "Currency trade offer master-coin derived",
     "22" => "Currency trade offer accept",
     "30" => "Register data-stream",

data/lib/mastercoin-ruby/message.rb

@@ -0,0 +1,83 @@
+module Mastercoin
+  class Message
+    # Try to decode the keys and grab the keys that have a logical sequence number
+    
+    # TODO Build it so that we bruteforce a couple of hashing to see if we can get the right amount
+    # Dont assume the first key is the compressed key
+    def self.probe(keys, xor_target)
+      decoded_keys = Message.decode(keys[1..-1], xor_target, return_as: :array)
+      decoded_keys.find_all do |key|
+        (1..keys.count).collect{|x| x.to_s.rjust(2,"0")}.to_a.include?(key[1][0..1])
+      end
+    end
+
+    def self.probe_and_read(keys, xor_target)
+      result = Message.probe(keys, xor_target)
+      transaction_type = (result[0][1] + result[1][1])[2..9].to_i(16)
+    
+      if transaction_type == Mastercoin::TRANSACTION_SELL_FOR_BITCOIN
+        Mastercoin::SellingOffer.decode_from_compressed_public_key([result[0][0], result[1][0]], xor_target)
+      elsif transaction_type.to_s == Mastercoin::TRANSACTION_SIMPLE_SEND.to_s
+        Mastercoin::SimpleSend.decode_from_compressed_public_key(keys, xor_target)
+      end
+    end
+
+    def self.decode(keys, xor_target, options = {})
+      if keys.is_a?(Array)
+        i = 1
+        key_data = keys.collect do |key|
+          impose = Mastercoin::Util.multiple_hash(xor_target, i)[0..-3]
+          i += 1
+          mangled_key = key.each_char.to_a.drop(2).reverse.drop(2).reverse.join
+          if options[:return_as] == :hash
+            {key => Mastercoin::Util.xor_pack_unpack_strings(impose, mangled_key)}
+          elsif options[:return_as] == :array
+            [key, Mastercoin::Util.xor_pack_unpack_strings(impose, mangled_key)]
+          else
+            Mastercoin::Util.xor_pack_unpack_strings(impose, mangled_key)
+          end
+        end
+      else
+        impose = Mastercoin::Util.multiple_hash(xor_target, 1)[0..-3]
+        key = keys.each_char.to_a.drop(2).reverse.drop(2).reverse.join
+        key_data = Mastercoin::Util.xor_pack_unpack_strings(impose, key)
+      end
+    end
+
+    def self.decode_from_compressed_public_key(keys, xor_target)
+      key_data = self.decode(keys, xor_target)
+      self.decode_key_to_data(key_data)
+    end
+
+    def encode_to_compressed_public_key(xor_target)
+      keys = self.encode_data_to_key
+
+      if keys.is_a?(String)
+        impose = Mastercoin::Util.multiple_hash(xor_target, 1)[0..-3]
+        new_key = "02" + Mastercoin::Util.xor_pack_unpack_strings(impose, keys)+ "00"
+        result = mangle_key_until_valid(new_key)
+      elsif keys.is_a?(Array)
+        i = 1
+        result = keys.collect do |key|
+          impose = Mastercoin::Util.multiple_hash(xor_target, i)[0..-3]
+          i += 1
+          new_key = "02" + Mastercoin::Util.xor_pack_unpack_strings(impose, key)+ "00"
+
+          mangle_key_until_valid(new_key)
+        end
+      end
+      result
+    end
+
+
+    def mangle_key_until_valid(key)
+      key[64..66] = Random.rand(256).to_s(16).rjust(2,"0")
+
+      if Mastercoin::Util.valid_ecdsa_point?(key)
+        return key
+      else
+        mangle_key_until_valid(key)
+      end
+    end
+  end
+end

data/lib/mastercoin-ruby/selling_offer.rb

@@ -0,0 +1,46 @@
+module Mastercoin
+  class SellingOffer < Mastercoin::Message
+    class CannotDecodeSellingOfferException < StandardError;end
+
+    # 14015bd586c0c7a28979ca294b114441f23bfc97be17cd6077b9e12e2709fec3
+    attr_accessor :transaction_type, :currency_id, :amount, :bitcoin_amount, :time_limit, :transaction_fee
+
+    def initialize(options = {})
+      options.reverse_merge!({time_limit: 10, transaction_fee: 20000})
+      self.transaction_type = Mastercoin::TRANSACTION_SELL_FOR_BITCOIN
+      self.currency_id = options[:currency_id]
+      self.amount = options[:amount]
+      self.bitcoin_amount = options[:bitcoin_amount]
+      self.time_limit = options[:time_limit]
+      self.transaction_fee = options[:transaction_fee]
+    end
+
+    def self.decode_key_to_data(keys)
+      raise CannotDecodeSellingOfferException.new("Need an array of two public keys in order to decode Selling Offer") unless keys.is_a?(Array) || keys.count != 2
+
+      key = Mastercoin::Util.sort_and_strip_keys(keys).join
+      
+      offer = SellingOffer.new
+      offer.transaction_type = key[0..7].to_i(16)
+      offer.currency_id = key[8..15].to_i(16)
+      offer.amount = key[16..31].to_i(16)
+      offer.bitcoin_amount = key[32..47].to_i(16)
+      offer.time_limit = key[48..49].to_i(16)
+      offer.transaction_fee = key[50..65].to_i(16)
+      offer
+    end
+
+    def encode_data_to_key
+      raw = self.transaction_type.to_i.to_s(16).rjust(8,"0") + self.currency_id.to_i.to_s(16).rjust(8, "0") + self.amount.to_i.to_s(16).rjust(16, "0") + self.bitcoin_amount.to_i.to_s(16).rjust(16, "0") + self.time_limit.to_i.to_s(16).rjust(2,"0") + self.transaction_fee.to_i.to_s(16).rjust(16,"0")
+      raw = raw.ljust(120,"0")
+      keys = raw.chars.each_slice(60).map(&:join)
+      keys.each_with_index.collect do |key, index|
+        "#{(index + 1).to_s(16).rjust(2,"0")}#{key}"
+      end
+    end
+
+    def explain
+      "Selling Offer of #{(self.amount / 1e8).to_f} #{Mastercoin::CURRENCY_IDS[self.currency_id.to_s]} for #{(self.bitcoin_amount / 1e8).to_f} Bitcoins. Time limit #{self.time_limit}. BTC Fee #{self.transaction_fee}"
+    end
+  end
+end

data/lib/mastercoin-ruby/simple_send.rb

@@ -1,5 +1,5 @@
 module Mastercoin
-  class SimpleSend
+  class SimpleSend < Mastercoin::Message
     attr_accessor :transaction_type, :currency_id, :amount, :receiving_address, :sequence 
 
     # Supply the amount in 'dacoinminster's
@@ -16,19 +16,18 @@ module Mastercoin
       01
     end
 
-    def self.decode_from_compressed_public_key(public_key)
+    def self.decode_key_to_data(public_key)
       simple_send = SimpleSend.new
-      simple_send.transaction_type = Mastercoin::TRANSACTION_SIMPLE_SEND
-      simple_send.currency_id = public_key[12..19].to_i(16)
-      simple_send.amount = public_key[20..35].to_i(16)
-      simple_send.sequence = public_key[2..3].to_i(16)
+      simple_send.transaction_type = public_key[2..9]#Mastercoin::TRANSACTION_SIMPLE_SEND
+      simple_send.currency_id = public_key[10..17].to_i(16)
+      simple_send.amount = public_key[18..33].to_i(16)
+      simple_send.sequence = public_key[0..1].to_i(16)
       return simple_send
     end
 
-    def encode_to_compressed_public_key
-      raw = "02" + (self.public_key_sequence.to_i.to_s(16).rjust(2, "0") + self.transaction_type.to_i.to_s(16).rjust(8,"0") + self.currency_id.to_i.to_s(16).rjust(8, "0") + self.amount.to_i.to_s(16).rjust(16, "0"))
-      raw = raw.ljust(66,"0")
-
+    def encode_data_to_key
+      raw = (self.public_key_sequence.to_i.to_s(16).rjust(2, "0") + self.transaction_type.to_i.to_s(16).rjust(8,"0") + self.currency_id.to_i.to_s(16).rjust(8, "0") + self.amount.to_i.to_s(16).rjust(16, "0"))
+      raw = raw.ljust(62,"0")
       return raw
     end
 
@@ -53,10 +52,10 @@ module Mastercoin
     end
 
     def looks_like_mastercoin?
-      Mastercoin::TRANSACTION_TYPES.keys.include?(self.transaction_type.to_s) && Mastercoin::CURRENCY_IDS.keys.include?(self.currency_id.to_s)
+      Mastercoin::TRANSACTION_TYPES.keys.include?(self.transaction_type.to_i.to_s) && Mastercoin::CURRENCY_IDS.keys.include?(self.currency_id.to_s)
     end
 
-    def to_s
+    def explain
       "SimpleSend transaction for %.8f #{self.currency_id_text}." % (self.amount / 1e8)
     end
 

data/lib/mastercoin-ruby/transaction.rb

@@ -4,14 +4,20 @@ module Mastercoin
 
     attr_accessor :btc_tx
     attr_accessor :transaction_type, :currency_id, :amount
+    attr_accessor :data_addresses, :rejected_outputs, :target_address, :multisig, :sending_address
+
+    attr_accessor :data
     attr_accessor :source_address
-    attr_accessor :data_addresses, :rejected_outputs, :target_address, :multisig
 
     def initialize(tx_hash)
       @store = Mastercoin.storage
       self.data_addresses = []
       self.rejected_outputs = [] 
       self.btc_tx = @store.get_tx(tx_hash)
+      self.sending_address = btc_tx.inputs.first.get_prev_out.get_address
+      self.source_address = Mastercoin::ExodusPayment.highest_output_for_tx(self.btc_tx)
+
+      exodus_value = nil
 
       raise TransactionNotFoundException.new("Transaction #{tx_hash} could not be found. Is your blockchain up to date?") if self.btc_tx.nil?
 
@@ -29,20 +35,21 @@ module Mastercoin
         self.multisig = false
       end
 
-      self.source_address = Mastercoin::ExodusPayment.highest_output_for_tx(self.btc_tx)
-
       if multisig
         self.btc_tx.outputs.each do |output|
           if output.get_address == Mastercoin::EXODUS_ADDRESS
-            # Do nothing yet; this is simply the exodus address
-          elsif output.script.is_multisig?
+            exodus_value = output.value
+          end
+        end
+
+        self.btc_tx.outputs.each do |output|
+          if output.script.is_multisig?
             keys = output.script.get_multisig_pubkeys.collect{|x| x.unpack("H*")[0]}
-            keys.each do |key| 
-              self.data_addresses << Mastercoin::SimpleSend.decode_from_compressed_public_key(key) if Mastercoin::SimpleSend.decode_from_compressed_public_key(key).looks_like_mastercoin?
-            end
+            self.data = Mastercoin::Message.probe_and_read(keys, self.sending_address)
+          elsif output.get_address == Mastercoin::EXODUS_ADDRESS
+            # Do nothing for now
           else
-            #TODO Change this not really too trust worthy
-            self.target_address = output.get_address if output.value == 0.00006 * 1e8
+            self.target_address = output.get_address if output.value == exodus_value
           end
         end
       else
@@ -50,7 +57,7 @@ module Mastercoin
           if output.get_address == Mastercoin::EXODUS_ADDRESS
             # Do nothing yet; this is simply the exodus address
           elsif Mastercoin::SimpleSend.decode_from_address(output.get_address).looks_like_mastercoin? # This looks like a data packet
-            self.data_addresses << Mastercoin::SimpleSend.decode_from_address(output.get_address)
+            self.data = Mastercoin::SimpleSend.decode_from_address(output.get_address)
           end
         end
 
@@ -58,24 +65,12 @@ module Mastercoin
           address = output.get_address
           sequence = Mastercoin::Util.get_sequence(address)
 
-          if self.data_addresses[0].sequence.to_s == sequence.to_s
+          if self.data.sequence.to_s == sequence.to_s
             self.target_address = address
           end
         end
       end
-
-      raise NoMastercoinTransactionException.new("Could not find a valid looking data-address, invalid.") unless self.data_addresses.any?
-
-      self.data_addresses.sort!{|x, y| x.sequence.to_i <=> y.sequence.to_i }
-
-      self.analyze_addresses!
-    end
-
-    def analyze_addresses!
-      address = self.data_addresses[0]
-      self.transaction_type = address.transaction_type
-      self.currency_id = address.currency_id
-      self.amount = address.amount
+      raise NoMastercoinTransactionException.new("Could not find a valid looking data-address, invalid.") unless self.data
     end
 
     def has_three_outputs?
@@ -87,11 +82,7 @@ module Mastercoin
     end
 
     def to_s
-      if self.transaction_type.to_s == "0"
-        "Simple send:: Sent #{self.amount / 1e8} '#{Mastercoin::CURRENCY_IDS[self.currency_id.to_s]}' to #{self.target_address}"
-      else
-        "Unknown transaction: #{self.transaction_type}"
-      end
+      self.data.explain
     end
   end
 end

data/lib/mastercoin-ruby/util.rb

@@ -1,5 +1,34 @@
 module Mastercoin
   class Util
+    def self.sort_keys(public_keys)
+      public_keys.sort{|x,y| x[0..1] <=> y[0..1]}
+    end
+
+    def self.strip_key(key)
+      return key[2..-1]
+    end
+
+
+    def self.sort_and_strip_keys(keys)
+      Util.sort_keys(keys).collect{|key| Util.strip_key(key)}
+    end
+
+    def self.xor_pack_unpack_strings(s1, s2)
+      s1_bytes = [s1].pack("H*").unpack("C*")
+      s2_bytes = [s2].pack("H*").unpack("C*")
+      s1_bytes.zip(s2_bytes).map { |a, b| (a ^ b).to_s(16).rjust(2,"0") }.join
+    end
+
+    def self.multiple_hash(target, times = 1)
+      times -= 1
+      new_target = Digest::SHA256.hexdigest(target).upcase
+      if times > 0 
+        return multiple_hash(new_target, times)
+      end
+
+      return new_target
+    end
+
     def self.valid_ecdsa_point?(pub_key)
       begin
         Bitcoin::Key.new(nil, pub_key).addr
@@ -14,8 +43,8 @@ module Mastercoin
       decoded = Bitcoin.decode_base58(bitcoin_address)
 
       seq = decoded[2..3].to_i(16) - 1
-      if seq > 255
-        seq -= 255
+      if seq < 0
+        seq += 256
       end
 
       return seq

data/mastercoin-ruby.gemspec

@@ -5,17 +5,18 @@
 
 Gem::Specification.new do |s|
   s.name = "mastercoin-ruby"
-  s.version = "0.0.4"
+  s.version = "0.0.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Maran"]
-  s.date = "2013-10-11"
+  s.date = "2013-10-28"
   s.description = "Basic implementation of the Mastercoin protocol."
   s.email = "maran.hidskes@gmail.com"
-  s.executables = ["exodus_payment", "mastercoin_transaction", "simple_send", "wallet.rb"]
+  s.executables = ["console", "exodus_payment", "mastercoin_transaction", "simple_send", "wallet.rb"]
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.md"
+    "README.md",
+    "TODO"
   ]
   s.files = [
     ".document",
@@ -24,7 +25,9 @@ Gem::Specification.new do |s|
     "LICENSE.txt",
     "README.md",
     "Rakefile",
+    "TODO",
     "VERSION",
+    "bin/console",
     "bin/exodus_payment",
     "bin/mastercoin_transaction",
     "bin/simple_send",
@@ -32,11 +35,14 @@ Gem::Specification.new do |s|
     "lib/mastercoin-ruby.rb",
     "lib/mastercoin-ruby/bitcoin_wrapper.rb",
     "lib/mastercoin-ruby/exodus_payment.rb",
+    "lib/mastercoin-ruby/message.rb",
+    "lib/mastercoin-ruby/selling_offer.rb",
     "lib/mastercoin-ruby/simple_send.rb",
     "lib/mastercoin-ruby/transaction.rb",
     "lib/mastercoin-ruby/util.rb",
     "mastercoin-ruby.gemspec",
-    "spec/simple_send.rb"
+    "spec/selling_offer_spec.rb",
+    "spec/simple_send_spec.rb"
   ]
   s.homepage = "http://github.com/maran/mastercoin-ruby"
   s.licenses = ["MIT"]
@@ -51,6 +57,7 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<bitcoin-ruby>, ["~> 0.0.1"])
       s.add_runtime_dependency(%q<sequel>, ["~> 4.1.1"])
       s.add_runtime_dependency(%q<thor>, [">= 0"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 3.0.0"])
       s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.8.7"])
@@ -59,6 +66,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<bitcoin-ruby>, ["~> 0.0.1"])
       s.add_dependency(%q<sequel>, ["~> 4.1.1"])
       s.add_dependency(%q<thor>, [">= 0"])
+      s.add_dependency(%q<activesupport>, [">= 3.0.0"])
       s.add_dependency(%q<rdoc>, ["~> 3.12"])
       s.add_dependency(%q<bundler>, ["~> 1.0"])
       s.add_dependency(%q<jeweler>, ["~> 1.8.7"])
@@ -68,6 +76,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<bitcoin-ruby>, ["~> 0.0.1"])
     s.add_dependency(%q<sequel>, ["~> 4.1.1"])
     s.add_dependency(%q<thor>, [">= 0"])
+    s.add_dependency(%q<activesupport>, [">= 3.0.0"])
     s.add_dependency(%q<rdoc>, ["~> 3.12"])
     s.add_dependency(%q<bundler>, ["~> 1.0"])
     s.add_dependency(%q<jeweler>, ["~> 1.8.7"])

data/spec/selling_offer_spec.rb

@@ -0,0 +1,54 @@
+require 'mastercoin-ruby'
+
+describe Mastercoin::SellingOffer do
+
+  context "Encoding and decoding public keys" do
+    before do
+      @selling_offer = Mastercoin::SellingOffer.new(currency_id: 2, amount: 1e8.to_i, bitcoin_amount: 1e6.to_i, time_limit: 6, transaction_fee: 1e5.to_i)
+    end
+
+    it "Should encode to exactly two public keys" do
+      keys = @selling_offer.encode_to_compressed_public_key("1J2svn2GxYx9LPrpCLFikmzn9kkrXBrk8B")
+      keys.count.should eq(2)
+    end
+
+    it "Should be backward compatible with existing transactions in the blockchain" do
+      selling = Mastercoin::SellingOffer.decode_from_compressed_public_key(["0226cb0561011d9045f6371cb09086ba7148d9942328bcf1dd78cb6edb35ccdda9", "022eac137ab02d826df0af54e92a352945c9892df6cd77f1a7c390fc82c8b0edea"], "13NRX88EZbS5q81x6XFrTECzrciPREo821")
+      selling.amount.should be(1e8.to_i)
+      selling.currency_id.should be(2)
+      selling.time_limit.should be(12)
+      selling.bitcoin_amount.should be(1000)
+      selling.transaction_fee.should be(100000)
+    end
+
+    it "Should encode valid public keys" do
+      keys = @selling_offer.encode_to_compressed_public_key("1J2svn2GxYx9LPrpCLFikmzn9kkrXBrk8B")
+      keys.first[0..-3].should eq("02d52c390e46f1110410078a9db14d124206924666fb10a5e8dbf9cc2e2ecde3")
+      keys.last[0..-3].should eq("02020f44668806819e67a030e82a6af98376dac1065d7fe533daf251d43aa836")
+      Mastercoin::Util.valid_ecdsa_point?(keys.first).should eq(true)
+      Mastercoin::Util.valid_ecdsa_point?(keys.last).should eq(true)
+    end
+
+    it "Should decode public keys into a valid transaction" do
+      keys = @selling_offer.encode_to_compressed_public_key("1J2svn2GxYx9LPrpCLFikmzn9kkrXBrk8B")
+      offer_two = Mastercoin::SellingOffer.decode_from_compressed_public_key(keys, "1J2svn2GxYx9LPrpCLFikmzn9kkrXBrk8B")
+      offer_two.amount.should eq(@selling_offer.amount)
+      offer_two.bitcoin_amount.should eq(@selling_offer.bitcoin_amount)
+      offer_two.currency_id.should eq(@selling_offer.currency_id)
+      offer_two.transaction_fee.should be(1e5.to_i)
+      offer_two.time_limit.should eq(@selling_offer.time_limit)
+    end
+
+    it "Should strip sequence and compressed key format" do
+      key = "0300000014000000020000000005f5e10000000000000f424060000000000018"
+      Mastercoin::Util.strip_key(key).should eq("00000014000000020000000005f5e10000000000000f424060000000000018")
+    end
+
+    it "Should sort keys based on sequence number" do 
+      keys = ["0300000014000000020000000005f5e10000000000000f424060000000000018","0200000014000000020000000005f5e10000000000000f424060000000000018", "0100000014000000020000000005f5e10000000000000f424060000000000018"]
+      Mastercoin::Util.sort_keys(keys).should eq(["0100000014000000020000000005f5e10000000000000f424060000000000018",
+                                                  "0200000014000000020000000005f5e10000000000000f424060000000000018",
+                                                   "0300000014000000020000000005f5e10000000000000f424060000000000018"])
+    end
+  end
+end

data/spec/{simple_send.rb → simple_send_spec.rb}

@@ -39,25 +39,25 @@ describe Mastercoin::SimpleSend do
     end
 
     it "Should output a valid looking compressed public key" do
-      public_key = @simple_send.encode_to_compressed_public_key
-      public_key.should eq("020100000000000000020000000000000032000000000000000000000000000000") 
+      public_key = @simple_send.encode_to_compressed_public_key(@simple_send.receiving_address)
+      public_key[0..-3].should eq("023d1de8362fca649b99f66e1c98f409e0d17edfcffc0b9082e1bc0330dc5798")
     end
 
     it "Should be a valid ECDSA point" do
-      public_key = @simple_send.encode_to_compressed_public_key
+      public_key = @simple_send.encode_to_compressed_public_key(@simple_send.receiving_address)
       Mastercoin::Util.valid_ecdsa_point?(public_key).should eq(true)
     end
 
     it "Should always start with 02 for compressed key" do
-      public_key = @simple_send.encode_to_compressed_public_key
+      public_key = @simple_send.encode_to_compressed_public_key(@simple_send.receiving_address)
       public_key[0..1].should eq("02")
     end
 
     it "Should be able to parse a given public key" do
-      simple_send = Mastercoin::SimpleSend.decode_from_compressed_public_key("02000000000000000002000000000000003200000000000000000000000000000")
-      simple_send.currency_id.should eq(2)
+      simple_send = Mastercoin::SimpleSend.decode_from_compressed_public_key("023d1de8362fca649b99f66e1c98f409e0d17edfcffc0b9082e1bc0330dc579811", @simple_send.receiving_address)
       simple_send.amount.should eq(50)
-      simple_send.transaction_type.should eq(Mastercoin::TRANSACTION_SIMPLE_SEND)
+      simple_send.currency_id.should eq(2)
+      simple_send.transaction_type.to_i.to_s.should eq(Mastercoin::TRANSACTION_SIMPLE_SEND)
       simple_send.public_key_sequence.should eq(1)
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mastercoin-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-11 00:00:00.000000000 Z
+date: 2013-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bitcoin-ruby
@@ -59,6 +59,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -126,6 +142,7 @@ dependencies:
 description: Basic implementation of the Mastercoin protocol.
 email: maran.hidskes@gmail.com
 executables:
+- console
 - exodus_payment
 - mastercoin_transaction
 - simple_send
@@ -134,6 +151,7 @@ extensions: []
 extra_rdoc_files:
 - LICENSE.txt
 - README.md
+- TODO
 files:
 - .document
 - Gemfile
@@ -141,7 +159,9 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- TODO
 - VERSION
+- bin/console
 - bin/exodus_payment
 - bin/mastercoin_transaction
 - bin/simple_send
@@ -149,11 +169,14 @@ files:
 - lib/mastercoin-ruby.rb
 - lib/mastercoin-ruby/bitcoin_wrapper.rb
 - lib/mastercoin-ruby/exodus_payment.rb
+- lib/mastercoin-ruby/message.rb
+- lib/mastercoin-ruby/selling_offer.rb
 - lib/mastercoin-ruby/simple_send.rb
 - lib/mastercoin-ruby/transaction.rb
 - lib/mastercoin-ruby/util.rb
 - mastercoin-ruby.gemspec
-- spec/simple_send.rb
+- spec/selling_offer_spec.rb
+- spec/simple_send_spec.rb
 homepage: http://github.com/maran/mastercoin-ruby
 licenses:
 - MIT
@@ -169,7 +192,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1425563484101339016
+      hash: -1833207625332828551
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: