dropzone_ruby 0.1

data/dropzone_ruby.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/dropzone/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Miracle Max"]
+  gem.email         = ["17Q4MX2hmktmpuUKHFuoRmS5MfB5XPbhod@mail2tor.com"]
+  gem.summary       = "An Anonymous Peer-To-Peer Local Contraband Marketplace"
+  gem.description   = 'Drop Zone is a solution to the problem of restricted sales in censored markets. The proposal is for the design of a protocol and reference client that encodes the location and a brief description of a good onto The Blockchain. Those wishing to purchase the good can search for items within a user-requested radius. Sellers list a good as available within a geographic region, subject to some degree of precision, for the purpose of obfuscating their precise location. Goods are announced next to an expiration, a hashtag, and if space permits, a description. Once a buyer finds a good in a defined relative proximity, a secure communication channel is opened between the parties on the Bitcoin test network ("testnet"). Once negotiations are complete, the buyer sends payment to the seller via the address listed on the Bitcoin mainnet. This spend action establishes reputation for the buyer, and potentially for the seller. Once paid, the seller is to furnish the exact GPS coordinates of the good to the buyer (alongside a small note such as "Check in the crevice of the tree"). When the buyer successfully picks up the item at the specified location, the buyer then issues a receipt with a note by spending flake to the address of the original post. In this way, sellers receive a reputation score. The solution is akin to that of Craigslist.org or Uber, but is distributed and as such provides nearly risk-free terms to contraband sellers, and drastically reduced risk to contraband buyers.'
+  gem.homepage      = "https://github.com/17Q4MX2hmktmpuUKHFuoRmS5MfB5XPbhod/dropzone_ruby"
+  gem.files         = `git ls-files`.split(/\n/m)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(spec)/})
+  gem.name          = "dropzone_ruby"
+  gem.require_paths = ["lib"]
+  gem.version       = Dropzone::VERSION
+  gem.required_ruby_version = '>= 1.9'
+  gem.license       = 'LGPL'
+
+  gem.add_runtime_dependency 'counterparty_ruby', '~> 1.2'
+  gem.add_runtime_dependency 'commander', '~> 4.3'
+  gem.add_runtime_dependency 'sequel', '~> 4.21'
+  gem.add_runtime_dependency 'sqlite3', '~> 1.3'
+  gem.add_runtime_dependency 'veto', '~> 1.0'
+  gem.add_runtime_dependency 'socksify', '~> 1.7'
+
+  gem.add_development_dependency 'rspec', '~> 3.2'
+  gem.add_development_dependency 'rake', '~> 10.4'
+  gem.add_development_dependency 'rdoc', '~> 4.2'
+  gem.add_development_dependency 'sham', '~> 1.1'
+end
+

data/lib/blockrio_ext.rb

@@ -0,0 +1,52 @@
+require 'time' 
+
+class BlockrIo
+  # NOTE: The blockr Api only shows the most recent 200 transactions on an 
+  # address. Either this method should use the non-API query mode, or an 
+  # alternate API driver will be needed to properly support this method.
+  #
+  # Additionally, this api call returns the block times, but not the relay times
+  # A better api would sort these by relay times.
+  def listtransactions(addr, include_unconfirmed = false)
+    # Confirmed Transactions:
+    ret = json_get('address', 'txs', addr)['data']['txs'].sort_by{|t| 
+      t['confirmations'] }
+
+    if include_unconfirmed
+      unconfirmed = json_get('address', 'unconfirmed', addr)['data']['unconfirmed']
+      # We don't need every output listed, just the tx:
+      unconfirmed.uniq!{|tx_h| tx_h['tx']}
+      ret.unshift(*unconfirmed.sort_by{|t| Time.parse t['time_utc']}.reverse)
+    end
+
+    ret
+  end
+
+  # The blockr.io block/txs method appears to omit some transactions. As such, 
+  # we'll be using blockchain.info for this query.
+  # Ideally, this would work: json_get('block', 'txs', number.to_s)['data']['txs']
+  def getblock(number)
+    block_hash = getblockinfo(number)['hash']
+    
+    resp  = RestClient::Resource.new( [ 'https://blockchain.info', 'block-index', 
+      block_hash ].join('/')+'?format=json' ).get(content_type: 'json')
+
+    raise ResponseError if resp.code != 200
+
+    JSON.parse(resp)['tx'].collect do |tx, i| 
+      {'tx' => tx['hash'], 'out' => tx['out']}
+    end
+  end
+
+  def getbalance(addr)
+    json_get('address', 'balance', addr)['data']['balance']
+  end
+
+  def getrawtransaction(tx_id)
+    json_get('tx', 'raw', tx_id.to_s)['data']['tx']
+  end
+
+  def getblockinfo(hash)
+    json_get('block', 'info', hash)['data']
+  end
+end

data/lib/dropzone/buyer.rb

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

data/lib/dropzone/command.rb

@@ -0,0 +1,488 @@
+require 'sequel'
+
+# This speeds up the CLI considerably, without any opportunity cost, so it's 
+# included for the sake of convenience
+class LocalConnectionCache
+  def initialize
+    config_dir = File.join(Dir.home, ".dropzone")
+    Dir.mkdir config_dir, 0700 unless Dir.exists? config_dir
+
+    @persistence = Sequel.connect 'sqlite://%s/cache.db' % config_dir
+    
+    @persistence.create_table :transactions do
+      primary_key :id
+      String :txid
+      String :receiver_addr
+      String :sender_addr
+      File :data
+      Boolean :is_testing
+      Integer :block_height
+    end unless @persistence.table_exists?(:transactions)
+
+    @transactions = @persistence[:transactions]
+    @listtransactions = {}
+  end
+
+  def tx_by_id(id, is_testing)
+    record_to_tx transactions.where(txid: id, is_testing: is_testing).first
+  end
+
+  def tx_by_id!(id, hash, is_testing)
+    transactions.insert(hash.tap{ |et| 
+      et[:data] = Sequel.blob et[:data] 
+      et[:txid] = id
+      et[:is_testing] = is_testing
+    }).to_s
+  end
+
+  def listtransactions(*key)
+    @listtransactions.has_key?(key) ? @listtransactions[key] : nil
+  end
+
+  def listtransactions!(addr, is_confirmed, value, is_testing)
+    @listtransactions[ [addr, is_confirmed, is_testing] ] = value
+  end
+
+  def invalidate_listtransactions!
+    @listtransactions = {}
+  end
+
+  private
+
+  def record_to_tx(record)
+    record.tap{|r| r.delete(:id) } if record
+  end
+
+  def transactions
+    @transactions
+  end
+end
+
+# This is mostly intended for use by the CLI client, though it's conceivable
+# that others may find it useful in some contexts.
+class DropZoneCommand
+  MAX_TABLE_WIDTH = 80
+
+  class << self
+    def create_command(action, klass, label, *attributes, &block)
+      define_method(action) do |args, options|
+        privkey = privkey_from args
+
+        params = parameterize options, *attributes
+
+        block.call privkey, args, params if block_given?
+
+        message = klass.new params
+
+        txid = message.save! privkey.to_base58
+
+        puts_object '%s: %s' % [label, message.receiver_addr], 'Tx: %s' % txid, attributes, 
+          message
+      end
+    end
+
+    def show_command(action, klass, label, finder, *attributes, &block)
+      define_method(action) do |args, options|
+        id = self.send finder,  args
+        
+        record = (block_given?) ? block.call(klass, id) : klass.new(id)
+
+        if record.respond_to?(:found?) and !record.found?
+          puts "%s Not Found" % label
+        else
+          params = attributes.collect{|attr| [attr,record.send(attr)]}.to_h
+
+          puts_object '%s: %s' % [label, id], nil, attributes, record
+        end
+      end
+    end
+  end
+
+  LISTING_ATTRS = [ :latitude, :longitude, :radius, :price_currency, 
+    :price_in_units, :description, :expiration_in ]
+  PROFILE_ATTRS = [ :alias, :description ]
+  INVOICE_ATTRS = [ :amount_due, :expiration_in ]
+  PAYMENT_ATTRS = [:description, :delivery_quality, :product_quality, 
+    :communications_quality, :invoice_txid ]
+
+  ADDRESS_TO_SELF = lambda{|privkey, args, params|
+    params.merge!(receiver_addr: privkey.addr) }
+
+  RECORD_BY_FIND = lambda{|klass, id| klass.find id }
+
+  show_command :listing_show, Dropzone::Listing, 'Listing', :by_txid, 
+    *LISTING_ATTRS+[:addr]
+
+  show_command :profile_buyer_show, Dropzone::BuyerProfile, 'Buyer', :by_addr,
+    *PROFILE_ATTRS
+
+  show_command :profile_seller_show, Dropzone::SellerProfile, 'Seller',:by_addr,
+    *(PROFILE_ATTRS+[:communications_pkey] )
+
+  show_command :invoice_show, Dropzone::Invoice, 'Invoice', :by_txid,
+    *INVOICE_ATTRS+[:sender_addr, :receiver_addr], &RECORD_BY_FIND
+
+  show_command :review_show, Dropzone::Payment, 'Review',:by_txid,
+    *PAYMENT_ATTRS+[:sender_addr, :receiver_addr], &RECORD_BY_FIND
+
+  create_command :profile_buyer_create, Dropzone::Buyer, 'Buyer', 
+    *(PROFILE_ATTRS+[:transfer_pkey] ), &ADDRESS_TO_SELF
+
+  create_command :profile_seller_create, Dropzone::Seller, 'Seller',
+    *(PROFILE_ATTRS+[:transfer_pkey, :communications_pkey] ), &ADDRESS_TO_SELF
+
+  create_command(:invoice_create, Dropzone::Invoice, 'Invoice',
+    *INVOICE_ATTRS) do |privkey, args, params|
+    receiver_addr = args[1]  if args.length > 1
+
+    raise OptionParser::MissingArgument, 'receiver_addr' unless (
+      receiver_addr && Bitcoin.valid_address?(receiver_addr) )
+
+    params.merge! receiver_addr: receiver_addr
+  end
+
+  create_command(:review_create, Dropzone::Payment, 'Review',
+    *PAYMENT_ATTRS ) do |privkey, args, params|
+    invoice_txid = args[1]  if args.length > 1
+
+    raise OptionParser::MissingArgument, 'invoice_txid' unless invoice_txid
+
+    invoice = Dropzone::Invoice.find invoice_txid
+
+    raise 'Invoice Not Found' unless invoice
+
+    params.merge! receiver_addr: invoice.sender_addr, invoice_txid: invoice_txid
+  end
+
+  create_command( :listing_create, Dropzone::Item, 'Listing', 
+    *LISTING_ATTRS) do |privkey, args, params|
+    %w(longitude latitude radius).each do |attr|
+      raise OptionParser::MissingArgument, attr unless params[attr.to_sym]
+    end
+  end
+
+  create_command( :listing_update, Dropzone::Item, 'Listing', 
+    :description, :price_currency, :price_in_units, 
+    :expiration_in ) do |privkey, args, params|
+
+    create_txid = args[1]  if args.length > 1
+
+    raise OptionParser::MissingArgument, 'create_txid' unless create_txid
+
+    params.merge! receiver_addr: privkey.addr, create_txid: create_txid
+  end
+
+  def initialize(is_spec = false)
+    @is_spec = is_spec
+    network! Bitcoin.network_name
+  end
+
+  attr_reader :connection
+
+  def network!(network_name)
+    unless @is_spec
+      Bitcoin.network = network_name
+      @connection = Dropzone::BitcoinConnection.new network_name
+      Dropzone::RecordBase.blockchain = @connection
+    end
+  end
+
+  def communication_new(args, options)
+    network! :testnet3
+
+    privkey = privkey_from args, :testnet3
+
+    receiver_addr = args[1]  if args.length > 1
+
+    raise OptionParser::MissingArgument, 'addr' unless (
+      receiver_addr && Bitcoin.valid_address?(receiver_addr) )
+
+    session = Dropzone::Session.new privkey.to_base58,
+      secret_for(privkey.addr, receiver_addr),
+      receiver_addr: receiver_addr 
+
+    txid = session.authenticate!
+
+    puts_table '%s: %s' % ['Session', txid], nil, [ 
+      [:sender_addr, privkey.addr], [:receiver_addr, receiver_addr] ]
+  end
+
+  def communication_list(args, options)
+    network! :testnet3
+
+    privkey = privkey_from args, :testnet3
+
+    Dropzone::Session.all(privkey.addr).each do |session|
+      puts_table '%s: %s' % ['Session', session.txid], nil, [ 
+        [:sender_addr, session.sender_addr], 
+        [:receiver_addr, session.receiver_addr] ]
+    end
+  end
+
+  def communication_say(args, options)
+    network! :testnet3
+
+    privkey = privkey_from args, :testnet3
+
+    txid = args[1]  if args.length > 1
+    message = args[2]  if args.length > 2
+
+    raise OptionParser::MissingArgument, 'txid' unless txid
+    raise OptionParser::MissingArgument, 'message' unless message
+
+    comm_init = Dropzone::Communication.find txid
+
+    raise "Invalid Session" unless comm_init && comm_init.is_init?
+
+    session = session_for privkey, comm_init
+
+    if !session.authenticated?
+      if comm_init.sender_addr == privkey.addr
+        raise "The receiver has not yet authenticated your request"
+      else
+        session.authenticate!
+
+        # This allows us to re-query the the session communications, and 
+        # retrive the auth_message we just created.
+        # NOTE: We nonetheless fail (sometimes) with a 
+        #  Dropzone::Session::Unauthenticated message as it takes a bit of time to 
+        #  populate the authentication relay into the mempool:
+        if Dropzone::BitcoinConnection.cache
+          Dropzone::BitcoinConnection.cache.invalidate_listtransactions!
+
+          puts "Waiting 10 seconds for authorization to propagate to the mempool..."
+          sleep 10
+        end
+      end
+    end
+
+    comm_txid = session << message
+
+    puts_table '%s: %s' % ['Communication', comm_txid], nil, [ 
+      ['Session', txid], 
+      [:sender_addr, privkey.addr], 
+      [:message, message] ]
+  end
+
+  def communication_show(args, options)
+    network! :testnet3
+
+    privkey = privkey_from args, :testnet3
+
+    txid = args[1]  if args.length > 1
+
+    raise OptionParser::MissingArgument, 'txid' unless txid
+
+    comm_init = Dropzone::Communication.find txid
+
+    raise "Invalid Session" unless comm_init && comm_init.is_init?
+
+    session = session_for privkey, comm_init
+
+    puts_table '%s: %s' % ['Communication', txid], nil,
+     session.communications.collect{|comm|
+      [comm.sender_addr, comm.contents_plain] }
+  end
+
+  def listing_find(args, options)
+    block_depth = args[0]  if args.length > 0
+
+    raise OptionParser::MissingArgument, "block_depth" unless block_depth
+
+    block_depth = block_depth.to_i
+
+    raise OptionParser::InvalidArgument, "block_depth" unless block_depth >= 0
+
+    location_attrs = [:latitude, :longitude, :radius]
+
+    params = parameterize options, *location_attrs+[:start_at]
+
+    via_location = location_attrs.collect{|k| params[k]}
+
+    raise "missing one or more of: latitude, longitude, or radius."  if (
+      via_location.any? && !via_location.all? )
+
+    start_at = params[:start_at].to_i || connection.block_height
+
+    finder_method = (via_location.all?) ? 
+      [ :find_in_radius, start_at, block_depth, *via_location] :
+      [ :find_creates_since_block, start_at, block_depth] 
+
+    Dropzone::Item.send(*finder_method) do |item|
+      puts_object '%s: %s' % ['Listing', item.txid], nil, LISTING_ATTRS, item
+    end
+  end
+
+  def send_value(args, options)
+    dest_addr = args[1]  if args.length > 1
+
+    raise OptionParser::MissingArgument, "dest_addr" unless dest_addr
+
+    network! (/\A1/.match dest_addr) ? :bitcoin : :testnet3
+
+    raise OptionParser::InvalidArgument, "dest_addr" unless Bitcoin.valid_address? dest_addr
+
+    amnt_btc = args[2] if args.length > 2
+
+    raise OptionParser::MissingArgument, "amnt_btc" unless amnt_btc
+
+    amnt_btc = BigDecimal.new amnt_btc
+
+    raise OptionParser::InvalidArgument, "amnt_btc" unless amnt_btc > 0
+
+    amnt_satoshis = (amnt_btc * Dropzone::BitcoinConnection::SATOSHIS_IN_BTC).to_i
+
+    privkey = privkey_from args, Bitcoin.network_name
+
+    txid = connection.send_value privkey, dest_addr, amnt_satoshis, 
+      Dropzone::MessageBase.default_tip
+
+    puts_table '%s: %s' % ['Transaction', txid], nil, [
+      ['From', privkey.addr ] ,
+      ['To', dest_addr ] ,
+      ['Amount (BTC)', amnt_btc.to_s('F').to_s ] 
+    ]
+  end
+
+  def balance(args, options)
+    addr = args.first
+
+    raise OptionParser::MissingArgument, "addr" unless addr
+     
+    network! (/\A1/.match addr) ? :bitcoin : :testnet3
+
+    raise OptionParser::InvalidArgument, "addr" unless Bitcoin.valid_address? addr
+
+    balance = connection.bitcoin.getbalance addr
+
+    puts_table '%s: %s' % ['Address', addr], nil, [
+      ['Balance', balance ] ]
+  end
+
+  private
+
+  def secret_for(sender_addr, receiver_addr)
+    record = local_persistence[:communication_keys].where( 
+      Sequel.expr(receiver_addr: receiver_addr) & 
+      Sequel.expr(sender_addr: sender_addr) ).first
+
+    if record
+      record[:secret]
+    else
+      secret = SecureRandom.random_bytes(128).unpack('H*').first
+
+      local_persistence[:communication_keys].insert sender_addr: sender_addr, 
+        receiver_addr: receiver_addr, secret: secret
+
+      secret
+    end
+  end
+
+  def local_persistence
+    unless @local_persistence
+      config_dir = File.join(Dir.home, ".dropzone")
+      Dir.mkdir config_dir, 0700 unless Dir.exists? config_dir
+
+      @local_persistence = Sequel.connect 'sqlite://%s/dropzone.db' % config_dir
+      
+      @local_persistence.create_table :communication_keys do
+        primary_key :id
+        String :sender_addr
+        String :receiver_addr
+        String :secret
+      end unless @local_persistence.table_exists? :communication_keys
+    end
+
+    @local_persistence
+  end
+
+  def session_for(privkey, comm_init)
+    receiver_addr = (comm_init.receiver_addr == privkey.addr) ?
+      comm_init.sender_addr : comm_init.receiver_addr
+
+    Dropzone::Session.new privkey.to_base58, 
+      secret_for(privkey.addr, receiver_addr),
+      (comm_init.sender_addr == privkey.addr) ? 
+        {receiver_addr: receiver_addr} : {with: comm_init}
+  end
+
+  def parameterize(options,*valid_params)
+    options.__hash__.find_all{|(k,v)| valid_params.include? k}.to_h
+  end
+
+  def privkey_from(args, network = nil)
+    start_network = Bitcoin.network_name if network
+
+    privkey = args.first
+
+    raise OptionParser::MissingArgument, "private_key" unless privkey
+
+    begin
+      Bitcoin.network = network if network
+      Bitcoin::Key.from_base58 privkey
+    rescue
+      raise OptionParser::InvalidArgument, "private_key"
+    ensure
+      Bitcoin.network = start_network if start_network
+    end
+  end
+
+  def by_txid(args)
+    txid = args.first
+
+    raise OptionParser::MissingArgument, "txid" unless txid
+
+    txid
+  end
+
+  def by_addr(args)
+    addr = args.first
+    raise OptionParser::MissingArgument, "addr" unless addr
+
+    raise OptionParser::InvalidArgument, "addr" unless Bitcoin.valid_address? addr
+
+    addr
+  end
+
+  def puts_object(header, footer, attributes, object)
+    puts_table header, footer, attributes.collect{|attr| 
+      value = object.send(attr)
+      [attr, value] if value
+    }.compact
+  end
+
+  def puts_table(header, footer, pairs)
+    pairs_h = pairs.to_h
+    widest_key = pairs_h.keys.sort_by{|k| k.to_s.length}.last.to_s.length
+    widest_value = pairs_h.values.sort_by{|v| v.to_s.length}.last.to_s.length
+
+    widest_header = (footer.nil? || (header.length > footer.length) ) ? 
+      header.length : footer.length
+
+    content_width = ((widest_key+widest_value) > widest_header) ?
+      (widest_key+widest_value + 2) : widest_header
+
+    content_width = MAX_TABLE_WIDTH if content_width > MAX_TABLE_WIDTH
+
+    endcap = "+%s+" % [ '-'*(content_width+2)] 
+
+    puts [ endcap, "| %-#{content_width}s |" % [header], endcap,
+      pairs.collect{|k,v| 
+        if (k.to_s.length+v.to_s.length+2) > content_width
+          data_width = content_width-widest_key-3
+          sentence_splitter = /(.{1,#{data_width}})( +|$\n?)|(.{1,#{data_width}})/m
+          v.scan(sentence_splitter).each_with_index.collect{|l,i|
+          "| %-#{content_width}s |" % [ 
+            ("%-#{widest_key}s: %s" % [(i == 0) ? k : '',l.first]) ]
+          }
+        else
+          "| %-#{content_width}s |" % ["%-#{widest_key}s: %s" % [k,v]]
+        end
+      },
+      endcap, 
+      (footer) ? ["| %-#{content_width}s |" % [footer], endcap] : nil
+    ].flatten.join("\n")
+  end
+
+end
+