tron.rb 1.1.2 → 1.1.3

data/lib/tron/abi/encoder.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+require "bigdecimal"
+require_relative 'util'
+require_relative 'constant'
+
+module Tron
+  module Abi
+    # Provides a utility module to assist encoding ABIs.
+    module Encoder
+      extend self
+
+      # Encodes a specific value, either static or dynamic.
+      #
+      # @param type [Tron::Abi::Type] type to be encoded.
+      # @param arg [String|Number] value to be encoded.
+      # @return [String] the encoded type.
+      # @raise [EncodingError] if value does not match type.
+      def type(type, arg)
+        if %w(string bytes).include? type.base_type and type.sub_type.empty? and type.dimensions.empty?
+          raise EncodingError, "Argument must be a String" unless arg.instance_of? String
+          arg = handle_hex_string arg, type
+
+          # encodes strings and bytes
+          size = type Type.size_type, arg.bytesize
+          padding = ::Tron::Abi::Constant::BYTE_ZERO * (Util.ceil32(arg.bytesize) - arg.bytesize)
+          (size + arg + padding).b
+        elsif type.base_type == "tuple" && type.dimensions.size == 1 && type.dimensions[0] != 0
+          result = ""
+          result += struct_offsets(type.nested_sub, arg)
+          result += arg.map { |x| type(type.nested_sub, x) }.join
+          result
+        elsif type.dynamic? && !type.dimensions.empty? && arg.is_a?(Array)
+
+          # encodes dynamic-sized arrays
+          head = type(Type.size_type, arg.size)
+          nested_sub = type.nested_sub
+
+          if nested_sub.dynamic?
+            tails = arg.map { |a| type(nested_sub, a) }
+            offset = arg.size * 32
+            tails.each do |t|
+              head += type(Type.size_type, offset)
+              offset += t.bytesize
+            end
+            head + tails.join
+          else
+            arg.each { |a| head += type(nested_sub, a) }
+            head
+          end
+        else
+          if type.dimensions.empty?
+
+            # encode a primitive type
+            primitive_type type, arg
+          else
+
+            # encode static-size arrays
+            arg.map { |x| type(type.nested_sub, x) }.join
+          end
+        end
+      end
+
+      # Encodes primitive types.
+      #
+      # @param type [Tron::Abi::Type] type to be encoded.
+      # @param arg [String|Number] value to be encoded.
+      # @return [String] the encoded primitive type.
+      # @raise [EncodingError] if value does not match type.
+      # @raise [ValueOutOfBounds] if value is out of bounds for type.
+      # @raise [ArgumentError] if encoding fails for type.
+      def primitive_type(type, arg)
+        case type.base_type
+        when "uint"
+          uint arg, type
+        when "int"
+          int arg, type
+        when "bool"
+          bool arg
+        when "ureal", "ufixed"
+          ufixed arg, type
+        when "real", "fixed"
+          fixed arg, type
+        when "string", "bytes"
+          bytes arg, type
+        when "tuple"
+          tuple arg, type
+        when "hash"
+          hash arg, type
+        when "address"
+          address arg
+        else
+          raise EncodingError, "Unhandled type: #{type.base_type} #{type.sub_type}"
+        end
+      end
+
+      private
+
+      # Properly encodes unsigned integers.
+      def uint(arg, type)
+        arg = coerce_number arg
+        raise ArgumentError, "Don't know how to handle this input." unless arg.is_a? Numeric
+        raise ValueOutOfBounds, "Number out of range: #{arg}" if arg > Util::UINT_MAX or arg < Util::UINT_MIN
+        real_size = type.sub_type.to_i
+        i = arg.to_i
+        raise ValueOutOfBounds, arg unless i >= 0 and i < 2 ** real_size
+        Util.zpad_int i
+      end
+
+      # Properly encodes signed integers.
+      def int(arg, type)
+        arg = coerce_number arg
+        raise ArgumentError, "Don't know how to handle this input." unless arg.is_a? Numeric
+        raise ValueOutOfBounds, "Number out of range: #{arg}" if arg > Util::INT_MAX or arg < Util::INT_MIN
+        real_size = type.sub_type.to_i
+        i = arg.to_i
+        raise ValueOutOfBounds, arg unless i >= -2 ** (real_size - 1) and i < 2 ** (real_size - 1)
+        Util.zpad_int(i % 2 ** 256)
+      end
+
+      # Properly encodes booleans.
+      def bool(arg)
+        raise EncodingError, "Argument is not bool: #{arg}" unless arg.instance_of? TrueClass or arg.instance_of? FalseClass
+        Util.zpad_int(arg ? 1 : 0)
+      end
+
+      # Properly encodes unsigned fixed-point numbers.
+      def ufixed(arg, type)
+        arg = coerce_number arg
+        raise ArgumentError, "Don't know how to handle this input." unless arg.is_a? Numeric
+        high, low = type.sub_type.split("x").map(&:to_i)
+        raise ValueOutOfBounds, arg unless arg >= 0 and arg < 2 ** high
+        Util.zpad_int((arg * 2 ** low).to_i)
+      end
+
+      # Properly encodes signed fixed-point numbers.
+      def fixed(arg, type)
+        arg = coerce_number arg
+        raise ArgumentError, "Don't know how to handle this input." unless arg.is_a? Numeric
+        high, low = type.sub_type.split("x").map(&:to_i)
+        raise ValueOutOfBounds, arg unless arg >= -2 ** (high - 1) and arg < 2 ** (high - 1)
+        i = (arg * 2 ** low).to_i
+        Util.zpad_int(i % 2 ** (high + low))
+      end
+
+      # Properly encodes byte-strings.
+      def bytes(arg, type)
+        raise EncodingError, "Expecting String: #{arg}" unless arg.instance_of? String
+        arg = handle_hex_string arg, type
+
+        if type.sub_type.empty?
+          size = Util.zpad_int arg.bytesize
+          padding = ::Tron::Abi::Constant::BYTE_ZERO * (Util.ceil32(arg.bytesize) - arg.bytesize)
+
+          # variable length string/bytes
+          (size + arg + padding).b
+        else
+          raise ValueOutOfBounds, arg unless arg.bytesize <= type.sub_type.to_i
+          padding = ::Tron::Abi::Constant::BYTE_ZERO * (32 - arg.bytesize)
+
+          # fixed length string/bytes
+          (arg + padding).b
+        end
+      end
+
+      # Properly encodes tuples.
+      def tuple(arg, type)
+        unless arg.is_a?(Hash) || arg.is_a?(Array)
+          raise EncodingError, "Expecting Hash or Array: #{arg}"
+        end
+        raise EncodingError, "Expecting #{type.components.size} elements: #{arg}" unless arg.size == type.components.size
+        arg = arg.transform_keys(&:to_s) if arg.is_a?(Hash) # because component_type.name is String
+
+        static_size = 0
+        type.components.each_with_index do |component, i|
+          if type.components[i].dynamic?
+            static_size += 32
+          else
+            static_size += Util.ceil32(type.components[i].size || 0)
+          end
+        end
+
+        dynamic_offset = static_size
+        offsets_and_static_values = []
+        dynamic_values = []
+
+        type.components.each_with_index do |component, i|
+          component_type = type.components[i]
+          if component_type.dynamic?
+            offsets_and_static_values << type(Type.size_type, dynamic_offset)
+            dynamic_value = type(component_type, arg.is_a?(Array) ? arg[i] : arg[component_type.name])
+            dynamic_values << dynamic_value
+            dynamic_offset += dynamic_value.bytesize
+          else
+            offsets_and_static_values << type(component_type, arg.is_a?(Array) ? arg[i] : arg.fetch(component_type.name))
+          end
+        end
+
+        offsets_and_static_values.join + dynamic_values.join
+      end
+
+      def coerce_number(arg)
+        return arg if arg.is_a? Numeric
+        return arg.to_i(0) if arg.is_a?(String) && arg.match?(/^-?(0x)?[0-9a-fA-F]+$/)
+        return BigDecimal(arg) if arg.is_a?(String) && arg.match?(/^-?\d+(\.\d+)?$/)
+        arg
+      end
+
+      # Properly encode struct offsets.
+      def struct_offsets(type, arg)
+        result = ""
+        offset = arg.size
+        tails_encoding = arg.map { |a| type(type, a) }
+        arg.size.times do |i|
+          if i == 0
+            offset *= 32
+          else
+            offset += tails_encoding[i - 1].bytesize
+          end
+          offset_string = type(Type.size_type, offset)
+          result += offset_string
+        end
+        result
+      end
+
+      # Properly encodes hash-strings.
+      def hash(arg, type)
+        size = type.sub_type.to_i
+        raise EncodingError, "Argument too long: #{arg}" unless size > 0 and size <= 32
+        if arg.is_a? Integer
+
+          # hash from integer
+          Util.zpad_int arg
+        elsif arg.size == size
+
+          # hash from encoded hash
+          Util.zpad arg, 32
+        elsif arg.size == size * 2
+
+          # hash from hexadecimal hash
+          Util.zpad_hex arg
+        else
+          raise EncodingError, "Could not parse hash: #{arg}"
+        end
+      end
+
+      # Properly encodes addresses.
+      def address(arg)
+        # Handle TRON-specific address encoding
+        require_relative '../utils/address'
+        
+        if arg.is_a?(String) && arg.start_with?('T') && arg.length == 34
+          # TRON address in Base58 format - convert to hex and pad
+          hex_addr = Utils::Address.to_hex(arg)
+          # Remove the 0x41 prefix and pad to 32 bytes (64 hex chars)
+          addr_without_prefix = hex_addr[2..-1]  # Remove '41' prefix
+          Util.zpad_hex addr_without_prefix
+        elsif arg.is_a? Integer
+          # address from integer
+          Util.zpad_int arg
+        elsif arg.size == 20
+          # address from raw 20-byte address
+          Util.zpad arg, 32
+        elsif arg.size == 40
+          # address from hexadecimal address (without 0x prefix)
+          Util.zpad_hex arg
+        elsif arg.size == 42 and arg[0, 2] == "0x"
+          # address from hexadecimal address with 0x prefix
+          Util.zpad_hex arg[2..-1]
+        else
+          raise EncodingError, "Could not parse address: #{arg}"
+        end
+      end
+
+      # The ABI encoder needs to be able to determine between a hex `"123"`
+      # and a binary `"123"` string.
+      def handle_hex_string(arg, type)
+        if Util.prefixed? arg or
+           (arg.size === type.sub_type.to_i * 2 and Util.hex? arg)
+
+          # 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 arg
+        else
+
+          # Everything else will be assumed binary or raw string.
+          arg.b
+        end
+      end
+    end
+  end
+end

data/lib/tron/abi/event.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'digest/keccak'
+require_relative 'type'
+require_relative 'encoder'
+require_relative 'decoder'
+require_relative 'util'
+
+module Tron
+  module Abi
+    # Represents a Solidity event for ABI encoding/decoding
+    class Event
+      attr_reader :name, :inputs, :anonymous, :signature, :topic_hash
+
+      # Create a new Event instance
+      #
+      # @param name [String] the event name
+      # @param inputs [Array<Hash>] the input parameters
+      # @param anonymous [Boolean] whether the event is anonymous
+      def initialize(name:, inputs: [], anonymous: false)
+        @name = name
+        @inputs = inputs
+        @anonymous = anonymous
+        @signature = generate_signature
+        @topic_hash = generate_topic_hash
+      end
+
+      # Generate the event signature
+      #
+      # @return [String] the event signature
+      def generate_signature
+        param_types = @inputs.map { |input| input[:type] }.join(',')
+        "#{@name}(#{param_types})"
+      end
+
+      # Generate the topic hash (Keccak256 hash of signature)
+      #
+      # @return [String] the topic hash as hex string
+      def generate_topic_hash
+        # Using Keccak256 hash from the gem
+        hash = Digest::Keccak.new(256).digest(@signature)
+        hash.unpack1('H*')
+      end
+
+      # Decode event log data from transaction receipt
+      #
+      # @param topics [Array<String>] the topics from the event log
+      # @param data [String] the data from the event log
+      # @return [Hash] decoded event parameters
+      def decode_log(topics, data)
+        # Create a result hash with the event name
+        result = { name: @name, params: [] }
+
+        # Remove '0x' prefix if present
+        raw_data = data.start_with?('0x') ? data[2..-1] : data
+        raw_topics = topics.map { |t| t.start_with?('0x') ? t[2..-1] : t }
+
+        # Process topics and inputs
+        topic_idx = @anonymous ? 0 : 1  # Skip the first topic if not anonymous
+        data_offset = 0
+
+        @inputs.each_with_index do |input, i|
+          type = Type.parse(input[:type])
+
+          if input[:indexed]  # This parameter was included in the topics
+            if topic_idx < raw_topics.length
+              # Decode the topic value
+              topic_data = raw_topics[topic_idx]
+              # For static types like uint, address, bool, etc., the value is directly in the topic
+              # For dynamic types like string, bytes, arrays, etc., the topic contains a hash of the value
+              decoded_value = if type.dynamic?
+                               # For dynamic types in topics, the topic contains the hash of the value
+                               # For proper decoding, you'd need the original value or to look it up elsewhere
+                               topic_data
+                             else
+                               # For static types, decode from the 32-byte topic value
+                               # Convert hex to binary before decoding
+                               Decoder.type(type, Util.hex_to_bin(topic_data))
+                             end
+              result[:params] << { name: input[:name], type: input[:type], value: decoded_value, indexed: true }
+              topic_idx += 1
+            end
+          else  # This parameter was included in the data section
+            if type.dynamic?
+              # For dynamic types, read the offset first
+              offset_ptr = raw_data[data_offset, 64]  # 32 bytes = 64 hex chars
+              # Convert hex to binary before deserializing
+              actual_offset = Util.deserialize_big_endian_to_int(Util.hex_to_bin(offset_ptr))
+
+              # Decode using the actual offset
+              # Convert hex to binary before decoding
+              decoded_value = Decoder.type(type, Util.hex_to_bin(raw_data[actual_offset * 2..-1]))
+              result[:params] << { name: input[:name], type: input[:type], value: decoded_value, indexed: false }
+              data_offset += 64  # Move by 64 hex chars for the offset pointer
+            else
+              # For static types, decode directly from current offset
+              size = type.size * 2  # size in bytes converted to hex chars
+              # Convert hex to binary before decoding
+              decoded_value = Decoder.type(type, Util.hex_to_bin(raw_data[data_offset, size]))
+              result[:params] << { name: input[:name], type: input[:type], value: decoded_value, indexed: false }
+              data_offset += size
+            end
+          end
+        end
+
+        result
+      end
+
+      # Create an Event instance from an ABI definition
+      #
+      # @param abi_def [Hash] the ABI definition
+      # @return [Event] a new Event instance
+      def self.from_abi(abi_def)
+        raise ArgumentError, "Not an event definition" unless abi_def[:type] == 'event' || abi_def['type'] == 'event'
+
+        new(
+          name: abi_def[:name] || abi_def['name'],
+          inputs: abi_def[:inputs] || abi_def['inputs'] || [],
+          anonymous: abi_def[:anonymous] || abi_def['anonymous'] || false
+        )
+      end
+
+      # Generate event signature from signature string
+      #
+      # @param sig [String] event signature (e.g. "Transfer(address,address,uint256)")
+      # @return [String] the topic hash
+      def self.signature(sig)
+        hash = Digest::Keccak.new(256).digest(sig)
+        hash.unpack1('H*')
+      end
+    end
+  end
+end

data/lib/tron/abi/function.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'digest/keccak'
+require_relative 'type'
+require_relative 'encoder'
+require_relative 'decoder'
+require_relative 'util'
+
+module Tron
+  module Abi
+    # Represents a Solidity function for ABI encoding/decoding
+    class Function
+      attr_reader :name, :inputs, :outputs, :signature, :method_id
+
+      # Create a new Function instance
+      #
+      # @param name [String] the function name
+      # @param inputs [Array<Hash>] the input parameters
+      # @param outputs [Array<Hash>] the output parameters
+      # @param constant [Boolean] whether the function is constant (view/pure)
+      # @param payable [Boolean] whether the function is payable
+      def initialize(name:, inputs: [], outputs: [], constant: false, payable: false)
+        @name = name
+        @inputs = inputs
+        @outputs = outputs
+        @constant = constant
+        @payable = payable
+        @signature = generate_signature
+        @method_id = generate_method_id
+      end
+
+      # Generate the function signature
+      #
+      # @return [String] the function signature
+      def generate_signature
+        param_types = @inputs.map { |input| input[:type] }.join(',')
+        "#{@name}(#{param_types})"
+      end
+
+      # Generate the method ID (first 4 bytes of Keccak256 hash of signature)
+      #
+      # @return [String] the method ID as hex string
+      def generate_method_id
+        # Using Keccak256 hash from the gem
+        hash = Digest::Keccak.new(256).digest(@signature)
+        # Take only first 4 bytes (8 hex chars)
+        hash[0, 4].unpack1('H*')
+      end
+
+      # Encode a function call with given parameters
+      #
+      # @param parameters [Array] the parameter values to encode
+      # @return [String] encoded function call data
+      def encode_input(parameters)
+        # Verify parameter count matches input count
+        raise ArgumentError, "Expected #{@inputs.length} parameters, got #{parameters.length}" unless parameters.length == @inputs.length
+
+        # Encode each parameter according to its type
+        encoded_params = []
+        parameters.each_with_index do |param, idx|
+          input_type = @inputs[idx][:type]
+          type = Type.parse(input_type)
+          encoded_params << Encoder.type(type, param)
+        end
+
+        # Combine method ID and encoded parameters
+        # Return hex string to maintain consistency with the ABI.encode function
+        Util.bin_to_hex(Util.hex_to_bin(@method_id) + encoded_params.join)
+      end
+
+      # Decode function output from returned data
+      #
+      # @param data [String] the returned data from the function call
+      # @return [Array] decoded output values
+      def decode_output(data)
+        # Remove the '0x' prefix if present
+        raw_data = data.start_with?('0x') ? data[2..-1] : data
+
+        # Decode each output parameter
+        results = []
+        offset = 0
+
+        @outputs.each do |output|
+          type = Type.parse(output[:type])
+          if type.dynamic?
+            # For dynamic types, read the offset first
+            offset_ptr = raw_data[offset, 64]  # 32 bytes = 64 hex chars
+            # Convert hex to binary before deserializing
+            actual_offset = Util.deserialize_big_endian_to_int(Util.hex_to_bin(offset_ptr))
+
+            # Decode using the actual offset
+            # Convert hex to binary before decoding
+            decoded_value = Decoder.type(type, Util.hex_to_bin(raw_data[actual_offset * 2..-1]))
+            results << decoded_value
+            offset += 64  # Move by 64 hex chars for the offset pointer
+          else
+            # For static types, decode directly from current offset
+            size = type.size * 2  # size in bytes converted to hex chars
+            # Convert hex to binary before decoding
+            decoded_value = Decoder.type(type, Util.hex_to_bin(raw_data[offset, size]))
+            results << decoded_value
+            offset += size
+          end
+        end
+
+        results
+      end
+
+      # Create a Function instance from an ABI definition
+      #
+      # @param abi_def [Hash] the ABI definition
+      # @return [Function] a new Function instance
+      def self.from_abi(abi_def)
+        raise ArgumentError, "Not a function definition" unless abi_def[:type] == 'function' || abi_def['type'] == 'function'
+
+        new(
+          name: abi_def[:name] || abi_def['name'],
+          inputs: abi_def[:inputs] || abi_def['inputs'] || [],
+          outputs: abi_def[:outputs] || abi_def['outputs'] || [],
+          constant: abi_def[:constant] || abi_def['constant'] || false,
+          payable: abi_def[:payable] || abi_def['payable'] || false
+        )
+      end
+
+      # Generate function signature from signature string
+      #
+      # @param sig [String] function signature (e.g. "transfer(address,uint256)")
+      # @return [String] the method ID
+      def self.signature(sig)
+        hash = Digest::Keccak.new(256).digest(sig)
+        hash[0, 4].unpack1('H*')
+      end
+    end
+  end
+end