tron.rb 1.1.9 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 232c93f724a0aeb89150ec237af9c4a6d504b3635aabff7c833e9b71660a8752
-  data.tar.gz: 4403e025c9d31a49e26da6cde92cfeb184df9626d97d76d662eb43ae3644728b
+  metadata.gz: 35bce6c89581cd9bd40fe5c0735ecc0c32967d8e009813f650b5ac72d109ba68
+  data.tar.gz: 3ae5de345bb422790b4d1e0088ee6fb90daa5f2bf6a5be6f0c26fef35f5bca35
 SHA512:
-  metadata.gz: 8032ab96d92f191b7a3c6923104d656a5edb451a0498b57d339fc823084d3041b3da618ed106d015d60d17c99fb50d11a1b0228d8c1ee61ab80876feaf535a43
-  data.tar.gz: a4bdca985bb3cf4389fd045711a2f7a3bcea9f15ddc4902a3ccb4c5e1e624d50140ae2ee1b0438fb23eb95f5e9e98e39c3316b060c877d6b22a27a45cb093df4
+  metadata.gz: 60866f0ac3fee060925d27bf6eebac0e5b05c5d93a44e509f8b5ed3b6119b00003a5085295cbe089d9ff0e454893ae2428272374ea1fe7d6da265d60f1cc1e5d
+  data.tar.gz: 722fb4af8c761a5033debf62cd09160ac355cc186ea1af598841e475a223b99a180687d20a0de479e31a7bd00f910ab5907efa8c07f36a6d55908241d0853e03

data/lib/tron/abi/packed/encoder.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative '../type'
+require_relative '../util'
+require_relative '../constant'
+require_relative '../../utils/address'
+
+module Tron
+  module Abi
+    module Packed
+      # Provides a utility module to assist in packed encoding ABIs.
+      module Encoder
+        extend self
+
+        # Encodes a specific value in non-standard packed encoding mode.
+        #
+        # @param type [String] type to be encoded.
+        # @param arg [String|Number] value to be encoded.
+        # @return [String] the packed encoded type.
+        # @raise [EncodingError] if value does not match type.
+        # @raise [ArgumentError] if encoding fails for type.
+        def type(type, arg)
+          case type
+          when /^uint(\d+)$/
+            uint(arg, $1.to_i / 8)
+          when /^int(\d+)$/
+            int(arg, $1.to_i / 8)
+          when "bool"
+            bool(arg)
+          when /^ureal(\d+)x(\d+)$/, /^ufixed(\d+)x(\d+)$/
+            ufixed(arg, $1.to_i / 8, $2.to_i)
+          when /^real(\d+)x(\d+)$/, /^fixed(\d+)x(\d+)$/
+            fixed(arg, $1.to_i / 8, $2.to_i)
+          when "string"
+            string(arg)
+          when /^bytes(\d+)$/
+            bytes(arg, $1.to_i)
+          when "bytes"
+            string(arg)
+          when /^tuple\((.+)\)$/
+            tuple($1.split(","), arg)
+          when /^hash(\d+)$/
+            hash(arg, $1.to_i / 8)
+          when "address"
+            address(arg)
+          when /^(.+)\[\]$/
+            array($1, arg)
+          when /^(.+)\[(\d+)\]$/
+            fixed_array($1, arg, $2.to_i)
+          else
+            raise EncodingError, "Unhandled type: #{type}"
+          end
+        end
+
+        private
+
+        # Properly encodes unsigned integers.
+        def uint(value, byte_size)
+          raise ArgumentError, "Don't know how to handle this input." unless value.is_a? Numeric
+          raise ValueOutOfBounds, "Number out of range: #{value}" if value > Constant::UINT_MAX or value < Constant::UINT_MIN
+          i = value.to_i
+          Util.zpad_int(i, byte_size)
+        end
+
+        # Properly encodes signed integers.
+        def int(value, byte_size)
+          raise ArgumentError, "Don't know how to handle this input." unless value.is_a? Numeric
+          raise ValueOutOfBounds, "Number out of range: #{value}" if value > Constant::INT_MAX or value < Constant::INT_MIN
+          real_size = byte_size * 8
+          i = value.to_i % 2 ** real_size
+          Util.zpad_int(i, byte_size)
+        end
+
+        # Properly encodes booleans.
+        def bool(value)
+          raise EncodingError, "Argument is not bool: #{value}" unless [TrueClass, FalseClass].any? { |bool_class| value.is_a?(bool_class) }
+          (value ? "\x01" : "\x00").b
+        end
+
+        # Properly encodes unsigned fixed-point numbers.
+        def ufixed(value, byte_size, decimals)
+          raise ArgumentError, "Don't know how to handle this input." unless value.is_a? Numeric
+          raise ValueOutOfBounds, value unless value >= 0 and value < 2 ** decimals
+          scaled_value = (value * (10 ** decimals)).to_i
+          uint(scaled_value, byte_size)
+        end
+
+        # Properly encodes signed fixed-point numbers.
+        def fixed(value, byte_size, decimals)
+          raise ArgumentError, "Don't know how to handle this input." unless value.is_a? Numeric
+          raise ValueOutOfBounds, value unless value >= -2 ** (decimals - 1) and value < 2 ** (decimals - 1)
+          scaled_value = (value * (10 ** decimals)).to_i
+          int(scaled_value, byte_size)
+        end
+
+        # Properly encodes byte(-string)s.
+        def bytes(value, length)
+          raise EncodingError, "Expecting String: #{value}" unless value.is_a? String
+          value = handle_hex_string(value, length)
+          raise ArgumentError, "Value must be a string of length #{length}" unless value.is_a?(String) && value.bytesize == length
+          value.b
+        end
+
+        # Properly encodes (byte-)strings.
+        def string(value)
+          raise ArgumentError, "Value must be a string" unless value.is_a?(String)
+          value.b
+        end
+
+        # Properly encodes tuples.
+        def tuple(types, values)
+          # Call the solidity_packed function to handle tuple encoding
+          Tron::Abi.solidity_packed(types, values)
+        end
+
+        # Properly encodes hash-strings.
+        def hash(value, byte_size)
+          raise EncodingError, "Argument too long: #{value}" unless byte_size > 0 and byte_size <= 32
+          hash_bytes = handle_hex_string(value, byte_size)
+          hash_bytes.b
+        end
+
+        # Properly encodes addresses.
+        def address(value)
+          if value.is_a?(String) && value.start_with?('T') && value.length == 34
+            # TRON address in Base58 format - convert to hex
+            hex_addr = Utils::Address.to_hex(value)
+            # Remove the 0x41 prefix and return raw bytes
+            Util.hex_to_bin(hex_addr[2..-1])
+          elsif value.is_a? Integer
+            # address from integer
+            Util.zpad_int(value, 20)
+          elsif value.size == 20
+            # address from raw 20-byte address
+            value
+          elsif value.size == 40
+            # address from hexadecimal address (without 0x prefix)
+            Util.hex_to_bin(value)
+          elsif value.size == 42 && value[0, 2] == "0x"
+            # address from hexadecimal address with 0x prefix
+            Util.hex_to_bin(value[2..-1])
+          else
+            raise EncodingError, "Could not parse address: #{value}"
+          end
+        end
+
+        # Properly encodes dynamic-sized arrays.
+        def array(type, values)
+          # For packed encoding, we don't encode array length, just concatenate values
+          values.map { |value| type(type, value) }.join.b
+        end
+
+        # Properly encodes fixed-size arrays.
+        def fixed_array(type, values, size)
+          raise ArgumentError, "Array size does not match" unless values.size == size
+          # For packed encoding, concatenate values directly
+          values.map { |value| type(type, value) }.join.b
+        end
+
+        # The ABI encoder needs to be able to determine between a hex `"123"`
+        # and a binary `"123"` string.
+        def handle_hex_string(val, len)
+          if Util.prefixed?(val) || (len == val.size / 2 && Util.hex?(val))
+            # There is no way telling whether a string is hex or binary with certainty
+            # in Ruby. Therefore, we assume a `0x` prefix to indicate a hex string.
+            # Additionally, if the string size is exactly the double of the expected
+            # binary size, we can assume a hex value.
+            Util.hex_to_bin(val)
+          else
+            # Everything else will be assumed binary or raw string.
+            val.b
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tron/abi/packed.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'packed/encoder'

data/lib/tron/abi.rb

@@ -22,6 +22,7 @@ module Tron
     require_relative 'abi/event'
     require_relative 'abi/util'
     require_relative 'abi/constant'
+    require_relative 'abi/packed'
     
     # For address handling functionality
     require_relative 'utils/address'
@@ -139,6 +140,21 @@ module Tron
       types
     end
 
+    # Encodes values using Solidity packed encoding (no padding to 32 bytes)
+    #
+    # @param types [Array<String>] array of type strings
+    # @param values [Array] array of values to encode
+    # @return [String] binary string of packed encoded values
+    def self.solidity_packed(types, values)
+      raise ArgumentError, "Types and values must be the same length" if types.length != values.length
+
+      packed = types.zip(values).map do |type, value|
+        Tron::Abi::Packed::Encoder.type(type, value)
+      end.join
+
+      packed.force_encoding(Encoding::ASCII_8BIT)
+    end
+
     # Decode output from a contract call
     #
     # @param type_str [String] the output type

data/lib/tron/version.rb

@@ -2,5 +2,5 @@
 
 # lib/tron/version.rb
 module Tron
-  VERSION = "1.1.9".freeze
+  VERSION = "1.2.1".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tron.rb
 version: !ruby/object:Gem::Version
-  version: 1.1.9
+  version: 1.2.1
 platform: ruby
 authors:
 - Bolo Michelin
@@ -141,6 +141,8 @@ files:
 - lib/tron/abi/encoder.rb
 - lib/tron/abi/event.rb
 - lib/tron/abi/function.rb
+- lib/tron/abi/packed.rb
+- lib/tron/abi/packed/encoder.rb
 - lib/tron/abi/type.rb
 - lib/tron/abi/util.rb
 - lib/tron/cache.rb