dropzone_ruby 0.1

data/lib/dropzone/communication.rb

@@ -0,0 +1,43 @@
+module Dropzone
+  class Communication < MessageBase
+    class NoSymmKey < StandardError; end
+
+    attr_message i: :iv, c: :contents, d: :der, p: :session_pkey
+
+    message_type 'COMMUN'
+
+    attr_accessor :symm_key
+
+    def contents_plain
+      raise NoSymmKey unless symm_key
+
+      aes = OpenSSL::Cipher::Cipher.new Session::CIPHER_ALGORITHM
+      aes.decrypt
+      aes.key = symm_key
+      aes.iv = iv
+
+      aes.update(contents) + aes.final
+    end
+
+    def is_init?; (der && session_pkey); end
+    def is_auth?; !session_pkey.nil?; end
+  end
+
+  class Communication::Validator < ValidatorBase
+    validates :message_type, format: /\ACOMMUN\Z/
+
+    validates_if_present :der, is_string: true
+    validates_if_present :session_pkey, is_string: true
+    validates_if_present :contents, is_string: true
+    validates_if_present :iv, is_string: true
+
+    # Ders always need session_pkey:
+    validates :session_pkey, not_null: true, unless: 'self.der.nil?'
+
+    # Content always needs an iv:
+    validates :iv, not_null: true, unless: 'self.contents.nil?'
+
+    # We should always have either contents or a pkey:
+    validates :contents, not_null: true, if: 'self.session_pkey.nil?'
+  end
+end

data/lib/dropzone/connection.rb

@@ -0,0 +1,312 @@
+module Dropzone
+  class BitcoinConnection
+    class WalletFundsTooLowOrNoUTXOs < StandardError; end
+
+    SATOSHIS_IN_BTC = 100_000_000
+
+    TXO_DUST = 5430 # 0.0000543 BTC
+
+    PREFIX = 'DZ'
+
+    attr_reader :bitcoin
+
+    def initialize(network, options = {})
+      @network = network
+      @bitcoin = options[:bitcoin] if options.has_key? :bitcoin
+      @is_testing = (/\Atestnet/.match network.to_s) ? true : false
+      @bitcoin ||= BlockrIo.new is_testing?
+    end
+
+    def is_testing?; @is_testing; end
+
+    def privkey_to_addr(key) 
+      set_network_mode!
+      Bitcoin::Key.from_base58(key).addr
+    end
+
+    def hash160_to_address(hash160) 
+      set_network_mode!
+      Bitcoin.hash160_to_address hash160
+    end
+
+    def hash160_from_address(addr)
+      set_network_mode!
+      Bitcoin.hash160_from_address addr
+    end
+
+    def valid_address?(addr) 
+      set_network_mode!
+      Bitcoin.valid_address? addr
+    end
+
+    # NOTE: 
+    #  - This needs to return the messages in Descending order by block
+    #    In the case that two transactions are in the same block, it goes by time
+    #  - This should only 'valid' return messages. Not transactions
+    def messages_by_addr(addr, options = {})
+      ret = cache.listtransactions addr, true, is_testing? if cache
+
+      unless ret
+        ret = bitcoin.listtransactions addr, true
+        cache.listtransactions! addr, true, ret, is_testing? if cache
+      end
+
+      ret = ret.collect{ |tx_h|
+        begin
+          msg = Dropzone::MessageBase.new_message_from tx_by_id(tx_h['tx'])
+
+          (msg && msg.valid?) ? msg : nil
+        rescue Counterparty::TxDecode::InvalidOutput,
+          Counterparty::TxDecode::MultisigUnsupported
+          next
+        end
+      }.compact
+
+      filter_messages ret, options
+    end
+
+    def messages_in_block(at_height, options = {})
+      ret = bitcoin.getblock(at_height).collect{ |tx_h|
+
+        # This is a speed hack that drastically reduces query times:
+        next if options[:type] == 'ITCRTE' && !tx_h_create?(tx_h)
+
+        begin
+          msg = Dropzone::MessageBase.new_message_from tx_by_id( tx_h['tx'], 
+            block_height: at_height )
+
+          (msg && msg.valid?) ? msg : nil
+        rescue Counterparty::TxDecode::InvalidOutput,
+          Counterparty::TxDecode::MultisigUnsupported,
+          Counterparty::TxDecode::UndefinedBehavior,
+          Counterparty::TxDecode::InvalidOpReturn
+          next
+        end
+      }.compact
+
+      filter_messages ret, options
+    end
+
+    def send_value(from_key, to_addr, send_satoshis, tip_satoshis)
+      set_network_mode!
+
+      new_tx = create_tx(from_key, send_satoshis+tip_satoshis){ |tx, allocated|
+        [ [send_satoshis, Bitcoin.hash160_from_address(to_addr)],
+          [(allocated-send_satoshis-tip_satoshis), from_key.hash160]
+        ].each do |(amt, to)|
+          tx.add_out Bitcoin::P::TxOut.new( amt,
+            Bitcoin::Script.to_hash160_script(to) )
+        end
+      }
+
+      sign_and_send new_tx, from_key
+    end
+
+    def sign_tx(tx, key)
+      set_network_mode!
+
+      # Sign the transaction:
+      tx.inputs.length.times do |i|
+        # Fetch the previous input:
+        prev_out_tx_hash = tx.inputs[i].prev_out.reverse.unpack('H*').first
+        prev_tx_raw = bitcoin.getrawtransaction(prev_out_tx_hash)['hex']
+        prev_tx = Bitcoin::P::Tx.new [prev_tx_raw].pack('H*')
+        
+        # Now we actually sign
+        sig = Bitcoin.sign_data Bitcoin.open_key(key.priv), 
+          tx.signature_hash_for_input(i, prev_tx)
+        tx.in[i].script_sig = Bitcoin::Script.to_signature_pubkey_script( sig, 
+          [key.pub].pack("H*"))
+      end
+      tx
+    end
+
+    def tx_by_id(id, options = {})
+      set_network_mode!
+
+      ret = cache.tx_by_id id, is_testing? if cache
+
+      unless ret
+        tx_h = bitcoin.getrawtransaction(id)
+        tx = Bitcoin::P::Tx.new [tx_h['hex']].pack('H*')
+    
+        if tx_h.has_key? 'blockhash'
+          options[:block_height] = bitcoin.getblockinfo(tx_h['blockhash'])['nb']
+        end
+
+        record = Counterparty::TxDecode.new tx,
+          prefix: Dropzone::BitcoinConnection::PREFIX
+
+        ret = options.merge({ data: record.data, 
+          receiver_addr: record.receiver_addr, 
+          txid: id,
+          sender_addr: record.sender_addr})
+
+        # NOTE that in the case of a reorg, this might have incorrect block
+        # heights cached. It's probable that we can/should cache these, and 
+        # merely set the block height when it's confirmed, and/or set the
+        # height to current_height+1
+        cache.tx_by_id! id, ret, is_testing? if cache && options[:block_height]
+      end
+
+      ret
+    end
+
+    def save!(data, private_key_wif)
+      set_network_mode!
+
+      from_key = Bitcoin::Key.from_base58 private_key_wif
+      
+      # We need to know how many transactions we'll have in order to know how
+      # many satoshi's to allocate. We start with 1, since that's the return
+      # address of the allocated input satoshis
+      data_outputs_needed = 1
+
+      bytes_in_output = Counterparty::TxEncode::BYTES_IN_MULTISIG
+
+      # 3 is for the two-byte DZ prefix, and the 1-byte length
+      data_outputs_needed += ((data[:data].length+3) / bytes_in_output).ceil
+
+      # We'll need a P2PSH for the destination if that applies
+      data_outputs_needed += 1 if data.has_key? :receiver_addr
+      tip = data[:tip] || 0
+
+      new_tx = create_tx(from_key,data_outputs_needed * TXO_DUST+tip) do |tx, amount_allocated|
+        outputs = Counterparty::TxEncode.new( 
+          [tx.inputs[0].prev_out.reverse_hth].pack('H*'),
+          data[:data], receiver_addr: data[:receiver_addr],
+          sender_pubkey: from_key.pub, prefix: PREFIX).to_opmultisig
+
+        outputs.each_with_index do |output,i|
+          tx.add_out Bitcoin::P::TxOut.new( (i == (outputs.length-1)) ? 
+            (amount_allocated - tip - TXO_DUST*(outputs.length - 1)) : TXO_DUST,
+            Bitcoin::Script.binary_from_string(output) )
+        end
+      end
+
+      sign_and_send new_tx, from_key
+    end
+
+    def block_height
+      bitcoin.getblockinfo('last')['nb']
+    end
+
+    private
+
+    def filter_messages(messages, options = {})
+      messages = messages.find_all{|msg| 
+        msg.block_height.nil? || (msg.block_height >= options[:start_block])
+      } if options[:start_block]
+
+      messages = messages.find_all{|msg| 
+        msg.block_height.nil? || (msg.block_height <= options[:end_block])
+      } if options[:end_block]
+
+      if messages && options.has_key?(:type)
+        messages = messages.find_all{|msg| msg.message_type == options[:type]} 
+      end
+
+      if options.has_key?(:between)
+        messages = messages.find_all{|c|
+          [c.receiver_addr, c.sender_addr].all?{|a| options[:between].include?(a) } }
+      end
+
+      (messages) ? messages : []
+    end
+
+
+    # This is a speed hack which keeps us from traversing through entire blocks
+    # by filtering based on the destination addresses
+    def tx_h_create?(tx_h)
+      address = tx_h['out'][0]['addr'] if [ 
+        tx_h.has_key?('out'), tx_h['out'][0], tx_h['out'][0]['addr'] ].all?
+
+      (address && Dropzone::Item::HASH_160_PARTS.match(address)) ? true : false
+    end
+
+    # Since the Bitcoin object is a singleton, and we'll be working alongside
+    # testnet, we need to start our methods by setting the correct network mode
+    def set_network_mode!
+      Bitcoin.network = @network
+    end
+
+    def sign_and_send(tx, key)
+      signed_hex = sign_tx(tx, key).to_payload.unpack('H*')[0]
+
+      bitcoin.sendrawtransaction signed_hex
+    end
+
+    def create_tx(key, allocate, &block)
+      # create a new transaction (and sign the inputs)
+      tx = Bitcoin::P::Tx.new(nil)
+      tx.ver, tx.lock_time = 1, 0
+
+      # allocate some inputs here:
+      amount_allocated = 0
+      allocate_inputs_for(key.addr, allocate).each do |unspent|
+        amount_allocated += to_satoshis(unspent['amount'])
+        tx.add_in Bitcoin::P::TxIn.new [unspent['tx'] ].pack('H*').reverse, 
+          unspent['n'].to_i
+      end
+
+      block.call(tx, amount_allocated)
+
+      tx
+    end
+
+    # We expect the amount to be in satoshis. As-is this method does not allocate
+    # mempool utxos for a spend.
+    def allocate_inputs_for(addr, amount)
+      allocated = 0
+
+      # NOTE: I think we're issuing more queries here than we should be due to a
+      # fetch for every utxo, instead of one fetch for every transaction. 
+      # (Which may have many utxo's per transaction.)
+      mempooled_utxos = bitcoin.listunconfirmed(addr).collect{|tx|
+        # Note that some api's may not retrieve the contents of an unconfirmed
+        # raw transaction.
+        unconfirmed_tx = bitcoin.getrawtransaction(tx['tx'])['hex']
+
+        if unconfirmed_tx
+          tx = Bitcoin::P::Tx.new [unconfirmed_tx].pack('H*')
+          tx.inputs.collect{|input| input.prev_out.reverse.unpack('H*').first}
+        else
+          nil
+        end
+      }.compact.flatten.uniq
+
+      utxos = []
+      bitcoin.listunspent(addr).sort_by{|utxo| utxo['confirmations']}.each{|utxo|
+        next if mempooled_utxos.include? utxo['tx'] 
+        utxos << utxo
+        allocated += to_satoshis(utxo['amount'])
+        break if allocated >= amount
+      }
+
+      raise WalletFundsTooLowOrNoUTXOs if allocated < amount
+
+      utxos
+    end
+
+    def to_satoshis(string)
+      self.class.to_satoshis string
+    end
+
+    def is_opreturn?(output)
+      /\AOP_RETURN/.match output
+    end
+
+    def self.to_satoshis(string)
+      (BigDecimal.new(string) * SATOSHIS_IN_BTC).to_i
+    end
+
+    def cache
+      self.class.cache
+    end
+
+    class << self
+      # This is a hook to speed up some operations via a local cache
+      attr_accessor :cache
+    end
+  end
+end

data/lib/dropzone/invoice.rb

@@ -0,0 +1,23 @@
+module Dropzone
+  class Invoice < MessageBase
+    attr_message_int p: :amount_due, e: :expiration_in
+
+    message_type 'INCRTE'
+
+    def payments
+      blockchain.messages_by_addr(sender_addr, type: 'INPAID', 
+        start_block: block_height).find_all{|p| p.invoice_txid == txid }
+    end
+  end
+
+  class Invoice::Validator < ValidatorBase
+    include MessageValidations
+    include BillingValidations
+
+    validates :message_type, format: /\AINCRTE\Z/
+
+    [:amount_due, :expiration_in].each do |attr|
+      validates_if_present attr, integer: true, greater_than_or_equal_to: 0
+    end
+  end
+end

data/lib/dropzone/item.rb

@@ -0,0 +1,160 @@
+module Dropzone
+  class Item < MessageBase
+    EARTH_RADIUS_IN_METERS = 6_371_000
+
+    HASH_160_PARTS = /\A(?:mfZ|1DZ)([1-9X]{9})([1-9X]{9})([1-9X]{6}).+/
+
+    attr_message d: :description, c: :price_currency, t: :create_txid
+    attr_message_int p: :price_in_units, e: :expiration_in
+
+    # These are receiver address attributes, not message attribs:
+    attr_reader :latitude, :longitude, :radius
+
+    @types_include = ['ITUPDT', 'ITCRTE']
+
+    def latitude
+      (@receiver_addr) ? 
+        integer_to_latlon( address_parts(@receiver_addr, 0) ) : 
+        @latitude
+    end
+
+    def longitude
+      (@receiver_addr) ? 
+        integer_to_latlon( address_parts(@receiver_addr, 1), 180 ) : 
+        @longitude
+    end
+
+    def radius
+      (@receiver_addr) ? 
+        address_parts(@receiver_addr, 2) : 
+        @radius
+    end
+
+    def message_type
+      return @message_type if @message_type 
+
+      create_txid ? 'ITUPDT' : 'ITCRTE'
+    end
+
+    # This is an easy guide to what we're doing here:
+    # http://www.reddit.com/r/Bitcoin/comments/2ss3en/calculating_checksum_for_bitcoin_address/
+    #
+    # NOTE: There was a digit off in the reference spec, this radius is a seven
+    #       digit number, not an eight digit number.
+    def receiver_addr
+      case 
+        when @receiver_addr then @receiver_addr
+        when create_txid then @sender_addr
+        when latitude && longitude && radius
+          receiver_addr_base = ('%s%09d%09d%06d' % [
+            (blockchain.is_testing?) ? 'mfZ' : ('1' + BitcoinConnection::PREFIX),
+            latlon_to_integer(latitude.to_f), 
+            latlon_to_integer(longitude.to_f, 180), 
+            radius.abs ]).tr('0','X')
+
+          # The x's pad the checksum component for us to ensure the base conversion
+          # produces the correct output. Similarly, we ignore them after the decode:
+          hex_address = Bitcoin.decode_base58(receiver_addr_base+'XXXXXXX')[0...42]
+
+          hash160 = [hex_address].pack('H*')
+           
+          # Bitcoin-ruby has a method to do much of this for us, but it is 
+          # broken in that it only supports main-net addresses, and not testnet3
+          checksum = Digest::SHA256.digest(Digest::SHA256.digest(hash160))[0,4]
+       
+          # Return the checksum'd receiver_addr
+          Bitcoin.encode_base58((hash160 + checksum).unpack('H*').first)
+        else 
+          nil
+      end
+    end
+
+    def self.blockchain
+      Dropzone::RecordBase.blockchain
+    end
+
+    # Returns all *Items created* since (and including) the provided block
+    # These are items and not listings, so as to query faster.
+    # Items are returned in the order of newest to oldest
+    def self.find_creates_since_block(starting_at, block_depth, &block)
+      starting_at.downto(starting_at-block_depth).collect{|i|
+        blockchain.messages_in_block(i, type: 'ITCRTE').collect do |item|
+          (block_given?) ? block.call(item, i) : item
+        end
+      }.flatten.compact
+    end
+
+    def self.find_in_radius(starting_at, block_depth, lat, long, in_meters, &block)
+      find_creates_since_block(starting_at, block_depth) do |item, nb|
+        if distance_between(item.latitude, item.longitude, lat, long) <= in_meters 
+          (block_given?) ? block.call(item, nb) : item
+        end
+      end
+    end
+
+    # haversine formula, pulled from :
+    # http://www.movable-type.co.uk/scripts/latlong.html
+    def self.distance_between(lat1, lon1, lat2, lon2)
+      delta_phi = to_rad(lat2-lat1)
+      delta_lamba = to_rad(lon2-lon1)
+
+      a = Math.sin(delta_phi/2) ** 2 + [ Math.cos(to_rad(lat1)), 
+        Math.cos(to_rad(lat2)), Math.sin(delta_lamba/2), 
+        Math.sin(delta_lamba/2) ].reduce(:*)
+
+      c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
+
+      EARTH_RADIUS_IN_METERS * c
+    end
+
+    def self.to_rad(angle)
+      angle.to_f / 180 * Math::PI
+    end
+
+    private
+
+    def address_parts(addr, part)
+      parts = HASH_160_PARTS.match(addr)
+      (parts.length > 0) ? parts[part+1].tr('X','0').to_i : nil
+    end
+
+    def latlon_to_integer(lat_or_lon, unsigned_offset = 90)
+      ((lat_or_lon + unsigned_offset) * 1_000_000).floor.abs unless lat_or_lon.nil?
+    end
+
+    def integer_to_latlon(lat_or_lon, unsigned_offset = 90)
+      (BigDecimal.new(lat_or_lon) / 1_000_000 - unsigned_offset).to_f unless lat_or_lon.nil?
+    end
+  end
+
+  class Item::Validator < ValidatorBase
+    include MessageValidations
+
+    validates :receiver_addr, equals_attribute: { attribute: :sender_addr }, 
+      if: "self.sender_addr && self.create_txid"
+
+    validates :latitude, numeric: true, unless: 'create_txid'
+    validates_if_present :latitude, greater_than_or_equal_to: -90, if: 'create_txid.nil?'
+    validates_if_present :latitude, less_than_or_equal_to: 90, if: 'create_txid.nil?'
+
+    validates :longitude, numeric: true, unless: 'create_txid'
+    validates_if_present :longitude, greater_than_or_equal_to: -180, if: 'create_txid.nil?'
+    validates_if_present :longitude, less_than_or_equal_to: 180, if: 'create_txid.nil?'
+
+    validates :radius, integer: true, unless: 'create_txid'
+    validates_if_present :radius, greater_than_or_equal_to: 0, if: 'create_txid.nil?'
+    validates_if_present :radius, less_than: 1000000, if: 'create_txid.nil?'
+
+    validates :message_type, format: /\AIT(?:CRTE|UPDT)\Z/
+
+    validates :price_currency, is_string: { 
+      message: 'is required if price is specified' },
+      unless: "price_in_units.nil? || create_txid"
+
+    validates_if_present :description, is_string: true
+    validates_if_present :price_in_units, integer: true, 
+      greater_than_or_equal_to: 0
+    validates_if_present :expiration_in, integer: true, 
+      greater_than_or_equal_to: 0
+  end
+end