universum 0.1.2 → 0.2.0

data/lib/universum/safe_array.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+class SafeArray
+
+  ## e.g.
+  ##  Array.of( Address ), Array.of( Integer), etc.
+
+  def self.build_class( klass_value )
+    ## note: care for now only about value type / class
+
+    ## note: keep a class cache
+    cache = @@cache ||= {}
+    klass = cache[ klass_value ]
+    return klass   if klass
+
+    klass = Class.new( SafeArray )
+    klass.class_eval( <<RUBY )
+      def self.klass_value
+        @klass_value ||= #{klass_value}
+      end
+RUBY
+    ## add to cache for later (re)use
+    cache[ klass_value ] = klass
+    klass
+  end
+
+
+  def self.new_zero()  new;  end
+  def self.zero()      @zero ||= new_zero;  end
+
+
+
+  def initialize
+    ## todo/check: if array works if value is a (nested/multi-dimensional) array
+    @ary  = []
+  end
+
+  def []=(index, value)
+    @ary[index] = value
+  end
+
+  def [](index)
+    item = @ary[ index ]
+    if item.nil?
+      ## todo/check:
+      ##    always return (deep) frozen zero object - why? why not?
+      ##     let user change the returned zero object - why? why not?
+      if self.class.klass_value.respond_to?( :new_zero )
+        ## note: use a new unfrozen copy of the zero object
+        ##    changes to the object MUST be possible (new "empty" modifable object expected)
+       item = self.class.klass_value.new_zero
+     else  # assume value semantics e.g. Integer, Bool, etc. zero values gets replaced
+       ## puts "use value semantics"
+       item = self.class.klass_value.zero
+     end
+    end
+    item
+  end
+
+  def push( item )
+    ## todo/fix: check if item.is_a? @type
+    ##   note: Address might be a String too (Address | String)
+    ##     store Address always as String!!! - why? why not?
+    @ary.push( item )
+  end
+
+  def size() @ary.size; end
+  def length() size; end
+end # class SafeArray

data/lib/universum/safe_hash.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+
+class SafeHash
+
+  ## e.g.
+  ##  Mapping.of( Address => Money )
+
+  ##   note: need to create new class!! for every mapping
+  ##     make klass_key class and
+  ##          klass_value class  into class instance variables
+  ##     that can get used by zero
+  ##       self.new returns a Hash.new/SafeHash.new like object
+
+  def self.build_class( klass_key, klass_value )
+    ## note: care for now only about value type / class
+
+    ## note: keep a class cache
+    cache = @@cache ||= {}
+    klass = cache[ klass_value ]
+    return klass   if klass
+
+    klass = Class.new( SafeHash )
+    klass.class_eval( <<RUBY )
+      def self.klass_key
+        @klass_key   ||= #{klass_key}
+      end
+      def self.klass_value
+        @klass_value ||= #{klass_value}
+      end
+RUBY
+    ## add to cache for later (re)use
+    cache[ klass_value ] = klass
+    klass
+  end
+
+
+  def self.new_zero()  new;  end
+  def self.zero()      @zero ||= new_zero;  end
+
+
+  def initialize
+    ## todo/check: if hash works if value is a (nested) hash
+    @h  = {}
+  end
+
+
+  def []=(key, value)
+    @h[key] = value
+  end
+
+  def [](key)
+    item = @h[ key ]
+    if item.nil?
+      ## pp self.class.klass_value
+      ## pp self.class.klass_value.zero
+
+      #####
+      # todo/check:
+      #    add zero to hash on lookup (increases size/length)
+      #    why? why not?
+
+      if self.class.klass_value.respond_to?( :new_zero )
+        ## note: use a dup(licated) unfrozen copy of the zero object
+        ##    changes to the object MUST be possible (new "empty" modifable object expected)
+       item = @h[ key ] = self.class.klass_value.new_zero
+     else  # assume value semantics e.g. Integer, Bool, etc. zero values gets replaced
+       ## puts "use value semantics"
+       item = @h[ key ] = self.class.klass_value.zero
+     end
+    end
+    item
+  end
+
+  def size() @h.size; end
+  def length() size; end
+end # class SafeHash

data/lib/universum/transaction.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+
+class Transaction
+
+  def self.send( **kwargs )  ## convenience helper for Uni.send_transaction
+    Universum.send_transaction( **kwargs )
+  end
+
+
+  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 :-)

data/lib/universum/type.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+
+## 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)
+       klass_key   = arg[0][0]
+       klass_value = arg[0][1]
+       klass = SafeHash.build_class( klass_key, klass_value )
+       klass.new
+     else
+       ## todo/fix: throw argument error/exception
+       Hash.new    ## that is, "plain" {} with all "standard" defaults
+     end
+  end
+end
+
+
+class Array
+  ## "typed" safe array "constructor"
+  ## e.g.  Array.of( Address ) or Array.of( Money ) or Array.of( Proposal, size: 2 ) etc.
+  def self.of( klass_value )
+    klass = SafeArray.build_class( klass_value )
+    klass.new  ## todo: add klass.new( **kwargs ) for size: 2 etc.
+  end
+end

data/lib/universum/units_money.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+class Integer
+
+  E3  = 10**3   # 1_000
+  E6  = 10**6   # 1_000_000
+  E9  = 10**9   # 1_000_000_000
+  E12 = 10**12  # 1_000_000_000_000
+  E15 = 10**15  # 1_000_000_000_000_000
+  E18 = 10**18  # 1_000_000_000_000_000_000
+
+  def e3()  self * E3; end
+  def e6()  self * E6; end
+  def e9()  self * E9; end
+  def e12() self * E12; end
+  def e15() self * E15; end
+  def e18() self * E18; end
+
+
+  ## todo/fix: move ethereum money units to a module and include here
+
+  ###########
+  # Ethereum money units
+  #
+  #  wei                     1 wei | 1
+  #  kwei (babbage)        1e3 wei | 1_000
+  #  mwei (lovelace | ada) 1e6 wei | 1_000_000
+  #  gwei (shannon)        1e9 wei | 1_000_000_000
+  #  microether (szabo)   1e12 wei | 1_000_000_000_000
+  #  milliether (finney)  1e15 wei | 1_000_000_000_000_000
+  #  ether                1e18 wei | 1_000_000_000_000_000_000
+  #
+  #  Names in Honor:
+  #   wei            => Wei Dai
+  #   lovelace | ada => Ada Lovelace (1815-1852)
+  #   babbage	       => Charles Babbage (1791-1871)
+  #   shannon	       => Claude Shannon (1916-2001)
+  #   szabo          => Nick Szabo
+  #   finney         => Hal Finney (1956-2014)
+
+  def wei()        self; end
+  def kwei()       self * E3; end
+  def mwei()       self * E6; end
+  def gwei()       self * E9; end
+  def microether() self * E12; end
+  def milliether() self * E15; end
+  def ether()      self * E18; end
+
+  ########################################################
+  ## alias - use alias or alias_method - why? why not?
+  def babbage()   kwei; end
+  def lovelace()  mwei; end
+  def ada()       mwei; end    ## todo/check: in use, really? keep just lovelave- why? why not?
+  def shannon()   gwei; end
+  def szabo()     microether; end
+  def finney()    milliether; end
+
+  def microeth()  microether; end
+  def micro()     microether; end
+  def millieth()  milliether; end
+  def milli()     milliether; end
+  def eth()       ether; end
+
+end  # class Integer

data/lib/universum/units_time.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+
+class Integer
+
+  ######################################
+  ## note: there's NO month (for now)!!!
+  ##   why?  month might be 28,29,30,31  days
+  ##    use days e.g. 30.days or 31.days etc.
+
+  HOUR_IN_SECONDS       =  60 * 60                # 60 minutes * 60 seconds
+  DAY_IN_SECONDS        =  24 * HOUR_IN_SECONDS   # 24 hours * 60 * 60
+  WEEK_IN_SECONDS       =   7 * DAY_IN_SECONDS    #  7 days * 24 * 60 * 60
+  FORTNIGHT_IN_SECONDS  =  14 * DAY_IN_SECONDS    # 14 days * 24 * 60 * 60
+  YEAR_IN_SECONDS       = 365 * DAY_IN_SECONDS    # 365 days * 24 * 60 * 60
+
+  def second()    self; end
+  def minute()    self * 60; end
+  def hour()      self * HOUR_IN_SECONDS; end
+  def day()       self * DAY_IN_SECONDS;  end
+  def week()      self * WEEK_IN_SECONDS; end
+  def fortnight() self * FORTNIGHT_IN_SECONDS; end
+  def year()      self * YEAR_IN_SECONDS; end
+
+  ########################################################
+  ## alias - use alias or alias_method - why? why not?
+  def seconds() second; end
+  def secs()    second; end
+  def sec()     second; end
+  def s()       second; end
+
+  def minutes() minute; end
+  def mins()    minute; end
+  def min()     minute; end
+  def m()       minute; end
+
+  def hours()   hour; end
+  def h()       hour; end
+
+  def days() day; end
+  def d()    day; end
+
+  def weeks() week; end
+  def w()     week; end
+
+  def fortnights() fortnight; end
+
+  def years() year; end
+  def y()     year; end
+
+end # class Integer

data/lib/universum/universum.rb

@@ -1,255 +1,6 @@
 # encoding: utf-8
 
 
-
-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?
@@ -263,7 +14,6 @@ class Msg
 end  # class Msg
 
 
-
 class Block
   attr_reader :timestamp, :number
 
@@ -274,150 +24,6 @@ class Block
 end  # class Block
 
 
-
-class Transaction
-
-  def self.send( **kwargs )  ## convenience helper for Uni.send_transaction
-    Universum.send_transaction( **kwargs )
-  end
-
-
-  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
-
-
-
-
 class Universum   ## Uni short for Universum
   ## convenience helpers