tron.rb 1.1.5 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 585ad45b691372d3698239c2bd3ad6c81a2f70409869867fb8e645ccba7aa29c
-  data.tar.gz: c45974ccdd37b4ce9ba68d0b395fc03ff08dad33d0997d90665ee376db2dfb0d
+  metadata.gz: f59c819dcc9f4459d1f1dfb4ac7fb574641f0328db9e9ddbfcedd8b0fb4d0d61
+  data.tar.gz: 78791543da62e51939da9740f996c5f58da444f701215816f1bb126f830b7e0d
 SHA512:
-  metadata.gz: b79bee6d4053770cc2f9f2d3fe8971c23a7cc828f59d28364695653f5843be4badab7a6bc0753b715c6ff651ca96dbe9eaaa7a8afb11ce3462e0708ca42bf32a
-  data.tar.gz: 39a090312157fe64b22ad82d3c76aac72a9ba2be75279ddd276b29f3e5ec282248d5d15ad76fb90debe4d200b984b6c4aa698f8660a0b076cf8db76b5f6f260b
+  metadata.gz: e83539da13849989f51dac5885fdf516eab9a06931b8ea898485523e35d20f924b40ac28d8d0136163810f282cd70f7ae6f37ea4584d7f08da49b40b29eeb9da
+  data.tar.gz: 5e5fadf2581f2c5c505afc929252878a8f121bd9e1e87c5af74a5c73f22752cb77181a963242e84aa699847f649d35ce57d38fa1c5e869df6f050fe8d913bf03

data/lib/tron/abi.rb

@@ -77,6 +77,44 @@ module Tron
       Util.bin_to_hex(result_binary)
     end
 
+    # Encode a function call with signature and parameters
+    #
+    # @param signature [String] function signature like "transfer(address,uint256)"
+    # @param parameters [Array] parameter values
+    # @return [String] hex-encoded function call (selector + params)
+    def self.encode_function_call(signature, parameters = [])
+      # Parse function signature to get parameter types
+      match = signature.match(/^(\w+)\((.*)\)$/)
+      raise ArgumentError, "Invalid function signature: #{signature}" unless match
+
+      function_name = match[1]
+      param_types_str = match[2]
+      param_types = param_types_str.empty? ? [] : param_types_str.split(',').map(&:strip)
+
+      # Get function selector (first 4 bytes of keccak256 hash)
+      require_relative 'utils/crypto'
+      hash = Utils::Crypto.keccak256(signature)
+      selector = Utils::Crypto.bin_to_hex(hash[0, 4])
+
+      # Encode parameters if any
+      if parameters.empty?
+        return selector
+      end
+
+      encoded_params = encode(param_types, parameters)
+      selector + encoded_params
+    end
+
+    # Decode output from a contract call
+    #
+    # @param type_str [String] the output type
+    # @param hex_data [String] hex-encoded output data
+    # @return [Object] decoded value
+    def self.decode_output(type_str, hex_data)
+      decoded = decode([type_str], hex_data)
+      decoded.first
+    end
+
     # Convenience method for decoding
     def self.decode(types, hex_data)
       # Convert hex to binary at the boundary

data/lib/tron/services/contract.rb

@@ -1,6 +1,5 @@
 require_relative '../utils/http'
 require_relative '../utils/address'
-require_relative '../utils/abi'
 require_relative '../abi'
 require_relative 'transaction'
 
@@ -86,7 +85,7 @@ module Tron
         endpoint = "#{@base_url}/wallet/triggerconstantcontract"
 
         # Encode function call
-        encoded_data = Utils::ABI.encode_function_call(function, parameters)
+        encoded_data = Abi.encode_function_call(function, parameters)
 
         # Use 'data' field instead of 'function_selector' (same as trigger_contract)
         payload = {
@@ -118,7 +117,7 @@ module Tron
           parameters: [operator_address, payment_id]
         )
 
-        Utils::ABI.decode_output('bool', result)
+        Abi.decode_output('bool', result)
       end
 
       # Gets the fee destination (example helper)
@@ -133,7 +132,7 @@ module Tron
           parameters: [operator_address]
         )
 
-        Utils::ABI.decode_output('address', result)
+        Abi.decode_output('address', result)
       end
 
       # Checks if an operator is registered (example helper)
@@ -148,7 +147,7 @@ module Tron
           parameters: [operator_address]
         )
 
-        Utils::ABI.decode_output('bool', result)
+        Abi.decode_output('bool', result)
       end
 
       private
@@ -173,7 +172,7 @@ module Tron
         endpoint = "#{@base_url}/wallet/triggersmartcontract"
 
         # Encode function call (selector + parameters)
-        encoded_data = Utils::ABI.encode_function_call(function, parameters)
+        encoded_data = Abi.encode_function_call(function, parameters)
 
         # IMPORTANT: Use 'data' field, not 'function_selector'
         # When function_selector is provided, the API expects it to be the signature string

data/lib/tron/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tron.rb
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.1.6
 platform: ruby
 authors:
 - Bolo Michelin
@@ -156,7 +156,6 @@ files:
 - lib/tron/services/resources.rb
 - lib/tron/services/transaction.rb
 - lib/tron/signature.rb
-- lib/tron/utils/abi.rb
 - lib/tron/utils/address.rb
 - lib/tron/utils/cache.rb
 - lib/tron/utils/crypto.rb

data/lib/tron/utils/abi.rb

@@ -1,321 +0,0 @@
-require 'digest'
-
-module Tron
-  module Utils
-    # Utility class for handling TRON contract ABIs
-    class ABI
-      # Type mappings for Solidity to Ruby
-      SOLIDITY_TYPES = {
-        'address' => :address,
-        'uint256' => :uint256,
-        'uint' => :uint256,
-        'bool' => :bool,
-        'bytes16' => :bytes16,
-        'bytes32' => :bytes32,
-        'string' => :string
-      }.freeze
-
-      # Parse function signature
-      #
-      # @param signature [String] the function signature to parse
-      # @return [Hash] a hash with :name and :params keys
-      # @raise [ArgumentError] if the signature is invalid
-      def self.parse_signature(signature)
-        match = signature.match(/^(\w+)\((.*)\)$/)
-        raise ArgumentError, "Invalid function signature: #{signature}" unless match
-
-        {
-          name: match[1],
-          params: match[2].empty? ? [] : match[2].split(',').map(&:strip)
-        }
-      end
-
-      # Encode function call
-      #
-      # @param signature [String] the function signature
-      # @param parameters [Array] the parameter values
-      # @return [String] the encoded function call
-      def self.encode_function_call(signature, parameters = [])
-        parsed = parse_signature(signature)
-
-        # Get function selector (first 4 bytes of keccak256 hash)
-        selector = function_selector(signature)
-
-        # Encode parameters
-        encoded_params = encode_parameters(parsed[:params], parameters)
-
-        selector + encoded_params
-      end
-
-      # Function selector (4-byte hash)
-      #
-      # @param signature [String] the function signature
-      # @return [String] the 4-byte function selector as hex
-      def self.function_selector(signature)
-        require_relative 'crypto'
-        # Note: TRON uses same ABI as Ethereum
-        # Using Keccak256 for hash
-        hash = Crypto.keccak256(signature)
-        # Take only the first 4 bytes (8 hex chars)
-        Crypto.bin_to_hex(hash[0, 4])
-      end
-
-      # Encode parameters
-      #
-      # @param types [Array<String>] the parameter types
-      # @param values [Array] the parameter values
-      # @return [String] the encoded parameters as hex
-      # @raise [ArgumentError] if there's a mismatch between types and values
-      def self.encode_parameters(types, values)
-        raise ArgumentError, "Types and values length mismatch" if types.length != values.length
-
-        encoded_parts = []
-        dynamic_params = []
-        dynamic_offset = types.length * 32 # Each static param takes 32 bytes (64 hex chars)
-        
-        types.each_with_index do |type, index|
-          value = values[index]
-          
-          case type
-          when 'address'
-            # Address is padded to 32 bytes (64 hex chars)
-            padded_address = encode_address(value)
-            encoded_parts << padded_address
-          when 'uint256', 'uint'
-            # Convert to hex and pad to 32 bytes (64 hex chars)
-            hex_value = encode_uint256(value)
-            encoded_parts << hex_value
-          when 'bool'
-            # Boolean to uint256 (1 for true, 0 for false)
-            encoded_parts << encode_bool(value)
-          when /^bytes(\d+)$/
-            # Static, fixed-size bytes array, pad to 32 bytes
-            encoded_parts << encode_bytes($1.to_i, value)
-          when 'string', 'bytes'
-            # For dynamic types, add offset and store actual data separately
-            encoded_parts << dynamic_offset.to_s(16).rjust(64, '0') # offset
-            # Calculate the actual data for later encoding
-            dynamic_data = encode_dynamic_parameter(type, value)
-            dynamic_params << dynamic_data
-            dynamic_offset += (dynamic_data.length / 2.0).ceil # Increase offset by byte length, rounded up to nearest whole byte
-          else
-            raise ArgumentError, "Unsupported ABI type: #{type}"
-          end
-        end
-        
-        # Encode dynamic parameters
-        dynamic_parts = []
-        dynamic_params.each do |data|
-          dynamic_parts << data
-        end
-        
-        (encoded_parts + dynamic_parts).join
-      end
-
-      # Encode a single value
-      #
-      # @param type [String] the type to encode
-      # @param value [Object] the value to encode
-      # @return [String] the encoded value as hex
-      # @raise [ArgumentError] if the type is unsupported
-      def self.encode_value(type, value)
-        case type
-        when 'address'
-          encode_address(value)
-        when 'uint256', 'uint'
-          encode_uint256(value)
-        when 'bool'
-          encode_bool(value)
-        when /^bytes(\d+)$/
-          encode_bytes($1.to_i, value)
-        when 'string'
-          encode_string(value)
-        else
-          raise ArgumentError, "Unsupported type: #{type}"
-        end
-      end
-
-      # Encode TRON address (T address to hex)
-      #
-      # @param address [String] the TRON address to encode
-      # @return [String] the encoded address as hex
-      def self.encode_address(address)
-        # Convert TRON T-address to hex address
-        # Remove 'T' prefix, convert base58 to hex, pad to 32 bytes
-        hex = Address.to_hex(address)
-        # Strip the 41 prefix for ABI encoding (only use the 20-byte address)
-        hex = hex[2..-1] if hex.start_with?('41')
-        hex.rjust(64, '0') # Pad to 64 hex chars (32 bytes)
-      end
-
-      # Encode uint256
-      #
-      # @param value [Integer, String] the value to encode
-      # @return [String] the encoded uint256 as hex
-      def self.encode_uint256(value)
-        value.to_i.to_s(16).rjust(64, '0')
-      end
-
-      # Encode bool
-      #
-      # @param value [Boolean] the boolean value to encode
-      # @return [String] the encoded boolean as hex
-      def self.encode_bool(value)
-        value ? '1'.rjust(64, '0') : '0'.rjust(64, '0')
-      end
-
-      # Encode bytes
-      #
-      # @param size [Integer] the size of the bytes type
-      # @param value [String] the value to encode
-      # @return [String] the encoded bytes as hex
-      def self.encode_bytes(size, value)
-        hex = value.is_a?(String) ? value.unpack1('H*') : value.to_s
-        # Limit to the size of the bytes type and pad to 32 bytes
-        hex_part = hex[0...(size * 2)] # Each byte is 2 hex chars
-        hex_part.ljust(64, '0')
-      end
-
-      # Encode string
-      #
-      # @param value [String] the string to encode
-      # @raise [NotImplementedError] since string encoding is handled separately
-      def self.encode_string(value)
-        # For dynamic types like string, return the length and data separately
-        # This will be handled by the main encode_parameters method
-        raise NotImplementedError, "String encoding is handled via encode_dynamic_parameter"
-      end
-
-      # Encode bytes (dynamic type)
-      #
-      # @param value [String] the bytes value to encode
-      # @return [String] the encoded dynamic bytes as hex
-      def self.encode_bytes_dynamic(value)
-        # For dynamic bytes, encode length and data
-        bytes_data = value.is_a?(String) ? value : value.to_s
-        bytes_array = bytes_data.start_with?('0x') ? bytes_data[2..-1].scan(/../) : bytes_data.scan(/../)
-        length = bytes_array.length.to_s(16).rjust(64, '0')
-        data = bytes_array.map { |b| b.rjust(2, '0') }.join
-        # Pad data to 32-byte boundaries (64 hex chars)
-        padded_length = ((data.length / 64.0).ceil * 64).to_i
-        padded_data = data.ljust(padded_length, '0')
-        
-        length + padded_data
-      end
-
-      # Decode output
-      #
-      # @param type [String] the type to decode
-      # @param hex_data [String] the hex data to decode
-      # @return [Object] the decoded value
-      def self.decode_output(type, hex_data)
-        case type
-        when 'bool'
-          hex_data.to_i(16) != 0
-        when 'address'
-          Address.from_hex(hex_data)
-        when 'uint256', 'uint'
-          hex_data.to_i(16)
-        else
-          hex_data
-        end
-      end
-
-      # Decodes parameters based on ABI types
-      #
-      # @param types [Array<String>] the types to decode
-      # @param data [String] the hex data to decode
-      # @return [Array] the decoded values
-      # @raise [ArgumentError] if the data is invalid or type is unsupported
-      def self.decode_parameters(types, data)
-        # Remove '0x' prefix if present
-        raw_data = data.start_with?('0x') ? data[2..-1] : data
-
-        # Ensure the data length is valid
-        if raw_data.length % 64 != 0
-          raise ArgumentError, "Invalid data length: must be multiple of 64 hex chars"
-        end
-
-        values = []
-        pos = 0
-
-        types.each do |type|
-          # Each parameter is 32 bytes (64 hex chars)
-          param_hex = raw_data[pos...(pos + 64)]
-          pos += 64
-
-          case type
-          when /address/
-            # Extract the address (last 40 hex chars)
-            addr_hex = param_hex[-40..-1]
-            # Add TRON prefix
-            values << "41#{addr_hex}"
-          when /uint/, /int/
-            # Convert hex to integer
-            values << param_hex.to_i(16)
-          when /bool/
-            # Boolean is 0 or 1
-            values << (param_hex.to_i(16) != 0)
-          when /string|bytes/
-            # Dynamic type - get offset first
-            offset = param_hex.to_i(16) * 2 # Convert to byte position in hex string
-
-            # Extract length of data
-            length_hex = raw_data[offset...(offset + 64)]
-            length = length_hex.to_i(16) * 2 # Each byte is 2 hex chars
-
-            # Extract actual data
-            actual_data = raw_data[(offset + 64)...(offset + 64 + length)]
-
-            if type.start_with?('string')
-              # Convert hex to string
-              values << [actual_data].pack('H*')
-            else
-              # Return hex string for bytes
-              values << actual_data
-            end
-          else
-            raise ArgumentError, "Unsupported ABI type for decoding: #{type}"
-          end
-        end
-
-        values
-      end
-
-      private
-
-      # Helper method to encode dynamic parameters
-      #
-      # @param type [String] the dynamic type ('string' or 'bytes')
-      # @param value [Object] the value to encode
-      # @return [String] the encoded dynamic parameter as hex
-      # @raise [ArgumentError] if the type is unsupported
-      def self.encode_dynamic_parameter(type, value)
-        if type.start_with?('string')
-          # For strings, we need to encode length and data
-          str_bytes = value.bytes
-          length = str_bytes.length.to_s(16).rjust(64, '0')
-          data = str_bytes.map { |b| b.to_s(16).rjust(2, '0') }.join
-          # Pad data to 32-byte boundaries (64 hex chars)
-          padded_length = ((data.length / 64.0).ceil * 64).to_i
-          padded_data = data.ljust(padded_length, '0')
-
-          length + padded_data
-        elsif type.start_with?('bytes')
-          # For bytes, similar to string
-          bytes_data = value.is_a?(String) ? value : value.to_s
-          bytes_array = bytes_data.start_with?('0x') ? bytes_data[2..-1].scan(/../) : bytes_data.scan(/../)
-          length = bytes_array.length.to_s(16).rjust(64, '0')
-          data = bytes_array.map { |b| b.rjust(2, '0') }.join
-          # Pad data to 32-byte boundaries (64 hex chars)
-          padded_length = ((data.length / 64.0).ceil * 64).to_i
-          padded_data = data.ljust(padded_length, '0')
-
-          length + padded_data
-        else
-          raise ArgumentError, "Unsupported dynamic type: #{type}"
-        end
-      end
-    end
-  end
-end