solidity-typed 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f81ad150dc806a0f2762f4d012dd5b2f64a6957f1a6b44b366823fab8a05b07
-  data.tar.gz: 269e9e51fa0a30e1b95d2abea121494bef11af559ec7f1063b6283c9315d15a3
+  metadata.gz: 87b1228588a659eb48208556c664337bdcc1297fef7caf31c337a64f5fd67cac
+  data.tar.gz: 751ea77f7d80035cb0d8592b1ca4bfe33c22bac624aabe9a9bdfa68c069cdb78
 SHA512:
-  metadata.gz: d614ebe7a9be302c64fec852d3c0105fd70574a9302315ac12d47a6dbedd434c5ec562eb00f657036bb20604ec32905644ad5af389e0fe318195c5ce26a8e892
-  data.tar.gz: 261b765c22ae3eb26c45e95ca9082dece2de4ee026d6cd74f9207db1fda6a02d040908d8bdd954e566333e6c5c2bb0d0b4423d57df2d4e1fad4b6ee7dd2d1ac1
+  metadata.gz: 7d0f52e49d76845b977b6e231094e8c224e2005bb462bd11d96cce0b34d4b214af6f2ab9e76ca20aff7f5d7933d25f3c1e45f26199335ab18542776a543381a2
+  data.tar.gz: e2c573374311bcc119a149e7923a52e4c254e110bb929fb804fff0327ecd40306e3329ea1b8c2ef72d1cd66ddba26f7b6b91e2a2670798774e99e31a91b26065

data/CHANGELOG.md

@@ -1,4 +1,4 @@
-### 0.2.0
+### 0.2.1
 ### 0.0.1 / 2023-09-10
 
 * Everything is new. First release

data/Manifest.txt

@@ -9,8 +9,11 @@ lib/solidity/typed/bool.rb
 lib/solidity/typed/conversion.rb
 lib/solidity/typed/enum.rb
 lib/solidity/typed/enum_builder.rb
+lib/solidity/typed/error.rb
+lib/solidity/typed/error_builder.rb
 lib/solidity/typed/event.rb
 lib/solidity/typed/event_builder.rb
+lib/solidity/typed/integer.rb
 lib/solidity/typed/mapping.rb
 lib/solidity/typed/mapping_builder.rb
 lib/solidity/typed/metatypes/array.rb

data/README.md

@@ -1,6 +1,6 @@
 # Solidity Typed
 
-solidity-typed - "zero-dependency" 100%-solidity compatible data type and application binary interface (abi) machinery incl. bool, (frozen) string, address, bytes, uint, int, enum, struct, array, mapping, event, and more for solidity-inspired contract (blockchain) programming languages incl. rubidity et al
+solidity-typed - "zero-dependency" 100%-solidity compatible data type and application binary interface (abi) machinery incl. bool, (frozen) string, address, bytes, uint, int, enum, struct, array, mapping, event, and more for solidity-inspired contract (blockchain) programming languages incl. rubidity, rubysol et al
 
 
 
@@ -11,12 +11,14 @@ solidity-typed - "zero-dependency" 100%-solidity compatible data type and applic
 * rdoc  :: [rubydoc.info/gems/solidity-typed](http://rubydoc.info/gems/solidity-typed)
 
 
-## What's Solidity?! What's Rubidity?!
+## 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)
 
+See [**Rubysol - Ruby for Layer 1 (L1) Contracts / Protocols with "Off-Chain" Indexer**  »](https://github.com/s6ruby/rubidity/tree/master/rubysol)
+
 
 
 
@@ -311,7 +313,7 @@ at the ruby code commons (rubycocos) org.
 
 ## Questions? Comments?
 
-Join us in the [Rubidity (community) discord (chat server)](https://discord.gg/3JRnDUap6y). Yes you can.
+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

@@ -5,7 +5,7 @@ require './lib/solidity/typed/version.rb'
 Hoe.spec 'solidity-typed' do
   self.version =  Solidity::Module::Typed::VERSION
 
-  self.summary = 'solidity-typed - "zero-dependency" 100%-solidity compatible data type and application binary interface (abi) machinery incl. bool, (frozen) string, address, bytes, uint, int, enum, struct, array, mapping, event, and more for solidity-inspired contract (blockchain) programming languages incl. rubidity et al'
+  self.summary = 'solidity-typed - "zero-dependency" 100%-solidity compatible data type and application binary interface (abi) machinery incl. bool, (frozen) string, address, bytes, uint, int, enum, struct, array, mapping, event, and more for solidity-inspired contract (blockchain) programming languages incl. rubidity, rubysol et al'
   self.description = summary
 
   self.urls    = { home: 'https://github.com/s6ruby/rubidity' }

data/lib/solidity/typed/conversion.rb

@@ -7,15 +7,27 @@
 module ConversionFunctions
 #####
 #  todo/check:   use AddressType.try_convert( literal_or_obj ) or such - why? why not?
-def address( literal=0 )
+def address( obj )
     ## hack for now support  address(0) 
     ##  todo/fix:  address( '0x0' ) too!!!!
-    return Types::Typed::AddressType.instance.zero   if literal.is_a?(::Integer) && literal == 0
+    return Types::Address.zero                    if obj.is_a?(::Integer) && obj == 0
 
-    Types::Typed::AddressType.instance.check_and_normalize_literal( literal )
+    ## note: for now assume contract is always "construct"ed (and, thus, has an address assigned)
+    return Types::Address.new( obj.__address__ )  if obj.is_a?( Contract )
+
+    Types::Address.new( obj )
 end  # methdod address 
 
 
+def uint( obj )
+    return obj.to_uint   if obj.is_a?( Types::Address )
+    return obj           if obj.is_a?( Types::UInt )
+
+    Types::UInt.new( obj )   ## assume obj is a integer number
+end
+alias_method :uint256, :uint
+alias_method :uint224, :uint
+alias_method :uint112, :uint   ## note: for now all are uint256 - fix? - why? why not?
 =begin
 def uint( obj=0 )
     ## check if typed?
@@ -24,6 +36,15 @@ end
 =end
 
 
+def bytes( obj )
+  return obj           if obj.is_a?( Types::Bytes )
+
+  Types::Bytes.new( obj )   
+end
+alias_method :bytes4, :bytes  ## fix-fix-fix  - cut of bytes (only first 4 bytes/8 hexchars)
+
+
+
 
 =begin  
   def string(i)

data/lib/solidity/typed/error.rb

@@ -0,0 +1,81 @@
+
+module Types
+
+## note:  CANNOT derive from Typed 
+##            
+
+##
+## why StandardError base?
+##     StandardError is  default for rescue
+
+
+class Error  <  StandardError
+
+   def type()     self.class.type; end  
+   def self.zero
+     raise "error cannot be zero (by defintion); sorry"
+   end
+   def zero?() false; end
+
+
+
+def initialize( *args, **kwargs  )
+   ## fix-fix-fix: first check for matching args - why? why not?
+    if kwargs.size > 0   ## assume kwargs
+      ## note: kwargs.size check matching attributes "upstream" in new!!!
+      self.class.attributes.each do |key, type|
+         value = kwargs[ key ]
+         raise ArgumentError,  "error arg with key >#{key}< missing; sorry"  if value.nil?
+         value = if value.is_a?(Typed)
+                   ## fix-fix-fix - check type match here!!!
+                   value
+                 else 
+                   type.new( value )
+                 end
+         instance_variable_set( "@#{key}", value )
+      end
+    else
+      self.class.attributes.zip( args ).each do |(key, type), value|
+         value = if value.is_a?(Typed)
+                ## fix-fix-fix - check type match here!!!
+                   value
+                 else 
+                   type.new( value )
+                 end
+         instance_variable_set( "@#{key}", value )
+      end
+   end
+   self  ## note: return reference to self for chaining method calls
+end
+
+
+def as_data
+   self.class.attributes.keys.map do |key|
+        ivar = instance_variable_get( "@#{key}" )
+        puts "  @#{key}:"
+        pp ivar
+        ivar.as_data
+   end
+end
+## keep serialize and/or as_json - why? why not?
+def serialize() as_data; end
+def as_json()   as_data; end
+
+
+
+def ==(other)
+   if other.is_a?( self.class )
+      self.class.attributes.keys.all? do |key|
+            __send__( key ) == other.__send__( key )
+      end
+   else
+      false
+   end
+end
+##  do note override eql? why? why not?
+#       default is object id equality???
+## alias_method :eql?, :==
+ 
+
+end # class Error
+end # module Types

data/lib/solidity/typed/error_builder.rb

@@ -0,0 +1,103 @@
+
+module Types
+class Error
+  
+# todo/fix:  scope: keep empty by default
+
+def self.build_class( class_name, scope: Types, **attributes )
+
+ ## todo/fix:
+ ## check if valid class_name MUST start with uppercase letter etc.
+ ##  todo/fix: check if constant is undefined in scoped namespace!!!!
+
+   attributes = attributes.map do |key,type|
+                  [key, typeof( type )]
+                end.to_h
+
+
+  ## note: error is a like a value type e.g. only getters
+  ##         no setters (can only initialized via constructor or such)              
+  klass = Class.new( Error ) do
+    attributes.each do |key,type|
+      define_method( key ) do
+        instance_variable_get( "@#{key}" )
+      end
+    end
+
+    
+    alias_method :old_freeze, :freeze   # note: store "old" orginal version of freeze
+    define_method( :freeze ) do
+      old_freeze    ## same as calling super
+      attributes.keys.each do |key|
+        instance_variable_get( "@#{key}" ).freeze
+      end
+      self   # return reference to self
+    end
+  end
+
+
+  ## check - if Typed:: qualifier needed here?
+  ##  note Error class NOT derived from Typed (but StandardError)!!!!
+  ##      thus requires qualifier!!!
+  type = Typed::ErrorType.new( class_name, klass )
+  klass.define_singleton_method( :type ) do
+    @type ||= type       
+  end
+
+  ## add attributes (with keys / types) class method 
+  klass.define_singleton_method( :attributes ) do
+     attributes 
+  end
+
+  ### todo/fix:
+  ##    auto-add support for kwargs too!!!
+
+  ## add self.new too - note: call/forward to "old" orginal self.new of Error (base) class
+  klass.define_singleton_method( :new ) do |*args, **kwargs|
+      if kwargs.size > 0   ## assume kwargs
+        if kwargs.size != attributes.size
+          raise ArgumentError, "[Error] wrong number of arguments for #{name}.new - #{kwargs.size} for #{attributes.size}"
+        end
+        ## check for matching names too - why? why not?
+        if kwargs.keys.sort != attributes.keys.sort
+          raise ArgumentError, "[Error] argument key (names) not matching for #{name}.new - #{kwargs.key.sort} != #{attributes.key.sort} for #{attributes.size}"
+        end  
+        old_new( **kwargs )
+      else
+        if args.size != attributes.size
+          ## check for required args/params - all MUST be passed in!!!
+          raise ArgumentError, "[Error] wrong number of arguments for #{name}.new - #{args.size} for #{attributes.size}"
+        end
+        old_new( *args )
+      end
+  end
+
+=begin
+  ## note: use Kernel for "namespacing"
+  ##   make all enums convenience converters (always) global
+  ##     including uppercase methods (e.g. State(), Color(), etc.) does NOT work otherwise (with other module includes)
+
+  ## add global "Kernel" convenience converter function
+  ##  e.g. Vote(0) is same as Vote.convert(0)
+  Kernel.class_eval( <<RUBY )
+    def #{class_name}( arg )
+       #{class_name}.convert( arg )
+    end
+RUBY
+=end
+
+ ## note: use scoped (module) and NOT Object for namespacing
+ ##   use include Safe to make all structs global
+ ##  fix-fix-fix - make class_name unique across contracts (e.g. reuse same name in different contract)
+  scope.const_set( class_name, klass )   ## returns klass (plus sets global constant class name)
+end # method build_class
+
+
+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 Error
+end  # module Types

data/lib/solidity/typed/integer.rb

@@ -0,0 +1,58 @@
+###
+#  integer exponential and ether money unit extensions / helper
+#
+#  include via module - why? why not?
+
+#
+# now with Float included here - change to numeric.rb or such - why? why not?
+#  or move to core_ext/numbers or such?
+
+
+class Integer
+    def e2()  self * 10**2; end   #                       100
+    def e3()  self * 10**3; end   #                      1000
+    def e4()  self * 10**4; end   #                    10_000
+    def e5()  self * 10**5; end   #                   100_000
+    def e6()  self * 10**6; end   #                 1_000_000
+    def e7()  self * 10**7; end   #                10_000_000
+    def e8()  self * 10**8; end   #               100_000_000
+    def e9()  self * 10**9; end   #             1_000_000_000
+    def e10() self * 10**10; end  #            10_000_000_000
+    def e11() self * 10**11; end  #           100_000_000_000
+    def e12() self * 10**12; end  #         1_000_000_000_000
+    def e13() self * 10**13; end  #        10_000_000_000_000
+    def e14() self * 10**14; end  #       100_000_000_000_000
+    def e15() self * 10**15; end  #     1_000_000_000_000_000
+    def e16() self * 10**16; end  #    10_000_000_000_000_000
+    def e17() self * 10**17; end  #   100_000_000_000_000_000
+    def e18() self * 10**18; end  # 1_000_000_000_000_000_000
+    def e19() self * 10**19; end
+    def e20() self * 10**20; end
+    def e21() self * 10**21; end
+    def e22() self * 10**22; end
+    def e23() self * 10**23; end
+    def e24() self * 10**24; end  # 1_000_000_000_000_000_000_000_000
+
+    ###########
+    # Ethereum money units
+    #  add more - why? why not?
+    #  use alias_method :ether, :e18 - why? why not?
+    def ether()   self * 10**18; end
+    alias_method :eth, :ether
+end # class Integer
+
+
+class Float
+    def e18() (self *10**18).to_i; end
+
+    ## note: add e6 (zeros) after conversion to int
+    ## 21e24.to_i = 20999999999999999110807552 !!!!
+    ## 21.0.e24   = 21000000000000000000000000
+    def e24() (self *10**18).to_i.e6; end
+
+    #  use alias_method :ether, :e18 - why? why not?
+    def ether() (self *10**18).to_i; end
+    alias_method :eth, :ether
+end
+
+  

data/lib/solidity/typed/metatypes/types.rb

@@ -440,6 +440,58 @@ end # class EventType
 
 
 
+###
+#  error for now kind of like a struct - why? why not?
+##    but MUST be initialized (and than frozen) 
+##    and no zero possible etc.
+
+class ErrorType < ReferenceType
+  attr_reader :error_name
+  attr_reader :error_class ## reference error_class here - why? why not? 
+  def initialize( error_name, error_class )
+    @error_name  = error_name
+    @error_class = error_class
+  end
+  def format
+    ## use tuple here (not error) - why? why not?
+     named_types = @error_class.attributes.map  {|key,type| "#{key} #{type.format}" }
+     "#{@error_name} error(#{named_types.join(',')})" 
+  end
+  alias_method :to_s, :format 
+
+  ## check what abi looks like if possible for error
+  ##                  is like tuple?
+
+  def ==(other)
+    other.is_a?( ErrorType ) &&
+    @error_name  == other.error_name &&  ## check for name too - why? why not? 
+    @error_class == other.error_class 
+  end
+ 
+
+  def typedclass_name() @error_class.name;  end
+  def typedclass() @error_class;  end
+ 
+  ## note: mut? == true MUST use new_zero (dup)
+  ##       mut? == false MUST use zero (frozen/shared/singelton)
+  def mut?() false; end
+  def zero
+    raise "error cannot be zero (by defintion); sorry"
+  end
+  alias_method :new_zero, :zero 
+
+  def new( initial_values )  ## todo/check: change to values with splat - why? why not?  
+      ## note: use "splat" here - must be empty or matching number of fields/attributes
+      ##  change - why? why not?
+     @error_class.new( *initial_values ) 
+  end 
+end # class ErrorType
+
+
+
+
+
+
 
 
 

data/lib/solidity/typed/numbers.rb

@@ -24,6 +24,8 @@ class UInt < TypedValue
      def -(other)  UInt.new( @value - other.to_int); end
      def *(other)  UInt.new( @value * other.to_int); end
      def /(other)  UInt.new( @value / other.to_int); end
+
+     def div(other) UInt.new( @value.div(other.to_int)); end
       ## add more Integer forwards here!!!!
      ##def_delegators :@value, :+, :-
 
@@ -83,6 +85,15 @@ class Timestamp < TypedValue
        @value.freeze  ## freeze here (and freeze self!) - why? why not?
        @value
     end 
+
+    ## todo/check - only allow other if Timestamp - why? why not? 
+    include Comparable
+    def <=>(other)  @value <=> other.to_int; end
+
+    def +(other) Timestamp.new( @value + other.to_int); end
+    def -(other)  Timestamp.new( @value - other.to_int); end
+ 
+    def to_int() @value; end  ## "automagilally" support implicit integer conversion - why? why not?
 end  # class Timestamp
 
 

data/lib/solidity/typed/values.rb

@@ -30,6 +30,20 @@ class String < TypedValue
                           :+
 
   def to_str() @value; end  ## "automagilally" support implicit string conversion - why? why not?
+
+
+  ## allow compare with "plain" string too - why? why not?
+  def ==(other)
+    if other.is_a?(String)   ## typed (frozen) string
+      @value == other.instance_variable_get( :@value )    ## compare value via as_data!!!
+    elsif other.is_a?( ::String ) ## ruby "literal" string
+      @value == other
+    else
+      false
+    end
+  end
+
+
 end   # class String
 
 
@@ -50,9 +64,28 @@ class Address < TypedValue
       @value.freeze  ## freeze here - why? why not?
       @value
    end
+
+   ## add compare - why? why not?
+   include Comparable
+   def <=>(other)
+      ## compare hexstring instead of unint? - why? why not?
+      if other.is_a?(Address) 
+         to_uint <=> other.to_uint
+      else
+         ## use type error or retur nil?
+         raise ArgumentError, "Address#<=>(other) expects Address; got #{other.class.name}" 
+      end
+   end
+
+
+   def to_uint  ## add helper here - why? why not?
+      num =  @value.to_i(16)
+      UInt.new( num )
+   end
 end  # class Address
 
 
+
 class InscriptionId < TypedValue
     def self.type() InscriptionIdType.instance; end  
     def self.zero() @zero ||= new; end

data/lib/solidity/typed/version.rb

@@ -3,7 +3,7 @@ module Solidity
     module Typed
       MAJOR = 0
       MINOR = 2
-      PATCH = 0
+      PATCH = 1
       VERSION = [MAJOR,MINOR,PATCH].join('.')
     
       def self.version

data/lib/solidity/typed.rb

@@ -8,7 +8,7 @@ require 'forwardable'  ## def_delegate
 class ValueError < StandardError; end
 ## if type is ok, but value of type not in range (e.g. uint with negative numbers)
 ##    or maybe enum out-of-range - why? why not? 
-
+##  todo/check - where ValueError gets used
 
 
 
@@ -43,6 +43,8 @@ require_relative 'typed/struct'
 require_relative 'typed/struct_builder'
 require_relative 'typed/event'
 require_relative 'typed/event_builder'
+require_relative 'typed/error'
+require_relative 'typed/error_builder'
 
 
 require_relative 'typed/enum'
@@ -50,6 +52,9 @@ require_relative 'typed/enum_builder'
 
 require_relative 'typed/conversion'
 
+###
+## more helpers / core extensions
+require_relative 'typed/integer'  # e.g. 1.e18, 1.ether, etc.
 
 
 #############

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solidity-typed
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-15 00:00:00.000000000 Z
+date: 2023-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -47,7 +47,7 @@ dependencies:
 description: solidity-typed - "zero-dependency" 100%-solidity compatible data type
   and application binary interface (abi) machinery incl. bool, (frozen) string, address,
   bytes, uint, int, enum, struct, array, mapping, event, and more for solidity-inspired
-  contract (blockchain) programming languages incl. rubidity et al
+  contract (blockchain) programming languages incl. rubidity, rubysol et al
 email: gerald.bauer@gmail.com
 executables: []
 extensions: []
@@ -67,8 +67,11 @@ files:
 - lib/solidity/typed/conversion.rb
 - lib/solidity/typed/enum.rb
 - lib/solidity/typed/enum_builder.rb
+- lib/solidity/typed/error.rb
+- lib/solidity/typed/error_builder.rb
 - lib/solidity/typed/event.rb
 - lib/solidity/typed/event_builder.rb
+- lib/solidity/typed/integer.rb
 - lib/solidity/typed/mapping.rb
 - lib/solidity/typed/mapping_builder.rb
 - lib/solidity/typed/metatypes/array.rb
@@ -109,5 +112,5 @@ specification_version: 4
 summary: solidity-typed - "zero-dependency" 100%-solidity compatible data type and
   application binary interface (abi) machinery incl. bool, (frozen) string, address,
   bytes, uint, int, enum, struct, array, mapping, event, and more for solidity-inspired
-  contract (blockchain) programming languages incl. rubidity et al
+  contract (blockchain) programming languages incl. rubidity, rubysol et al
 test_files: []