0xfacet-typed 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a0ed00364240e4bb50034acabd0cec233cd24cae34ccda46f7e245a52d43b666
+  data.tar.gz: 359636ba089c58bf1fdd97d45b425dec14d63ee30f58815d9a268cfba5a3fa8e
+SHA512:
+  metadata.gz: 2bb991ecfa5a60979e4998e13613dc9400df98d09ee892d5e6747107d3675944b9178c072b1c3ae39d54d3ce1e7f7b06f523312c24d35e5efe1e8c7b04649c58
+  data.tar.gz: 70c0e53db248bb2f12353059bf1d42adc468d7d2d7bb27b8f25b17df30d7143df6be72ce621df153506e388b3d888dfe89fe77b8e224f4cb7e00b783a27dafac

data/CHANGELOG.md

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

data/Manifest.txt

@@ -0,0 +1,12 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+lib/0xfacet/typed.rb
+lib/0xfacet/typed/array_type.rb
+lib/0xfacet/typed/attr_public_read_private_write.rb
+lib/0xfacet/typed/contract_errors.rb
+lib/0xfacet/typed/contract_type.rb
+lib/0xfacet/typed/mapping_type.rb
+lib/0xfacet/typed/type.rb
+lib/0xfacet/typed/typed_variable.rb

data/README.md

@@ -0,0 +1,25 @@
+# 0xFacet Typed  
+
+0xfacet-typed - solidity-like value and reference types for rubidity o.g.
+
+
+* home  :: [github.com/s6ruby/rubidity.review](https://github.com/s6ruby/rubidity.review)
+* bugs  :: [github.com/s6ruby/rubidity.review/issues](https://github.com/s6ruby/rubidity/issues)
+* gem   :: [rubygems.org/gems/0xfacet-typed](https://rubygems.org/gems/0xfacet-typed)
+* rdoc  :: [rubydoc.info/gems/0xfacet-typed](http://rubydoc.info/gems/0xfacet-typed)
+
+
+
+## About
+
+What's happening herè?
+
+The idea is to look at the facet vm code as-is (that is, NOT suggesting new or alternate syntax and semantics) in the review / commentary 
+and start to (re)package / modular-ize 
+code in "place holder" gems (waiting for adoption by the founders) such as 0xfacet and 0xfacet-typed and 0xfacet-rubidity.
+
+See [Rubidity O.G. (Dumb Contracts) Public Code Review / (More) Tests / Gems & More »](https://github.com/s6ruby/rubidity.review)
+
+
+
+

data/Rakefile

@@ -0,0 +1,31 @@
+require 'hoe'
+
+# require './lib/0xfacet/typed/version.rb'
+
+
+Hoe.spec '0xfacet-typed' do
+
+  self.version =   '0.0.1'
+
+  self.summary = '0xfacet-typed - solidity-like value and reference types for rubidity o.g.'
+  self.description = summary
+
+  self.urls    = { home: 'https://github.com/s6ruby/rubidity.review' }
+
+  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 = [
+  ]
+
+
+  self.licenses = ['Public Domain']
+
+  self.spec_extras = {
+    required_ruby_version: '>= 2.3'
+  }
+end

data/lib/0xfacet/typed/array_type.rb

@@ -0,0 +1,89 @@
+class ArrayType < TypedVariable
+  def initialize(...)
+    super(...)
+    value.on_change = on_change
+  end
+  
+  def serialize
+    value.data.map(&:serialize)
+  end
+  
+  class Proxy
+    extend AttrPublicReadPrivateWrite
+    
+    attr_accessor :on_change
+    attr_public_read_private_write :value_type, :data
+    
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      
+      other.value_type == value_type &&
+      other.data == data
+    end
+  
+    def initialize(
+      initial_value = [],
+      value_type:,
+      initial_length: nil,
+      on_change: nil
+    )
+      unless value_type.is_value_type?
+        raise VariableTypeError.new("Only value types can me array elements")
+      end
+      
+      self.value_type = value_type
+      self.data = initial_value
+      
+      if initial_length
+        amount_to_pad = initial_length - data.size
+        
+        amount_to_pad.times do
+          data << TypedVariable.create(value_type) 
+        end
+      end
+      
+      self.on_change = on_change
+    end
+  
+    def [](index)
+      index_var = TypedVariable.create_or_validate(:uint256, index, on_change: on_change)
+      
+      raise "Index out of bounds" if index_var >= data.size
+
+      value = data[index_var]
+      value || TypedVariable.create_or_validate(value_type, on_change: on_change)
+    end
+  
+    def []=(index, value)
+      index_var = TypedVariable.create_or_validate(:uint256, index, on_change: on_change)
+      
+      raise "Sparse arrays are not supported" if index_var > data.size
+
+      old_value = self.data[index_var]
+      val_var = TypedVariable.create_or_validate(value_type, value, on_change: on_change)
+      
+      if old_value != val_var
+        on_change&.call
+        self.data[index_var] ||= val_var
+        self.data[index_var].value = val_var.value
+      end
+    end
+    
+    def push(value)
+      next_index = data.size
+      
+      self.[]=(next_index, value)
+      nil
+    end
+    
+    def pop
+      on_change&.call
+      
+      data.pop
+    end
+    
+    def length
+      data.length
+    end
+  end
+end

data/lib/0xfacet/typed/attr_public_read_private_write.rb

@@ -0,0 +1,9 @@
+module AttrPublicReadPrivateWrite
+  def attr_public_read_private_write(*names)
+    attr_accessor(*names)
+
+    names.each do |name|
+      private "#{name}="
+    end
+  end
+end

data/lib/0xfacet/typed/contract_errors.rb

@@ -0,0 +1,34 @@
+module ContractErrors
+  class ContractError < StandardError
+    attr_accessor :contract
+    attr_accessor :error_status
+  
+    def initialize(message, contract = nil)
+      super(message)
+      @contract = contract
+    end
+    
+    def message
+      return super if contract.blank?
+      
+      trace = !Rails.env.production? ? backtrace.join("\n") : ''
+      
+      "#{contract.class.name} error: " + super
+    end
+  end
+  
+  class StaticCallError < StandardError; end  
+  class TransactionError < StandardError; end
+  class ContractRuntimeError < ContractError; end
+  class ContractDefinitionError < ContractError; end
+  class StateVariableTypeError < StandardError; end
+  class VariableTypeError < StandardError; end
+  class StateVariableMutabilityError < StandardError; end
+  class ContractArgumentError < StandardError; end
+  class CallingNonExistentContractError < TransactionError; end
+  class InvalidOverrideError < StandardError; end
+  class FunctionAlreadyDefinedError < StandardError; end
+  class InvalidEthscriptionError < StandardError; end
+  class InvalidDestructuringError < StandardError; end
+  class InvalidStateVariableChange < StandardError; end
+end

data/lib/0xfacet/typed/contract_type.rb

@@ -0,0 +1,64 @@
+class ContractType < TypedVariable  
+  def initialize(...)
+    super(...)
+  end
+  
+  def serialize
+    value.address
+  end
+  
+  def method_missing(name, *args, **kwargs, &block)
+    value.send(name, *args, **kwargs, &block)
+  end
+  
+  def respond_to_missing?(name, include_private = false)
+    value.respond_to?(name, include_private) || super
+  end
+
+  class Proxy
+    include ContractErrors
+    extend AttrPublicReadPrivateWrite
+    
+    attr_public_read_private_write :contract_type, :address,
+      :uncast_address, :contract_interface
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      
+      other.contract_type == contract_type &&
+      other.address == address
+    end
+    
+    def initialize(contract_type:, address:, contract_interface:)
+      self.uncast_address = address
+      address = TypedVariable.create_or_validate(:address, address).value
+    
+      self.contract_type = contract_type
+      self.address = address
+      self.contract_interface = contract_interface
+    end
+    
+    def method_missing(name, *args, **kwargs, &block)
+      computed_args = args.presence || kwargs
+      
+      super unless contract_interface
+      
+      known_function = contract_interface.public_abi[name]
+      
+      unless known_function && known_function.args.length == computed_args.length
+        raise ContractError.new("Contract doesn't implement interface: #{contract_type}, #{name}")
+      end
+      
+      TransactionContext.call_stack.execute_in_new_frame(
+        to_contract_address: address,
+        function: name,
+        args: computed_args,
+        type: :call
+      )
+    end
+    
+    def respond_to_missing?(name, include_private = false)
+      !!contract_interface.public_abi[name] || super
+    end    
+  end
+end

data/lib/0xfacet/typed/mapping_type.rb

@@ -0,0 +1,102 @@
+class MappingType < TypedVariable
+  def initialize(...)
+    super(...)
+    value.on_change = on_change
+  end
+  
+  def serialize
+    value.serialize
+  end
+  
+  class Proxy
+    extend AttrPublicReadPrivateWrite
+    
+    attr_accessor :on_change
+    attr_public_read_private_write :transformed_keys, :data, :key_type, :value_type
+    
+    def serialize
+      serialized_dirty_data = {}
+      
+      transformed_keys.each do |key|
+        value = data[key]
+        
+        unless value.value == value.type.default_value
+          serialized_dirty_data[key.serialize.to_s] = value.serialize
+        end
+      end
+      
+      clean_data = data.except(*transformed_keys)
+      clean_data.merge(serialized_dirty_data).deep_dup
+    end
+    
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      
+      other.key_type == key_type &&
+      other.value_type == value_type &&
+      other.serialize == serialize
+    end
+    
+    def initialize(initial_value = {}, key_type:, value_type:, on_change: nil)
+      self.key_type = key_type
+      self.value_type = value_type
+      
+      self.data = initial_value
+      self.transformed_keys = Set.new
+      self.on_change = on_change
+    end
+    
+    def [](key_var)
+      raw_key = key_var.is_a?(TypedVariable) ? key_var.value : key_var
+      string_key = raw_key.to_s
+    
+      typed_key_var = TypedVariable.create_or_validate(key_type, key_var, on_change: on_change)
+    
+      # First, attempt a lookup using the typed key
+      value = data[typed_key_var]
+    
+      # If no value is found, try looking it up as a string (how it would be stored in JSONB)
+      if value.nil? && data.key?(string_key)
+        value = TypedVariable.create_or_validate(value_type, data[string_key], on_change: on_change)
+        
+        data.delete(string_key)
+        set_value(typed_key_var, value)
+      end
+    
+      # If the value is still nil, it truly doesn't exist; create a new default value
+      if value.nil?
+        value = TypedVariable.create_or_validate(value_type, on_change: on_change)
+        set_value(typed_key_var, value)
+      end
+      
+      value
+    end
+
+    def []=(key_var, value)
+      key_var = TypedVariable.create_or_validate(key_type, key_var, on_change: on_change)
+      val_var = TypedVariable.create_or_validate(value_type, value, on_change: on_change)
+
+      if value_type.mapping?
+        raise TypeError, "Mappings cannot be assigned to mappings"
+      end
+      
+      old_value = self.data[key_var]
+      
+      if old_value != val_var
+        on_change&.call
+        
+        transformed_keys.add(key_var)
+
+        data[key_var] ||= val_var
+        data[key_var].value = val_var.value
+      end
+    end
+    
+    private
+    
+    def set_value(key, value)
+      data[key] = value
+      transformed_keys.add(key)
+    end
+  end
+end

data/lib/0xfacet/typed/type.rb

@@ -0,0 +1,290 @@
+class Type
+  include ContractErrors
+  
+  attr_accessor :name, :metadata, :key_type, :value_type, :initial_length
+  
+  INTEGER_TYPES = (8..256).step(8).flat_map do |num|
+    ["uint#{num}", "int#{num}"]
+   end.map(&:to_sym)
+  
+  TYPES = [:string, :mapping, :address, :bytes32, :contract,
+          :bool, :address, :uint256, :int256, :array, :datetime, :bytes] + INTEGER_TYPES
+  
+  TYPES.each do |type|
+    define_method("#{type}?") do
+      self.name == type
+    end
+  end
+  
+  def self.value_types
+    TYPES.select do |type|
+      create(type).is_value_type?
+    end
+  end
+  
+  def initialize(type_name, metadata = {})
+    if type_name.is_a?(Array)
+      if type_name.length != 1
+        raise "Invalid array type #{type_name.inspect}"
+      end
+      
+      value_type = type_name.first
+      
+      if TYPES.exclude?(value_type)
+        raise "Invalid type #{value_type.inspect}"
+      end
+      
+      metadata = { value_type: value_type }
+      type_name = :array
+    end
+    
+    type_name = type_name.to_sym
+    
+    if TYPES.exclude?(type_name)
+      raise "Invalid type #{type_name}"
+    end
+    
+    self.name = type_name.to_sym
+    self.metadata = metadata.deep_dup
+  end
+  
+  def self.create(type_or_name, metadata = {})
+    return type_or_name if type_or_name.is_a?(self)
+    
+    new(type_or_name, metadata)
+  end
+  
+  def key_type=(type)
+    return if type.nil?
+    @key_type = self.class.create(type)
+  end
+  
+  def value_type=(type)
+    return if type.nil?
+    @value_type = self.class.create(type)
+  end
+  
+  def metadata=(metadata)
+    self.key_type = metadata[:key_type]
+    self.value_type = metadata[:value_type]
+    self.initial_length = metadata[:initial_length] if metadata[:initial_length]
+  end
+  
+  def can_be_assigned_from?(other_type)
+    return true if self == other_type
+
+    if is_uint? && other_type.is_uint? || is_int? && other_type.is_int?
+      return extract_integer_bits >= other_type.extract_integer_bits
+    end
+    
+    if address? && other_type.contract?
+      return true
+    end
+
+    false
+  end
+  
+  def values_can_be_compared?(other_type)
+    return true if can_be_assigned_from?(other_type)
+
+    if is_uint? && other_type.is_uint? || is_int? && other_type.is_int?
+      return true
+    end
+    false
+  end
+  
+  def metadata
+    (@metadata ||= {}).with_indifferent_access
+  end
+  
+  def to_s
+    name.to_s
+  end
+  
+  def default_value
+    is_int256_uint256_datetime = is_int? || is_uint? || datetime?
+  
+    val = case
+    when is_int256_uint256_datetime
+      0
+    when address?
+      "0x" + "0" * 40
+    when bytes32?
+      "0x" + "0" * 64
+    when string? || bytes?
+      ''
+    when bool?
+      false
+    when mapping?
+      MappingType::Proxy.new(key_type: key_type, value_type: value_type)
+    when array?
+      ArrayType::Proxy.new(value_type: value_type, initial_length: initial_length)
+    when contract?
+      ContractType::Proxy.new(contract_interface: metadata[:interface], address: nil, contract_type: nil)
+    else
+      raise "Unknown default value for #{self.inspect}"
+    end
+    
+    check_and_normalize_literal(val)
+  end
+  
+  def raise_variable_type_error(literal)
+    raise VariableTypeError.new("Invalid #{self}: #{literal.inspect}")
+  end
+  
+  def parse_integer(literal)
+    base = literal.start_with?("0x") ? 16 : 10
+    
+    begin
+      Integer(literal, base)
+    rescue ArgumentError => e
+      raise_variable_type_error(literal)
+    end
+  end
+  
+  def check_and_normalize_literal(literal)
+    if literal.is_a?(TypedVariable)
+      raise VariableTypeError, "Only literals can be passed to check_and_normalize_literal: #{literal.inspect}"
+    end
+    
+    if address?
+      if literal.is_a?(ContractType::Proxy)
+        return literal.address
+      end
+      
+      unless literal.is_a?(String) && literal.match?(/\A0x[a-f0-9]{40}\z/i)
+        raise_variable_type_error(literal)
+      end
+      
+      return literal.downcase
+    elsif is_uint?
+      if literal.is_a?(String)
+        literal = parse_integer(literal)
+      end
+        
+      if literal.is_a?(Integer) && literal.between?(0, 2 ** extract_integer_bits - 1)
+        return literal
+      end
+      
+      raise_variable_type_error(literal)
+    elsif is_int?
+      if literal.is_a?(String)
+        literal = parse_integer(literal)
+      end
+      
+      if literal.is_a?(Integer) && literal.between?(-2 ** (extract_integer_bits - 1), 2 ** (extract_integer_bits - 1) - 1)
+        return literal
+      end
+      
+      raise_variable_type_error(literal)
+    elsif string?
+      unless literal.is_a?(String)
+        raise_variable_type_error(literal)
+      end
+      
+      return literal.freeze
+    elsif bool?
+      unless literal == true || literal == false
+        raise_variable_type_error(literal)
+      end
+      
+      return literal
+    elsif bytes32?
+      unless literal.is_a?(String) && literal.match?(/\A0x[a-f0-9]{64}\z/i)
+        raise_variable_type_error(literal)
+      end
+      
+      return literal.downcase
+    elsif bytes?
+      if literal.is_a?(String) && literal.length == 0
+        return literal
+      end
+      
+      unless literal.is_a?(String) && literal.match?(/\A0x[a-fA-F0-9]*\z/) && literal.size.even?
+        raise_variable_type_error(literal)
+      end
+      
+      return literal.downcase
+    elsif datetime?
+      dummy_uint = Type.create(:uint256)
+      
+      begin
+        return dummy_uint.check_and_normalize_literal(literal)
+      rescue VariableTypeError => e
+        raise_variable_type_error(literal)
+      end
+    elsif mapping?
+      if literal.is_a?(MappingType::Proxy)
+        return literal
+      end
+      
+      unless literal.is_a?(Hash)
+        raise VariableTypeError.new("invalid #{literal}")
+      end
+    
+      proxy = MappingType::Proxy.new(literal, key_type: key_type, value_type: value_type)
+      
+      return proxy
+    elsif array?
+      if literal.is_a?(ArrayType::Proxy)
+        return literal
+      end
+      
+      unless literal.is_a?(Array)
+        raise_variable_type_error(literal)
+      end
+      
+      data = literal.map do |value|
+        TypedVariable.create(value_type, value)
+      end
+    
+      proxy = ArrayType::Proxy.new(data, value_type: value_type, initial_length: initial_length)
+      
+      return proxy
+    elsif contract?
+      if literal.is_a?(ContractType::Proxy)
+        return literal
+      else
+        raise_variable_type_error("No literals allowed for contract types")
+      end
+    end
+    
+    raise VariableTypeError.new("Unknown type #{self.inspect}: #{literal.inspect}")
+  end
+  
+  def is_uint?
+    name.to_s.start_with?('uint')
+  end
+
+  def is_int?
+    name.to_s.start_with?('int')
+  end
+  
+  def extract_integer_bits
+    return name.to_s[4..-1].to_i if is_uint?
+    return name.to_s[3..-1].to_i if is_int?
+    raise "Not an integer type: #{self}"
+  end
+  
+  def ==(other)
+    other.is_a?(self.class) &&
+    other.name == name &&
+    other.metadata.except(:initial_length) == metadata.except(:initial_length)
+  end
+  
+  def !=(other)
+    !(self == other)
+  end
+  
+  def hash
+    [name, metadata].hash
+  end
+
+  def eql?(other)
+    hash == other.hash
+  end
+  
+  def is_value_type?
+    !mapping? && !array?
+  end
+end

data/lib/0xfacet/typed/typed_variable.rb

@@ -0,0 +1,129 @@
+class TypedVariable
+  include ContractErrors
+  extend AttrPublicReadPrivateWrite
+  
+  attr_accessor :value, :on_change
+  attr_public_read_private_write :type
+
+  def initialize(type, value = nil, on_change: nil, **options)
+    self.type = type
+    self.value = value || type.default_value
+    self.on_change = on_change
+  end
+  
+  def self.create(type, value = nil, on_change: nil, **options)
+    type = Type.create(type)
+    
+    options[:on_change] = on_change
+    
+    if type.mapping?
+      MappingType.new(type, value, **options)
+    elsif type.array?
+      ArrayType.new(type, value, **options)
+    elsif type.contract?
+      ContractType.new(type, value, **options)
+    else
+      new(type, value, **options)
+    end
+  end
+  
+  def self.create_or_validate(type, value = nil, on_change: nil)
+    if value.is_a?(TypedVariable)
+      unless Type.create(type).can_be_assigned_from?(value.type)
+        raise VariableTypeError.new("invalid #{type}: #{value.inspect}")
+      end
+      
+      value = value.value
+    end
+    
+    create(type, value, on_change: on_change)
+  end
+  
+  def as_json(args = {})
+    serialize
+  end
+  
+  def serialize
+    value
+  end
+  
+  def to_s
+    if value.is_a?(String) || value.is_a?(Integer)
+      value.to_s
+    else
+      raise "No string conversion"
+    end
+  end
+  
+  def deserialize(serialized_value)
+    self.value = serialized_value
+  end
+  
+  def value=(new_value)
+    new_value = type.check_and_normalize_literal(new_value)
+    
+    if @value != new_value
+      on_change&.call
+      
+      if new_value.respond_to?(:on_change=)
+        new_value.on_change = on_change
+      end
+      
+      @value = new_value
+    end
+  end
+  
+  def method_missing(name, *args, &block)
+    if value.respond_to?(name)
+      result = value.send(name, *args, &block)
+      
+      if result.class == value.class
+        begin
+          result = type.check_and_normalize_literal(result)
+        rescue ContractErrors::VariableTypeError => e
+          if type.is_uint?
+            result = TypedVariable.create(:uint256, result)
+          else
+            raise
+          end
+        end
+      end
+      
+      result
+      
+      if name.to_s.end_with?("=") && !%w[>= <=].include?(name.to_s[-2..])
+        self.value = result if type.is_value_type?
+        self
+      else
+        result
+      end
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    value.respond_to?(name, include_private) || super
+  end
+  
+  def !=(other)
+    !(self == other)
+  end
+  
+  def ==(other)
+    if other.is_a?(self.class)
+      return false unless type.values_can_be_compared?(other.type)
+      return value == other.value
+    else
+      return value == TypedVariable.create(type, other).value
+    end
+  end
+  
+  def hash
+    [value, type].hash
+  end
+
+  def eql?(other)
+    hash == other.hash
+  end
+end

data/lib/0xfacet/typed.rb

@@ -0,0 +1,16 @@
+
+
+require 'active_support/all'
+
+
+## our own code
+require_relative 'typed/contract_errors'   ## move upstream to 0xfacet !!!
+
+require_relative 'typed/attr_public_read_private_write'
+require_relative 'typed/type'
+require_relative 'typed/typed_variable'
+require_relative 'typed/array_type'
+require_relative 'typed/mapping_type'
+require_relative 'typed/contract_type'
+
+

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: 0xfacet-typed
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gerald Bauer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: 0xfacet-typed - solidity-like value and reference types for rubidity
+  o.g.
+email: gerald.bauer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+- Rakefile
+- lib/0xfacet/typed.rb
+- lib/0xfacet/typed/array_type.rb
+- lib/0xfacet/typed/attr_public_read_private_write.rb
+- lib/0xfacet/typed/contract_errors.rb
+- lib/0xfacet/typed/contract_type.rb
+- lib/0xfacet/typed/mapping_type.rb
+- lib/0xfacet/typed/type.rb
+- lib/0xfacet/typed/typed_variable.rb
+homepage: https://github.com/s6ruby/rubidity.review
+licenses:
+- Public Domain
+metadata: {}
+post_install_message:
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: 0xfacet-typed - solidity-like value and reference types for rubidity o.g.
+test_files: []