universum 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13cb94b578f32502fa462ae5244745a0acaed5fa
-  data.tar.gz: 70e43de209bc06bd7f9d2e8dd3ae4e53ba237b9a
+  metadata.gz: 47cb21b47f820960440d6b734508522afd0669f5
+  data.tar.gz: f95c32cd1cc6fc27aae94a40dabd0638215b9886
 SHA512:
-  metadata.gz: c51e13fbc51f64d5f56dd62e2b731986674124a309df6eb2fe7f3f8c68a423363610a64d40df8e03b9f5bd091a5c2bec89b7d71156c5a32f594d2f095a447d42
-  data.tar.gz: 4bcd6d2df8a752af20d92883ce309d4796161341be7927cdaa027af1bde78b45fd545050bb296599ad58aff7f3233f6b64d70d41f15f7423d1da91b1b37d8421
+  metadata.gz: 431ac7abd03c738136fc014cf36e8646d29f4a1ed07dc10d69701e0d6317660224ec579d75f5ee38675ee51bc17050682b5c507cb7dfa07ef1146d595d4dc13f
+  data.tar.gz: b9d01fa01a6d3b4c3ab569748052477faf9fcdfe1bebb06fcf2284d6e4e9186d5907c1b520079c95adb28d0cee657774b0f0714d85bd63a660edc01ce16bb713

data/LICENSE.md

@@ -0,0 +1,116 @@
+CC0 1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator and
+subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the
+purpose of contributing to a commons of creative, cultural and scientific
+works ("Commons") that the public can reliably and without fear of later
+claims of infringement build upon, modify, incorporate in other works, reuse
+and redistribute as freely as possible in any form whatsoever and for any
+purposes, including without limitation commercial purposes. These owners may
+contribute to the Commons to promote the ideal of a free culture and the
+further production of creative, cultural and scientific works, or to gain
+reputation or greater distribution for their Work in part through the use and
+efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation
+of additional consideration or compensation, the person associating CC0 with a
+Work (the "Affirmer"), to the extent that he or she is an owner of Copyright
+and Related Rights in the Work, voluntarily elects to apply CC0 to the Work
+and publicly distribute the Work under its terms, with knowledge of his or her
+Copyright and Related Rights in the Work and the meaning and intended legal
+effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not limited
+to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display, communicate,
+  and translate a Work;
+
+  ii. moral rights retained by the original author(s) and/or performer(s);
+
+  iii. publicity and privacy rights pertaining to a person's image or likeness
+  depicted in a Work;
+
+  iv. rights protecting against unfair competition in regards to a Work,
+  subject to the limitations in paragraph 4(a), below;
+
+  v. rights protecting the extraction, dissemination, use and reuse of data in
+  a Work;
+
+  vi. database rights (such as those arising under Directive 96/9/EC of the
+  European Parliament and of the Council of 11 March 1996 on the legal
+  protection of databases, and under any national implementation thereof,
+  including any amended or successor version of such directive); and
+
+  vii. other similar, equivalent or corresponding rights throughout the world
+  based on applicable law or treaty, and any national implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention of,
+applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
+unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
+and Related Rights and associated claims and causes of action, whether now
+known or unknown (including existing as well as future claims and causes of
+action), in the Work (i) in all territories worldwide, (ii) for the maximum
+duration provided by applicable law or treaty (including future time
+extensions), (iii) in any current or future medium and for any number of
+copies, and (iv) for any purpose whatsoever, including without limitation
+commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes
+the Waiver for the benefit of each member of the public at large and to the
+detriment of Affirmer's heirs and successors, fully intending that such Waiver
+shall not be subject to revocation, rescission, cancellation, termination, or
+any other legal or equitable action to disrupt the quiet enjoyment of the Work
+by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be
+judged legally invalid or ineffective under applicable law, then the Waiver
+shall be preserved to the maximum extent permitted taking into account
+Affirmer's express Statement of Purpose. In addition, to the extent the Waiver
+is so judged Affirmer hereby grants to each affected person a royalty-free,
+non transferable, non sublicensable, non exclusive, irrevocable and
+unconditional license to exercise Affirmer's Copyright and Related Rights in
+the Work (i) in all territories worldwide, (ii) for the maximum duration
+provided by applicable law or treaty (including future time extensions), (iii)
+in any current or future medium and for any number of copies, and (iv) for any
+purpose whatsoever, including without limitation commercial, advertising or
+promotional purposes (the "License"). The License shall be deemed effective as
+of the date CC0 was applied by Affirmer to the Work. Should any part of the
+License for any reason be judged legally invalid or ineffective under
+applicable law, such partial invalidity or ineffectiveness shall not
+invalidate the remainder of the License, and in such case Affirmer hereby
+affirms that he or she will not (i) exercise any of his or her remaining
+Copyright and Related Rights in the Work or (ii) assert any associated claims
+and causes of action with respect to the Work, in either case contrary to
+Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+  a. No trademark or patent rights held by Affirmer are waived, abandoned,
+  surrendered, licensed or otherwise affected by this document.
+
+  b. Affirmer offers the Work as-is and makes no representations or warranties
+  of any kind concerning the Work, express, implied, statutory or otherwise,
+  including without limitation warranties of title, merchantability, fitness
+  for a particular purpose, non infringement, or the absence of latent or
+  other defects, accuracy, or the present or absence of errors, whether or not
+  discoverable, all to the greatest extent permissible under applicable law.
+
+  c. Affirmer disclaims responsibility for clearing rights of other persons
+  that may apply to the Work or any use thereof, including without limitation
+  any person's Copyright and Related Rights in the Work. Further, Affirmer
+  disclaims responsibility for obtaining any necessary consents, permissions
+  or other rights required for any use of the Work.
+
+  d. Affirmer understands and acknowledges that Creative Commons is not a
+  party to this document and has no duty or obligation with respect to this
+  CC0 or use of the Work.
+
+For more information, please see
+<http://creativecommons.org/publicdomain/zero/1.0/

data/Manifest.txt

@@ -1,6 +1,13 @@
-HISTORY.md
+CHANGELOG.md
+LICENSE.md
 Manifest.txt
 README.md
 Rakefile
 lib/universum.rb
+lib/universum/universum.rb
 lib/universum/version.rb
+test/contracts/greeter.rb
+test/contracts/mytoken.rb
+test/helper.rb
+test/test_greeter.rb
+test/test_version.rb

data/README.md

@@ -1,13 +1,178 @@
-# Universum
+New to Universum? See the [Universum (World Computer) White Paper](https://github.com/openblockchains/universum/blob/master/WHITEPAPER.md)!
+
+
+
+# Universum (Ruby Edition)
 
 next generation ethereum 2.0 world computer runtime - run contract scripts / transactions in plain vanilla / standard ruby on the blockchain - update the (contract-protected / isolated) world states with plain vanilla / standard SQL
 
 
+* home  :: [github.com/openblockchains/universum](https://github.com/openblockchains/universum)
+* bugs  :: [github.com/openblockchains/universum/issues](https://github.com/openblockchains/universum/issues)
+* gem   :: [rubygems.org/gems/universum](https://rubygems.org/gems/universum)
+* rdoc  :: [rubydoc.info/gems/universum](http://rubydoc.info/gems/universum)
+
 
 ## Usage
 
-to be done
 
+### The Greeter - Your Digital Pal Who's Fun to Be With
+
+Let's use the ["Create a digital greeter"](https://www.ethereum.org/greeter) starter example from Ethereum
+to compare contracts in Solidity with contracts in Ruby:
+
+
+
+``` solidity
+pragma solidity >=0.4.22 <0.6.0;
+
+contract Mortal {
+    /* Define variable owner of the type address */
+    address owner;
+
+    /* This constructor is executed at initialization and sets the owner of the contract */
+    constructor() public { owner = msg.sender; }
+
+    /* Function to recover the funds on the contract */
+    function kill() public { if (msg.sender == owner) selfdestruct(msg.sender); }
+}
+
+contract Greeter is Mortal {
+    /* Define variable greeting of the type string */
+    string greeting;
+
+    /* This runs when the contract is executed */
+    constructor(string memory _greeting) public {
+        greeting = _greeting;
+    }
+
+    /* Main function */
+    function greet() public view returns (string memory) {
+        return greeting;
+    }
+}
+```
+
+and
+
+``` ruby
+class Greeter < Contract
+
+  def initialize( greeting )
+    @owner    = msg.sender
+    @greeting = greeting
+  end
+
+  def greet
+    @greeting
+  end
+
+  def kill
+    selfdestruct( msg.sender )  if msg.sender == @owner
+  end
+end  # class Greeter
+```
+
+(Source: [`contracts/greeter.rb`](test/contracts/greeter.rb))
+
+
+
+And let's run the greeter with Universum (Uni):
+
+``` ruby
+require 'universum'
+
+require_relative 'greeter'
+
+
+Account['0x1111']    ## setup a test account
+
+tx = Uni.send_transaction( from: '0x1111', data: [Greeter, 'Hello World!'] )
+greeter = tx.receipt.contract
+
+puts greeter.greet
+#=> Hello World!
+
+tx = Uni.send_transaction( from: '0x1111', data: [Greeter, '¡Hola, mundo!'] )
+greeter_es = Receipt[ tx ].contract
+
+puts greeter_es.greet
+#=> ¡Hola, mundo!
+
+puts greeter.greet
+#=> Hello World!
+puts greeter_es.greet
+#=> ¡Hola, mundo!
+...
+```
+
+
+
+### The Coin - Minimum Viable Token
+
+What's next? Let's use the ["Create your own crypto-currency"](https://www.ethereum.org/token) example from Ethereum
+to compare contracts in Solidity with contracts in Ruby again:
+
+``` solidity
+pragma solidity >=0.4.22 <0.6.0;
+
+contract MyToken {
+    /* This creates an array with all balances */
+    mapping (address => uint256) public balanceOf;
+
+    /* Initializes contract with initial supply tokens to the creator of the contract */
+    constructor(
+        uint256 initialSupply
+        ) public {
+        balanceOf[msg.sender] = initialSupply;              // Give the creator all initial tokens
+    }
+
+    /* Send coins */
+    function transfer(address _to, uint256 _value) public returns (bool success) {
+        require(balanceOf[msg.sender] >= _value);           // Check if the sender has enough
+        require(balanceOf[_to] + _value >= balanceOf[_to]); // Check for overflows
+        balanceOf[msg.sender] -= _value;                    // Subtract from the sender
+        balanceOf[_to] += _value;                           // Add the same to the recipient
+        return true;
+    }
+}
+```
+
+and
+
+``` ruby
+class MyToken < Contract
+
+  def initialize( initial_supply )
+    @balance_of = Mapping.of( Address => Money )
+    @balance_of[ msg.sender] = initial_supply
+  end
+
+  def transfer( to, value )
+    assert( @balance_of[ msg.sender ] >= value )
+    assert( @balance_of[ to ] + value >= @balance_of[ to ] )
+
+    @balance_of[ msg.sender ] -= value
+    @balance_of[ to ]         += value
+
+    return true
+  end
+end   # class MyToken
+```
+
+(Source: [`contracts/mytoken.rb`](test/contracts/mytoken.rb))
+
+
+
+
+## More Contract Samples
+
+See the [`/universum-contracts`](https://github.com/openblockchains/universum-contracts) collection.
+
+
+## More Documentation / Articles / Contracts
+
+[Programming Crypto Blockchain Contracts Step-by-Step Book / Guide](https://github.com/openblockchains/programming-cryptocontracts) - Let's Start with Ponzi & Pyramid Schemes. Run Your Own Lotteries, Gambling Casinos and more on the Blockchain World Computer...
 
 
 
@@ -15,7 +180,9 @@ to be done
 
 Just install the gem:
 
-    $ gem install universum
+```
+$ gem install universum
+```
 
 
 ## License

data/Rakefile

@@ -15,7 +15,7 @@ Hoe.spec 'universum' do
 
   # switch extension to .markdown for gihub formatting
   self.readme_file  = 'README.md'
-  self.history_file = 'HISTORY.md'
+  self.history_file = 'CHANGELOG.md'
 
   self.extra_deps = [
   ]

data/lib/universum.rb

@@ -1,11 +1,10 @@
 # encoding: utf-8
 
-require 'pp'
-
 
 ## our own code
 require 'universum/version'    # note: let version always go first
 
+require 'universum/universum'
+
 
-pp Universum.banner
-pp Universum.root
+puts Universum.banner   ## say hello

data/lib/universum/universum.rb

@@ -0,0 +1,588 @@
+# encoding: utf-8
+
+
+## stdlibs
+require 'pp'         ## pretty print (pp)
+require 'digest'
+
+
+def sha256( str )
+  Digest::SHA256.hexdigest( str )
+end
+
+
+
+module Address
+  def self.zero() '0x0000'; end
+
+  def address
+    if @address
+      @address
+    else
+      if is_a? Contract
+         ##  fix/todo:  use/lookup proper addr from contract
+         ## construct address for now from object_id
+         "0x#{(object_id << 1).to_s(16)}"
+      else  ## assume Account
+         '0x0000'
+      end
+    end
+  end # method address
+
+  def transfer( value )  ## @payable @public
+    ## todo/fix: throw exception if insufficient funds
+    send( value )   # returns true/false
+  end
+
+  def send( value )  ## @payable @public
+    ## todo/fix: assert value > 0
+    ## todo/fix: add missing  -= part in transfer!!!!
+
+    ## use this (current contract) for debit (-) ammount
+    this._sub( value )    # sub(tract) / debit from the sender (current contract)
+    _add( value )         # add / credit to the recipient
+  end
+
+  def balance
+    @balance ||= 0   ## return 0 if undefined
+  end
+
+  ### private (internal use only) methods - PLEASE do NOT use (use transfer/send)
+  def _sub( value )
+    @balance ||= 0   ## return 0 if undefined
+    @balance -= value
+  end
+
+  def _add( value )
+    @balance ||= 0   ## return 0 if undefined
+    @balance += value
+  end
+end  # class Address
+
+
+## add dummy bool class for mapping and (payable) method signature
+
+class Integer
+  def self.zero() 0; end
+end
+
+class Bool
+  def self.zero() false; end
+end
+
+class Money
+  def self.zero() 0; end
+end
+
+class Void   ## only used (reserved) for (payable) method signature now
+end
+
+
+class Mapping
+  def self.of( *args )
+     ## e.g. gets passed in [{Address=>Integer}]
+     ##  check for Integer - use Hash.new(0)
+     ##  check for Bool    - use Hash.new(False)
+     if args[0].is_a? Hash
+       arg = args[0].to_a   ## convert to array (for easier access)
+       if arg[0][1] == Integer
+         Hash.new( Integer.zero )     ## if key missing returns 0 and NOT nil (the default)
+       elsif arg[0][1] == Money
+         Hash.new( Money.zero )     ## if key missing returns 0 and NOT nil (the default)
+       elsif arg[0][1] == Bool
+         Hash.new( Bool.zero )
+       elsif arg[0][1] == Address
+         Hash.new( Address.zero )
+       else   ## assume "standard" defaults
+         ## todo: issue warning about unknown type - why? why not?
+         Hash.new
+       end
+     else
+       Hash.new    ## that is, "plain" {} with all "standard" defaults
+     end
+  end
+end
+
+
+
+
+class Array
+  def self.of( *args )
+     Array.new    ## that is, "plain" [] with all "standard" defaults
+  end
+end
+
+
+class String
+  def transfer( value )
+    ## check if self is an address
+    if self.start_with?( '0x' )
+      Account[self].transfer( value )
+    else
+      raise "(Auto-)Type Conversion from Address (Hex) String to Account Failed; Expected String Starting with 0x got #{self}; Contract Halted (Stopped)"
+    end
+  end
+
+  def send( value )
+    ## check if self is an address
+    if self.start_with?( '0x' )
+      Account[self].send( value )
+    else
+      raise "(Auto-)Type Conversion from Address (Hex) String to Account Failed; Expected String Starting with 0x got #{self}; Contract Halted (Stopped)"
+    end
+  end
+end
+
+
+class Account
+
+  @@directory = {}
+  def self.find_by_address( key )
+     ## clean key (allow "embedded" name e.g 0x1111 (Alice))
+     key = key.gsub(/\(.+\)/, '' ).strip
+     @@directory[ key ]
+  end
+  def self.find( key ) find_by_address( key ); end   # make find_by_address the default finder
+  def self.at( key) find_by_address( key ); end   # another "classic" alias for find_by_address
+
+  def self.[]( key )
+    o = find_by_address( key )
+    if o
+      o
+    else
+      o = new( key )
+      ## note: auto-register (new) address in (yellow page) directory
+      @@directory[ key ] = o
+      o
+    end
+  end
+
+  def self.all()  @@directory.values;  end
+
+
+  ####
+  #  account (builtin) services / transaction methods
+  include Address    ## includes address + send/transfer/balance
+
+  ## note: for now allow write access too!!!
+  def balance=( value )
+    @balance = value
+  end
+
+  attr_reader :tx
+  def _auto_inc_tx() @tx += 1; end   ## "internal" method - (auto) increment transaction (tx) counter
+
+  ## note: needed by transfer/send
+  def this()       Universum.this;         end   ## returns current contract
+
+private
+  def initialize( address, balance: 0, tx: 0 )
+    @address = address    # type address - (hex) string starts with 0x
+    @balance = balance    # uint
+    @tx      = tx         # transaction (tx) count (used for nonce and replay attack protection)
+  end
+
+end # class Account
+
+
+class Contract
+
+  @@directory = {}
+  def self.find_by_address( key )
+     ## clean key (allow "embedded" class name e.g 0x4de2ee8 (SatoshiDice))
+     key = key.gsub(/\(.+\)/, '' ).strip
+     @@directory[ key ];
+  end
+  def self.find( key ) find_by_address( key ); end   # make find_by_address the default finder
+  def self.at( key) find_by_address( key ); end     # another "classic" alias for find_by_address
+  def self.[]( key ) find_by_address( key ); end
+
+  def self.store( key, o ) @@directory.store( key, o ); end  ## store (add) new contract object (o) to hash / directory
+  def self.all() @@directory.values; end
+
+
+
+  ####
+  #  account (builtin) services / transaction methods
+  include Address    ## includes address + send/transfer/balance
+
+  ## function sig(nature) macro for types (dummy for now)
+  # e.g. use like
+  #   payable :process
+  #   payable :initialize
+  #   payable :bet, Integer
+  #   payable :lend_money, Address => Bool   ## returns Bool
+  def self.payable( *args ); end
+
+  payable :receive
+
+  ####
+  #  todo/double check: auto-add payable default fallback - why? why not?
+  def receive    ## @payable default fallback - use different name - why? why not? (e.g. handle/process/etc.)
+  end
+
+
+  def assert( condition )
+    if condition == true
+      ## do nothing
+    else
+      raise 'Contract Assertion Failed; Contract Halted (Stopped)'
+    end
+  end
+
+
+  def this()       Universum.this;         end   ## returns current contract
+  def log( event ) Universum.log( event ); end
+  def msg()        Universum.msg;          end
+  def block()      Universum.block;        end
+  def blockhash( number )
+    ## todo/fix: only allow going back 255 blocks; check if number is in range!!!
+    Universum.blockhash( number )
+  end
+
+private
+  def selfdestruct( owner )   ## todo/check: use a different name e.g. destruct/ delete - why? why not?
+    ## selfdestruct function (for clean-up on blockchain)
+    owner.send( @balance )    ## send back all funds owned/hold by contract
+
+     ## fix: does nothing for now - add some code (e.g. cleanup)
+     ##  mark as destruct - why? why not?
+  end
+
+end  # class Contract
+
+
+
+
+## blockchain message (msg) context
+##   includes:  sender (address)
+##  todo: allow writable attribues e.g. sender - why? why not?
+class Msg
+  attr_reader :sender, :value
+
+  def initialize( sender: '0x0000', value: 0 )
+    @sender = sender
+    @value  = value
+  end
+end  # class Msg
+
+
+
+class Block
+  attr_reader :timestamp, :number
+
+  def initialize( timestamp: Time.now.to_i, number: 0 )
+    @timestamp = timestamp   # unix epoch time (in seconds since 1970)
+    @number    = number      # block height (start with 0 - genesis block)
+  end
+end  # class Block
+
+
+
+class Transaction
+  attr_reader :from, :to, :value, :data, :nonce
+
+  def initialize( from:, to:, value:, data:, nonce: nil )
+    ## note: from only allows accounts
+    if from.is_a?( Account )
+      account = from
+    else
+      account = Account.at( from )   ## lookup account by address
+    end
+
+    @from = account.address
+
+    if to.is_a?( Contract )
+      @to = "#{to.address} (#{to.class.name})"
+    elsif to.is_a?( Account )     ## note: to allows Contracts AND Accounts
+      @to = to.address
+    else
+      @to = to    # might be a contract or account (pass through for now)
+    end
+
+    @value = value
+    @data  = data
+
+    if nonce
+      @nonce = nonce
+    else
+      ## auto-add nonce (that is, tx counter - auto-increment)
+      @nonce = account.tx  ## get transaction (tx) counter (starts with 0)
+      account._auto_inc_tx
+    end
+  end
+
+  def log_str
+    ## for debug add transaction (tx) args (e.g. from, value, etc.)
+    tx_args_str = ""
+    tx_args_str << "from: #{@from} ##{@nonce}"
+    tx_args_str << ", value: #{@value}"  if @value > 0
+
+    if @to == '0x0000'  ## special case - contract creation transaction
+      klass      = @data[0]       ## contract class - todo/fix: check if data[] is a contract class!!!
+      call_args  = @data[1..-1]   ## arguments
+
+      ## convert all args to string (with inspect) for debugging
+      ##   check if pretty_inspect adds trailing newline? why? why not? possible?
+      call_args_str = call_args.reduce( [] ) { |ary,arg| ary; ary << arg.inspect }.join( ', ' )
+
+      "#{tx_args_str} => to: #{@to} create contract #{klass.name}.new( #{call_args_str} )"
+    else
+      if @data.empty?  ## assume receive (default method) for now if data empty (no method specified)
+        "#{tx_args_str} => to: #{@to} call default fallback"
+      else
+        m         = @data[0]       ## method name / signature
+        call_args = @data[1..-1]   ## arguments
+
+        ## convert all args to string (with inspect) for debugging
+        ##   check if pretty_inspect adds trailing newline? why? why not? possible?
+        call_args_str = call_args.reduce( [] ) { |ary,arg| ary; ary << arg.inspect }.join( ', ' )
+
+        "#{tx_args_str} => to: #{@to} call #{m}( #{call_args_str} )"
+      end
+    end
+  end
+
+
+  def receipt
+    Receipt.find( self )
+  end
+
+  def contract   # convenience helper (quick contract lookup)
+    rec = receipt
+    if rec
+      rec.contract
+    else
+      nil
+    end
+  end
+end  # class Transaction
+
+Tx = Transaction    ## add some convenience aliases (still undecided what's the most popular :-)
+
+
+
+
+class Receipt   ## transaction receipt
+
+  @@directory = {}
+  def self.find( tx )
+     key = "#{tx.from}/#{tx.nonce}"
+     @@directory[ key ];
+  end
+  def self.[]( tx ) find( tx ); end
+
+  def self.store( o )
+     key = "#{o.from}/#{o.nonce}"
+     @@directory.store( key, o ); end  ## store (add) new receipt object (o) to hash / directory
+  def self.all() @@directory.values; end
+
+
+   ## required attributes / fields
+   attr_reader :nonce, :from, :to, :value,
+               :block_number
+   ## optional
+   attr_reader :contract_address
+
+   def initialize( tx:,
+                   block:,
+                   contract: nil )
+      @nonce = tx.nonce
+      @from  = tx.from
+      @to    = tx.to
+      @value = tx.value
+      ## todo/fix: add data too!!!
+
+      @block_number    = block.number
+      ## todo/fix: add block_hash
+
+      if contract
+        ## note: for easier debugging add class name in () to address (needs to get stripped away in lookup)
+        @contract_address = "#{contract.address} (#{contract.class.name})"
+      else
+        @contract_address = nil
+      end
+   end
+
+   def contract   # convenience helper (quick contract lookup)
+     if @contract_address
+       Contract.find( @contract_address )
+     else
+       nil
+     end
+   end
+end
+
+
+## base class for events
+class Event
+  ## return a new Struct-like read-only class
+  def self.build_class( *fields )
+    klass = Class.new( Event ) do
+      define_method( :initialize ) do |*args|
+        fields.zip( args ).each do |field, arg|
+          instance_variable_set( "@#{field}", arg )
+        end
+      end
+
+      fields.each do |field|
+        define_method( field ) do
+          instance_variable_get( "@#{field}" )
+        end
+      end
+    end
+
+    ## add self.new too - note: call/forward to "old" orginal self.new of Event (base) class
+    klass.define_singleton_method( :new ) do |*args|
+      old_new( *args )
+    end
+
+    klass
+  end
+
+  class << self
+    alias_method :old_new, :new       # note: store "old" orginal version of new
+    alias_method :new,     :build_class    # replace original version with create
+  end
+end  # class Event
+
+
+class Universum   ## Uni short for Universum
+  ## convenience helpers
+
+  def self.send_transaction( from:, to: '0x0000', value: 0, data: [] )
+    counter = @@counter ||= 0    ## total tx counter for debugging (start with 0)
+    @@counter += 1
+
+    ## note: always lookup (use) account for now
+    if from.is_a?( Account )
+      account = from
+    else
+      account = Account.at( from )
+    end
+
+    ## setup contract msg context
+    self.msg = { sender: account.address, value: value }
+
+
+    ## allow shortcut for Class (without ctor arguments) - no need to wrap in array
+    data = [data]   if data.is_a? Class
+
+    tx = Transaction.new( from: account, to: to, value: value, data: data )
+
+
+    ## special case - contract creation transaction
+    if to == '0x0000'
+      klass = data[0]       ## contract class - todo/fix: check if data[] is a contract class!!!
+      args  = data[1..-1]   ## arguments
+
+      puts "** tx ##{counter} (block ##{block.number}): #{tx.log_str}"
+      contract = klass.new( *args )   ## note: balance and this (and msg.send/transfer) NOT available/possible !!!!
+
+      if value > 0
+        ## move value to msg (todo/fix: restore if exception)
+        account._sub( value )  # (sub)tract / debit from the sender (account)
+        contract._add( value )        # add / credit to the recipient
+      end
+
+      puts " new #{contract.class.name} contract adddress: #{contract.address.inspect}"
+      ## add new contract to (lookup) directory
+      Contract.store( contract.address, contract )
+
+      ## issue (mined) transaction receipt
+      receipt = Receipt.new( tx: tx,
+                             block: block,
+                             contract: contract )
+    else
+       if value > 0
+         ## move value to msg (todo/fix: restore if exception)
+         account._sub( value )  # (sub)tract / debit from the sender (account)
+         to._add( value )       # add / credit to the recipient
+       end
+
+       self.this = to    ## assumes for now that to is always a contract (and NOT an account)!!!
+
+       data = [:receive]   if data.empty?  ## assume receive (default method) for now if data empty (no method specified)
+
+       m    = data[0]       ## method name / signature
+       args = data[1..-1]   ## arguments
+
+       puts "** tx ##{counter} (block ##{block.number}): #{tx.log_str}"
+
+       to.__send__( m, *args )    ## note: use __send__ to avoid clash with send( value ) for sending payments!!!
+
+       ## issue (mined) transaction receipt
+       receipt = Receipt.new( tx: tx,
+                              block: block )
+    end
+
+    Receipt.store( receipt )
+    tx   # return transaction
+  end
+
+
+  def self.accounts()  Account.all; end
+  def self.contracts() Contract.all; end
+
+
+  def self.msg
+    @@msg ||= Msg.new
+  end
+
+  def self.msg=( value )
+    if value.is_a? Hash
+      kwargs = value
+      @@msg = Msg.new( kwargs )
+    else   ## assume Msg class/type
+      @@msg = value
+    end
+  end
+
+
+  def self.blockhash( number )
+    ## for now return "dummy" blockhash
+    sha256( "blockhash #{number}" )
+  end
+
+  def self.block
+    @@block ||= Block.new
+  end
+
+  def self.block=( value )
+    if value.is_a? Hash
+      kwargs = value
+      @@block = Block.new( kwargs )
+    else   ## assume Block class/type
+      @@block = value
+    end
+  end
+
+  def self.this    ## returns current contract
+    @@this
+  end
+
+  def self.this=(value)
+    ## todo/fix: check that value is a contract
+    @@this = value
+  end
+
+
+  def self.handlers    ## use listeners/observers/subscribers/... - why? why not?
+    @@handlers ||= []
+  end
+
+  def self.log( event )
+    handlers.each { |h| h.call( event ) }
+  end
+end  ## class Universum
+
+
+
+Uni = Universum   ## add some convenience aliases (still undecided what's the most popular :-)
+UNI = Universum
+UN  = Universum
+U   = Universum
+
+
+## (auto-)add (debug) log handler for now - pretty print (pp) events to console
+Uni.handlers << (->(event) { puts "** event: #{event.pretty_inspect}" })

data/lib/universum/version.rb

@@ -1,11 +1,14 @@
 # encoding: utf-8
 
 
-module Universum
+##
+## note: Universum is a class (and NOT a module for now)
+
+class Universum
 
   MAJOR = 0
-  MINOR = 0
-  PATCH = 1
+  MINOR = 1
+  PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/test/contracts/greeter.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+
+class Greeter < Contract
+
+  def initialize( greeting )
+    @owner    = msg.sender
+    @greeting = greeting
+  end
+
+  def greet
+    @greeting
+  end
+
+  def kill
+     selfdestruct( msg.sender )  if msg.sender == @owner
+  end
+end  # class Greeter

data/test/contracts/mytoken.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+
+class MyToken < Contract
+
+  def initialize( initial_supply )
+    @balance_of = Mapping.of( Address => Money )
+    @balance_of[ msg.sender] = initial_supply
+  end
+
+  def transfer( to, value )
+    assert( @balance_of[ msg.sender ] >= value )
+    assert( @balance_of[ to ] + value >= @balance_of[ to ] )
+
+    @balance_of[ msg.sender ] -= value
+    @balance_of[ to ]         += value
+
+    return true
+  end
+end   # class MyToken

data/test/helper.rb

@@ -0,0 +1,8 @@
+## minitest setup
+
+require 'minitest/autorun'
+
+
+## our own code
+
+require 'universum'

data/test/test_greeter.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_greeter.rb
+
+
+require 'helper'
+
+
+require 'contracts/greeter'    ## use require_relative - why? why not?
+
+
+class TestGreeter < MiniTest::Test
+
+def test_run
+   account = Account['0x1111']
+
+   tx = Uni.send_transaction( from: '0x1111', data: [Greeter, 'Hello World!'] )
+   pp tx
+   pp tx.receipt
+
+   greeter = tx.receipt.contract
+
+   assert 'Hello World!', greeter.greet
+   assert 'Hello World!', greeter.greet
+
+   tx = Uni.send_transaction( from: '0x1111', data: [Greeter, '¡Hola, mundo!'] )
+
+   greeter_es = Receipt[ tx ].contract
+
+   assert '¡Hola, mundo!', greeter_es.greet
+
+   assert 'Hello World!',   greeter.greet
+   assert '¡Hola, mundo!',  greeter_es.greet
+end
+
+end # class TestGreeter

data/test/test_version.rb

@@ -0,0 +1,21 @@
+# 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 Universum.version
+   pp Universum.banner
+   pp Universum.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: universum
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-29 00:00:00.000000000 Z
+date: 2019-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -46,16 +46,24 @@ email: wwwmake@googlegroups.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- HISTORY.md
+- CHANGELOG.md
+- LICENSE.md
 - Manifest.txt
 - README.md
 files:
-- HISTORY.md
+- CHANGELOG.md
+- LICENSE.md
 - Manifest.txt
 - README.md
 - Rakefile
 - lib/universum.rb
+- lib/universum/universum.rb
 - lib/universum/version.rb
+- test/contracts/greeter.rb
+- test/contracts/mytoken.rb
+- test/helper.rb
+- test/test_greeter.rb
+- test/test_version.rb
 homepage: https://github.com/openblockchains/universum
 licenses:
 - Public Domain