rlp-lite 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b94a62e8d77c1f5752f02e1088db2394fb281800a444fc744bcb17e2c8bb1d3f
+  data.tar.gz: 4708183e54acac23ef32ebd0f74c2b78cdced4778752dbe6b2d51260363dd6b8
+SHA512:
+  metadata.gz: 5fadf8e0fe94f689ba0ee198bd7e2d94c5bd6d606261d26c2308a2a676fe9ddb9e5489ec00ff31b2e592987727982b02bdeb48dea3ee105c8ab8ca1fa8b9988a
+  data.tar.gz: 390a76f7d97500ee445e653a98eb250ff254f0936167e6900444f5e3540439453023f463c7272ed5d453416d2f2d2a46cd884736dc9399f26b6b1eb95c1c1f0a

data/CHANGELOG.md

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

data/Manifest.txt

@@ -0,0 +1,13 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+lib/rlp-lite.rb
+lib/rlp-lite/decoder.rb
+lib/rlp-lite/encoder.rb
+lib/rlp-lite/sedes.rb
+lib/rlp-lite/sedes/big_endian_int.rb
+lib/rlp-lite/sedes/binary.rb
+lib/rlp-lite/sedes/list.rb
+lib/rlp-lite/util.rb
+lib/rlp-lite/version.rb

data/README.md

@@ -0,0 +1,33 @@
+#  Recursive Length Prefix (RLP) Lite
+
+
+rlp-lite - light-weight machinery to serialize / deserialze via rlp
+
+
+
+* home  :: [github.com/pixelartexchange/artbase](https://github.com/pixelartexchange/artbase)
+* bugs  :: [github.com/pixelartexchange/artbase/issues](https://github.com/pixelartexchange/artbase/issues)
+* gem   :: [rubygems.org/gems/rlp-lite](https://rubygems.org/gems/rlp-lite)
+* rdoc  :: [rubydoc.info/gems/rlp-lite](http://rubydoc.info/gems/rlp-lite)
+
+
+
+
+## Usage
+
+to be done
+
+
+
+
+## License
+
+The scripts are dedicated to the public domain.
+Use it as you please with no restrictions whatsoever.
+
+
+## Questions? Comments?
+
+
+Post them on the [D.I.Y. Punk (Pixel) Art reddit](https://old.reddit.com/r/DIYPunkArt). Thanks.
+

data/Rakefile

@@ -0,0 +1,31 @@
+require 'hoe'
+require './lib/rlp-lite/version.rb'
+
+
+Hoe.spec 'rlp-lite' do
+
+  self.version = Rlp::VERSION
+
+  self.summary = "rlp-lite - light-weight machinery to serialize / deserialze via rlp (recursive length prefix)"
+  self.description = summary
+
+  self.urls    = { home: 'https://github.com/pixelartexchange/artbase' }
+
+  self.author  = 'Gerald Bauer'
+  self.email   = 'wwwmake@googlegroups.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/rlp-lite/decoder.rb

@@ -0,0 +1,97 @@
+  module Rlp
+
+    # Provides an RLP-decoder.
+    module Decoder
+      extend self
+
+      # Decodes an RLP-encoded object.
+      #
+      # @param rlp [String] an RLP-encoded object.
+      # @return [Object] the decoded and maybe deserialized object.
+      # @raise [Eth::Rlp::DecodingError] if the input string does not end after
+      #     the root item.
+      def perform(rlp)
+        rlp = Util.hex_to_bin( rlp ) if Util.is_hex?( rlp )
+        rlp = Util.str_to_bytes( rlp )
+        begin
+          item, next_start = consume_item( rlp, 0 )
+        rescue Exception => e
+          raise DecodingError, "Cannot decode rlp string: #{e}"
+        end
+        raise DecodingError, "RLP string ends with #{rlp.size - next_start} superfluous bytes" if next_start != rlp.size
+        return item
+      end
+
+
+      private
+
+      # Consume an RLP-encoded item from the given start.
+      def consume_item(rlp, start)
+        t, l, s = consume_length_prefix rlp, start
+        consume_payload rlp, s, t, l
+      end
+
+      # Consume an RLP length prefix at the given position.
+      def consume_length_prefix(rlp, start)
+        b0 = rlp[start].ord
+        if b0 < PRIMITIVE_PREFIX_OFFSET
+
+          # single byte
+          [:str, 1, start]
+        elsif b0 < PRIMITIVE_PREFIX_OFFSET + SHORT_LENGTH_LIMIT
+          raise DecodingError, "Encoded as short string although single byte was possible" if (b0 - PRIMITIVE_PREFIX_OFFSET == 1) && rlp[start + 1].ord < PRIMITIVE_PREFIX_OFFSET
+
+          # short string
+          [:str, b0 - PRIMITIVE_PREFIX_OFFSET, start + 1]
+        elsif b0 < LIST_PREFIX_OFFSET
+          enforce_no_zero_bytes rlp, start
+
+          # long string
+          ll = b0 - PRIMITIVE_PREFIX_OFFSET - SHORT_LENGTH_LIMIT + 1
+          l = Util.big_endian_to_int rlp[(start + 1)...(start + 1 + ll)]
+          raise DecodingError, "Long string prefix used for short string" if l < SHORT_LENGTH_LIMIT
+          [:str, l, start + 1 + ll]
+        elsif b0 < LIST_PREFIX_OFFSET + SHORT_LENGTH_LIMIT
+
+          # short list
+          [:list, b0 - LIST_PREFIX_OFFSET, start + 1]
+        else
+          enforce_no_zero_bytes rlp, start
+
+          # long list
+          ll = b0 - LIST_PREFIX_OFFSET - SHORT_LENGTH_LIMIT + 1
+          l = Util.big_endian_to_int rlp[(start + 1)...(start + 1 + ll)]
+          raise DecodingError, "Long list prefix used for short list" if l < SHORT_LENGTH_LIMIT
+          [:list, l, start + 1 + ll]
+        end
+      end
+
+      # Enforce RLP slices to not start with empty bytes.
+      def enforce_no_zero_bytes(rlp, start)
+        raise DecodingError, "Length starts with zero bytes" if rlp.slice(start + 1) == BYTE_ZERO
+      end
+
+      # Consume an RLP payload at the given position of given type and size.
+      def consume_payload(rlp, start, type, length)
+        case type
+        when :str
+          [rlp[start...(start + length)], start + length]
+        when :list
+          items = []
+          next_item_start = start
+          payload_end = next_item_start + length
+          while next_item_start < payload_end
+            item, next_item_start = consume_item rlp, next_item_start
+            items.push item
+          end
+          raise DecodingError, "List length prefix announced a too small length" if next_item_start > payload_end
+          [items, next_item_start]
+        else
+          raise TypeError, "Type must be either :str or :list"
+        end
+      end
+    end
+
+
+end  #  module Rlp
+

data/lib/rlp-lite/encoder.rb

@@ -0,0 +1,59 @@
+
+  # Provides an recursive-length prefix (RLP) encoder and decoder.
+  module Rlp
+
+    # Provides an RLP-encoder.
+    module Encoder
+      extend self
+
+      # Encodes a Ruby object in RLP format.
+      #
+      # @param obj [Object] a Ruby object.
+      # @return [String] the RLP encoded item.
+      # @raise [Eth::Rlp::EncodingError] in the rather unlikely case that the item
+      #     is too big to encode (will not happen).
+      # @raise [Eth::Rlp::SerializationError] if the serialization fails.
+      def perform(obj)
+        item = Sedes.infer(obj).serialize(obj)
+        result = encode_raw( item )
+      end
+
+      private
+
+      # Encodes the raw item.
+      def encode_raw(item)
+        return item    if item.instance_of? Rlp::Data
+        return encode_primitive item if Sedes.is_primitive? item
+        return encode_list item if Sedes.is_list? item
+        raise EncodingError "Cannot encode object of type #{item.class.name}"
+      end
+
+      # Encodes a single primitive.
+      def encode_primitive(item)
+        return Util.str_to_bytes item if item.size == 1 && item.ord < PRIMITIVE_PREFIX_OFFSET
+        payload = Util.str_to_bytes item
+        prefix = length_prefix payload.size, PRIMITIVE_PREFIX_OFFSET
+        "#{prefix}#{payload}"
+      end
+
+      # Encodes a single list.
+      def encode_list(list)
+        payload = list.map { |item| encode_raw item }.join
+        prefix = length_prefix payload.size, LIST_PREFIX_OFFSET
+        "#{prefix}#{payload}"
+      end
+
+      # Determines a length prefix.
+      def length_prefix(length, offset)
+        if length < SHORT_LENGTH_LIMIT
+          (offset + length).chr
+        elsif length < LONG_LENGTH_LIMIT
+          length_string = Util.int_to_big_endian( length )
+          length_len = (offset + SHORT_LENGTH_LIMIT - 1 + length_string.size).chr
+          "#{length_len}#{length_string}"
+        else
+          raise EncodingError, "Length greater than 256**8: #{length}"
+        end
+      end
+    end
+  end   # module Rlp

data/lib/rlp-lite/sedes/big_endian_int.rb

@@ -0,0 +1,73 @@
+
+
+  module Rlp
+    module Sedes
+
+      # A serializable, big-endian, unsigned integer type.
+      class BigEndianInt
+
+        # Create a serializable, big-endian, unsigned integer.
+        #
+        # @param size [Integer] the size of the big endian.
+        def initialize(size = nil)
+          @size = size
+        end
+
+        # Serialize a big-endian integer.
+        #
+        # @param obj [Integer] the integer to be serialized.
+        # @return [String] a serialized big-endian integer.
+        # @raise [SerializationError] if provided object is not an integer.
+        # @raise [SerializationError] if provided integer is negative.
+        # @raise [SerializationError] if provided integer is too big for @size.
+        def serialize(obj)
+          raise SerializationError, "Can only serialize integers" unless obj.is_a?(Integer)
+          raise SerializationError, "Cannot serialize negative integers" if obj < 0
+          raise SerializationError, "Integer too large (does not fit in #{@size} bytes)" if @size && obj >= 256 ** @size
+          s = obj == 0 ? BYTE_EMPTY : _int_to_big_endian(obj)
+          @size ? "#{BYTE_ZERO * [0, @size - s.size].max}#{s}" : s
+        end
+
+        # Deserializes an unsigned integer.
+        #
+        # @param serial [String] the serialized integer.
+        # @return [Integer] a number.
+        # @raise [DeserializationError] if provided serial is of wrong size.
+        # @raise [DeserializationError] if provided serial is not of minimal length.
+        def deserialize(serial)
+          raise DeserializationError, "Invalid serialization (wrong size)" if @size && serial.size != @size
+          raise DeserializationError, "Invalid serialization (not minimal length)" if !@size && serial.size > 0 && serial[0] == BYTE_ZERO
+          serial = serial || BYTE_ZERO
+          _big_endian_to_int(serial)
+        end
+
+
+###
+#  private helpers
+
+
+ # Converts an integer to big endian.
+    #
+    # @param num [Integer] integer to be converted.
+    # @return [String] packed, big-endian integer string.
+    def _int_to_big_endian( num )
+      hex = num.to_s(16)
+      hex = "0#{hex}"   if hex.size.odd?
+
+      [hex].pack("H*")    ## note Util.hex_to_bin() "inline" shortcut
+    end
+
+   # Converts a big endian to an interger.
+    #
+    # @param str [String] big endian to be converted.
+    # @return [Integer] an unpacked integer number.
+    def _big_endian_to_int(str)
+      str.unpack("H*").first.to_i(16)
+    end
+
+
+
+end  # class BigEndianInt
+
+end  # module Sedes
+end  # module Rlp

data/lib/rlp-lite/sedes/binary.rb

@@ -0,0 +1,103 @@
+  module Rlp
+    module Sedes
+
+      # A sedes type for binary values.
+      class Binary
+
+          # Create a serializable binary of fixed size.
+          #
+          # @param l [Integer] the fixed size of the binary.
+          # @param allow_empty [Boolean] indicator wether empty binaries should be allowed.
+          # @return [Eth::Rlp::Sedes::Binary] a serializable binary of fixed size.
+          def self.fixed_length(l, allow_empty: false)
+            new(min_length: l, max_length: l, allow_empty: allow_empty)
+          end
+
+          # Checks wether the given object is of a valid binary type.
+          #
+          # @param obj [Object] the supposed binary item to check.
+          # @return [Boolean] true if valid.
+          def self.valid_type?(obj)
+            obj.instance_of? String
+          end
+
+
+        # Create a serializable binary of variable size.
+        #
+        # @param min_length [Integer] the minimum size of the binary.
+        # @param max_length [Integer] the maximum size of the binary.
+        # @param allow_empty [Boolean] indicator wether empty binaries should be allowed.
+        def initialize(min_length: 0, max_length: INFINITY, allow_empty: false)
+          @min_length = min_length
+          @max_length = max_length
+          @allow_empty = allow_empty
+        end
+
+        # Serializes a binary.
+        #
+        # @param obj [String] the binary to serialize.
+        # @return [Object] a serialized binary.
+        # @raise [SerializationError] if provided object is of invalid type.
+        # @raise [SerializationError] if provided binary is of invalid length.
+        def serialize(obj)
+          raise SerializationError, "Object is not a serializable (#{obj.class})" unless self.class.valid_type? obj
+          serial = _str_to_bytes( obj )
+          raise SerializationError, "Object has invalid length" unless valid_length? serial.size
+          serial
+        end
+
+        # Deserializes a binary.
+        #
+        # @param serial [Object] the serialized binary.
+        # @return [String] a deserialized binary.
+        # @raise [DeserializationError] if provided serial is of wrong type.
+        # @raise [DeserializationError] if provided serial is of wrong length.
+        def deserialize(serial)
+          raise DeserializationError, "Objects of type #{serial.class} cannot be deserialized" unless _is_primitive? serial
+          raise DeserializationError, "#{serial.class} has invalid length" unless valid_length? serial.size
+          serial
+        end
+
+        # Checks wether the given length fits the defined size boundaries of the
+        # binary type.
+        #
+        # @param length [Integer] the supposed length of the binary item.
+        # @return [Boolean] true if valid.
+        def valid_length?(length)
+          (@min_length <= length && length <= @max_length) ||
+          (@allow_empty && length == 0)
+        end
+
+#######
+#  private helpers
+
+ # Converts a binary string to bytes.
+    #
+    # @param str [String] binary string to be converted.
+    # @return [Object] the string bytes.
+    def _str_to_bytes(str)
+      _is_bytes?(str) ? str : str.b
+    end
+
+      # Checks if a string is a byte-string.
+    #
+    # @param str [String] a string to check.
+    # @return [Boolean] true if it's an ASCII-8bit encoded byte-string.
+    def _is_bytes?(str)
+      str && str.instance_of?(String) && str.encoding.name == 'ASCII-8BIT'
+    end
+
+    # Checks if the given item is a string primitive.
+    #
+    # @param item [Object] the item to check.
+    # @return [Boolean] true if it's a string primitive.
+    def _is_primitive?(item)
+      item.instance_of?(String)
+    end
+
+
+end  # class Binary
+
+
+end   # module Sedes
+end   #  module Rlp

data/lib/rlp-lite/sedes/list.rb

@@ -0,0 +1,68 @@
+
+  module Rlp
+    module Sedes
+
+      # A sedes type for lists of fixed length.
+      class List < Array
+
+        # Create a serializable list of fixed size.
+        #
+        # @param elements [Array] an array indicating the structure of the list.
+        # @param strict [Boolean] an option to enforce the given structure.
+        def initialize(elements: [], strict: true)
+          super()
+
+          @strict = strict
+          elements.each do |e|
+            if Sedes.is_sedes?(e)
+              push e
+            elsif Sedes.is_list?(e)
+              push List.new(elements: e)
+            else
+              raise TypeError, "Instances of List must only contain sedes objects or nested sequences thereof."
+            end
+          end
+        end
+
+        # Serialize an array.
+        #
+        # @param obj [Array] the array to be serialized.
+        # @return [Array] a serialized list.
+        # @raise [SerializationError] if provided array is not a sequence.
+        # @raise [SerializationError] if provided array is of wrong length.
+        def serialize(obj)
+          raise SerializationError, "Can only serialize sequences" unless Sedes.is_list?(obj)
+          raise SerializationError, "List has wrong length" if (@strict && self.size != obj.size) || self.size < obj.size
+          result = []
+          obj.zip(self).each_with_index do |(element, sedes), i|
+            result.push sedes.serialize(element)
+          end
+          result
+        end
+
+        # Deserializes a list.
+        #
+        # @param serial [Array] the serialized list.
+        # @return [Array] a deserialized list.
+        # @raise [DeserializationError] if provided serial is not a sequence.
+        # @raise [DeserializationError] if provided serial is of wrong length.
+        def deserialize(serial)
+          raise DeserializationError, "Can only deserialize sequences" unless Sedes.is_list?(serial)
+          raise DeserializationError, "List has wrong length" if @strict && serial.size != self.size
+          result = []
+          len = [serial.size, self.size].min
+          len.times do |i|
+            sedes = self[i]
+            element = serial[i]
+            result.push sedes.deserialize(element)
+          end
+          result.freeze
+        end
+
+
+
+end  #  class List
+
+
+end   # module Sedes
+end   # module Rlp

data/lib/rlp-lite/sedes.rb

@@ -0,0 +1,73 @@
+
+
+  module Rlp
+    module Sedes
+
+      # Provides a singleton {Rlp::Sedes} class to infer objects and types.
+      class << self
+
+        # Tries to find a sedes objects suitable for a given Ruby object.
+        #
+        # The sedes objects considered are `obj`'s class, {big_endian_int} and
+        # {binary}. If `obj` is a list, an {Rlp::Sedes::List} will be
+        # constructed recursively.
+        #
+        # @param obj [Object] the Ruby object for which to find a sedes object.
+        # @raise [TypeError] if no appropriate sedes could be found.
+        def infer(obj)
+          return obj.class      if is_sedes?( obj.class )
+          return big_endian_int if obj.is_a?(Integer) && obj >= 0
+          return binary         if Binary.valid_type? obj
+          return List.new(elements: obj.map { |item| infer( item ) })  if is_list?( obj )
+          raise TypeError, "Did not find sedes handling type #{obj.class.name}"
+        end
+
+
+        # Determines if an object is a sedes object.
+        #
+        # @param obj [Object] the object to check.
+        # @return [Boolean] true if it's serializable and deserializable.
+        def is_sedes?(obj)
+          obj.respond_to?(:serialize) && obj.respond_to?(:deserialize)
+        end
+
+        # A utility to use a big-endian, unsigned integer sedes type with
+        # unspecified length.
+        #
+        # @return [Rlp::Sedes::BigEndianInt] a big-endian, unsigned integer sedes.
+        def big_endian_int
+          @big_endian_int ||= BigEndianInt.new
+        end
+
+        # A utility to use a binary sedes type.
+        #
+        # @return [Rlp::Sedes::Binary] a binary sedes.
+        def binary
+          @binary ||= Binary.new
+        end
+
+        ##############################
+        ### more helpers
+
+    # Checks if the given item is a string primitive.
+    #
+    # @param item [Object] the item to check.
+    # @return [Boolean] true if it's a string primitive.
+    def is_primitive?(item)
+      item.instance_of?(String)
+    end
+
+    # Checks if the given item is a list.
+    #
+    # @param item [Object] the item to check.
+    # @return [Boolean] true if it's a list.
+    def is_list?(item)
+      !is_primitive?(item) && item.respond_to?(:each)
+    end
+
+
+
+
+      end
+    end
+  end  #  module Rlp

data/lib/rlp-lite/util.rb

@@ -0,0 +1,108 @@
+
+module Rlp
+module Util
+   extend self
+
+
+
+
+  # Checks if a string is hex-adecimal.
+    #
+    # @param str [String] a string to be checked.
+    # @return [String] a match if true; `nil` if not.
+    def is_hex?(str)
+      return false unless str.is_a? String
+      str = remove_hex_prefix str
+      str.match /\A[0-9a-fA-F]*\z/
+    end
+
+  # Removes the `0x` prefix of a hexa-decimal string.
+    #
+    # @param hex [String] a prefixed hex-string.
+    # @return [String] an unprefixed hex-string.
+    def remove_hex_prefix(hex)
+      return hex[2..-1] if is_prefixed? hex
+      return hex
+    end
+
+   # Checks if a string is prefixed with `0x`.
+    #
+    # @param hex [String] a string to be checked.
+    # @return [String] a match if true; `nil` if not.
+    def is_prefixed?(hex)
+      hex.match /\A0x/
+    end
+
+     # Packs a hexa-decimal string into a binary string. Also works with
+    # `0x`-prefixed strings.
+    #
+    # @param hex [String] a hexa-decimal string to be packed.
+    # @return [String] a packed binary string.
+    # @raise [TypeError] if value is not a string or string is not hex.
+    def hex_to_bin(hex)
+      raise TypeError, "Value must be an instance of String" unless hex.instance_of? String
+      hex = remove_hex_prefix hex
+      raise TypeError, "Non-hexadecimal digit found" unless is_hex? hex
+      [hex].pack("H*")
+    end
+
+   # Unpacks a binary string to a hexa-decimal string.
+    #
+    # @param bin [String] a binary string to be unpacked.
+    # @return [String] a hexa-decimal string.
+    # @raise [TypeError] if value is not a string.
+    def bin_to_hex(bin)
+      raise TypeError, "Value must be an instance of String" unless bin.instance_of? String
+      bin.unpack("H*").first
+    end
+
+
+  # Converts a binary string to bytes.
+    #
+    # @param str [String] binary string to be converted.
+    # @return [Object] the string bytes.
+    def str_to_bytes(str)
+      is_bytes?(str) ? str : str.b
+    end
+
+      # Checks if a string is a byte-string.
+    #
+    # @param str [String] a string to check.
+    # @return [Boolean] true if it's an ASCII-8bit encoded byte-string.
+    def is_bytes?(str)
+      str && str.instance_of?(String) && str.encoding.name == 'ASCII-8BIT'
+    end
+
+
+
+      # Converts an integer to big endian.
+    #
+    # @param num [Integer] integer to be converted.
+    # @return [String] packed, big-endian integer string.
+    def int_to_big_endian(num)
+      hex = num.to_s(16) unless is_hex? num
+      hex = "0#{hex}" if hex.size.odd?
+      hex_to_bin hex
+    end
+
+
+
+   # Converts a big endian to an interger.
+    #
+    # @param str [String] big endian to be converted.
+    # @return [Integer] an unpacked integer number.
+    def big_endian_to_int(str)
+      str.unpack("H*").first.to_i(16)
+    end
+
+    # Deserializes big endian data string to integer.
+    #
+    # @param str [String] serialized big endian integer string.
+    # @return [Integer] an deserialized unsigned integer.
+    def deserialize_big_endian_to_int(str)
+      Sedes.big_endian_int.deserialize str.sub(/\A(\x00)+/, "")
+    end
+
+
+end   # module Util
+end   # module Rlp

data/lib/rlp-lite/version.rb

@@ -0,0 +1,5 @@
+
+module Rlp
+  VERSION='0.0.1'
+end
+

data/lib/rlp-lite.rb

@@ -0,0 +1,82 @@
+
+require_relative "rlp-lite/version"
+require_relative "rlp-lite/util"
+
+require_relative "rlp-lite/decoder"
+require_relative "rlp-lite/encoder"
+
+require_relative "rlp-lite/sedes/big_endian_int"
+require_relative "rlp-lite/sedes/binary"
+require_relative "rlp-lite/sedes/list"
+require_relative "rlp-lite/sedes"
+
+
+
+# Provides an recursive-length prefix (RLP) encoder and decoder.
+
+module Rlp
+   ## add constants "inline" here
+   ##  (no need to use a Constant namespace - why? why not?)
+
+
+   ## todo/check   - use encoding -ascii-8bit for source file or ? - why? why not?
+   ## use  #b/.b  to ensure binary encoding? - why? why not?
+   BYTE_EMPTY = "".freeze   # The empty byte is defined as "".
+   BYTE_ZERO = "\x00".freeze   # The zero byte is 0x00.
+   BYTE_ONE = "\x01".freeze    # The byte one is 0x01.
+
+
+
+   # The RLP short length limit.
+   SHORT_LENGTH_LIMIT = 56
+
+   # The RLP long length limit.
+   LONG_LENGTH_LIMIT = (256 ** 8)
+
+   # The RLP primitive type offset.
+   PRIMITIVE_PREFIX_OFFSET = 0x80
+
+   # The RLP array type offset.
+   LIST_PREFIX_OFFSET = 0xc0
+
+
+   # Infinity as constant for convenience.
+   INFINITY = (1.0 / 0.0)
+
+
+ # The Rlp module exposes a variety of exceptions grouped as {RlpException}.
+ class RlpException < StandardError; end
+
+ # An error-type to point out RLP-encoding errors.
+ class EncodingError < RlpException; end
+
+ # An error-type to point out RLP-decoding errors.
+ class DecodingError < RlpException; end
+
+ # An error-type to point out RLP-type serialization errors.
+ class SerializationError < RlpException; end
+
+ # An error-type to point out RLP-type serialization errors.
+ class DeserializationError < RlpException; end
+
+ # A wrapper to represent already RLP-encoded data.
+ class Data < String; end
+
+
+    # Performes an {Rlp::Encoder} on any ruby object.
+    #
+    # @param obj [Object] any ruby object.
+    # @return [String] a packed, RLP-encoded item.
+    def self.encode(obj) Encoder.perform( obj ); end
+
+
+    # Performes an {Rlp::Decoder} on any RLP-encoded item.
+    #
+    # @param rlp [String] a packed, RLP-encoded item.
+    # @return [Object] a decoded ruby object.
+    def self.decode(rlp) Decoder.perform( rlp ); end
+end   # module Rlp
+
+
+
+

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: rlp-lite
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gerald Bauer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-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: '3.23'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+description: rlp-lite - light-weight machinery to serialize / deserialze via rlp (recursive
+  length prefix)
+email: wwwmake@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+- Rakefile
+- lib/rlp-lite.rb
+- lib/rlp-lite/decoder.rb
+- lib/rlp-lite/encoder.rb
+- lib/rlp-lite/sedes.rb
+- lib/rlp-lite/sedes/big_endian_int.rb
+- lib/rlp-lite/sedes/binary.rb
+- lib/rlp-lite/sedes/list.rb
+- lib/rlp-lite/util.rb
+- lib/rlp-lite/version.rb
+homepage: https://github.com/pixelartexchange/artbase
+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.3.7
+signing_key:
+specification_version: 4
+summary: rlp-lite - light-weight machinery to serialize / deserialze via rlp (recursive
+  length prefix)
+test_files: []