mastercoin-ruby 0.0.2

data/lib/mastercoin-ruby/exodus_payment.rb

@@ -0,0 +1,146 @@
+module Mastercoin
+  class ExodusPayment
+
+    attr_accessor :coins_bought, :bonus_bought, :address, :tx, :time_included
+
+    def to_s
+      "Bought #{self.coins_bought} Mastercoins and got a #{self.bonus_bought} Mastercoins extra."
+    end
+
+    def to_json
+      {coins_bought: self.coins_bought, bonus_bought: self.bonus_bought}.to_json
+    end
+
+    def total_amount
+      self.coins_bought + self.bonus_bought
+    end
+
+    def self.from_transaction(hash) 
+      buying = ExodusPayment.new
+      buying.coins_bought = 0
+      buying.bonus_bought = 0
+
+      store = Mastercoin.storage
+      tx = store.get_tx(hash)
+      raise TransactionNotFoundException.new("Could not find the given transaction with #{hash}. Perhaps your blockchain is not up-to-date?") unless tx
+      buying.tx = tx
+      block_time = store.get_block_by_tx(tx.hash).time
+      buying.time_included = block_time
+      highest = ExodusPayment.highest_output_for_tx(tx)
+      buying.address = highest
+
+      exodus_output = tx.outputs.find{|x| x.to_hash(with_address:true)["address"] == Mastercoin::EXODUS_ADDRESS}
+
+      if tx.get_block.depth <= Mastercoin::END_BLOCK
+        btc_amount = (exodus_output.value / 1e8)
+        bought =  btc_amount * 100
+        buying.coins_bought += bought
+        date_difference = (Mastercoin::END_TIME.to_i - block_time.to_i) / 60.0 / 60 / 24 / 7
+        if date_difference > 0
+          bonus = (btc_amount * 100 * (date_difference * 0.1))
+
+          buying.bonus_bought += sprintf("%0.08f", bonus).to_f
+        end
+      end
+      return buying
+    end
+
+    def self.highest_output_for_tx(tx)
+      result = {}
+      output_hash = tx.in.collect{|x| x.get_prev_out.to_hash(with_address: true) }
+
+      output_hash.each do |output|
+        address = output['address']
+        result[address] ||= 0
+        result[address] += output['value'].to_f
+      end
+
+      highest_input = result.sort{|x,y| y[1] <=> x[1]}
+      highest_input = highest_input[0][0]
+    end
+    
+    # This is a very slow and probably very inefficient way to calculate the coins bought
+    # TODO: Please rewrite
+    def self.from_address(address)
+      buying = ExodusPayment.new
+      @used = {}
+      @rejected_tx = []
+
+      buying.address = address
+
+      buying.coins_bought = 0
+      buying.bonus_bought = 0
+
+      store = Mastercoin.storage
+      txouts = store.get_txouts_for_address(address)
+
+      # 1. Get all outputs for an address
+      # 2. Check to see if this ouput has a next input for the Exodus address
+      #    A. Get the tx for the next input if any exist
+      #    B. Check if the tx has any outputs with the Exodus address
+      # 3. If so find which input did the total best payments to Exodus
+      # 4. Check the inputs for Exodus output and award the one with the highest total
+
+      txouts.each do |txout|
+        Mastercoin.log.debug("Checking txout: #{txout.to_hash(with_address: true)}")
+        input = txout.get_next_in
+
+        if input
+          tx = input.get_tx
+          next if @rejected_tx.include?(tx.hash)
+
+          block_time = store.get_block_by_tx(tx.hash).time
+
+          if tx.get_block.depth > Mastercoin::END_BLOCK
+            Mastercoin.log.debug("Transaction after end date: Rejecting")
+            @rejected_tx << tx.hash
+            next
+          end
+
+          addresses = tx.outputs.collect{|x| x.to_hash(with_address: true)["address"] }
+
+          unless addresses.include?(Mastercoin::EXODUS_ADDRESS)
+            Mastercoin.log.debug("TX #{tx.hash} does not include transaction to Exodus")
+            @rejected_tx << tx.hash
+            next
+          else
+            Mastercoin.log.debug("TX #{tx.hash} is a transaction to Exodus")
+          end
+
+          highest_input = ExodusPayment.highest_output_for_tx(tx)
+
+          Mastercoin.log.debug("Highest input for #{tx.hash} is #{highest_input}")
+
+          # Get all the inputs from this transaction and see which has the higest one. the Funds belong to the input with the highest value
+          tx.out.each do |output|
+            if output.get_addresses.flatten.include?(Mastercoin::EXODUS_ADDRESS) && !@used.keys.include?(tx.hash)
+              Mastercoin.log.debug("TX #{tx.hash} is not inside our used tx hash: #{@used.keys}")
+
+              unless txout.get_address == highest_input
+                Mastercoin.log.debug("This is not the highest input; can't give the coins. #{txout.get_address} we needed #{highest_input}")
+                next
+              else
+              end
+
+              @used[tx.hash] = highest_input
+
+              btc_amount = (output.value / 1e8)
+              bought = btc_amount * 100
+              buying.coins_bought += bought
+              date_difference = (Mastercoin::END_TIME.to_i - block_time.to_i) / 60.0 / 60 / 24 / 7
+              if date_difference > 0
+                bonus = (btc_amount * 100 * (date_difference * 0.1))
+
+                buying.bonus_bought += sprintf("%0.08f", bonus).to_f
+              end
+            else
+              Mastercoin.log.debug("This is not the Exodus output; probably change address")
+            end
+          end
+        end
+      end
+      return buying
+    end
+  end
+end
+

data/lib/mastercoin-ruby/simple_send.rb

@@ -0,0 +1,67 @@
+module Mastercoin
+  class SimpleSend
+    attr_accessor :transaction_type, :currency_id, :amount, :receiving_address, :sequence 
+
+    # Supply the amount in 'dacoinminster's
+    def initialize(options= {})
+      self.transaction_type = Mastercoin::TRANSACTION_SIMPLE_SEND
+      self.currency_id = options[:currency_id]
+      self.amount = options[:amount]
+      self.receiving_address = options[:receiving_address]
+    end
+
+    # hardcode the sequence for a public key simple send since it's always fits inside a public key
+    # Please note that we start at 01 - 00 will generate unvalid ECDSA points somehow
+    def public_key_sequence
+      01
+    end
+
+    def self.decode_from_compressed_public_key(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)
+      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")
+
+      return raw
+    end
+
+    def encode_to_address
+      raw = (self.get_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") + "000000")
+      Bitcoin.hash160_to_address(raw)
+    end
+
+    def self.decode_from_address(raw_address)
+      simple_send = Mastercoin::SimpleSend.new
+      decoded = Bitcoin.decode_base58(raw_address)
+      simple_send.sequence = decoded[2..3].to_i(16)
+      simple_send.transaction_type = decoded[4..11].to_i(16)
+      simple_send.currency_id = decoded[12..19].to_i(16)
+      simple_send.amount = decoded[20..35].to_i(16)
+      return simple_send
+    end
+
+    def get_sequence(bitcoin_address = nil)
+      bitcoin_address ||= self.receiving_address
+      Mastercoin::Util.get_sequence(bitcoin_address)
+    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)
+    end
+
+    def to_s
+      "SimpleSend transaction for %.8f #{self.currency_id_text}." % (self.amount / 1e8)
+    end
+
+    def currency_id_text
+      Mastercoin::CURRENCY_IDS[self.currency_id.to_s]
+    end
+  end
+end

data/lib/mastercoin-ruby/transaction.rb

@@ -0,0 +1,94 @@
+module Mastercoin
+  class Transaction
+    class NoMastercoinTransactionException < StandardError;end;
+
+    attr_accessor :btc_tx
+    attr_accessor :transaction_type, :currency_id, :amount
+    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)
+
+      raise TransactionNotFoundException.new("Transaction #{tx_hash} could not be found. Is your blockchain up to date?") if self.btc_tx.nil?
+
+      unless self.has_genesis_as_output?
+        raise NoMastercoinTransaction.new("This transaction does not contain a txout to the genesis address, invalid.")
+      end
+
+      unless self.has_three_outputs?
+        raise NoMastercoinTransaction.new("This transaction does not contain three outputs, invalid.")
+      end
+ 
+      if self.btc_tx.outputs.collect{|x| x.script.is_multisig?}.include?(true)
+        self.multisig = true
+      else
+        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?
+            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
+          else
+            #TODO Change this not really too trust worthy
+            self.target_address = output.get_address if output.value == 0.00006 * 1e8
+          end
+        end
+      else
+        self.btc_tx.outputs.each do |output|
+          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)
+          end
+        end
+
+        self.btc_tx.outputs.each do |output|
+          address = output.get_address
+          sequence = Mastercoin::Util.get_sequence(address)
+          if self.data_addresses[0].sequence.to_s == sequence.to_s
+            self.target_address = address
+          end
+        end
+      end
+
+      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
+    end
+
+    def has_three_outputs?
+      self.btc_tx.outputs.size >= 3
+    end
+
+    def has_genesis_as_output?
+      self.btc_tx.outputs.collect{|x| x.get_address == Mastercoin::EXODUS_ADDRESS}.any?
+    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
+    end
+  end
+end

data/lib/mastercoin-ruby/util.rb

@@ -0,0 +1,24 @@
+module Mastercoin
+  class Util
+    def self.valid_ecdsa_point?(pub_key)
+      begin
+        Bitcoin::Key.new(nil, pub_key).addr
+      rescue OpenSSL::PKey::EC::Point::Error
+        return false
+      end
+
+      return true
+    end
+
+    def self.get_sequence(bitcoin_address)
+      decoded = Bitcoin.decode_base58(bitcoin_address)
+
+      seq = decoded[2..3].to_i(16) - 1
+      if seq > 255
+        seq -= 255
+      end
+
+      return seq
+    end
+  end
+end

data/lib/mastercoin-ruby.rb

@@ -0,0 +1,54 @@
+require 'bitcoin'
+require 'logger'
+
+module Mastercoin
+  class TransactionNotFoundException < StandardError;end
+  autoload :SimpleSend, 'mastercoin-ruby/simple_send'
+  autoload :ExodusPayment, 'mastercoin-ruby/exodus_payment'
+  autoload :Transaction, 'mastercoin-ruby/transaction'
+  autoload :Util, 'mastercoin-ruby/util'
+  autoload :BitcoinWrapper, 'mastercoin-ruby/bitcoin_wrapper'
+
+  TRANSACTION_SIMPLE_SEND = "0"
+
+  TRANSACTION_TYPES = {
+    TRANSACTION_SIMPLE_SEND => "Simple transfer",
+    "10" => "Mark saving",
+    "11" => "Mark compromised",
+    "20" => "Currency trade offer bitcoins",
+    "21" => "Currency trade offer master-coin derived",
+    "22" => "Currency trade offer accept",
+    "30" => "Register data-stream",
+    "40" => "Bet offer",
+    "100" => "Create child currency"
+  }
+
+  CURRENCY_IDS = {
+    "1" => "Mastercoin",
+    "2" => "Test Mastercoin"
+  }
+
+  EXODUS_ADDRESS = "1EXoDusjGwvnjZUyKkxZ4UHEf77z6A5S4P"
+  END_TIME = Time.new(2013,9,01,00,00,00, "+00:00")
+  END_BLOCK = 255365
+
+  def self.set_storage(storage_string)
+    @storage_string = storage_string
+  end
+
+  def self.storage
+    Bitcoin.network ||= :bitcoin
+    @@storage ||= Bitcoin::Storage.sequel(:db => @storage_string)
+    return @@storage
+  end
+
+  def self.init_logger(level = Logger::INFO)
+    @@log ||= Logger.new(STDOUT)
+    @@log.level = level
+    @@log
+  end
+
+  def self.log
+    @@log ||= Mastercoin.init_logger
+  end
+end

data/mastercoin-ruby.gemspec

@@ -0,0 +1,77 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "mastercoin-ruby"
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Maran"]
+  s.date = "2013-09-25"
+  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.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "bin/exodus_payment",
+    "bin/mastercoin_transaction",
+    "bin/simple_send",
+    "bin/wallet.rb",
+    "lib/mastercoin-ruby.rb",
+    "lib/mastercoin-ruby/bitcoin_wrapper.rb",
+    "lib/mastercoin-ruby/exodus_payment.rb",
+    "lib/mastercoin-ruby/simple_send.rb",
+    "lib/mastercoin-ruby/transaction.rb",
+    "lib/mastercoin-ruby/util.rb",
+    "mastercoin-ruby.gemspec",
+    "spec/simple_send.rb"
+  ]
+  s.homepage = "http://github.com/maran/mastercoin-ruby"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "Ruby library for the Mastercoin protocol"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      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_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.7"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      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<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.7"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    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<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.7"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

data/spec/simple_send.rb

@@ -0,0 +1,64 @@
+require 'mastercoin-ruby'
+
+describe Mastercoin::SimpleSend do
+  before do 
+    @simple_send = Mastercoin::SimpleSend.new(currency_id: 2, amount: 50, receiving_address: "184mQaxRYwiU2jqUE852FZGQvbZyRhcDSu")
+  end
+
+  context "Encoding and decoding addresses" do
+    it "Should output a valid looking bitcoin address" do
+      address = @simple_send.encode_to_address
+      address.should eq("17vrMab8gQx72eCEaUxJzL4fg5VwEUumJQ") 
+    end
+
+    it "Should decode a valid looking bitcoin address" do
+      simple_send = Mastercoin::SimpleSend.decode_from_address("17vrMab8gQx72eCEaUxJzL4fg5VwEUumJQ")
+      simple_send.currency_id.should eq(2)
+      simple_send.amount.should eq(50)
+      simple_send.transaction_type.to_s.should eq(Mastercoin::TRANSACTION_SIMPLE_SEND)
+    end
+
+    it "Should backwards compatible with existing transactions" do
+      simple_send = Mastercoin::SimpleSend.decode_from_address("1CVE9Au1XEm3MkYxeAhUDVqWvaHrP98iUt")
+      simple_send.amount.should eq(100 * 1e8)
+      simple_send.sequence.should eq(126)
+      simple_send.transaction_type.should eq(0)
+    end
+
+    it "Should be backwards compatible with sequences" do
+      Mastercoin::SimpleSend.new.get_sequence("1CcJFxoEW5PUwesMVxGrq6kAPJ1TJsSVqq").should eq(126)
+    end
+  end
+
+  context "Encoding and decoding public keys" do
+    it "Should accept all options for a SimpleSend transaction" do
+      @simple_send.currency_id.should eq(2)
+      @simple_send.amount.should eq(50)
+      @simple_send.receiving_address.should eq("184mQaxRYwiU2jqUE852FZGQvbZyRhcDSu")
+      @simple_send.transaction_type.should eq(Mastercoin::TRANSACTION_SIMPLE_SEND)
+    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") 
+    end
+
+    it "Should be a valid ECDSA point" do
+      public_key = @simple_send.encode_to_compressed_public_key
+      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[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.amount.should eq(50)
+      simple_send.transaction_type.should eq(Mastercoin::TRANSACTION_SIMPLE_SEND)
+      simple_send.public_key_sequence.should eq(1)
+    end
+  end
+end