rubysol 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 43d35a08ccf1d5b5dff18647a35cd0080da617acb43e299b3c4a0f477b366dae
+  data.tar.gz: 200f1cfe5afb3eb2e90be4c8eb34d31a8c71143d29a1c8d7662be90f9c8d4257
+SHA512:
+  metadata.gz: 7f59e4b03ee479d4992aaf8fe49e00a4004574fcfffad96da7bad39d5017a6fd19070a060c981304961ba7c2b34592c6e20792c679a34e5865b9d016eefdc485
+  data.tar.gz: e977a4a7df706617c3891e4ec2291c96797e8a4154c37a9c3b514905597f49254faa41119e30473c003e483845319f08a75f273571443608cffd909968587e0e

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+### 0.1.0 / 2023-11-15
+
+* Everything is new. First release

data/Manifest.txt

@@ -0,0 +1,13 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+lib/rubysol.rb
+lib/rubysol/abi_proxy.rb
+lib/rubysol/contract.rb
+lib/rubysol/contract/crypto.rb
+lib/rubysol/contract/runtime.rb
+lib/rubysol/generator.rb
+lib/rubysol/library.rb
+lib/rubysol/runtime.rb
+lib/rubysol/version.rb

data/README.md

@@ -0,0 +1,170 @@
+# Rubysol  
+
+rubysol - ruby for (blockchain) layer 1 (l1) contracts / protocols with "off-chain" indexer; 100% compatible with solidity datatypes and abis
+
+
+* home  :: [github.com/s6ruby/rubidity](https://github.com/s6ruby/rubidity)
+* bugs  :: [github.com/s6ruby/rubidity/issues](https://github.com/s6ruby/rubidity/issues)
+* gem   :: [rubygems.org/gems/rubysol](https://rubygems.org/gems/rubysol)
+* rdoc  :: [rubydoc.info/gems/rubysol](http://rubydoc.info/gems/rubysol)
+
+
+
+## What's Solidity?! What's Rubidity?! What's Rubysol?!
+
+See [**Solidity - Contract Application Binary Interface (ABI) Specification** »](https://docs.soliditylang.org/en/latest/abi-spec.html)
+
+See [**Rubidity - Ruby for Layer 1 (L1) Contracts / Protocols with "Off-Chain" Indexer**  »](https://github.com/s6ruby/rubidity)
+
+
+
+
+## Usage
+
+### Token Contract - Rubysol "Off-Chain" Example
+
+Let's try an "off-chain" token contract with 
+the "core" rubysol language.
+
+
+``` ruby
+require 'rubysol'
+
+
+class TestToken < Contract    
+
+    event :Transfer, from:   Address, 
+                     to:     Address, 
+                     amount: UInt 
+
+    storage  name:        String, 
+             symbol:      String, 
+             decimals:    UInt,       
+             totalSupply: UInt,
+             balanceOf:   mapping( Address, UInt ) 
+
+
+    sig [String, String, UInt, UInt] 
+    def constructor(name:, 
+                   symbol:, 
+                   decimals:,
+                   totalSupply:) 
+        @name = name
+        @symbol = symbol
+        @decimals = decimals
+        @totalSupply = totalSupply
+
+        @balanceOf[msg.sender] = totalSupply
+     end
+
+    sig [Address, UInt], returns: Bool 
+    def transfer( to:, amount: )
+        assert @balanceOf[msg.sender] >= amount, 'Insufficient balance'
+        
+        @balanceOf[msg.sender] -= amount
+        @balanceOf[to] += amount
+   
+        log Transfer, from: msg.sender, to: to, amount: amount        
+        true
+    end
+end  # class TestToken  
+```
+
+
+and let's test run the contract ....
+
+``` ruby
+pp TestToken.state_variable_definitions
+pp TestToken.events 
+pp TestToken.is_abstract_contract
+
+abi = TestToken.abi
+
+pp TestToken.public_abi
+  
+
+contract = TestToken.new
+pp contract
+
+
+## test globals (context)
+pp contract.msg
+pp contract.msg.sender
+contract.msg.sender = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'   # a(lice)
+pp contract.msg.sender
+
+
+pp contract.serialize
+#=> {:name=>"", 
+#    :symbol=>"", 
+#    :decimals=>0, 
+#    :totalSupply=>0, 
+#    :balanceOf=>{}}
+      
+
+contract.constructor(
+               'My Fun Token',
+               'FUN',
+               18,
+               21000000 )
+
+pp contract.serialize
+#=> {:name=>"My Fun Token",
+#    :symbol=>"FUN",
+#    :decimals=>18,
+#    :totalSupply=>21000000,
+#    :balanceOf=>{'0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"=>21000000}}
+
+pp contract.name
+#=> "My Fun Token"
+pp contract.symbol
+#=> "FUN"
+pp contract.decimals    
+#=> 18
+pp contract.totalSupply
+#=> 21000000
+
+pp contract.balanceOf( '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
+#=> 21000000
+
+
+pp contract.transfer( '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', 
+                    10000 )
+
+pp contract.serialize
+#=> {:name=>"My Fun Token",
+#    :symbol=>"FUN",
+#    :decimals=>18,
+#    :totalSupply=>21000000,
+#    :balanceOf=>
+#    {"0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"=>20990000, 
+#     "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"=>10000}}
+
+pp contract.balanceOf( '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
+#=> 20990000 
+pp contract.balanceOf( '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb')
+#=> 10000
+```
+
+
+And so on.  To be continued ...
+
+
+
+## Bonus - More Blockchain (Crypto) Tools, Libraries & Scripts In Ruby
+
+See [**/blockchain**](https://github.com/rubycocos/blockchain) 
+at the ruby code commons (rubycocos) org.
+
+
+
+
+## Questions? Comments?
+
+Join us in the [Rubidity & Rubysol (community) discord (chat server)](https://discord.gg/3JRnDUap6y). Yes you can.
+Your questions and commentary welcome.
+
+Or post them over at the [Help & Support](https://github.com/geraldb/help) page. Thanks.
+
+
+

data/Rakefile

@@ -0,0 +1,33 @@
+require 'hoe'
+require './lib/rubysol/version.rb'
+
+
+Hoe.spec 'rubysol' do
+
+  self.version =   Rubysol::Module::Lang::VERSION
+
+  self.summary = 'rubysol - ruby for (blockchain) layer 1 (l1) contracts / protocols with "off-chain" indexer; 100% compatible with solidity datatypes and abis'
+  self.description = summary
+
+  self.urls    = { home: 'https://github.com/s6ruby/rubidity' }
+
+  self.author  = 'Gerald Bauer'
+  self.email   = 'gerald.bauer@gmail.com'
+
+  # switch extension to .markdown for gihub formatting
+  self.readme_file  = 'README.md'
+  self.history_file = 'CHANGELOG.md'
+
+  self.extra_deps = [
+    ['solidity-typed', '>= 0.2.0'],
+    ['digest-lite'],      ## pulls in keccak256
+    ['hexutils'],         ## pulls in hex/to_hex (decode/encode_hex)
+  ]
+
+
+  self.licenses = ['Public Domain']
+
+  self.spec_extras = {
+    required_ruby_version: '>= 2.3'
+  }
+end

data/lib/rubysol/abi_proxy.rb

@@ -0,0 +1,206 @@
+
+
+class AbiProxy
+  
+  ## todo: make data private!!!
+  ##  make  read access available via #each !!!
+  attr_accessor :contract_class
+  
+  def initialize(contract_class)
+    @contract_class = contract_class
+    @generated = false
+
+    parents = contract_class.linearized_parents 
+    if parents.empty?
+      ## do nothing
+    else 
+      _merge_state_variables( parents)
+    end
+  end
+
+###
+##  keep a list of generated classes (only needed/possible to generatae once)
+def self.contract_classes() @classes ||= []; end
+def _contract_classes() self.class.contract_classes; end
+
+
+## generated? - use flag to keep track of code generation (only one time needed/required)  
+def generated?() @generated; end
+def generate_functions
+  @generated = true
+
+  puts "==> generate (typed) functions for #{@contract_class.name}"
+  
+  parents = @contract_class.linearized_parents 
+  ## revesee order - why? why not?
+  parents.each do |parent|
+    _generate_functions( parent )
+  end
+  _generate_functions( @contract_class )
+end
+
+
+def _generate_functions( contract_class )
+  ## start with simple (no parents) for now
+
+   sigs = contract_class.sigs
+   puts "#{sigs.size} function signatures in #{contract_class.name}:"
+   pp sigs
+
+   ## note: only generate once for now!!!!
+   ##        maybe check later if new sigs?? possible? why? why not?
+   if _contract_classes.include?( contract_class )
+       puts "   already generated!"
+   else
+     ## generate global function (e.g. ERC20() or such)
+     Generator.global_function( contract_class )
+
+     # sigs.each do |name, definition|
+     #    Generator.typed_function( contract_class, name, 
+     #                                  inputs: definition[:inputs] )
+     #  end
+     _contract_classes << contract_class
+   end
+end
+
+
+  ### todo/check -- where used? check for parent_contracts
+  # def parent_contracts
+  #  contract_class.parent_contracts
+  # end
+  
+  
+  
+  def _merge_state_variables( parents )
+    puts "[debug] AbiProxy#merge_parent_state_variables - #{contract_class}"
+    parent_state_variables = parents.map(&:state_variable_definitions).reverse
+    vars = parent_state_variables.reduce( {} ) { |mem,h| mem.merge(h) }
+                                 .merge( contract_class.state_variable_definitions)
+    puts "[debug]   merged state_variables:"
+    pp vars
+    contract_class.state_variable_definitions = vars    
+  end 
+    
+ 
+
+  def public_abi
+    ### note: calculate for now on-the-fly - why? why not?
+    ##   cache results - why? why not?
+    contracts = [@contract_class] + @contract_class.linearized_parents
+    ## note: use reverse order - 
+    ##         most concreate comes last (for override)
+    contracts = contracts.reverse  
+
+
+    ## todo/fix: add (contract) klass for source to data???  - why? why not?
+    data = {}
+
+    contracts.each do |klass|
+      klass.sigs.each do |name, definition|
+           if definition[:options].include?( :public )
+              ## check for override 
+              ##   and issue info for now 
+                if data.has_key?( name )
+                  ## Solidity lets developers change how a function in the parent contract is implemented
+                  ##  in the derived class. This is known as function overriding. 
+                  ##  The function in the parent contract needs to be declared with
+                  ##  the keyword virtual to indicate that it can be overridden 
+                  ## in the deriving contract.
+                  ##  
+                  ##   todo: check for virtual keyword - why? why not?
+                    if name == :constructor
+                      puts "   overriding constructor in #{klass.name}"
+                    else
+                      puts "   overriding function #{name} in #{klass.name}"
+                    end
+                end
+                data[name] = definition  
+           else
+              puts "   skip non-public sig - #{name} #{definition.inspect}"
+           end
+      end
+    end
+
+    data
+  end
+  alias_method :public_api, :public_abi   ## only use public_abi (not api) - why? why not?
+
+
+  ## rename to to_abi_json or export_abi_json or solidity_abi_json or ??
+  def public_abi_as_json
+   ##
+   ## todo/fix: add events too!!!
+   ## todo/fix:  add input parameter names too!!!!
+
+# json format:    
+#      Type - defines the nature of the function (receive, fallback, constructor) 
+#      Name - defines the name of the function
+#      Inputs - array of objects with name, type, components
+#      Outputs - array of objects similar to inputs
+#      stateMutability - defines the mutability of the function (pure, view, non-payable or payable) 
+#
+#  "type": "constructor",
+#  "inputs": [
+#   { "type": "string", "name": "symbol" },
+#   { "type": "string", "name": "name" }
+#  ]
+#
+#  "type": "function",
+#  "name": "balanceOf",
+#  "stateMutability": "view",
+#    "inputs": [
+#      { "type": "address", "name": "owner"}
+#    ],
+#    "outputs": [
+#      { "type": "uint256"}
+#    ]
+
+     data = []
+ 
+     public_abi.each do |name, definition|
+                   inputs = definition[:inputs].map do |input|
+                                             ## todo: use a _arg1, _arg2, 
+                                             ##   count or such - why?
+                                          { 'type' => input.to_s,
+                                            'name' => '_'
+                                          }
+                                     end  
+
+                    state_mutability = 'nonpayable'  ## default is nonpayable (double check)
+                    state_mutability = 'view'   if definition[:options].include?( :view )
+
+               if name == :constructor
+                   data << { 
+                              'type'            => 'constructor', 
+                              'stateMutability' => state_mutability,
+                              'inputs'          =>  inputs
+                            }     
+               else
+                   ## check if outputs is a single entry or array or nil or hash?
+                   outputs = definition[:outputs].is_a?( Array ) ?
+                                      definition[:outputs]  : [definition[:outputs]] 
+                   outputs = outputs.map do |output|
+                                             ## todo: use a _arg1, _arg2, 
+                                             ##   count or such - why?
+                                          { 'type' => output.to_s,
+                                            'name' => '_'
+                                          }
+                                     end  
+
+                   data << {
+                              'type'     => 'function', 
+                              'name'     =>  name.to_s,                    
+                              'stateMutability' => state_mutability,
+                              'inputs'   =>  inputs,
+                              'outputs'  =>  outputs,
+                           }
+               end              
+     end
+     data   
+  end
+
+
+  def public_abi_to_json
+      JSON.pretty_generate( public_abi_as_json )
+  end
+end  # class  AbiProxy

data/lib/rubysol/contract/crypto.rb

@@ -0,0 +1,27 @@
+
+
+### use a differet name? why? why not?
+##     e.g CryptoFunctons or ...
+
+module CryptoHelper     
+###
+#  Digest::KeccakLite.new( 256 ).hexdigest( 'abc' )   # or
+#  Digest::KeccakLite.hexdigest( 'abc', 256 )
+#  #=> "4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45"  
+
+
+  ## fix-fix-fix - return a bytes32 type!!!!!!
+  def keccak256( input )
+  ## todo/fix: check if input is binary string 
+  ##    (convert to bytes - why? why not?)
+  ##    should really always use hex_to_bin !!! 
+  ##    and convert the result in the end only - why? why not??
+
+    str = Types::String.new( input )
+
+    ## fix: convert hexdigest to binary
+    '0x' + Digest::KeccakLite.hexdigest( str.as_data, 256  )
+  end
+
+
+end  # module CryptoHelper

data/lib/rubysol/contract/runtime.rb

@@ -0,0 +1,56 @@
+### use a differet name? why? why not?
+###   Runtime__ or Runtime ___ ???
+
+
+module RuntimeHelper    
+    
+  ### keep assert here - why? why not?
+  ##    use AssertHelper or ErrorHelper or ...    
+  ##
+  ## note: change from require to assert
+  ##         to avoid confusion with ruby require - why? why not?
+  def assert(condition, message='no message')
+    unless condition
+      # caller_location = caller_locations.detect { |l| l.path.include?('/app/models/contracts') }
+      # file = caller_location.path.gsub(%r{.*app/models/contracts/}, '')
+      # line = caller_location.lineno
+      
+      puts "!! ASSERT FAILED - #{message}"
+
+      error_message = "#{message}"     ##. (#{file}:#{line})"
+      ## todo/fix: change to (built-in) ???Error, ....
+      ##  check for error to raise for assertion fail??
+      raise error_message
+    end
+  end
+   
+
+  ## note: for now this is just the solidity alias/used name
+  ##  for ruby's self  - anything missing - why? why not?
+  ##  - to get the address - use address( this ) 
+  def this()  self; end
+
+
+  ## todo/check: change current_transaction to tx - why? why not?  
+  def current_transaction()  Runtime.current_transaction; end
+ 
+  def msg()                  Runtime.msg; end
+  def block()                Runtime.block; end
+
+  def log( event_klass, *args, **kwargs )
+
+    raise "event class expected; got: >#{event_klass.inspect}<; sorry"  unless event_klass.ancestors.include?( Types::Event)
+    
+    rec = if kwargs.size > 0
+            event_klass.new( **kwargs )
+          else
+            event_klass.new( *args )
+          end
+    data = rec.as_data   ## "serialize" to "plain" types
+    
+    current_transaction.log_event( { event: event_klass.name, 
+                                     data:  data })
+  end
+
+end  # module RuntimeHelper
+