tron.rb 1.0.9 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 530fde2195467fe3316fced5499bb3d4a82823b47ee0032fca7c676f89cf3b6c
-  data.tar.gz: 518fa7e74e09d85694f00aee805e10debd469798969d7eff715bc73bfb0be7ef
+  metadata.gz: cb44ecaf6775b445b5cda375645bdc6f7bfc0cc05900d22fa12a5fb6978d2a6a
+  data.tar.gz: 36e1035e31e0eb67e06c12302f4e5df652f8935112e3d4c2dcf2be7b2f5add83
 SHA512:
-  metadata.gz: 62e0177fdab3c7046b2b3db15745ac01b4ae7db31acae4b3f0b1cf570dde96d3c4e56f6e80185ad323b3a2de6378b4b9f9fbc6536d9590b705c361d2ed95f01f
-  data.tar.gz: 14caf1ed3a549c8423db2562416ec0cc894b4fd8398acbc69d2c646f008c6cff7240c86ed2b811fdfb1ec3e204516d49c1cefa324de0f43a4d70d1c9c7cae1c7
+  metadata.gz: 63d164e6bc937089543273590658b616395082aa8bc8e0b4054bbc2e2e63cbdd34d44d02a42a3f8c79bec3cf58ea333aa0aa4271b8d9a20f489075631d29727b
+  data.tar.gz: 218564b3026bb5a33fdf44f328bc609b5f3627f09ff644d2b5d9372e272477f02238c44562892420ac5194520e0b9784cf3ea668617bbf017e22720504699a8c

data/README.md

@@ -1,6 +1,10 @@
 # TRON Ruby Client
 
-A Ruby gem for interacting with the TRON blockchain to check wallet balances and related information.
+A Ruby gem for interacting with the TRON blockchain with comprehensive features including key management, contract interaction, and enhanced security.
+
+## Requirements
+
+- Ruby >= 3.0 (required for keccak cryptographic library)
 
 ## Installation
 
@@ -14,79 +18,26 @@ Or add to your Gemfile:
 gem 'tron.rb'
 ```
 
-## Configuration
+## Documentation
 
-You can configure the client using environment variables or programmatically:
+Full documentation is available through YARD. To generate the documentation locally:
 
-#### Using Environment Variables:
 ```bash
-export TRONGRID_API_KEY=your_api_key
-export TRONSCAN_API_KEY=your_tronscan_api_key
-```
-
-#### Using Code:
-```ruby
-require 'tron'
-
-Tron.configure do |config|
-  config.api_key = 'your_trongrid_api_key'
-  config.tronscan_api_key = 'your_tronscan_api_key'
-  config.network = :mainnet  # or :shasta or :nile
-  config.timeout = 30
-
-  # Cache configuration (optional)
-  config.cache_enabled = true     # Enable/disable caching (default: true)
-  config.cache_ttl = 300          # Cache TTL in seconds (default: 300 = 5 minutes)
-  config.cache_max_stale = 600    # Max stale time in seconds (default: 600 = 10 minutes)
-end
-```
-
-### Cache Configuration
-
-The gem includes intelligent caching to prevent rate limit errors and improve performance.
-
-#### Default Configuration (Recommended)
-
-```ruby
-client = Tron::Client.new(
-  api_key: ENV['TRONGRID_API_KEY'],
-  tronscan_api_key: ENV['TRONSCAN_API_KEY']
-)
-# Cache enabled by default with 5-minute TTL
-```
-
-#### Custom Cache Configuration
-
-```ruby
-client = Tron::Client.new(
-  api_key: ENV['TRONGRID_API_KEY'],
-  tronscan_api_key: ENV['TRONSCAN_API_KEY'],
-  cache: {
-    enabled: true,
-    ttl: 60,        # Cache for 1 minute
-    max_stale: 600  # Serve stale data up to 10 minutes if API fails
-  }
-)
+yard doc
 ```
 
-#### Disable Cache
-
-```ruby
-client = Tron::Client.new(cache: { enabled: false })
-```
+Then open `doc/index.html` in your browser.
 
-#### Monitor Cache Performance
+## Key Features
 
-```ruby
-stats = client.cache_stats
-puts "Price cache hit rate: #{stats[:price][:hit_rate]}%"
-puts "Balance cache hit rate: #{stats[:balance][:hit_rate]}%"
-
-# Clear cache manually
-client.clear_cache
-```
-
-**Performance:** Caching provides 2,000x+ faster response times for repeated requests and eliminates 429 rate limit errors.
+- **Local Key Management**: Generate and manage private/public key pairs locally
+- **Secure Transaction Signing**: Sign transactions locally without sending private keys to APIs
+- **Comprehensive ABI Support**: Full Solidity ABI support for complex contract interactions
+- **TRON-Specific Address Handling**: Correct TRON address format using Base58 with 'T' prefix
+- **Protocol Buffer Serialization**: Proper TRON transaction serialization
+- **Enhanced Security**: Private keys never leave the machine during signing
+- **Wallet Operations**: Balance checking, resource info, token prices, and portfolio tracking
+- **Smart Contract Interaction**: Call and trigger smart contracts
 
 ## Usage
 
@@ -99,295 +50,130 @@ ruby bin/tron-wallet TWd4WrZ9wn84f5x1hZhL4DHvk738ns5jwb
 
 ### As a Library
 
-#### Initialize Client:
 ```ruby
 require 'tron'
 
-# Use default configuration (loads from ENV)
+# Initialize client
 client = Tron::Client.new
 
-# Or with custom configuration
-client = Tron::Client.new(
-  api_key: 'your_trongrid_api',
-  tronscan_api_key: 'your_tronscan_api',
-  network: :mainnet,
-  timeout: 30
-)
-```
-
-#### Get TRX Balance:
-```ruby
-trx_balance = client.balance_service.get_trx('TWd4WrZ9wn84f5x1hZhL4DHvk738ns5jwb')
-```
-
-#### Get TRC20 Token Balances:
-```ruby
-tokens = client.balance_service.get_trc20_tokens('TWd4WrZ9wn84f5x1hZhL4DHvk738ns5jwb')
-```
-
-#### Get Account Resources:
-```ruby
-resources = client.resources_service.get('TWd4WrZ9wn84f5x1hZhL4DHvk738ns5jwb')
-```
-
-#### Get Token Prices:
-```ruby
-price = client.price_service.get_token_price('trx')
-usd_price = client.price_service.get_token_price_usd('trx')
-```
-
-#### Get Complete Wallet Information:
-```ruby
+# Get wallet information
 wallet_info = client.get_wallet_balance('TWd4WrZ9wn84f5x1hZhL4DHvk738ns5jwb')
-full_info = client.get_full_account_info('TWd4WrZ9wn84f5x1hZhL4DHvk738ns5jwb')
-```
-
-#### Get Wallet Portfolio with USD Values:
-```ruby
-# Get wallet portfolio with balances, USD prices, and total value
-portfolio = client.get_wallet_portfolio('TWd4WrZ9wn84f5x1hZhL4DHvk738ns5jwb')
-
-# Include tokens with zero balance
-portfolio = client.get_wallet_portfolio('TWd4WrZ9wn84f5x1hZhL4DHvk738ns5jwb', include_zero_balances: true)
-
-puts "Total Portfolio Value: $#{portfolio[:total_value_usd]}"
-portfolio[:tokens].each do |token|
-  puts "#{token[:symbol]}: #{token[:token_balance]} ($#{token[:usd_value]})"
-end
 ```
 
-## Features
-
-- ✓ TRX balance
-- ✓ TRC20 token balances (USDT, USDC, USDD, TUSD, WBTC)
-- ✓ Account resources (bandwidth & energy)
-- ✓ Token prices
-- ✓ Portfolio tracking
-- ✓ Multi-network support (mainnet, shasta, nile)
-- ✓ Intelligent caching with TTL and stale-while-revalidate
-- ✓ Cache statistics and monitoring
-- ✓ Clean, simple output
-- ✓ Proper decimal formatting
-- ✓ Environment variable support
-- ✓ Rate limit management with API keys
-
-## Caching
-
-The gem includes an intelligent caching system to reduce API calls and improve performance.
-
-### How Caching Works
-
-The cache uses a **time-based expiration strategy** with **stale-while-revalidate** behavior:
-
-1. **Fresh Cache (age < TTL)**: Returns cached value immediately
-2. **Stale Cache (age > TTL but < max_stale)**: Attempts to refresh, falls back to stale value on error
-3. **Expired Cache (age > max_stale)**: Forces refresh, raises error if refresh fails
-
-This approach ensures:
-- Fast responses from fresh cache
-- High availability with stale fallbacks
-- Automatic background refresh for popular endpoints
+## Configuration
 
-### Cache Configuration
+The client can be configured using environment variables or programmatically:
 
 ```ruby
 Tron.configure do |config|
-  # Enable or disable caching globally (default: true)
-  config.cache_enabled = true
-
-  # Set default TTL (time-to-live) in seconds (default: 300 = 5 minutes)
-  config.cache_ttl = 300
-
-  # Set max stale time in seconds (default: 600 = 10 minutes)
-  config.cache_max_stale = 600
+  config.api_key = 'your_trongrid_api_key'
+  config.network = :mainnet  # or :shasta or :nile
+  config.timeout = 30
 end
 ```
 
-### Endpoint-Specific TTL Values
+## Local Transaction Signing
 
-Different endpoints have optimized TTL values based on data volatility:
+**NEW in v2.0:** Secure local transaction signing with secp256k1!
 
-| Endpoint Type | TTL | Max Stale | Use Case |
-|---------------|-----|-----------|----------|
-| **balance** | 5 min | 10 min | Wallet balances, moderate volatility |
-| **price** | 1 min | 2 min | Token prices, high volatility |
-| **token_info** | 15 min | 30 min | Token metadata, low volatility |
-| **resources** | 5 min | 10 min | Account resources, moderate volatility |
-| **default** | 5 min | 10 min | Unclassified endpoints |
+Your private keys **NEVER** leave your machine when using local signing.
 
-### Cache Statistics
-
-Monitor cache performance to optimize your configuration:
+### Quick Start
 
 ```ruby
-# Get global cache statistics
-stats = Tron::Cache.global_stats
-puts "Cache Hit Rate: #{stats[:hit_rate_percentage]}%"
-puts "Total Hits: #{stats[:total_hits]}"
-puts "Total Misses: #{stats[:total_misses]}"
-puts "Cache Size: #{stats[:cache_size]} entries"
-
-# Get statistics for a specific cache entry
-key_stats = Tron::Cache.stats("specific_key")
-if key_stats
-  puts "Entry Hits: #{key_stats[:hits]}"
-  puts "Entry Misses: #{key_stats[:misses]}"
-  puts "Cached At: #{key_stats[:cached_at]}"
-  puts "Expires At: #{key_stats[:expires_at]}"
-  puts "Expired: #{key_stats[:expired]}"
-end
-```
-
-### Cache Management
-
-```ruby
-# Clear entire cache
-Tron::Cache.clear
-
-# Delete specific cache entry
-Tron::Cache.delete("cache_key")
-
-# Check if key exists in cache
-if Tron::Cache.exists?("cache_key")
-  puts "Key is cached"
-end
+require 'tron'
 
-# Get cache size
-puts "Cache has #{Tron::Cache.size} entries"
+# Generate a new key or import existing one
+key = Tron::Key.new                          # Generate new key
+# OR
+key = Tron::Key.new(priv: "your_hex_key")    # Import existing key
 
-# Reset statistics (useful for testing)
-Tron::Cache.reset_stats
+# Get your TRON address
+address = key.address
+# => "TYxyz123..."
 ```
 
-### Advanced Cache Usage
-
-#### Disable Caching for Specific Requests
+### Signing Transactions
 
 ```ruby
-# Disable cache for a specific HTTP request
-response = Tron::Utils::HTTP.get(url, headers, { enabled: false })
-```
+# Initialize client
+client = Tron::Client.new(network: :mainnet)
 
-#### Custom TTL for Specific Requests
+# Step 1: Create transaction via TronGrid API
+from_hex = Tron::Utils::Address.to_hex(from_address)
+to_hex = Tron::Utils::Address.to_hex(to_address)
 
-```ruby
-# Use custom TTL values for a specific request
-response = Tron::Utils::HTTP.get(url, headers, {
-  ttl: 60,         # 1 minute
-  max_stale: 120   # 2 minutes
-})
-```
+transaction = Tron::Utils::HTTP.post(
+  "#{client.configuration.base_url}/wallet/createtransaction",
+  {
+    owner_address: from_hex,
+    to_address: to_hex,
+    amount: 1_000_000  # 1 TRX in SUN
+  }
+)
 
-#### Use Endpoint-Specific TTL
+# Step 2: Sign locally (SECURE - private key stays on your machine!)
+tx_hash = Tron::Utils::Crypto.hex_to_bin(transaction['txID'])
+signature = key.sign(tx_hash)
+transaction['signature'] = [signature]
 
-```ruby
-# Use predefined TTL for specific endpoint type
-response = Tron::Utils::HTTP.get(url, headers, {
-  endpoint_type: :price  # Uses 1 min TTL, 2 min max_stale
-})
+# Step 3: Broadcast
+result = Tron::Utils::HTTP.post(
+  "#{client.configuration.base_url}/wallet/broadcasttransaction",
+  transaction
+)
 ```
 
-### Cache Best Practices
-
-1. **Enable caching in production** - Reduces API calls and improves response times
-2. **Monitor hit rates** - Aim for >70% hit rate for frequently accessed data
-3. **Adjust TTL based on data volatility** - Shorter TTL for prices, longer for token metadata
-4. **Use stale fallbacks** - Ensures high availability during API issues
-5. **Clear cache after mutations** - If you modify data, clear related cache entries
-
-## Services Architecture
-
-The gem is organized into modular services:
-
-- `Tron::Services::Balance` - TRX and TRC20 token balances
-- `Tron::Services::Resources` - Account resources (bandwidth/energy)
-- `Tron::Services::Price` - Token price information
-- `Tron::Utils::HTTP` - HTTP client with error handling and caching
-- `Tron::Utils::Address` - TRON address validation and conversion
-- `Tron::Cache` - Thread-safe caching with TTL and statistics
+### Using Transaction Service
 
-## API Reference
+The library provides a convenient service:
 
-### Balance Service
-- `get_trx(address)` - Get TRX balance
-- `get_trc20_tokens(address)` - Get all TRC20 token balances
-- `get_all(address)` - Get all balance information
-
-### Resources Service
-- `get(address)` - Get account resources (bandwidth, energy)
-
-### Price Service
-- `get_token_price(token)` - Get price information for a token
-- `get_all_prices()` - Get prices for all tokens
-- `get_token_price_usd(token)` - Get price in USD
-- `get_token_value_usd(balance, token)` - Calculate dollar value
-- `get_multiple_token_prices(tokens)` - Get multiple token prices
-- `format_price(price, currency)` - Format price with currency
-
-## Output Example
-
-```
-════════════════════════════════════════════════════════════
-TRON WALLET BALANCE CHECKER
-════════════════════════════════════════════════════════════
-Wallet: TWd4WrZ9wn84f5x1hZhL4DHvk738ns5jwb
-
-TRX Balance:
-  1234.567890 TRX
-
-TRC20 Token Balances:
-  USDT   100.000000
-  USDC   50.500000
+```ruby
+client = Tron::Client.new(network: :mainnet)
 
-Account Resources:
-  Bandwidth: 1,500 / 5,000
-  Energy:    10,000 / 50,000
+# Create transaction first (via API)
+transaction = create_your_transaction(...)
 
-════════════════════════════════════════════════════════════
+# Sign and broadcast in one call
+result = client.transaction_service.sign_and_broadcast(
+  transaction,
+  your_private_key,
+  local_signing: true  # DEFAULT - keeps private key secure!
+)
 ```
 
-## Environment Variables
-
-- `TRONGRID_API_KEY` - TronGrid API key (optional, increases rate limits)
-- `TRONSCAN_API_KEY` - Tronscan API key (optional, increases rate limits)
+### Security Features
 
-## Getting an API Key
+✅ **Local Signing** - Private keys never transmitted
+✅ **secp256k1** - Industry-standard elliptic curve cryptography
+✅ **SHA256** - Proper TRON transaction hashing
+✅ **Base58** - Correct TRON address format with checksum
+✅ **Testnet Support** - Test on Shasta before using mainnet
 
-1. Visit [TronGrid](https://www.trongrid.io/)
-2. Sign up for a free account
-3. Get your API key from the dashboard
-4. Use it in your `.env` file or as an environment variable
+### Complete Example
 
-## Popular Token Addresses
+See `examples/local_signing_example.rb` for a comprehensive guide including:
+- Key generation and import
+- Transaction creation
+- Local signing
+- Broadcasting
+- Security best practices
 
-- USDT: `TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t`
-- USDC: `TEkxiTehnzSmAaVPYYJNTY7v1KHVqCvRdx`
-- USDD: `TPYmHEhy5n8TCEfYGqW2rPxsghSfzghPDn`
-- TUSD: `TUpMhErZL2fhh4sVNULzmL7sbb8NkK57eX`
-- WBTC: `TXpw8XeWYeTUd4quDskoUqeQPowRh4jY65`
+### Testing on Shasta Testnet
 
-## Contributing
+Before using real funds, test on Shasta testnet:
 
-We follow the [Conventional Commits](https://www.conventionalcommits.org/) specification for commit messages. This enables automated release notes and semantic versioning.
-We use Minitest for testing.
+```ruby
+# Use Shasta testnet
+client = Tron::Client.new(network: :shasta)
 
-### Commit Message Format
-- `fix: ...` for bug fixes (triggers PATCH release)
-- `feat: ...` for new features (triggers MINOR release)
-- `feat!: ...` or `BREAKING CHANGE: ...` for breaking changes (triggers MAJOR release)
+# Get free test TRX from faucet
+# Visit: https://www.trongrid.io/faucet
 
-### Running Tests
-```bash
-bundle install
-bundle exec rake test
+# Your code here...
 ```
 
-## Automated Releases
-
-This project uses GitHub Actions to automate releases:
-1. Commits following Conventional Commits format trigger release PRs
-2. Release PRs are automatically created and must be manually reviewed and merged
-3. Once merged to master, the gem is automatically built and published to RubyGems
+**Validated:** Local signing has been tested and confirmed working on TRON Shasta testnet with real transactions!
 
 ## License
 

data/lib/tron/abi/constant.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Tron
+  module Abi
+    # Provides constants for ABI encoding/decoding
+    module Constant
+      extend self
+
+      # Byte zero constant
+      # @return [String] binary string containing zero byte
+      BYTE_ZERO = "\x00".b
+
+      # Byte one constant
+      # @return [String] binary string containing one byte
+      BYTE_ONE = "\x01".b
+    end
+  end
+end

data/lib/tron/abi/decoder.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+require_relative 'util'
+require_relative 'constant'
+
+module Tron
+  module Abi
+    # Provides a utility module to assist decoding ABIs.
+    module Decoder
+      extend self
+
+      # Decodes a specific value, either static or dynamic.
+      #
+      # @param type [Tron::Abi::Type] type to be decoded.
+      # @param arg [String] encoded type data string.
+      # @return [String] the decoded data for the type.
+      # @raise [DecodingError] if decoding fails for type.
+      def type(type, arg)
+        if %w(string bytes).include?(type.base_type) and type.sub_type.empty?
+          # Case: decoding a string/bytes
+          if type.dimensions.empty?
+            l = Util.deserialize_big_endian_to_int arg[0, 32]
+            data = arg[32..-1]
+            raise DecodingError, "Wrong data size for string/bytes object" unless data.bytesize == Util.ceil32(l)
+
+            # decoded strings and bytes
+            data[0, l]
+            # Case: decoding array of string/bytes
+          else
+            l = Util.deserialize_big_endian_to_int arg[0, 32]
+            raise DecodingError, "Wrong data size for dynamic array" unless arg.bytesize >= 32 + 32 * l
+
+            # Decode each element of the array
+            (1..l).map do |i|
+              pointer = Util.deserialize_big_endian_to_int arg[i * 32, 32] # Pointer to the size of the array's element
+              raise DecodingError, "Offset out of bounds" if pointer < 32 * l || pointer > arg.bytesize - 64
+              data_l = Util.deserialize_big_endian_to_int arg[32 + pointer, 32] # length of the element
+              raise DecodingError, "Offset out of bounds" if pointer + 32 + Util.ceil32(data_l) > arg.bytesize
+              type(Type.parse(type.base_type), arg[pointer + 32, Util.ceil32(data_l) + 32])
+            end
+          end
+        elsif type.base_type == "tuple" && type.dimensions.empty?
+          offset = 0
+          result = []
+          raise DecodingError, "Cannot decode tuples without known components" if type.components.nil?
+          type.components.each_with_index do |c, i|
+            if c.dynamic?
+              pointer = Util.deserialize_big_endian_to_int arg[offset, 32]
+              next_offset = if i + 1 < type.components.size
+                  Util.deserialize_big_endian_to_int arg[offset + 32, 32]
+                else
+                  arg.bytesize
+                end
+              raise DecodingError, "Offset out of bounds" if pointer > arg.bytesize || next_offset > arg.bytesize || next_offset < pointer
+              result << type(c, arg[pointer, next_offset - pointer])
+              offset += 32
+            else
+              size = c.size
+              raise DecodingError, "Offset out of bounds" if offset + size > arg.bytesize
+              result << type(c, arg[offset, size])
+              offset += size
+            end
+          end
+          result
+        elsif type.dynamic?
+          l = Util.deserialize_big_endian_to_int arg[0, 32]
+          nested_sub = type.nested_sub
+
+          if nested_sub.dynamic?
+            raise DecodingError, "Wrong data size for dynamic array" unless arg.bytesize >= 32 + 32 * l
+            offsets = (0...l).map do |i|
+              off = Util.deserialize_big_endian_to_int arg[32 + 32 * i, 32]
+              raise DecodingError, "Offset out of bounds" if off < 32 * l || off > arg.bytesize - 64
+              off
+            end
+            offsets.map { |off| type(nested_sub, arg[32 + off..]) }
+          else
+            raise DecodingError, "Wrong data size for dynamic array" unless arg.bytesize >= 32 + nested_sub.size * l
+            # decoded dynamic-sized arrays with static sub-types
+            (0...l).map { |i| type(nested_sub, arg[32 + nested_sub.size * i, nested_sub.size]) }
+          end
+        elsif !type.dimensions.empty?
+          l = type.dimensions.first
+          nested_sub = type.nested_sub
+
+          if nested_sub.dynamic?
+            raise DecodingError, "Wrong data size for static array" unless arg.bytesize >= 32 * l
+            offsets = (0...l).map do |i|
+              off = Util.deserialize_big_endian_to_int arg[32 * i, 32]
+              raise DecodingError, "Offset out of bounds" if off < 32 * l || off > arg.bytesize - 32
+              off
+            end
+            offsets.each_with_index.map do |off, i|
+              size = (i + 1 < offsets.length ? offsets[i + 1] : arg.bytesize) - off
+              type(nested_sub, arg[off, size])
+            end
+          else
+            # decoded static-size arrays with static sub-types
+            (0...l).map { |i| type(nested_sub, arg[nested_sub.size * i, nested_sub.size]) }
+          end
+        else
+
+          # decoded primitive types
+          primitive_type type, arg
+        end
+      end
+
+      # Decodes primitive types.
+      #
+      # @param type [Tron::Abi::Type] type to be decoded.
+      # @param data [String] encoded primitive type data string.
+      # @return [String] the decoded data for the type.
+      # @raise [DecodingError] if decoding fails for type.
+      def primitive_type(type, data)
+        case type.base_type
+        when "address"
+          # Handle TRON-specific address decoding
+          # Addresses are 32 bytes (256 bits) with the last 20 bytes being the actual address
+          # The TRON prefix is 0x41, so the address part without prefix should be 40 hex chars
+          addr_bytes = data[-20..-1]  # Get last 20 bytes
+          addr_hex = Util.bin_to_hex(addr_bytes)
+          
+          require_relative '../utils/address'
+          # Convert 40 hex chars (20 bytes) to TRON address
+          Utils::Address.to_base58(Tron::Key::ADDRESS_PREFIX + addr_hex)
+        when "string", "bytes"
+          if type.sub_type.empty?
+            size = Util.deserialize_big_endian_to_int data[0, 32]
+
+            # decoded dynamic-sized array
+            decoded = data[32..-1][0, size]
+            decoded.force_encoding(Encoding::UTF_8)
+            decoded
+          else
+
+            # decoded static-sized array
+            data[0, type.sub_type.to_i]
+          end
+        when "hash"
+
+          # decoded hash
+          data[(32 - type.sub_type.to_i), type.sub_type.to_i]
+        when "uint"
+
+          # decoded unsigned integer
+          Util.deserialize_big_endian_to_int data
+        when "int"
+          u = Util.deserialize_big_endian_to_int data
+          i = u >= 2 ** (type.sub_type.to_i - 1) ? (u - 2 ** 256) : u
+
+          # decoded integer
+          i
+        when "ureal", "ufixed"
+          high, low = type.sub_type.split("x").map(&:to_i)
+
+          # decoded unsigned fixed point numeric
+          Util.deserialize_big_endian_to_int(data) * 1.0 / 2 ** low
+        when "real", "fixed"
+          high, low = type.sub_type.split("x").map(&:to_i)
+          u = Util.deserialize_big_endian_to_int data
+          i = u >= 2 ** (high + low - 1) ? (u - 2 ** (high + low)) : u
+
+          # decoded fixed point numeric
+          i * 1.0 / 2 ** low
+        when "bool"
+
+          # decoded boolean
+          data[-1] == ::Tron::Abi::Constant::BYTE_ONE
+        else
+          raise DecodingError, "Unknown primitive type: #{type.base_type}"
+        end
+      end
+    end
+  end
+end