dropzone_ruby 0.1

data/lib/dropzone/listing.rb

@@ -0,0 +1,64 @@
+module Dropzone
+  class Listing < RecordBase
+    include StateAccumulator
+
+    attr_reader :txid, :create_item
+
+    self.message_types = 'ITUPDT'
+
+    state_attr :description, :price_currency, :price_in_units, :expiration_in
+
+    def initialize(txid)
+      @txid = txid
+
+      item = Item.find txid
+      @create_item = item if item && item.valid? && item.message_type == 'ITCRTE'
+
+      if create_item
+        attrs_from create_item
+
+        messages(start_block: create_item.block_height).reverse.each{ |item| 
+          attrs_from item if item.create_txid == txid}
+      end
+    end
+
+    def found?
+      !@create_item.nil?
+    end
+
+    def expiration_at
+      create_item.block_height+expiration_in
+    end
+    
+    def addr; from_create :sender_addr; end
+    def latitude; from_create :latitude; end
+    def longitude; from_create :longitude; end
+    def radius; from_create :radius; end
+
+    def seller_profile
+      @seller_profile ||= SellerProfile.new addr if addr
+    end
+
+    private
+
+    def from_create(attr)
+      create_item.send attr if create_item
+    end
+  end
+
+  class Listing::Validator < ValidatorBase
+    validate :must_have_active_seller
+    validate :must_have_created_item
+
+    def must_have_active_seller(listing)
+      errors.add :seller_profile, "invalid or missing" if ( 
+        listing.seller_profile.nil? || !listing.seller_profile.valid? || 
+        !listing.seller_profile.active? )
+    end
+
+    def must_have_created_item(listing)
+      errors.add :create_item, "invalid or missing" unless (
+        listing.create_item && listing.create_item.valid? )
+    end
+  end
+end

data/lib/dropzone/message_base.rb

@@ -0,0 +1,178 @@
+module Dropzone
+  module MessageValidations
+    def self.included(base)
+      base.validates :receiver_addr, presence: true
+    end
+  end
+
+  module ProfileValidations
+    def self.included(base)
+      base.validates :receiver_addr, equals_attribute: { attribute: :sender_addr }, 
+        unless: "self.transfer_pkey", if: "self.sender_addr"
+
+      base.validates :transfer_pkey, equals_attribute: { attribute: :receiver_addr,
+        unless: "self.transfer_pkey.nil? || self.transfer_pkey == 0" }
+    end
+  end
+
+  module BillingValidations
+    def self.included(base)
+      base.validates :receiver_addr, doesnt_equal_attribute: { attribute: :sender_addr }, 
+        if: "self.sender_addr"
+    end
+  end
+
+  class MessageBase < RecordBase
+    DEFAULT_TIP = 20_000
+
+    attr_reader :receiver_addr, :sender_addr, :message_type, :block_height, :txid
+
+    def initialize(attrs = {})
+      data = attrs.delete(:data)
+
+      attrs.merge(data_hash_from_hex(data)).each do |attr, value|
+        instance_variable_set '@%s' % attr, value
+      end
+    end
+
+    def save!(private_key)
+      self.blockchain.save! to_transaction, private_key
+    end
+
+    def to_transaction
+      {receiver_addr: receiver_addr, data: data_to_hex, 
+        tip: MessageBase.default_tip }
+    end
+
+    def data_to_hex
+      data_to_hash.inject(message_type.dup) do |ret, (key, value)|
+        value_hex = case
+          when value.nil?
+            nil
+          when self.class.is_attr_int?(key)
+            Bitcoin::Protocol.pack_var_int(value.to_i)
+          when self.class.is_attr_pkey?(key)
+            Bitcoin::Protocol.pack_var_string(
+              (value == 0) ? 0.chr : 
+                [anynet_for_address(:hash160_from_address, value)].pack('H*'))
+          else
+            Bitcoin::Protocol.pack_var_string([value.to_s].pack('a*'))
+        end 
+
+        (value_hex.nil?) ? ret : 
+          ret << Bitcoin::Protocol.pack_var_string(key.to_s) << value_hex
+      end
+    end
+
+    def data_to_hash
+      self.class.message_attribs.inject({}) do |ret , (short, full)|
+        ret.merge(short => self.send(full))
+      end
+    end
+
+    private
+
+    def anynet_for_address(method, addr)
+      start_network = Bitcoin.network_name
+
+      begin
+        Bitcoin.network = (/\A1/.match addr) ? :bitcoin : :testnet3
+
+        return Bitcoin.send(method, addr)
+      ensure
+        Bitcoin.network = start_network
+      end
+    end
+
+    def data_hash_from_hex(data)
+      return {} unless /\A(.{6})(.*)/m.match data
+
+      message_type, pairs, data = $1, $2, {}
+
+      while(pairs.length > 0) do 
+        short_key, pairs = Bitcoin::Protocol.unpack_var_string(pairs)
+
+        value, pairs = (self.class.is_attr_int? short_key.to_sym) ? 
+          Bitcoin::Protocol.unpack_var_int(pairs) :
+          Bitcoin::Protocol.unpack_var_string(pairs)
+
+        if self.class.is_attr_pkey?(short_key.to_sym) && value
+          value = (value == 0.chr) ? 0 : 
+            anynet_for_address(:hash160_to_address, value.unpack('H*')[0])
+        end
+
+        full_key = self.class.message_attribs[short_key.to_sym]
+        data[full_key] = value
+      end
+
+      data
+    end
+
+    class << self
+      attr_writer :default_tip
+
+      def default_tip
+        @default_tip || DEFAULT_TIP
+      end
+
+      def message_attribs
+        @message_attribs
+      end
+
+      def is_attr_int?(attr)
+        @message_integers && @message_integers.include?(attr)
+      end
+
+      def is_attr_pkey?(attr)
+        @message_pkeys && @message_pkeys.include?(attr)
+      end
+
+      def message_type(type)
+        @types_include ||= [type]
+
+        define_method(:message_type){ type }
+      end
+
+      def attr_message(attribs)
+        @message_attribs ||= {}
+        @message_attribs.merge! attribs 
+
+        attribs.each{ |short_attr, full_attr| attr_reader full_attr }
+      end
+
+      def attr_message_int(attribs)
+        @message_integers ||= []
+        @message_integers += attribs.keys
+
+        attr_message attribs
+      end
+
+      def attr_message_pkey(attribs)
+        @message_pkeys ||= []
+        @message_pkeys += attribs.keys
+
+        attr_message attribs
+      end
+
+      def find(txid)
+        tx = RecordBase.blockchain.tx_by_id txid
+        tx ? self.new(tx) : nil
+      end
+
+      def types_include?(type)
+        @types_include && @types_include.include?(type)
+      end
+
+      def new_message_from(tx)
+        @messages ||= ObjectSpace.each_object(Class).select {|klass| 
+          klass < Dropzone::MessageBase }
+
+        if /\A([a-z0-9]{6})/i.match tx[:data]
+          message_klass = @messages.find{|klass| klass.types_include? $1}
+          (message_klass) ? message_klass.new(tx) : nil
+        end
+      end
+
+    end
+  end
+end

data/lib/dropzone/payment.rb

@@ -0,0 +1,36 @@
+module Dropzone
+  class Payment < MessageBase
+    attr_message d: :description, t: :invoice_txid
+    attr_message_int q: :delivery_quality,  p: :product_quality, 
+      c: :communications_quality
+
+    def invoice
+      @invoice ||= Invoice.find invoice_txid if invoice_txid
+    end
+
+    message_type 'INPAID'
+  end
+
+  class Payment::Validator < ValidatorBase
+    include MessageValidations
+    include BillingValidations
+
+    validates :message_type, format: /\AINPAID\Z/
+
+    validates_if_present :description, is_string: true
+    validates_if_present :invoice_txid, is_string: true
+
+    [:delivery_quality,:product_quality,:communications_quality ].each do |attr|
+      validates_if_present attr, integer: true, inclusion: 0..8
+    end
+    
+    validate :must_have_corresponding_invoice
+
+    def must_have_corresponding_invoice(payment)
+      invoice = payment.invoice
+
+      errors.add :invoice_txid, "can't be found" if ( invoice.nil? || 
+        !invoice.valid? || (invoice.sender_addr != payment.receiver_addr) )
+    end
+  end
+end

data/lib/dropzone/profile.rb

@@ -0,0 +1,86 @@
+module Dropzone
+  class Profile < RecordBase
+    include StateAccumulator
+
+    attr_reader :addr, :transfer_pkey, :prior_profile
+
+    def initialize(addr)
+      @addr = addr
+
+      messages.reverse.each_with_index do |seller, i|
+        # There is a bit of extra logic if the seller profile was transferred
+        # from elsewhere
+        if i == 0 && seller.transfer_pkey
+          # Load the profile from the prior address and pop it off the stack
+          @prior_profile = self.class.new seller.sender_addr
+
+          # It's possible the prior profile was invalid
+          break unless @prior_profile.valid?
+
+          # And it's possible the prior profile was deactivated or not
+          # transferred to us:
+          break unless @prior_profile.transfer_pkey == addr
+
+          attrs_from @prior_profile
+        else
+          # This prevents a second inbound transfer from happening:
+          next if seller.transfer_pkey == addr 
+
+          # In case they transferred away :
+          @transfer_pkey = seller.transfer_pkey
+
+          attrs_from seller
+        end
+
+        break if @transfer_pkey
+      end
+    end
+
+    def closed?; (@transfer_pkey == 0); end
+    def active?; @transfer_pkey.nil? end
+    def found?; messages.length > 0; end
+  end
+
+  module ValidateProfile
+    def self.included(base)
+      base.validate :must_have_declaration
+      base.validate :prior_profile_is_valid
+      base.validate :prior_profile_transferred_to_us
+    end
+
+    def must_have_declaration(profile)
+      errors.add :addr, "profile not found" unless profile.messages.length > 0
+    end
+
+    def prior_profile_is_valid(profile)
+      if profile.prior_profile && !profile.prior_profile.valid?
+        errors.add :prior_profile, "invalid"
+      end 
+    end
+
+    def prior_profile_transferred_to_us(profile)
+      if profile.prior_profile && profile.prior_profile.transfer_pkey != profile.addr
+        errors.add :prior_profile, "invalid transfer or closed"
+      end 
+    end
+  end
+
+  # A profile is different than a Seller message, as it's the concatenation of
+  # Seller messages, and is missing the transfer and sender_addr. 
+  class SellerProfile < Profile
+    self.message_types = 'SLUPDT'
+
+    state_attr :description, :alias, :communications_pkey
+
+    class Validator < ValidatorBase; include ValidateProfile; end
+  end
+
+  class BuyerProfile < Profile
+    self.message_types = 'BYUPDT'
+
+    state_attr :description, :alias
+
+    class Validator < ValidatorBase; include ValidateProfile; end
+  end
+
+end

data/lib/dropzone/record_base.rb

@@ -0,0 +1,34 @@
+module Dropzone
+  class ValidatorBase
+    IS_STRING = /\A.+\Z/
+
+    include Veto.validator
+
+    def self.validates_if_present(attr, options)
+      validates attr, options.merge({unless: "self.%s.nil?" % attr.to_s})
+    end
+  end
+
+  # This lets us set connection parameters across the entire library. 
+  # A cattr_inheritable-esque implementation  might be worth adding at some point.
+  class RecordBase
+    def blockchain; 
+      RecordBase.blockchain
+    end
+
+    def valid?; validator.valid? self; end
+
+    def errors
+      validator.valid? self
+      validator.errors
+    end
+
+    private 
+
+    def validator; @validator ||= self.class.const_get(:Validator).new; end
+
+    class << self
+      attr_accessor :blockchain
+    end
+  end
+end

data/lib/dropzone/seller.rb

@@ -0,0 +1,21 @@
+module Dropzone
+  class Seller < MessageBase
+    message_type 'SLUPDT'
+
+    attr_message d: :description, a: :alias
+    attr_message_pkey t: :transfer_pkey, p: :communications_pkey
+  end
+
+  class Seller::Validator < ValidatorBase
+    include MessageValidations
+    include ProfileValidations
+
+    validates :message_type, format: /\ASLUPDT\Z/
+
+    validates_if_present :description, is_string: true
+    validates_if_present :alias, is_string: true
+
+    validates_if_present :communications_pkey, is_pkey: true
+    validates_if_present :transfer_pkey, is_pkey: true
+  end
+end

data/lib/dropzone/session.rb

@@ -0,0 +1,161 @@
+module Dropzone
+  class Session
+    CIPHER_ALGORITHM = 'AES-256-CBC'
+
+    class Unauthenticated < StandardError; end
+    class MissingReceiver < StandardError; end
+    class InvalidWithReceiver < StandardError; end
+    class DerAlreadyExists < StandardError; end
+    class InvalidCommunication < StandardError; end
+    class SessionInvalid < StandardError; end
+
+    attr_accessor :priv_key, :receiver_addr, :session_key, :with, :end_block
+
+    def initialize(priv_key, session_secret, options = {})
+      @priv_key, @session_key = priv_key, OpenSSL::BN.new(session_secret, 16)
+      @end_block = options[:end_block] if options.has_key? :end_block
+
+      # Either you attach to an existing session, or create a new one
+      case 
+        when options.has_key?(:receiver_addr)
+          # New Session:
+          @receiver_addr = options[:receiver_addr]
+        when options.has_key?(:with)
+          # Existing Session:
+          raise InvalidWithReceiver unless options[:with].receiver_addr == sender_addr
+          @with = options[:with]
+          @receiver_addr = @with.sender_addr
+        else
+          raise MissingReceiver
+      end
+    end
+
+    def blockchain; self.class.blockchain; end
+    def sender_addr; blockchain.privkey_to_addr priv_key; end
+
+    # Iv passing is supported only for the purpose of making tests completely 
+    # deterministic
+    def send(contents, iv = nil)
+      raise Unauthenticated unless authenticated?
+ 
+      # Cipher Setup:
+      aes = OpenSSL::Cipher::Cipher.new CIPHER_ALGORITHM
+      aes.encrypt
+      
+      iv ||= aes.random_iv
+      aes.iv = iv
+
+      aes.key = symm_key
+
+      # Encrypt Time:
+      cipher = aes.update contents
+      cipher << aes.final
+
+      communicate! contents: cipher.to_s, iv: iv
+    end
+
+    alias :<< :send
+
+    def authenticate!(der = nil)
+      is_init = (communication_init.nil? || authenticated?)
+
+      # If we're already authenticated, we'll try to re-initialize. Presumably
+      # one would want to do this if they lost a secret key, or that key were
+      # somehow compromised
+      if is_init
+        dh = OpenSSL::PKey::DH.new(der || 1024)
+     else
+        raise DerAlreadyExists unless der.nil?
+        dh = OpenSSL::PKey::DH.new with.der
+      end
+
+      dh.priv_key = session_key
+      dh.generate_key! 
+
+      communicate! session_pkey: [dh.pub_key.to_s(16)].pack('H*'),
+        der: (is_init) ? dh.public_key.to_der : nil
+    end
+
+    def symm_key
+      return @symm_key if @symm_key
+
+      # If we can't compute, then it's ok to merely indicate this:
+      return nil unless communication_init && communication_auth
+
+      dh = OpenSSL::PKey::DH.new communication_init.der
+      dh.priv_key = session_key
+      dh.generate_key!
+
+      @symm_key = dh.compute_key OpenSSL::BN.new(
+        their_pkey.session_pkey.unpack('H*').first, 16)
+    end
+
+    def authenticated?
+      communication_init && communication_auth
+    end
+
+    def communication_init
+      # NOTE that this returns the newest initialization
+      commun_messages.find(&:is_init?)
+    end
+
+    # This is the response to the init
+    def communication_auth
+      # NOTE that this returns the newest auth, or nil if we encounter an init
+      commun_messages.find{|c| 
+        break if c.is_init?
+        c.is_auth? }
+    end
+
+    def their_pkey
+      [communication_init, communication_auth].find{|c| 
+        c.sender_addr == receiver_addr && c.receiver_addr == sender_addr }
+    end
+
+    def communications
+      if authenticated?
+        communications = commun_messages(
+          start_block: communication_init.block_height ).reject(&:is_auth?)
+        communications.each{|c| c.symm_key = symm_key}    
+        communications
+      else
+        []
+      end
+    end
+
+    private
+
+    # Addr's of who this conversation is between
+    def between
+      [sender_addr, receiver_addr]
+    end
+
+    def commun_messages(options = {})
+      options[:type] = 'COMMUN'
+      options[:end_block] = @end_block if @end_block
+      options[:between] = between
+      blockchain.messages_by_addr(sender_addr, options)
+    end
+
+    def communicate!(attrs)
+      comm = Communication.new( {receiver_addr: receiver_addr, 
+        sender_addr: sender_addr}.merge(attrs) )
+
+      raise InvalidCommunication unless comm.valid?
+      
+      comm.save! priv_key
+    end
+
+    class << self
+      attr_writer :blockchain 
+
+      def blockchain
+        @blockchain || Dropzone::RecordBase.blockchain
+      end
+
+      def all(addr)
+        blockchain.messages_by_addr(addr, type: 'COMMUN').find_all(&:is_init?)
+      end
+    end
+  end
+end