rubysol 0.1.0

data/lib/rubysol/generator.rb

@@ -0,0 +1,394 @@
+
+
+##
+#  "centralize"
+##   meta-programming magic (code generation) in module here - why? why not?
+##    find a better name e.g Magic? Pilot? or CodeGen or Metagen or ???
+module Generator
+
+
+############
+## helpers
+def self._demodulize( path )
+   ## turn class.name into a symbol cutting off all namepspaces (::)
+   ##  e.g.  Contracts::ERC20 => ERC20 
+   ##
+   ##  note: ActiveSupport::String#demodulize is the same (for string)
+
+   path = path.to_s 
+   if i = path.rindex('::')
+     path[(i+2)..-1]
+   else
+     path
+   end
+end   
+
+
+
+module Function
+####
+##  rename to pack_params/args or cook_params or typed_params or ???
+
+
+def self.typecheck( type, value )
+    ##   check if value is already typed?
+    if value.is_a?( Types::Typed )
+       ## type check
+       raise TypeError, "type #{type} expected; got #{value.pretty_print_inspect}"  unless type == value.type
+       value
+    else
+        ## assume "literal" value
+        type.new( value )
+    end
+end
+
+
+def self.params( method, inputs, *args_unsafe, **kwargs_unsafe )
+    m = method
+    params = m.parameters
+    ## puts "params for #{m} - #{m.owner}:"
+    ## pp params
+    
+    ## e.g.
+    ## [[:keyreq, :name], 
+    ##  [:keyreq, :symbol], 
+    ##  [:keyreq, :decimals], 
+    ##  [:keyreq, :totalSupply]]
+    ## get keys
+    keys = params.map { |param| param[1] }
+    ## puts "keys:"
+    ## pp keys
+ 
+    kwargs =  if !args_unsafe.empty? 
+                 values = inputs.zip( args_unsafe ).map do |type, value|
+                              typecheck( type, value )
+                          end
+                 ## puts "args:"
+                 ## puts values.pretty_print_inspect
+
+                 keys.zip( values ).map do |key,value|
+                                         [key,value]
+                 end.to_h
+              elsif !kwargs_unsafe.empty?
+                 types = keys.zip( inputs ).map do |key,type|
+                                         [key,type]
+                         end.to_h
+                 ## puts "types:"
+                 ## pp types
+                 kwargs_unsafe.map do |key,value|
+                    type = types[key]
+                    raise ArgumentError, "unknown kwarg #{key}; sorry"   if type.nil?
+                    [key, typecheck( type, value)]
+                end.to_h
+              else
+                ## assume no args - e.g. construct - double check for empty input spec/def!!!
+                if inputs.empty?
+                  {}   
+                else
+                  raise ArgumentError, "Array (args) or Hash (kwargs) required for func call; sorry"
+                end
+              end
+
+    unless kwargs.empty?          
+      puts "#{kwargs.size} kwarg(s):"
+      pp kwargs
+    end
+    
+    kwargs
+end
+end  # module Function
+
+
+## to rename to generate_typed or generate_wrapped or ??
+##      typed_method??
+def self.typed_function( contract_class, name, inputs: )  
+    ## note: must? find matching method in class
+    ## todo/fix:  use methods( false) if available (do NOT look-up in subclasses or such)
+
+    ## note: make sure name and contract_name is always a symbol
+    name          = name.to_sym
+    contract_name = _demodulize( contract_class.name ).to_sym   
+ 
+            exists = contract_class.instance_methods( false ).include?( name )
+            if !exists
+              error_message = "[ERRRO] no method #{name} found for sig in class #{contract_class.name}"
+              puts error_message
+              ## fix: change to NoMethodError - exists?
+              raise NameError, error_message
+            end
+      
+            ## note:  method lookup via method needs an object / INSTANCE
+            ##             NOT working with class only!!!!
+            ## m = contract_class.method( name )
+            ## puts "  bingo! #{name} - #{m.owner}"
+            puts "  bingo! #{name}"
+        
+
+## avoid recursive circle
+##    exlcude method from method_add automagic wrapping/generation 
+
+  contract_class.sigs_exclude << :"__#{contract_name}__#{name}_unsafe"
+  contract_class.sigs_exclude << :"__#{contract_name}__#{name}"
+  contract_class.sigs_exclude << name
+
+
+            ##
+            ##  use :name_raw instead of :name_unsafe - why? why not?
+ 
+            ## rewire
+            ##   alias_method :name_unsafe, :name
+            ##   alias_method :name,        :name_typed 
+            contract_class.class_eval do
+
+               define_method :"__#{contract_name}__#{name}" do |*args_unsafe,**kwargs_unsafe|
+                  puts "==> calling __#{contract_name}__#{name} (class #{contract_class.name})"
+        
+                  m = method( :"__#{contract_name}__#{name}_unsafe" )
+                  kwargs = Function.params( m, inputs, *args_unsafe, **kwargs_unsafe )
+                  
+                  ret = m.call( **kwargs )
+                  ## todo/fix:
+                  ##   check returns type / value too
+                  ret
+               end 
+      
+               ## note: must add class/contract name (via prefix) here!! 
+               ## rename (unsafe/untyped) method
+               alias_method :"__#{contract_name}__#{name}_unsafe", name
+               alias_method name,  :"__#{contract_name}__#{name}"
+               ## if name == :constructor  ### add ERC20() or such
+               ##   alias_method contract_name, :"__#{contract_name}__#{name}"
+               ## end
+               ##  - use leading underscore - why? why not? e.g. _ERC20()
+               ##        as alternative to NOT conflict with global conversion function - why? why not?
+            end
+end  # method typed_function
+
+
+def self.typed_library_function( contract_class, name, inputs: )  
+  ## note: must? find matching method in class
+  ## todo/fix:  use methods( false) if available (do NOT look-up in subclasses or such)
+
+  ## todo - make sure contract_class is a module (not a class) !!!!
+
+  ## note: make sure name and contract_name is always a symbol
+  name          = name.to_sym
+  contract_name = _demodulize( contract_class.name ).to_sym   
+
+          exists = contract_class.instance_methods( false ).include?( name )
+          if !exists
+            error_message = "[ERRRO] no method #{name} found for sig in module #{contract_class.name}"
+            puts error_message
+            ## fix: change to NoMethodError - exists?
+            raise NameError, error_message
+          end
+    
+          ## note:  method lookup via method needs an object / INSTANCE
+          ##             NOT working with class only!!!!
+          ## m = contract_class.method( name )
+          ## puts "  bingo! #{name} - #{m.owner}"
+          puts "  bingo! #{name}"
+      
+
+## avoid recursive circle
+##    exlcude method from method_add automagic wrapping/generation 
+
+contract_class.sigs_exclude << :"#{name}_unsafe"
+contract_class.sigs_exclude << name
+
+          ##
+          ##  use :name_raw instead of :name_unsafe - why? why not?
+
+          ## rewire
+          ##   alias_method :name_unsafe, :name
+          ##   alias_method :name,        :name_typed 
+          contract_class.class_eval do
+  
+             alias_method :"#{name}_unsafe", name
+  
+             define_method name do |*args_unsafe,**kwargs_unsafe|
+                puts "==> calling #{contract_name}.#{name} (module #{contract_class.name})"
+      
+                m = method( :"#{name}_unsafe" )
+                kwargs = Function.params( m, inputs, *args_unsafe, **kwargs_unsafe )
+                
+                ret = m.call( **kwargs )
+                ## todo/fix:
+                ##   check returns type / value too
+                ret
+             end 
+ 
+             ## make into module functions!!!
+             module_function name
+             module_function :"#{name}_unsafe"
+          end
+end  # method typed_library_function
+
+
+
+###
+#  add public getters helpers
+def self.getter_function(  contract_class, name, type )  
+    ## note: make sure name is always a symbol
+    name          = name.to_sym
+
+    if type.mapping?
+        mapping_getter_function( contract_class, name, type )
+    elsif type.array?
+      puts "[debug] auto-generate public array getter - #{name} : #{type}:"
+
+    
+      ## auto-add/register sig(nature) in here - why? why not?
+      ## contract_class.sig( name, 
+      ##      [Types::Typed::UIntType.instance], 
+      ##        :view, returns: type.sub_type )
+
+      ## auto-add/register sig(nature) in here - why? why not?
+      ## fix-fix-fix - check if outputs is an array (or still single type?)
+      contract_class.sigs[ name ] = { inputs: [typeof(Types::UInt)],
+                                      outputs: [typeof(type.sub_type)],
+                                      options: [:view,:public] } 
+      contract_class.sigs_exclude << name
+
+
+      contract_class.class_eval do
+        ## note: hack: must use kwargs for now!!! index: (not index) for now
+        define_method name do |index:|
+          puts "[debug] call public (state) array getter for #{name} : #{type} with index #{index} (#{contract_class.name})"
+          puts "[debug]  self -> #{self}"
+          value = instance_variable_get( :"@#{name}" )
+          value[index]   
+        end
+      end # class_evel
+
+      ## auto-add typed wrapper!!!!!
+      typed_function( contract_class, name, inputs: [typeof(Types::UInt)] )
+    else
+      puts "[debug] auto-generate public getter - #{name} : #{type}:"
+
+      ## auto-add/register sig(nature) in here - why? why not?
+      ## fix-fix-fix - check if outputs is an array (or still single type?)
+      contract_class.sigs[ name ] = { inputs: [],
+                                      outputs: [typeof(type)],
+                                      options: [:view, :public] } 
+      contract_class.sigs_exclude << name
+
+
+      contract_class.class_eval do
+       define_method name do
+         puts "[debug] call public (state) getter for #{name} : #{type} (#{contract_class.name})"
+         puts "[debug]  self -> #{self}"
+         value = instance_variable_get( :"@#{name}" )
+         value
+       end
+      end # class_eval
+
+      ## auto-add typed wrapper!!!!!
+      typed_function( contract_class, name, inputs: [] )
+    end # if
+
+    ## puts "after - instance_methods:"
+    ## pp contract_class.instance_methods( false )
+end  # method getter_function
+
+
+
+def self.mapping_getter_function( contract_class, name, type )
+    ## note: make sure name is always a symbol
+    name          = name.to_sym
+    
+    index = 0
+    current_type = type
+
+    sig_args = []
+    while current_type.mapping? do
+      sig_args << current_type.key_type
+      current_type = current_type.value_type
+      index += 1
+    end
+
+    
+    puts "[debug]  auto-generate public mapping getter - #{name} : #{type} (#{contract_class.name}):"
+    puts "sig_args:"
+    pp sig_args
+    ## auto-add/register sig(nature) in here - why? why not?
+    ## contract_class.sig( name, sig_args, :view, returns: current_type)
+    puts "    index: #{index}"
+# {:arg0=>:address}
+#    index: 1
+
+    ## check - if sig_args is alreay array of types (or typedclasses???)
+    sig_args = sig_args.map {|sig_arg| typeof(sig_arg) }
+
+    contract_class.sigs[ name ] = { inputs:  sig_args,
+                                    outputs: [typeof(current_type)],
+                                    options: [:view, :public] }
+    contract_class.sigs_exclude << name
+
+
+    puts  contract_class.sigs[ name ].pretty_print_inspect
+ 
+
+      contract_class.class_eval do
+       ## note: hack: must use kwargs for now!!! arg0, arg1, arg2, for now
+       define_method name do |arg0:, arg1: nil, arg2: nil, arg3: nil|
+        puts "[debug] call public (state) mapping getter for #{name} : #{type} - index: #{index} (#{contract_class.name})"
+        puts "[debug]  self -> #{self}"
+        args = [arg0, arg1, arg2, arg3]
+        puts "[debug]  args -> #{args.pretty_print_inspect}"
+     
+        ## raise ArgumentError, "expected #{index} argument(s); got #{args.size}" if args.size != index
+
+        value = instance_variable_get( "@#{name}" )
+         (0...index).each do |i|
+           value = value[ args[i] ]
+         end
+        value
+       end
+    end # class_eval
+
+    ## auto-add typed wrapper!!!!!
+    typed_function( contract_class, name, inputs: sig_args )
+
+end  # method mapping_getter_function
+
+
+
+##
+#  add global contract function to lookup AND typecheck
+##          contracts using  Contract.at 
+##   add via Module and Kernel - why? why not?        
+module Globals
+end  # module Globals
+
+## todo/check: move Kernel include to  rubidity.rb script (with requires) - why? why not?
+::Kernel.include( Globals )
+
+def self.global_function( contract_class )
+  ## todo/check: check if method exists already - why? why not?
+
+  contract_name = _demodulize( contract_class.name ).to_sym   
+
+  ## use module_eval if exists? why? why not?
+  ## example:
+  ##  def ERC20( address )
+  ##    klass = ERC20
+  ##    puts "==> calling #{klass.name}( #{address.pretty_print_inspect })"
+  ##    obj = klass.at( address )
+  ##    raise ArgumentError, "no #{klass.name} contract @ addreess #{address} found; sorry"   if obj.nil?
+  ##    puts "  bingo! #{obj.class.name} (#{obj.class.parent_contracts}) contract found @ #{address}"
+  ##    obj
+  ##  end  
+  Globals.class_eval do
+   define_method contract_name do |address|
+      klass = contract_class
+      puts "==> calling #{klass.name}( #{address.pretty_print_inspect })"
+      obj = klass.at( address )
+      raise ArgumentError, "no #{klass.name} contract @ address #{address} found; sorry"   if obj.nil?
+      puts "  bingo! #{obj.class.name} (#{obj.class.parent_contracts}) contract found @ #{address}"
+      obj
+   end
+  end
+end
+end  # module Generator
+

data/lib/rubysol/library.rb

@@ -0,0 +1,126 @@
+
+module Library
+
+  def self.extended(base)
+    puts "==> turn (extend) module >#{base.name}< into library"
+    base.include( Types )  ## make solidity types availbe (Address, Bytes, etc.)
+    base.extend( ClassMethods )
+    ## todo/fix: add  runtime and crypto methods too? why? why not? 
+  end
+
+
+  module ClassMethods
+    def struct( class_name, **attributes )
+      typedclass = Types::Struct.new( class_name, scope: self, **attributes )
+      typedclass  
+    end
+    
+    def enum( class_name, *args )
+      typedclass = Types::Enum.new( class_name, *args, scope: self  )
+      typedclass
+    end
+    
+####
+#   note:  sig machinery with method_added MUST come last here
+def sigs
+  @sigs ||= {}
+end
+
+def sigs_unnamed   ## unnamed sigs stack 
+  @sigs_unnamed ||= []
+end 
+
+## ignore this methods; 
+##   do NOT (auto-)generate wrapper method popping (unnamed) sig from stack!!!   
+def sigs_exclude
+  ## note: always exclude  globals
+  ##        get or can get changed via runtime modules (simulacrm) and such!!!
+  ##  e.g. msg.sender, block.timestamp, tx.origin, etc. 
+  @sigs_exclude ||= [:block, :tx, :msg]
+end
+
+
+
+def sig( args=[], *options, returns: nil )
+
+  puts "[debug] add sig args: #{args.inspect}, options: #{options.inspect}, returns: #{returns.inspect}"
+  ## use inputs for args) and outputs for returns  - why? why not?
+
+  ## check if include explicit visibility in options
+  if  options.include?( :public ) ||
+      options.include?( :private ) ||
+      options.include?( :internal )
+      # do nothing / pass-along as is
+  else
+      # auto-add default up-front - :public or :internal if name starting with underscore (_)
+      visibility =  name.start_with?( '_' )  ? :internal : :public
+      options.unshift( visibility )
+  end
+
+  ####  
+  #  auto-convert args (inputs), returns (outputs) to type (defs)
+  args = args.map { |value| typeof( value ) }
+
+  ###
+  ## note: turn returns into an array - empty if nil, etc.
+  ##        always wrap into array
+  returns =  if returns.nil?
+                  []
+             elsif returns.is_a?( ::Array ) 
+                  returns 
+             else  ## assume single type
+                  [returns]  
+             end  
+
+  returns = returns.map { |value| typeof( value ) }
+
+
+  @sigs_unnamed ||= [] 
+  @sigs_unnamed.push( { inputs:  args,
+                        outputs: returns,
+                        options: options } )
+end
+
+
+
+def method_added( name )
+
+  if sigs_exclude.include?( name )
+     puts "--- skip method added hook >#{name}< - found in sigs exclude"
+     return ## do nothing; 
+  else
+     puts "==> method added hook >#{name}<... processing..."
+  end
+
+  ## pp name
+  ## pp name.class.name
+
+  name = name.to_sym  ## note: make sure name is ALWAYS a symbol
+
+  ## note:  method lookup via method needs an object / INSTANCE
+  ##             NOT working with class only!!!!
+ 
+  # m = method( name )
+  # pp m.name
+  # pp m.parameters
+  # pp m
+
+  raise "no unnamed sig(nature) on stack for method >#{name}< in module >#{self.name}<; sorry"   if sigs_unnamed.size == 0
+  sig_unnamed = sigs_unnamed.pop  
+  puts "    using sig_unnamed: #{sig_unnamed.inspect}"
+  
+
+  @sigs ||= {}
+  raise "duplicate method sig(nature) for method >#{name}< in module >#{self.name}<; sorry"   if @sigs.has_key?( name )
+  @sigs[ name ] = sig_unnamed
+
+
+
+  puts "    generate typed_library_function >#{name}<"
+  Generator.typed_library_function( self, name, 
+                                      inputs: sig_unnamed[ :inputs ] )  
+
+  puts "<== method added hook >#{name}< done."                               
+end
+end # module ClassMethods
+end  # module Library

data/lib/rubysol/runtime.rb

@@ -0,0 +1,82 @@
+## todo/ find a better name - why? why not?
+##   change to Blockchain/Chain/Node/Client/Runner/Ctx/Context or ??? 
+class Runtime   
+
+
+  class Message
+    attr_reader :sender
+    
+    def sender=(address)
+      ## note: allow literal and typed address
+      @sender = address.is_a?( Types::Address) ?
+                    address : Types::Address.new( address )
+    end
+  end   # class Message
+  
+
+  class Tx 
+    attr_reader :origin
+    def origin=(address)
+      @origin = address.is_a?( Types::Address ) ?
+                   address : Types::Address.new( address )
+    end
+
+      def log_event( event )
+         puts "==> log_event:"
+         pp event
+      end
+=begin
+  def log_event(event)
+    call_receipt.logs << event
+    event
+  end
+=end
+  end  # class Tx
+  
+
+  class Block
+    attr_accessor :number, :timestamp
+    
+    # def initialize(current_transaction)
+    #   @current_transaction = current_transaction
+    # end
+    
+    def blockhash( block_number )
+      ##
+      # unless @current_transaction.ethscription.block_number == block_number.value # TODO FIX
+      #  raise "Not implemented"
+      # end
+      # 
+      # @current_transaction.ethscription.block_blockhash
+
+      # todo - check what ("dummy") to return here??
+    end
+    
+    def number=(number)
+      @number =    number.is_a?( Types::UInt ) ? 
+                      number : Types::UInt.new( number )
+    end
+    
+    def timestamp=(timestamp)
+      @timestamp =  timestamp.is_a?( Types::Timestamp ) ?
+                        timestamp : Types::Timestamp.new( timestamp )
+    end
+  end   # class Block
+
+
+
+  def self.msg()   @msg    ||= Message.new; end
+  def self.block() @block  ||= Block.new; end     
+
+
+  ## use begin_transaction or
+  ##     new_transaction or  __ - why? why not?
+  def self.start_transaction()   @tx = Tx.new; end
+  def self.current_transaction() @tx ||= Tx.new; end
+
+  class << self
+    alias_method :start_tx,   :start_transaction
+    alias_method :current_tx, :current_transaction
+  end
+end  # class Runtime   
+

data/lib/rubysol/version.rb

@@ -0,0 +1,23 @@
+module Rubysol
+  module Module
+    module Lang
+      MAJOR = 0
+      MINOR = 1
+      PATCH = 0
+      VERSION = [MAJOR,MINOR,PATCH].join('.')
+    
+      def self.version
+        VERSION
+      end
+    
+      def self.banner
+        "rubysol/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}] in (#{root})"
+      end
+    
+      def self.root
+        File.expand_path( File.dirname(File.dirname(File.dirname(File.dirname(__FILE__)))) )
+      end
+    
+    end # module Lang
+  end # module Module
+end # module Rubysol