tron.rb 1.1.9 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 232c93f724a0aeb89150ec237af9c4a6d504b3635aabff7c833e9b71660a8752
-  data.tar.gz: 4403e025c9d31a49e26da6cde92cfeb184df9626d97d76d662eb43ae3644728b
+  metadata.gz: b5cd08e96e3394fc24fb6626f6a36eda41ee19b69c5ae1dc7c80de31cb357464
+  data.tar.gz: aed0379a31288c32a74bd7d4aa644c88a5c07899782f853c8a2d0498fe277e01
 SHA512:
-  metadata.gz: 8032ab96d92f191b7a3c6923104d656a5edb451a0498b57d339fc823084d3041b3da618ed106d015d60d17c99fb50d11a1b0228d8c1ee61ab80876feaf535a43
-  data.tar.gz: a4bdca985bb3cf4389fd045711a2f7a3bcea9f15ddc4902a3ccb4c5e1e624d50140ae2ee1b0438fb23eb95f5e9e98e39c3316b060c877d6b22a27a45cb093df4
+  metadata.gz: 8d127adf6c6f7c3477b4627295725454bfe3e59a409f42d18756d7a6e023d4f0b922c8314cede795a1d291644a309c9a00a03236b206dbec279fc59423d03f8f
+  data.tar.gz: ed54942d4329923a49af1f9399157cca3d157b857fe13810e86111707bac6ca645ace01753b1db268cc2f68fce1eeb6b8bfcb7fd22d9c26fdd3486022cb87e8b

data/lib/tron/abi/constant.rb

@@ -6,6 +6,22 @@ module Tron
     module Constant
       extend self
 
+      # Maximum value for uint256 (2^256 - 1)
+      # @return [Integer] maximum value for uint256
+      UINT_MAX = 2**256 - 1
+
+      # Minimum value for uint256
+      # @return [Integer] minimum value for uint256
+      UINT_MIN = 0
+
+      # Maximum value for int256 (2^255 - 1)
+      # @return [Integer] maximum value for int256
+      INT_MAX = 2**255 - 1
+
+      # Minimum value for int256 (-(2^255))
+      # @return [Integer] minimum value for int256
+      INT_MIN = -(2**255)
+
       # Byte zero constant
       # @return [String] binary string containing zero byte
       BYTE_ZERO = "\x00".b

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/util.rb

@@ -26,14 +26,15 @@ module Tron
         ((x + 31) / 32).floor * 32
       end
 
-      # Pads an integer to 32 bytes in binary format
+      # Pads an integer to a specified number of bytes in binary format
       #
       # @param x [Integer] the integer to pad
+      # @param len [Integer] the number of bytes to pad to (default: 32)
       # @return [String] the padded integer as a binary string
-      def zpad_int(x)
+      def zpad_int(x, len = 32)
         # Ensure x is positive for modulo operation
-        x = x % (2 ** 256) if x >= 2 ** 256 || x < 0
-        [x.to_s(16).rjust(64, '0')].pack('H*')
+        x = x % (2 ** (8 * len)) if x >= 2 ** (8 * len) || x < 0
+        [x.to_s(16).rjust(len * 2, '0')].pack('H*')
       end
 
       # Pads a string to a specified length with null bytes

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/key.rb

@@ -146,6 +146,32 @@ module Tron
       sign(hashed_message)
     end
 
+    # Signs a typed data hash using TRON TIP-191 standard
+    # This is used for structured data signing (similar to EIP-712 but with TIP-191 prefix)
+    # The hash should be the keccak256 of the packed structured data
+    #
+    # @param hash [String] binary hash (32 bytes) of the structured data
+    # @return [String] signature as hexadecimal string with v value adjusted to 27/28
+    def sign_typed_data(hash)
+      # Add TRON TIP-191 prefix for 32-byte hashes
+      # Ref: https://github.com/tronprotocol/tips/blob/master/tip-191.md
+      prefix = "\x19Tron Signed Message:\n32"
+      prefixed_data = prefix.b + hash
+      prefixed_hash = Tron::Utils::Crypto.keccak256(prefixed_data)
+
+      # Sign the prefixed hash
+      context = Secp256k1::Context.new
+      compact, recovery_id = context.sign_recoverable(@private_key, prefixed_hash).compact
+      signature = compact.bytes
+
+      # Adjust v value to 27 or 28 (standard Ethereum/TRON signature format)
+      # Instead of recovery_id (0 or 1), use 27 + recovery_id
+      v = recovery_id + 27
+      signature << v
+
+      Tron::Utils::Crypto.bin_to_hex(signature.pack('c*'))
+    end
+
     # Verifies a signature against a data blob
     #
     # @param blob [String] the original signed data

data/lib/tron/services/transaction.rb

@@ -41,6 +41,144 @@ module Tron
         Utils::HTTP.post(endpoint, payload)
       end
 
+      # Gets detailed transaction information by transaction ID (includes error details)
+      #
+      # @param tx_id [String] the transaction ID (txID)
+      # @return [Hash] the detailed transaction information from the blockchain
+      def get_transaction_info(tx_id)
+        endpoint = "#{@base_url}/wallet/gettransactioninfobyid"
+        payload = { value: tx_id }
+
+        Utils::HTTP.post(endpoint, payload)
+      end
+
+      # Waits for transaction confirmation
+      #
+      # @param tx_id [String] the transaction ID to wait for
+      # @param max_attempts [Integer] maximum number of attempts to check (default: 15)
+      # @return [Hash] the transaction information when confirmed
+      # @raise [RuntimeError] if transaction is reverted or times out
+      def wait_for_transaction(tx_id, max_attempts = 15)
+        print "Waiting for transaction: #{tx_id}"
+
+        max_attempts.times do |i|
+          sleep 2
+          print '.'
+
+          begin
+            tx_info = get_transaction(tx_id)
+
+            if tx_info && tx_info['ret'] && tx_info['ret'][0]
+              result = tx_info['ret'][0]['contractRet']
+
+              if result == 'SUCCESS'
+                puts "\n✓ Transaction confirmed"
+                return tx_info
+              end
+
+              if result == 'REVERT'
+                puts "\n❌ Transaction reverted"
+
+                # Get the actual revert reason from transaction info
+                error_message = extract_revert_reason(tx_id)
+
+                # Raise with just the error message
+                raise "Transaction failed: #{error_message}"
+              end
+            end
+          rescue RuntimeError => e
+            # If it's already a formatted error, re-raise it
+            raise e if e.message.start_with?('Transaction failed:')
+            # Transaction might not be available yet, continue waiting
+            next if i < max_attempts - 1
+            raise e
+          rescue => e
+            # Transaction might not be available yet, continue waiting
+            next if i < max_attempts - 1
+            raise e
+          end
+        end
+
+        raise 'Transaction timeout'
+      end
+
+      private
+
+      # Extracts the revert reason from a failed transaction
+      #
+      # @param tx_id [String] the transaction ID
+      # @return [String] the decoded error message
+      def extract_revert_reason(tx_id)
+        tx_detail = get_transaction_info(tx_id)
+
+        # Debug: Print the full transaction info
+        if ENV['DEBUG']
+          puts "\n🔍 DEBUG - Full transaction info:"
+          puts JSON.pretty_generate(tx_detail) rescue puts(tx_detail.inspect)
+        end
+
+        # Try to get error from contractResult (this contains the ABI-encoded revert reason)
+        if tx_detail && tx_detail['contractResult'] && !tx_detail['contractResult'].empty?
+          contract_result = tx_detail['contractResult'][0]
+          puts "🔍 DEBUG - contractResult: #{contract_result}" if ENV['DEBUG']
+
+          # Check if this is an Error(string) revert (starts with 08c379a0)
+          if contract_result && contract_result.start_with?('08c379a0')
+            begin
+              # ABI encoding for Error(string):
+              # - 4 bytes (8 hex chars): function selector (08c379a0)
+              # - 32 bytes (64 hex chars): offset to string data
+              # - 32 bytes (64 hex chars): length of string
+              # - N bytes: actual string data
+
+              # Skip selector (8 chars) and offset (64 chars)
+              data = contract_result[8 + 64..-1]
+
+              # Read length (next 64 chars)
+              length_hex = data[0...64]
+              length = length_hex.to_i(16)
+              puts "🔍 DEBUG - String length: #{length}" if ENV['DEBUG']
+
+              # Read string data (next length * 2 hex chars)
+              string_hex = data[64, length * 2]
+              puts "🔍 DEBUG - String hex: #{string_hex}" if ENV['DEBUG']
+
+              # Decode hex to UTF-8
+              error_message = [string_hex].pack('H*').force_encoding('UTF-8')
+              puts "🔍 DEBUG - Decoded error: #{error_message}" if ENV['DEBUG']
+
+              return error_message unless error_message.empty?
+            rescue => e
+              puts "🔍 DEBUG - Error decoding contractResult: #{e.message}" if ENV['DEBUG']
+              puts "🔍 DEBUG - Backtrace: #{e.backtrace.first(3).join("\n")}" if ENV['DEBUG']
+              # If decoding fails, fall through
+            end
+          end
+        end
+
+        # Try to get error from resMessage (hex-encoded error string)
+        if tx_detail && tx_detail['resMessage']
+          error_hex = tx_detail['resMessage']
+          puts "🔍 DEBUG - resMessage (hex): #{error_hex}" if ENV['DEBUG']
+
+          begin
+            # Decode hex to UTF-8 string
+            error_message = [error_hex].pack('H*').force_encoding('UTF-8')
+            # Clean up the message (remove null bytes and control characters)
+            error_message = error_message.gsub(/[\x00-\x1f\x7f]/, '').strip
+
+            puts "🔍 DEBUG - Decoded resMessage: #{error_message}" if ENV['DEBUG']
+            return error_message unless error_message.empty?
+          rescue => e
+            puts "🔍 DEBUG - Error decoding resMessage: #{e.message}" if ENV['DEBUG']
+            # If decoding fails, continue to try other methods
+          end
+        end
+
+        # Default to generic revert message
+        'REVERT opcode executed'
+      end
+
       private
 
       # Signs a transaction locally using the private key
@@ -104,8 +242,26 @@ module Tron
 
         # Check if the transaction was successful
         unless response['result']
-          error = response['Error'] || response['error'] || 'Unknown error'
-          raise "Transaction failed: #{error}"
+          error_message = response['Error'] || response['error'] || response['message'] || 'Unknown error'
+
+          # Build detailed error message
+          error_details = ["❌ Transaction broadcast failed: #{error_message}"]
+
+          # Add code if available
+          if response['code']
+            error_details << "   Error code: #{response['code']}"
+          end
+
+          # Add transaction ID if available
+          if response['txid'] || response['txID']
+            tx_id = response['txid'] || response['txID']
+            error_details << "   Transaction ID: #{tx_id}"
+          end
+
+          # Add full response for debugging
+          error_details << "   Full response: #{response.inspect}"
+
+          raise error_details.join("\n")
         end
 
         response

data/lib/tron/version.rb

@@ -2,5 +2,5 @@
 
 # lib/tron/version.rb
 module Tron
-  VERSION = "1.1.9".freeze
+  VERSION = "1.2.2".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.2
 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