ledger-lite 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc54a08adc58f1f0a7c50cb0ce42439ed2dd5312
-  data.tar.gz: '05199c14456c983c82d94981f098075ea49d743b'
+  metadata.gz: 27bbb8efe382ef8c1c4fa635037363e667ec46c9
+  data.tar.gz: 13f8ddac47b8b2f8b44074fe8d3b0a6da256e32e
 SHA512:
-  metadata.gz: e52f287dbe9e9aff4cfe896f728a19c060e730bc86db485e1ff555ac6df3239d1b032f48684adf91b8810f97e50f57cc3ae60055d0398d588ca9339a5faddfa8
-  data.tar.gz: a4fbb0a4344cdd8dfe161c5ec855e9e49943d4414c29b58da4cf829ffb09664b10a95b313faf45c697e9b05657c3c780f09434c99aaa4849c7a1064253759fc2
+  metadata.gz: 9fafcfdd2f34532ec5885e6db2c35bb594e19027bfdc55fca920dfb69c7231e795ca1b29e7e3c135e703d3745c9274997196291895055b696673fd8cb8e94363
+  data.tar.gz: cc347bb5d02ba4cb6ca76aa348bcdbcc59ff8abf3f413268c3705599395607b69783f2d5c1d216758a9fafb308573d4e7985c8f23ae0b6d4846717da9329f703

data/Manifest.txt

@@ -6,4 +6,6 @@ Rakefile
 lib/ledger-lite.rb
 lib/ledger-lite/version.rb
 test/helper.rb
-test/test_transfer.rb
+test/test_blocks.rb
+test/test_transactions.rb
+test/test_version.rb

data/README.md

@@ -9,6 +9,203 @@ ledger-lite library / gem - hyper ledger book for the distributed blockchain int
 * rdoc  :: [rubydoc.info/gems/ledger-lite](http://rubydoc.info/gems/ledger-lite)
 
 
+## Usage
+
+Let's add some transactions to the (hyper) ledger book:
+
+| From                | To           |   $ |
+|---------------------|--------------|----:|
+| Keukenhof (†)       | Vincent      |  11 |
+| Vincent             | Anne         |   3 |
+| Anne                | Julia        |   2 |
+| Julia               | Luuk         |   1 |
+|                     |              |     |
+| Dutchgrown (†)      | Ruben        |  11 |
+| Vincent             | Max          |   3 |
+| Ruben               | Julia        |   2 |
+| Anne                | Martijn      |   1 |
+
+(†): Mining Transaction - New Dutch Gulden ($) on the Market!
+
+
+
+### Use `send` (send payment/transfer money)
+
+```ruby
+
+ledger = Ledger.new
+
+ledger.send( "Keukenhof†",  "Vincent", 11 )
+ledger.send( "Vincent",     "Anne",     3 )
+ledger.send( "Anne",        "Julia",    2 )
+ledger.send( "Julia",       "Luuk",     1 )
+
+ledger.send( "Dutchgrown†", "Ruben",   11 )
+ledger.send( "Vincent",     "Max",      3 )
+ledger.send( "Ruben",       "Julia",    2 )
+ledger.send( "Anne",        "Martijn",  1 )
+
+pp ledger   ## pp = pretty print
+
+```
+
+resulting in
+
+```
+#<LedgerLite::Ledger
+ @addr={
+   "Vincent" => 5,
+   "Anne"    => 0,
+   "Julia"   => 3,
+   "Luuk"    => 1,
+   "Ruben"   => 9,
+   "Max"     => 3,
+   "Martijn" => 1}>
+```
+
+that is, the addr hash holds all addresses (addr) with the account balances
+telling you who owns how much:
+
+| Addr(ess)           | Balance $ |
+|---------------------|----------:|
+| Vincent             |         5 |
+| Anne                |         0 |
+| Julia               |         3 |
+| Luuk                |         1 |
+| Ruben               |         9 |
+| Max                 |         3 |
+| Martijn             |         1 |
+
+
+### Use `write` to write / add transactions
+
+Or use transaction (tx) classes/structs:
+
+``` ruby
+ledger = Ledger.new
+
+ledger.write( Tx.new( "Keukenhof†",  "Vincent", 11 ))
+ledger.write( Tx.new( "Vincent",     "Anne",     3 ))
+ledger.write( Tx.new( "Anne",        "Julia",    2 ))
+ledger.write( Tx.new( "Julia",       "Luuk",     1 ))
+
+ledger.write( Tx.new( "Dutchgrown†", "Ruben",   11 ))
+ledger.write( Tx.new( "Vincent",     "Max",      3 ))
+ledger.write( Tx.new( "Ruben",       "Julia",    2 ))
+ledger.write( Tx.new( "Anne",        "Martijn",  1 ))
+
+pp ledger
+```
+
+
+Or pass in many transaction (Tx) classes/structs:
+
+``` ruby
+ledger = Ledger.new
+
+ledger.write( Tx.new( "Keukenhof†",  "Vincent", 11 ),
+              Tx.new( "Vincent",     "Anne",     3 ),
+              Tx.new( "Anne",        "Julia",    2 ),
+              Tx.new( "Julia",       "Luuk",     1 ))
+
+ledger.write( Tx.new( "Dutchgrown†", "Ruben",   11 ),
+              Tx.new( "Vincent",     "Max",      3 ),
+              Tx.new( "Ruben",       "Julia",    2 ),
+              Tx.new( "Anne",        "Martijn",  1 ))
+
+pp ledger
+```
+
+Or use the operator `<<` alias for `write`:
+
+```ruby
+ledger = Ledger.new
+
+ledger <<  Tx.new( "Keukenhof†",  "Vincent", 11 )
+ledger <<  Tx.new( "Vincent",     "Anne",     3 )
+ledger <<  Tx.new( "Anne",        "Julia",    2 )
+ledger <<  Tx.new( "Julia",       "Luuk",     1 )
+
+ledger << [Tx.new( "Dutchgrown†", "Ruben",   11 ),
+           Tx.new( "Vincent",     "Max",      3 ),
+           Tx.new( "Ruben",       "Julia",    2 ),
+           Tx.new( "Anne",        "Martijn",  1 )]
+
+pp ledger
+```
+
+Or use transaction hashes:
+
+``` ruby
+ledger = Ledger.new
+
+ledger.write( { from: "Keukenhof†",  to: "Vincent",  amount: 11 },
+              { from: "Vincent",     to: "Anne",     amount:  3 },
+              { from: "Anne",        to: "Julia",    amount:  2 },
+              { from: "Julia",       to: "Luuk",     amount:  1 })
+
+ledger.write( { from: "Dutchgrown†", to: "Ruben",    amount: 11 },
+              { from: "Vincent",     to: "Max",      amount:  3 },
+              { from: "Ruben",       to: "Julia",    amount:  2 },
+              { from: "Anne",        to: "Martijn",  amount:  1 })
+
+pp ledger
+```
+
+
+Or use blocks of transaction hashes:
+
+``` ruby
+
+ledger = Ledger.new
+
+ledger.write( Block.new( { from: "Keukenhof†",  to: "Vincent",    amount: 11 },
+                         { from: "Vincent",     to: "Anne",       amount:  3 },
+                         { from: "Anne",        to: "Julia",      amount:  2 },
+                         { from: "Julia",       to: "Luuk",       amount:  1 } ),
+              Block.new( { from: "Dutchgrown†", to: "Ruben",      amount: 11 },
+                         { from: "Vincent",     to: "Max",        amount:  3 },
+                         { from: "Ruben",       to: "Julia",      amount:  2 },
+                         { from: "Anne",        to: "Martijn",    amount:  1 } ))
+
+pp ledger
+```
+
+
+Or use blocks of transaction classes/structs:
+
+``` ruby
+ledger = Ledger.new
+
+ledger.write( Block.new( Tx.new( "Keukenhof†",  "Vincent",  11 ),
+                         Tx.new( "Vincent",     "Anne",      3 ),
+                         Tx.new( "Anne",        "Julia",     2 ),
+                         Tx.new( "Julia",       "Luuk",      1 )),
+              Block.new( Tx.new( "Dutchgrown†", "Ruben",    11 ),
+                         Tx.new( "Vincent",     "Max",       3 ),
+                         Tx.new( "Ruben",       "Julia",     2 ),
+                         Tx.new( "Anne",        "Martijn",   1 )))
+
+pp ledger
+```
+
+Or use blocks of transaction classes/structs (with keyword arguments):
+
+```ruby
+ledger = Ledger.new
+
+ledger.write( Block.new( Tx.new( from: "Keukenhof†",  to: "Vincent", amount: 11 ),
+                         Tx.new( from: "Vincent",     to: "Anne",    amount:  3 ),
+                         Tx.new( from: "Anne",        to: "Julia",   amount:  2 ),
+                         Tx.new( from: "Julia",       to: "Luuk",    amount:  1 )),
+              Block.new( Tx.new( from: "Dutchgrown†", to: "Ruben",   amount: 11 ),
+                         Tx.new( from: "Vincent",     to: "Max",     amount:  3 ),
+                         Tx.new( from: "Ruben",       to: "Julia",   amount:  2 ),
+                         Tx.new( from: "Anne",        to: "Martijn", amount:  1 )))
+
+pp ledger
+```
+
 
 
 ## License

data/lib/ledger-lite.rb

@@ -1,13 +1,14 @@
 # encoding: utf-8
 
-require 'pp'        # for pp => pretty printer
-
+require 'pp'            # for pp => pretty printer
+require 'forwardable'
 require 'date'
 require 'time'
 require 'json'
 
 
 
+
 ## our own code
 require 'ledger-lite/version'    # note: let version always go first
 
@@ -15,52 +16,114 @@ require 'ledger-lite/version'    # note: let version always go first
 
 module LedgerLite
 
+
+
+class Configuration
+
+  ## system settings
+
+  ##  use a different name e.g.
+  ##  -  mint  (like royal mint or federal coin mint?) or
+  ##  -  base
+  ##  -  magic  (for creating coins out-of-nothing?) or
+  ##  -  network or ??) - why? why not?
+  ##
+  attr_accessor :coinbase
+
+  ##  note: for now is an array (allow/ support multiple coinbases)
+  ##  note: add a (†) coinbase  marker
+  COINBASE = ['Coinbase†']
+
+  def initialize
+    @coinbase = COINBASE
+  end
+
+  def coinbase?( addr )
+    @coinbase.include?( addr )
+  end
+end # class Configuration
+
+
+
+
 class Ledger
+  extend Forwardable
+
+
+  ## lets you use
+  ##   Ledger.configure do |config|
+  ##      config.coinbase = ['Keukenhof†']
+  ##   end
+
+  def self.configure
+    yield( config )
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+
 
   attr_reader :addr     ## make addr private e.g. remove - why? e.g. use hash forwards/delegates - why not?
 
-  def initialize( args=[] )
-    ## todo/fix: use *args - same interface as merkletree/blochchain-lite
 
+  ## delegate some methods (and operators) to addr hash (for easier/shortcut access)
+  def_delegators :@addr, :[], :size, :each, :empty?, :any?
+
+
+  def initialize( *args )
     @addr = {}
 
-    args.each do |arg|
-      if arg.respond_to?( :transactions )   ## bingo! assume it's block if it has transactions method
-        transfer( arg.transactions )
-      else
-        transfer( arg )
-      end
-    end
+     ## add all transactions passed in on startup; if no args - do nothing
+     unless args.empty?
+       ## note: MUST unsplat (*) args
+       ##   otherwise args get "double" wrapped in array
+       write( *args )
+     end
   end # method initialize
 
 
 
-  ##
-  # find a better name - why? why not?
-  ##  e.g. use can? funds? sufficient? has_funds?
-  def sufficient_funds?( addr, amount )
-    ## fix:
-    true
+  def write( *args )
+    puts "write:"
+    pp args
+
+    ##  note: allow/support splat-* for now for convenience (auto-wraps args into array)
+    if args.size == 1 && args[0].is_a?( Array )
+      puts " unwrap array in array"
+      blks_or_txns = args[0]   ## "unwrap" array in array
+    else
+      blks_or_txns = args      ## use "auto-wrapped" splat array
+    end
+
+    ## "unpack" transactions from possible (optional) blocks
+    ##   and return "flattend" **single** array of transactions
+    transactions = unpack_transactions( blks_or_txns )
+
+    ## unpack & unsplat array (to pass in args to send) => from, to, amount
+    transactions.each { |tx| send( *unpack(tx) ) }
   end
 
+  ## note: add and the << operator is an alias for write
+  alias :add :write
+  alias :<<  :write
 
-  def transfer( arg )
-    ## todo/fix: use *args - same interface as merkletree/blochchain-lite
 
-    puts "transfer:"
-    pp arg
+  def unpack_transactions( blocks )
+    ## "unpack" transactions from possible (optional) blocks
+    ##   and return "flattend" **single** array of transactions
 
-    if arg.is_a?( Array )
-      txs = arg
-      txs.each { |tx| do_transfer( *unpack(tx) ) }  ## unpack & unsplat array (to pass in args) => from, to, amount
-    else
-      ## assume single tx
-      tx = arg
-      do_transfer( *unpack(tx) )  ## unpack & unsplat array (to pass in args) => from, to, amount
+    blocks.reduce( [] ) do |acc, block|
+      if block.respond_to?( :transactions )   ## bingo! assume it's block if it has transactions method
+        acc + block.transactions
+      else   ## note: otherwise assumes it's just a "plain" **single** transaction
+        tx = block
+        acc + [tx]    ## wrap in array (use acc << tx  - with side effects/mutate in place - why? why not?)
+      end
     end
   end
 
-
   def unpack( tx )
     ## "unpack" from, to, amount values
 
@@ -80,22 +143,38 @@ class Ledger
   end
 
 
-  ## apply/do single transaction
+  ##
+  # find a better name - why? why not?
+  ##  e.g. use can? funds? sufficient? has_funds?
+  def sufficient_funds?( addr, amount )
+    return true   if self.class.config.coinbase?( addr )    ## note: coinbase has unlimited funds!!!
+    @addr.has_key?( addr ) && @addr[addr] - amount >= 0
+  end
+
+
+  ## apply/do single transaction - send payment - do transfer
   ##  - find a different name - why? why not?
-  def do_transfer( from, to, amount )
+  def send( from, to, amount )
 
     if sufficient_funds?( from, amount )
-      @addr[ from ] ||= 0
-      @addr[ from ] -= amount
+      if self.class.config.coinbase?( from )
+        # note: coinbase has unlimited funds!! ("virtual" built-in money printing address)
+      else
+         @addr[ from ] ||= 0
+         @addr[ from ] -= amount
+      end
       @addr[ to ] ||= 0
       @addr[ to ] += amount
     end
+  end  # method transfer
 
-  end  # do_transfer
+  ## note: transfer is an alias for send (payment)
+  alias :transfer :send
 
 
 end # class Ledger
 
+
 end # module LedgerLite
 
 

data/lib/ledger-lite/version.rb

@@ -3,9 +3,9 @@
 
 module LedgerLite
 
-  MAJOR = 0
+  MAJOR = 1
   MINOR = 0
-  PATCH = 1
+  PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/test/test_blocks.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_blocks.rb
+
+
+require 'helper'
+
+
+class TestBlocks < MiniTest::Test
+
+def setup
+  Ledger.configure do |config|
+     config.coinbase = ["Keukenhof†", "Dutchgrown†"]
+  end
+end
+
+def test_blocks_with_hash
+
+  b0 = Block.new( { from: "Keukenhof†", to: "Vincent",    amount: 11 },
+                  { from: "Vincent",    to: "Anne",       amount:  3 },
+                  { from: "Anne",       to: "Julia",      amount:  2 },
+                  { from: "Julia",      to: "Luuk",       amount:  1 } )
+
+  b1 = Block.new( { from: "Dutchgrown†", to: "Ruben",   amount: 11 },
+                  { from: "Vincent",     to: "Max",     amount:  3 },
+                  { from: "Ruben",       to: "Julia",   amount:  2 },
+                  { from: "Anne",        to: "Martijn", amount:  1 } )
+
+  blockchain = [b0,b1]
+
+  ledger = Ledger.new( blockchain )
+
+  pp ledger
+
+  balances = {"Vincent"=>5,
+              "Anne"=>0,
+              "Julia"=>3,
+              "Luuk"=>1,
+              "Ruben"=>9,
+              "Max"=>3,
+              "Martijn"=>1}
+  assert_equal balances, ledger.addr
+end
+
+
+def test_blocks_with_tx_v1
+
+  b0 = Block.new( Tx.new( from: "Keukenhof†", to: "Vincent", amount: 11 ),
+                  Tx.new( from: "Vincent",    to: "Anne",    amount:  3 ),
+                  Tx.new( from: "Anne",       to: "Julia",   amount:  2 ),
+                  Tx.new( from: "Julia",      to: "Luuk",    amount:  1 ))
+
+  b1 = Block.new( Tx.new( from: "Dutchgrown†", to: "Ruben",   amount: 11 ),
+                  Tx.new( from: "Vincent",     to: "Max",     amount:  3 ),
+                  Tx.new( from: "Ruben",       to: "Julia",   amount:  2 ),
+                  Tx.new( from: "Anne",        to: "Martijn", amount:  1 ))
+
+  blockchain = [b0,b1]
+
+  ledger = Ledger.new( blockchain )
+
+  pp ledger
+
+  balances = {"Vincent"=>5,
+              "Anne"=>0,
+              "Julia"=>3,
+              "Luuk"=>1,
+              "Ruben"=>9,
+              "Max"=>3,
+              "Martijn"=>1}
+  assert_equal balances, ledger.addr
+end
+
+
+
+def test_blocks_with_tx_v2
+
+  b0 = Block.new( Tx.new( "Keukenhof†", "Vincent", 11 ),
+                  Tx.new( "Vincent",    "Anne",     3 ),
+                  Tx.new( "Anne",       "Julia",    2 ),
+                  Tx.new( "Julia",      "Luuk",     1 ))
+
+  b1 = Block.new( Tx.new( "Dutchgrown†", "Ruben", 11 ),
+                  Tx.new( "Vincent", "Max",        3 ),
+                  Tx.new( "Ruben",   "Julia",      2 ),
+                  Tx.new( "Anne",    "Martijn",    1 ))
+
+  blockchain = [b0,b1]
+
+  ledger = Ledger.new( blockchain )
+
+  pp ledger
+
+  balances = {"Vincent"=>5,
+              "Anne"=>0,
+              "Julia"=>3,
+              "Luuk"=>1,
+              "Ruben"=>9,
+              "Max"=>3,
+              "Martijn"=>1}
+  assert_equal balances, ledger.addr
+end
+
+
+end  # class TestBlocks

data/test/test_transactions.rb

@@ -0,0 +1,156 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_transactions.rb
+
+
+require 'helper'
+
+
+class TestTransactions < MiniTest::Test
+
+def setup
+  Ledger.configure do |config|
+    config.coinbase = ["Keukenhof†", "Dutchgrown†"]
+  end
+end
+
+
+def test_send
+
+  ledger = Ledger.new
+
+  ledger.send( "Keukenhof†",  "Vincent", 11 )
+  ledger.send( "Vincent",     "Anne",     3 )
+  ledger.send( "Anne",        "Julia",    2 )
+  ledger.send( "Julia",       "Luuk",     1 )
+
+  ledger.send( "Dutchgrown†", "Ruben",   11 )
+  ledger.send( "Vincent",     "Max",      3 )
+  ledger.send( "Ruben",       "Julia",    2 )
+  ledger.send( "Anne",        "Martijn",  1 )
+
+  pp ledger
+
+  balances = {"Vincent"=>5,
+              "Anne"=>0,
+              "Julia"=>3,
+              "Luuk"=>1,
+              "Ruben"=>9,
+              "Max"=>3,
+              "Martijn"=>1}
+  assert_equal balances, ledger.addr
+end
+
+
+def test_with_tx_v1
+
+  ledger = Ledger.new
+
+  ledger.write( Tx.new( "Keukenhof†",  "Vincent", 11 ))
+  ledger.write( Tx.new( "Vincent",     "Anne",     3 ))
+  ledger.write( Tx.new( "Anne",        "Julia",    2 ))
+  ledger.write( Tx.new( "Julia",       "Luuk",     1 ))
+
+  ledger.write( Tx.new( "Dutchgrown†", "Ruben",   11 ))
+  ledger.write( Tx.new( "Vincent",     "Max",      3 ))
+  ledger.write( Tx.new( "Ruben",       "Julia",    2 ))
+  ledger.write( Tx.new( "Anne",        "Martijn",  1 ))
+
+  pp ledger
+
+  balances = {"Vincent"=>5,
+              "Anne"=>0,
+              "Julia"=>3,
+              "Luuk"=>1,
+              "Ruben"=>9,
+              "Max"=>3,
+              "Martijn"=>1}
+  assert_equal balances, ledger.addr
+end
+
+
+def test_with_tx_v2
+
+  ledger = Ledger.new
+
+  ledger.write( Tx.new( "Keukenhof†",  "Vincent", 11 ),
+                Tx.new( "Vincent",     "Anne",     3 ),
+                Tx.new( "Anne",        "Julia",    2 ),
+                Tx.new( "Julia",       "Luuk",     1 ))
+
+  ledger.write( Tx.new( "Dutchgrown†", "Ruben",   11 ),
+                Tx.new( "Vincent",     "Max",      3 ),
+                Tx.new( "Ruben",       "Julia",    2 ),
+                Tx.new( "Anne",        "Martijn",  1 ))
+
+  pp ledger
+
+  balances = {"Vincent"=>5,
+              "Anne"=>0,
+              "Julia"=>3,
+              "Luuk"=>1,
+              "Ruben"=>9,
+              "Max"=>3,
+              "Martijn"=>1}
+  assert_equal balances, ledger.addr
+end
+
+
+def test_with_tx_v3
+
+  ledger = Ledger.new
+
+  ledger << Tx.new( "Keukenhof†",  "Vincent", 11 )
+  ledger << Tx.new( "Vincent",     "Anne",     3 )
+  ledger << Tx.new( "Anne",        "Julia",    2 )
+  ledger << Tx.new( "Julia",       "Luuk",     1 )
+
+  ledger << [Tx.new( "Dutchgrown†", "Ruben",   11 ),
+             Tx.new( "Vincent",     "Max",      3 ),
+             Tx.new( "Ruben",       "Julia",    2 ),
+             Tx.new( "Anne",        "Martijn",  1 )]
+
+  pp ledger
+
+  balances = {"Vincent"=>5,
+              "Anne"=>0,
+              "Julia"=>3,
+              "Luuk"=>1,
+              "Ruben"=>9,
+              "Max"=>3,
+              "Martijn"=>1}
+  assert_equal balances, ledger.addr
+end
+
+
+
+def test_with_hash
+
+  ledger = Ledger.new
+
+  ledger.write( { from: "Keukenhof†", to: "Vincent",  amount: 11 },
+                { from: "Vincent",    to: "Anne",     amount:  3 },
+                { from: "Anne",       to: "Julia",    amount:  2 },
+                { from: "Julia",      to: "Luuk",     amount:  1 })
+
+  ledger.write( { from: "Dutchgrown†", to: "Ruben",   amount: 11 },
+                { from: "Vincent",     to: "Max",     amount:  3 },
+                { from: "Ruben",       to: "Julia",   amount:  2 },
+                { from: "Anne",        to: "Martijn", amount:  1 })
+
+  pp ledger
+
+  balances = {"Vincent"=>5,
+              "Anne"=>0,
+              "Julia"=>3,
+              "Luuk"=>1,
+              "Ruben"=>9,
+              "Max"=>3,
+              "Martijn"=>1}
+  assert_equal balances, ledger.addr
+end
+
+
+end  # class TestTransactions

data/test/test_version.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_version.rb
+
+
+require 'helper'
+
+
+class TestVersion < MiniTest::Test
+
+def test_version
+   pp LedgerLite.version
+   pp LedgerLite.banner
+   pp LedgerLite.root
+
+   assert true  ## (for now) everything ok if we get here
+end
+
+
+end  # class TestVersion

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ledger-lite
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-04 00:00:00.000000000 Z
+date: 2018-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -58,7 +58,9 @@ files:
 - lib/ledger-lite.rb
 - lib/ledger-lite/version.rb
 - test/helper.rb
-- test/test_transfer.rb
+- test/test_blocks.rb
+- test/test_transactions.rb
+- test/test_version.rb
 homepage: https://github.com/openblockchains/ledger.lite.rb
 licenses:
 - Public Domain

data/test/test_transfer.rb

@@ -1,118 +0,0 @@
-# encoding: utf-8
-
-###
-#  to run use
-#     ruby -I ./lib -I ./test test/test_transfer.rb
-
-
-require 'helper'
-
-
-class TestTransfer < MiniTest::Test
-
-
-def test_do_transfer
-
-  ledger = Ledger.new
-
-  ledger.do_transfer( "Vicent",  "Anne",    3 )
-  ledger.do_transfer( "Anne",    "Julia",   2 )
-  ledger.do_transfer( "Julia",   "Luuk",    1 )
-
-  ledger.do_transfer( "Vincent", "Max",     3 )
-  ledger.do_transfer( "Anne",    "Martijn", 2 )
-  ledger.do_transfer( "Ruben",   "Julia",   1 )
-
-  pp ledger
-
-  balances = {"Vicent"=>-3,
-              "Anne"=>-1,
-              "Julia"=>2,
-              "Luuk"=>1,
-              "Vincent"=>-3,
-              "Max"=>3,
-              "Martijn"=>2,
-              "Ruben"=>-1}
-  assert_equal balances, ledger.addr
-end
-
-
-def test_transfer_with_tx_v1
-
-  ledger = Ledger.new
-
-  ledger.transfer( Tx.new( "Vicent",  "Anne",    3 ))
-  ledger.transfer( Tx.new( "Anne",    "Julia",   2 ))
-  ledger.transfer( Tx.new( "Julia",   "Luuk",    1 ))
-
-  ledger.transfer( Tx.new( "Vincent", "Max",     3 ))
-  ledger.transfer( Tx.new( "Anne",    "Martijn", 2 ))
-  ledger.transfer( Tx.new( "Ruben",   "Julia",   1 ))
-
-  pp ledger
-
-  balances = {"Vicent"=>-3,
-              "Anne"=>-1,
-              "Julia"=>2,
-              "Luuk"=>1,
-              "Vincent"=>-3,
-              "Max"=>3,
-              "Martijn"=>2,
-              "Ruben"=>-1}
-  assert_equal balances, ledger.addr
-end
-
-
-def test_transfer_with_tx_v2
-
-  ledger = Ledger.new
-
-  ledger.transfer( [Tx.new( "Vicent",  "Anne",    3 ),
-                    Tx.new( "Anne",    "Julia",   2 ),
-                    Tx.new( "Julia",   "Luuk",    1 )])
-
-  ledger.transfer( [Tx.new( "Vincent", "Max",     3 ),
-                    Tx.new( "Anne",    "Martijn", 2 ),
-                    Tx.new( "Ruben",   "Julia",   1 )])
-
-  pp ledger
-
-  balances = {"Vicent"=>-3,
-              "Anne"=>-1,
-              "Julia"=>2,
-              "Luuk"=>1,
-              "Vincent"=>-3,
-              "Max"=>3,
-              "Martijn"=>2,
-              "Ruben"=>-1}
-  assert_equal balances, ledger.addr
-end
-
-
-def test_transfer_with_hash
-
-  ledger = Ledger.new
-
-  ledger.transfer( [{ from: "Vicent",  to: "Anne",  amount: 3 },
-                    { from: "Anne",    to: "Julia", amount: 2 },
-                    { from: "Julia",   to: "Luuk",  amount: 1 }])
-
-  ledger.transfer( [{ from: "Vincent", to: "Max",     amount: 3 },
-                    { from: "Anne",    to: "Martijn", amount: 2 },
-                    { from: "Ruben",   to: "Julia",   amount: 1 }])
-
-  pp ledger
-
-  balances = {"Vicent"=>-3,
-              "Anne"=>-1,
-              "Julia"=>2,
-              "Luuk"=>1,
-              "Vincent"=>-3,
-              "Max"=>3,
-              "Martijn"=>2,
-              "Ruben"=>-1}
-  assert_equal balances, ledger.addr
-end
-
-
-end  # class TestTransfer