shilling 0.1.0

data/lib/shilling/block.rb

@@ -0,0 +1,44 @@
+
+
+Block = BlockchainLite::ProofOfWork::Block
+
+## see https://github.com/openblockchains/blockchain.lite.rb/blob/master/lib/blockchain-lite/proof_of_work/block.rb
+
+######
+## add more methods
+
+class Block
+
+
+def to_h
+  { index:             @index,
+    timestamp:         @timestamp,
+    nonce:             @nonce,
+    transactions:      @transactions.map { |tx| tx.to_h },
+    transactions_hash: @transactions_hash,
+    previous_hash:     @previous_hash,
+    hash:              @hash }
+end
+
+def self.from_h( h )
+  transactions = h['transactions'].map { |h_tx| Tx.from_h( h_tx ) }
+
+  ## todo: use hash and transactions_hash to check integrity of block - why? why not?
+
+  ## parse iso8601 format e.g 2017-10-05T22:26:12-04:00
+  timestamp    = Time.parse( h['timestamp'] )
+
+  self.new( h['index'],
+            transactions,
+            h['previous_hash'],
+            timestamp: timestamp,
+            nonce: h['nonce'].to_i )
+end
+
+
+def valid?
+  true   ## for now always valid
+end
+
+
+end # class Block

data/lib/shilling/blockchain.rb

@@ -0,0 +1,47 @@
+
+
+
+class Blockchain
+  extend Forwardable
+  def_delegators :@chain, :[], :size, :each, :empty?, :any?, :last
+
+
+  def initialize( chain=[] )
+    @chain = chain
+  end
+
+  def <<( txs )
+    ## todo: check if is block or array
+    ##   if array (of transactions) - auto-add (build) block
+    ##   allow block - why? why not?
+    ##  for now just use transactions (keep it simple :-)
+
+    if @chain.size == 0
+      block = Block.first( txs )
+    else
+      block = Block.next( @chain.last, txs )
+    end
+    @chain << block
+  end
+
+
+
+  def as_json
+    @chain.map { |block| block.to_h }
+  end
+
+  def transactions
+    ## "accumulate" get all transactions from all blocks "reduced" into a single array
+    @chain.reduce( [] ) { |acc, block| acc + block.transactions }
+  end
+
+
+
+  def self.from_json( data )
+    ## note: assumes data is an array of block records/objects in json
+    chain = data.map { |h| Block.from_h( h ) }
+    self.new( chain )
+  end
+
+
+end  # class Blockchain

data/lib/shilling/cache.rb

@@ -0,0 +1,22 @@
+
+
+class Cache
+  def initialize( name )
+    @name = name
+  end
+
+  def write( data )
+    File.open( @name, 'w:utf-8' ) do |f|
+      f.write JSON.pretty_generate( data )
+    end
+  end
+
+  def read
+    if File.exists?( @name )
+      data = File.open( @name, 'r:bom|utf-8' ).read
+      JSON.parse( data )
+    else
+      nil
+    end
+  end
+end   ## class Cache

data/lib/shilling/ledger.rb

@@ -0,0 +1,30 @@
+
+class Ledger
+  attr_reader :wallets     ## use addresses - why? why not? for now single address wallet (wallet==address)
+
+  def initialize( chain=[] )
+    @wallets = {}
+    chain.each do |block|
+      apply_transactions( block.transactions )
+    end
+  end
+
+  def sufficient_funds?( wallet, amount )
+    return true   if Shilling.config.coinbase?( wallet )
+    @wallets.has_key?( wallet ) && @wallets[wallet] - amount >= 0
+  end
+
+
+private
+
+  def apply_transactions( transactions )
+    transactions.each do |tx|
+      if sufficient_funds?(tx.from, tx.amount)
+        @wallets[tx.from] -= tx.amount   unless Shilling.config.coinbase?( tx.from )
+        @wallets[tx.to] ||= 0
+        @wallets[tx.to] += tx.amount
+      end
+    end
+  end
+
+end   ## class Ledger

data/lib/shilling/node.rb

@@ -0,0 +1,82 @@
+
+
+class Node
+  attr_reader :id, :peers, :wallet, :bank
+
+  def initialize( address: )
+    @id     = SecureRandom.uuid
+    @peers  = []
+    @wallet = Wallet.new( address )
+    @bank   = Bank.new @wallet.address
+  end
+
+
+
+  def on_add_peer( host, port )
+    @peers << [host, port]
+    @peers.uniq!
+    # TODO/FIX: no need to send to every peer, just the new one
+    send_chain_to_peers
+    @bank.pending.each { |tx| send_transaction_to_peers( tx ) }
+  end
+
+  def on_delete_peer( index )
+    @peers.delete_at( index )
+  end
+
+
+  def on_add_transaction( from, to, amount, id )
+    ## note: for now must always pass in id - why? why not? possible tx without id???
+    tx = Tx.new( from, to, amount, id )
+    if @bank.sufficient_funds?( tx.from, tx.amount ) && @bank.add_transaction( tx )
+      send_transaction_to_peers( tx )
+      return true
+    else
+      return false
+    end
+  end
+
+  def on_send( to, amount )
+    tx = @wallet.generate_transaction( to, amount )
+    if @bank.sufficient_funds?( tx.from, tx.amount ) && @bank.add_transaction( tx )
+      send_transaction_to_peers( tx )
+      return true
+    else
+      return false
+    end
+  end
+
+
+  def on_mine!
+    @bank.mine_block!
+    send_chain_to_peers
+  end
+
+  def on_resolve( data )
+    chain_new = Blockchain.from_json( data )
+    if @bank.resolve!( chain_new )
+      send_chain_to_peers
+      return true
+    else
+      return false
+    end
+  end
+
+
+
+private
+
+  def send_chain_to_peers
+    data = JSON.pretty_generate( @bank.as_json )   ## payload in json
+    @peers.each do |(host, port)|
+      Net::HTTP.post(URI::HTTP.build(host: host, port: port, path: '/resolve'), data )
+    end
+  end
+
+  def send_transaction_to_peers( tx )
+    @peers.each do |(host, port)|
+      Net::HTTP.post_form(URI::HTTP.build(host: host, port: port, path: '/transactions'), tx.to_h )
+    end
+  end
+
+end   ## class Node

data/lib/shilling/pool.rb

@@ -0,0 +1,42 @@
+####################################
+#  pending (unconfirmed) transactions (mem) pool
+
+class Pool
+  extend Forwardable
+  def_delegators :@transactions, :[], :size, :each, :empty?, :any?
+
+
+  def initialize( transactions=[] )
+    @transactions = transactions
+  end
+
+  def transactions() @transactions; end
+
+  def <<( tx )
+    @transactions << tx
+  end
+
+
+  def update!( txns_confirmed )
+    ## find a better name?
+    ##  remove confirmed transactions from pool
+
+    ##   document - keep only pending transaction not yet (confirmed) in blockchain ????
+    @transactions = @transactions.select do |tx_unconfirmed|
+      txns_confirmed.none? { |tx_confirmed| tx_confirmed.id == tx_unconfirmed.id }
+    end
+  end
+
+
+
+  def as_json
+    @transactions.map { |tx| tx.to_h }
+  end
+
+  def self.from_json( data )
+    ## note: assumes data is an array of block records/objects in json
+    transactions = data.map { |h| Tx.from_h( h ) }
+    self.new( transactions )
+  end
+
+end  # class Pool

data/lib/shilling/service.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+module Shilling
+
+  class Service < Sinatra::Base
+
+    def self.banner
+      "shilling/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}] on Sinatra/#{Sinatra::VERSION} (#{ENV['RACK_ENV']})"
+    end
+
+
+  PUBLIC_FOLDER = "#{Shilling.root}/lib/shilling/public"
+  VIEWS_FOLDER  = "#{Shilling.root}/lib/shilling/views"
+
+  set :public_folder, PUBLIC_FOLDER # set up the static dir (with images/js/css inside)
+  set :views, VIEWS_FOLDER # set up the views dir
+
+  set :static, true # set up static file routing  -- check - still needed?
+
+
+  set connections: []
+
+
+
+  get '/style.css' do
+    scss :style    ## note: converts (pre-processes) style.scss to style.css
+  end
+
+
+  get '/' do
+    @node = node   ## todo: pass along node as hash varialbe / assigns to erb
+    erb :index
+  end
+
+
+  post '/send' do
+    node.on_send( params[:to], params[:amount].to_i )
+    settings.connections.each { |out| out << "data: added transaction\n\n" }
+    redirect '/'
+  end
+
+
+  post '/transactions' do
+    if node.on_add_transaction(
+      params[:from],
+      params[:to],
+      params[:amount].to_i,
+      params[:id]
+    )
+      settings.connections.each { |out| out << "data: added transaction\n\n" }
+    end
+    redirect '/'
+  end
+
+  post '/mine' do
+    node.on_mine!
+    redirect '/'
+  end
+
+  post '/peers' do
+    node.on_add_peer( params[:host], params[:port].to_i )
+    redirect '/'
+  end
+
+  post '/peers/:index/delete' do
+    node.on_delete_peer( params[:index].to_i )
+    redirect '/'
+  end
+
+
+
+  post '/resolve' do
+    data = JSON.parse(request.body.read)
+    if data['chain'] && node.on_resolve( data['chain'] )
+      status 202     ### 202 Accepted; see httpstatuses.com/202
+      settings.connections.each { |out| out << "data: resolved\n\n" }
+    else
+      status 200    ### 200 OK
+    end
+  end
+
+
+  get '/events', provides: 'text/event-stream' do
+    stream :keep_open do |out|
+      settings.connections << out
+      out.callback { settings.connections.delete(out) }
+    end
+  end
+
+private
+
+#########
+## return network node (built and configured on first use)
+##   fix: do NOT use @@ - use a class level method or something
+def node
+  if defined?( @@node )
+    @@node
+  else
+    puts "[debug] shilling - build (network) node (address: #{Shilling.config.address})"
+    @@node = Node.new( address: Shilling.config.address )
+    @@node
+  end
+  ####
+  ## check why this is a syntax error:
+  ## @node ||= do
+  ##   puts "[debug] shilling - build (network) node (address: #{Shilling.config.address})"
+  ##   @node = Node.new( address: Shilling.config.address )
+  ## end
+end
+
+  end # class Service
+
+end # module Shilling

data/lib/shilling/tool.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+
+module Shilling
+
+class Tool
+
+def run( args )
+  opts = {}
+
+  parser = OptionParser.new do |cmd|
+    cmd.banner = "Usage: shilling [options]"
+
+    cmd.separator ""
+    cmd.separator "  Wallet options:"
+
+    cmd.on("-n", "--name=NAME", "Address name (default: Theresa)") do |name|
+      ## use -a or --adr or --address as option flag - why? why not?
+      ##  note: default now picks a random address from WALLET_ADDRESSES
+      opts[:address] = name
+    end
+
+
+    cmd.separator ""
+    cmd.separator "  Server (node) options:"
+
+    cmd.on("-o", "--host HOST", "listen on HOST (default: 0.0.0.0)") do |host|
+      opts[:Host] = host    ## note: rack server handler expects :Host
+    end
+
+    cmd.on("-p", "--port PORT", "use PORT (default: 4567)") do |port|
+      opts[:Port] = port    ## note: rack server handler expects :Post
+    end
+
+    cmd.on("-h", "--help", "Prints this help") do
+      puts cmd
+      exit
+    end
+  end
+
+  parser.parse!( args )
+  pp opts
+
+
+  ###################
+  ## startup server (via rack interface/handler)
+
+  app_class = Service    ##  use  app = Service.new  -- why? why not?
+  host = opts[:Host] || '0.0.0.0'
+  port = opts[:Port] || '4567'
+
+  Shilling.configure do |config|
+    config.address = opts[:address] || 'Theresa'
+  end
+
+  Rack::Handler::WEBrick.run( app_class, Host: host, Port: port ) do |server|
+      ## todo: add traps here - why, why not??
+  end
+
+
+end  ## method run
+
+
+end   ## class Tool
+
+end   ## module Shilling