tron.rb 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cb06efba2988905e0c66fa13f78960c58b91b08646a1822ad1878182ad359f90
+  data.tar.gz: f3f3b0b7b88280f7fcbc5733b57d752abef9a8623ea7a05a360e91c790131f33
+SHA512:
+  metadata.gz: 6fcef166d0c652dcb4deaf3040eb71f9647009e315d53486adbfd505bc322848d9516f6d60d72f3623bc4fc11b11fe6d58798544df7b566f9782828add54d501
+  data.tar.gz: deb26afaafb9c7dc395dabcb17ac31a4ff01c1458f61d6e3db394659d1c1ad2daf6e2a7a82ed4f2e59d6efb61776d178e1e38254aa2e5b978da6b77064f400fe

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ScionX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS OF A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,201 @@
+# TRON Ruby Client
+
+A Ruby gem for interacting with the TRON blockchain to check wallet balances and related information.
+
+## Installation
+
+```bash
+gem install tron.rb
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem 'tron.rb'
+```
+
+## Configuration
+
+You can configure the client using environment variables or programmatically:
+
+#### 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
+end
+```
+
+## Usage
+
+### Command Line
+
+```bash
+# Use the CLI tool to check wallet balances
+ruby bin/tron-wallet TWd4WrZ9wn84f5x1hZhL4DHvk738ns5jwb
+```
+
+### As a Library
+
+#### Initialize Client:
+```ruby
+require 'tron'
+
+# Use default configuration (loads from ENV)
+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
+wallet_info = client.get_wallet_balance('TWd4WrZ9wn84f5x1hZhL4DHvk738ns5jwb')
+full_info = client.get_full_account_info('TWd4WrZ9wn84f5x1hZhL4DHvk738ns5jwb')
+```
+
+## 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)
+- ✓ Clean, simple output
+- ✓ Proper decimal formatting
+- ✓ Environment variable support
+- ✓ Rate limit management with API keys
+
+## 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
+- `Tron::Utils::Address` - TRON address validation and conversion
+
+## API Reference
+
+### 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
+
+Account Resources:
+  Bandwidth: 1,500 / 5,000
+  Energy:    10,000 / 50,000
+
+════════════════════════════════════════════════════════════
+```
+
+## Environment Variables
+
+- `TRONGRID_API_KEY` - TronGrid API key (optional, increases rate limits)
+- `TRONSCAN_API_KEY` - Tronscan API key (optional, increases rate limits)
+
+## Getting an API Key
+
+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
+
+## Popular Token Addresses
+
+- USDT: `TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t`
+- USDC: `TEkxiTehnzSmAaVPYYJNTY7v1KHVqCvRdx`
+- USDD: `TPYmHEhy5n8TCEfYGqW2rPxsghSfzghPDn`
+- TUSD: `TUpMhErZL2fhh4sVNULzmL7sbb8NkK57eX`
+- WBTC: `TXpw8XeWYeTUd4quDskoUqeQPowRh4jY65`
+
+## Contributing
+
+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.
+
+### 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)
+
+### Running Tests
+```bash
+bundle install
+bundle exec rake test
+```
+
+## 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
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

data/bin/tron-wallet

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/tron'
+
+def format_number(num)
+  num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\1,').reverse
+end
+
+def check_balances(address)
+  raise ArgumentError, 'Invalid TRON address.' if address.empty? || !address.start_with?('T')
+
+  client = Tron::Client.new
+
+  puts '═' * 60
+  puts 'TRON WALLET BALANCE CHECKER'
+  puts '═' * 60
+  puts "Wallet: #{address}\n\n"
+
+  puts 'TRX Balance:'
+  trx_balance = client.balance_service.get_trx(address)
+  puts "  #{trx_balance} TRX\n\n"
+
+  puts 'TRC20 Token Balances:'
+  tokens = client.balance_service.get_trc20_tokens(address)
+  if tokens.empty?
+    puts '  (No token balances found)'
+  else
+    tokens.each { |t| puts "  #{t[:symbol].ljust(10)} #{sprintf("%.#{t[:decimals]}f", t[:balance])}" }
+  end
+
+  puts "\nAccount Resources:"
+  res = client.resources_service.get(address)
+  puts "  Bandwidth: #{format_number(res[:bandwidth]).ljust(15)} / #{format_number(res[:bandwidthLimit])}"
+  puts "  Energy:    #{format_number(res[:energy]).ljust(15)} / #{format_number(res[:energyLimit])}"
+  puts '═' * 60
+end
+
+wallet_address = ARGV[0]
+if wallet_address.nil? || wallet_address.empty?
+  puts 'Error: No wallet address provided.'
+  puts 'Usage: ruby bin/tron-wallet <TRON_WALLET_ADDRESS>'
+  exit 1
+end
+
+begin
+  check_balances(wallet_address)
+rescue => e
+  puts "Error: #{e.message}"
+  exit 1
+end

data/lib/tron/client.rb

@@ -0,0 +1,75 @@
+# lib/tron/client.rb
+require_relative 'configuration'
+require_relative 'services/balance'
+require_relative 'services/resources'
+require_relative 'services/price'
+
+module Tron
+  class Client
+    attr_reader :configuration
+
+    def initialize(options = {})
+      @configuration = Configuration.new
+      
+      # Apply options
+      options.each do |key, value|
+        if @configuration.respond_to?("#{key}=")
+          @configuration.send("#{key}=", value)
+        end
+      end
+
+      # Load from environment if not set in options
+      @configuration.api_key ||= ENV['TRONGRID_API_KEY']
+      @configuration.tronscan_api_key ||= ENV['TRONSCAN_API_KEY']
+    end
+
+    def self.configure
+      yield configuration if block_given?
+    end
+
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def balance_service
+      @balance_service ||= Services::Balance.new(@configuration)
+    end
+
+    def resources_service
+      @resources_service ||= Services::Resources.new(@configuration)
+    end
+
+    def price_service
+      @price_service ||= Services::Price.new(@configuration)
+    end
+
+    # Convenience methods that combine multiple services
+    def get_wallet_balance(address, strict: false)
+      validate_address!(address)
+      
+      {
+        address: address,
+        trx_balance: balance_service.get_trx(address),
+        trc20_tokens: balance_service.get_trc20_tokens(address, strict: strict)
+      }
+    end
+
+    def get_full_account_info(address, strict: false)
+      validate_address!(address)
+      
+      {
+        address: address,
+        trx_balance: balance_service.get_trx(address),
+        trc20_tokens: balance_service.get_trc20_tokens(address, strict: strict),
+        resources: resources_service.get(address)
+      }
+    end
+
+    private
+
+    def validate_address!(address)
+      require_relative 'utils/address'
+      raise ArgumentError, "Invalid TRON address: #{address}" unless Utils::Address.validate(address)
+    end
+  end
+end

data/lib/tron/configuration.rb

@@ -0,0 +1,37 @@
+# lib/tron/configuration.rb
+module Tron
+  class Configuration
+    attr_accessor :api_key, :tronscan_api_key, :network, :timeout, :base_url, :tronscan_base_url, :strict_mode
+
+    def initialize
+      @network = :mainnet
+      @timeout = 30
+      @strict_mode = false
+      setup_urls
+    end
+
+    def network=(network)
+      @network = network
+      setup_urls
+    end
+
+    private
+
+    def setup_urls
+      case @network
+      when :mainnet
+        @base_url = 'https://api.trongrid.io'
+        @tronscan_base_url = 'https://apilist.tronscanapi.com'
+      when :shasta
+        @base_url = 'https://api.shasta.trongrid.io'
+        @tronscan_base_url = 'https://api.shasta.tronscanapi.com'
+      when :nile
+        @base_url = 'https://nile.trongrid.io'
+        @tronscan_base_url = 'https://api.nileex.net'
+      else
+        @base_url = 'https://api.trongrid.io'
+        @tronscan_base_url = 'https://apilist.tronscanapi.com'
+      end
+    end
+  end
+end

data/lib/tron/services/balance.rb

@@ -0,0 +1,112 @@
+# lib/tron/services/balance.rb
+require_relative '../utils/http'
+require_relative '../utils/address'
+
+module Tron
+  module Services
+    class Balance
+      def initialize(config)
+        @config = config
+      end
+
+      def get_trx(address)
+        validate_address!(address)
+        
+        url = "#{@config.base_url}/v1/accounts/#{address}"
+        headers = api_headers
+        
+        response = Utils::HTTP.get(url, headers)
+        
+        # Validate response structure
+        raise "Unexpected API response format" unless response.is_a?(Hash)
+        raise "Missing 'data' field in response" unless response.key?('data')
+        raise "Invalid 'data' format in response" unless response['data'].is_a?(Array)
+        raise "Empty account data in response" if response['data'].empty?
+        
+        account_data = response['data'].first
+        raise "Invalid account data format" unless account_data.is_a?(Hash)
+        
+        # The balance field is only present when > 0; defaults to 0 for new/empty accounts
+        raw_balance = account_data.fetch('balance', 0)
+        format_balance(raw_balance, 6)
+      end
+
+      def get_trc20_tokens(address, strict: false)
+        validate_address!(address)
+        
+        url = "#{@config.tronscan_base_url}/api/account/wallet?address=#{address}&asset_type=1"
+        headers = tronscan_headers
+        
+        response = Utils::HTTP.get(url, headers)
+        
+        # Validate response structure
+        raise "Unexpected API response format for TRC20 tokens" unless response.is_a?(Hash)
+        raise "Missing 'data' field in TRC20 response" unless response.key?('data')
+        raise "Invalid 'data' format in TRC20 response" unless response['data'].is_a?(Array)
+        
+        response['data'].select { |token| token['token_type'] == 20 && token['balance'].to_f > 0 }
+          .map do |token|
+            validate_token_data!(token)
+            {
+              symbol: token['token_abbr'] || token['token_name'],
+              name: token['token_name'],
+              balance: token['balance'].to_f,
+              decimals: (token['token_decimal'] || 6).to_i,
+              address: token['token_id']
+            }
+          end
+      end
+
+      private
+
+      def validate_token_data!(token)
+        unless token.is_a?(Hash)
+          raise "Invalid token data format: expected hash"
+        end
+        
+        # Check required fields exist
+        ['token_type', 'balance'].each do |field|
+          unless token.key?(field)
+            raise "Missing required field '#{field}' in token data: #{token}"
+          end
+        end
+      end
+
+      def get_all(address, strict: false)
+        validate_address!(address)
+        
+        {
+          address: address,
+          trx_balance: get_trx(address),
+          trc20_tokens: get_trc20_tokens(address, strict: strict)
+        }
+      end
+
+      private
+
+      def validate_address!(address)
+        raise ArgumentError, "Invalid TRON address: #{address}" unless Utils::Address.validate(address)
+      end
+
+      def format_balance(raw_balance, decimals)
+        balance = raw_balance.to_i
+        divisor = 10 ** decimals
+        whole = balance / divisor
+        fraction = balance % divisor
+        "#{whole}.#{fraction.to_s.rjust(decimals, '0')}"
+      end
+
+      def api_headers
+        headers = { 'accept' => 'application/json' }
+        headers['TRON-PRO-API-KEY'] = @config.api_key if @config.api_key
+        headers
+      end
+
+      def tronscan_headers
+        headers = { 'accept' => 'application/json' }
+        headers['TRON-PRO-API-KEY'] = @config.tronscan_api_key if @config.tronscan_api_key
+        headers
+      end
+    end
+  end
+end

data/lib/tron/services/price.rb

@@ -0,0 +1,116 @@
+# lib/tron/services/price.rb
+require_relative '../utils/http'
+
+module Tron
+  module Services
+    class Price
+      def initialize(config)
+        @config = config
+      end
+
+      def get_token_price(token = 'trx')
+        url = "#{@config.tronscan_base_url}/api/token/price?token=#{token}"
+        headers = tronscan_headers
+        
+        response = Utils::HTTP.get(url, headers)
+        
+        # Validate response structure
+        unless response.is_a?(Hash)
+          raise "Unexpected API response format for token price"
+        end
+        
+        response
+      rescue => e
+        if @config.strict_mode
+          raise e
+        else
+          warn "Warning: Could not fetch price for #{token}: #{e.message}"
+          nil
+        end
+      end
+
+      def get_all_prices
+        url = "#{@config.tronscan_base_url}/api/getAssetWithPriceList"
+        headers = tronscan_headers
+        
+        response = Utils::HTTP.get(url, headers)
+        
+        # Validate response structure
+        unless response.is_a?(Hash)
+          raise "Unexpected API response format for price list"
+        end
+        
+        response
+      rescue => e
+        if @config.strict_mode
+          raise e
+        else
+          warn "Warning: Could not fetch token price list: #{e.message}"
+          nil
+        end
+      end
+
+      def get_token_price_usd(token)
+        price_data = get_token_price(token)
+        return nil unless price_data.is_a?(Hash)
+        
+        if price_data['price_in_usd']
+          price_data['price_in_usd'].to_f
+        elsif price_data['priceInUsd']
+          price_data['priceInUsd'].to_f
+        else
+          nil
+        end
+      end
+
+      def get_token_value_usd(balance, token)
+        price = get_token_price_usd(token)
+        if price
+          balance_num = balance.to_f
+          balance_num * price
+        else
+          nil
+        end
+      end
+
+      def get_multiple_token_prices(tokens)
+        prices = {}
+        tokens.each_with_index do |token, index|
+          # Add a small delay between requests to avoid rate limiting
+          sleep(0.1) if index > 0
+          begin
+            prices[token] = get_token_price_usd(token)
+          rescue => e
+            if @config.strict_mode
+              raise e
+            else
+              warn "Warning: Could not fetch price for #{token}: #{e.message}"
+              prices[token] = nil
+            end
+          end
+        end
+        prices
+      end
+
+      def format_price(price, currency = 'USD')
+        if price.nil?
+          '(price unavailable)'
+        elsif price < 0.0001
+          "#{sprintf('%.8f', price)} #{currency}"
+        elsif price < 1
+          "#{sprintf('%.6f', price)} #{currency}"
+        else
+          "#{sprintf('%.4f', price)} #{currency}"
+        end
+      end
+
+      private
+
+      def tronscan_headers
+        headers = { 'accept' => 'application/json' }
+        headers['TRON-PRO-API-KEY'] = @config.tronscan_api_key if @config.tronscan_api_key
+        headers
+      end
+    end
+  end
+end

data/lib/tron/services/resources.rb

@@ -0,0 +1,127 @@
+# lib/tron/services/resources.rb
+require_relative '../utils/http'
+require_relative '../utils/address'
+
+module Tron
+  module Services
+    class Resources
+      def initialize(config)
+        @config = config
+      end
+
+      def get(address)
+        validate_address!(address)
+        
+        # Try getaccountresource first
+        begin
+          get_account_resources(address)
+        rescue => e
+          # Fallback to getaccount if getaccountresource fails
+          get_account_resources_fallback(address)
+        end
+      end
+
+      private
+
+      def get_account_resources(address)
+        url = "#{@config.base_url}/wallet/getaccountresource"
+        headers = api_headers
+        
+        response = Utils::HTTP.post(url, { address: address, visible: true }.to_json, headers)
+        
+        # Validate response structure
+        unless response.is_a?(Hash)
+          raise "Unexpected API response format for account resources"
+        end
+        
+        # Handle error response format
+        if response.key?('Error')
+          return default_resources
+        end
+
+        # Validate required fields exist
+        ['freeNetLimit', 'freeNetUsed', 'TotalNetLimit', 'EnergyLimit', 'EnergyUsed'].each do |field|
+          unless response.key?(field)
+            puts "Warning: Missing field '#{field}' in account resources response: #{response}" if $DEBUG
+          end
+        end
+
+        free_net_limit = response['freeNetLimit']&.to_i || 0
+        free_net_used = response['freeNetUsed']&.to_i || 0
+        total_net_limit = response['TotalNetLimit']&.to_i || 0
+        energy_limit = response['EnergyLimit']&.to_i || 0
+        energy_used = response['EnergyUsed']&.to_i || 0
+        
+        available_bandwidth = [0, free_net_limit - free_net_used].max
+        available_energy = [0, energy_limit - energy_used].max
+        available_total_net = [0, total_net_limit].max
+
+        {
+          bandwidth: available_bandwidth,
+          bandwidthLimit: free_net_limit,
+          energy: available_energy,
+          energyLimit: energy_limit,
+          storage: 0,
+          storageLimit: 0,
+          totalFreeBandwidth: available_total_net,
+          totalFreeBandwidthLimit: total_net_limit
+        }
+      end
+
+      def get_account_resources_fallback(address)
+        url = "#{@config.base_url}/wallet/getaccount"
+        headers = api_headers
+        
+        response = Utils::HTTP.post(url, { address: address, visible: true }.to_json, headers)
+        
+        # Validate response structure
+        unless response.is_a?(Hash) && response.key?('data')
+          raise "Unexpected response format from getaccount endpoint"
+        end
+        
+        account_data = response['data']&.first || {}
+        
+        free_net_limit = account_data['freeNetLimit']&.to_i || 0
+        free_net_used = account_data['freeNetUsed']&.to_i || 0
+        energy_limit = account_data['EnergyLimit']&.to_i || 0
+        energy_used = account_data['EnergyUsed']&.to_i || 0
+        storage_limit = account_data['StorageLimit']&.to_i || 0
+        storage_used = account_data['StorageUsed']&.to_i || 0
+        
+        {
+          bandwidth: [0, free_net_limit - free_net_used].max,
+          bandwidthLimit: free_net_limit,
+          energy: [0, energy_limit - energy_used].max,
+          energyLimit: energy_limit,
+          storage: [0, storage_limit - storage_used].max,
+          storageLimit: storage_limit,
+          totalFreeBandwidth: 0,
+          totalFreeBandwidthLimit: 0
+        }
+      end
+
+      def validate_address!(address)
+        raise ArgumentError, "Invalid TRON address: #{address}" unless Utils::Address.validate(address)
+      end
+
+      def api_headers
+        headers = { 'accept' => 'application/json', 'Content-Type' => 'application/json' }
+        headers['TRON-PRO-API-KEY'] = @config.api_key if @config.api_key
+        headers
+      end
+
+      def default_resources
+        {
+          bandwidth: 0,
+          bandwidthLimit: 0,
+          energy: 0,
+          energyLimit: 0,
+          storage: 0,
+          storageLimit: 0,
+          totalFreeBandwidth: 0,
+          totalFreeBandwidthLimit: 0
+        }
+      end
+    end
+  end
+end

data/lib/tron/utils/address.rb

@@ -0,0 +1,39 @@
+# lib/tron/utils/address.rb
+require 'base58'
+
+module Tron
+  module Utils
+    class Address
+      def self.validate(address)
+        return false unless address && address.length == 34 && address.start_with?('T')
+        
+        begin
+          base58_part = address[1..-1]
+          Base58.decode(base58_part)
+          true
+        rescue
+          false
+        end
+      end
+
+      def self.to_hex(address)
+        return address if address.start_with?('41') && address.length == 42 # Already hex format
+
+        base58_part = address.start_with?('T') ? address[1..-1] : address
+        decoded = Base58.decode(base58_part)
+        '41' + decoded.unpack('H*').first
+      end
+
+      def self.to_base58(hex_address)
+        return hex_address if hex_address.start_with?('T') && hex_address.length == 34 # Already base58 format
+
+        hex_without_prefix = hex_address.start_with?('41') ? hex_address[2..-1] : hex_address
+        address_bytes = [hex_without_prefix].pack('H*')
+        
+        require 'digest'
+        checksum = Digest::SHA256.digest(Digest::SHA256.digest(address_bytes))[0...4]
+        Base58.binary_to_base58(address_bytes + checksum)
+      end
+    end
+  end
+end

data/lib/tron/utils/http.rb

@@ -0,0 +1,48 @@
+# lib/tron/utils/http.rb
+require 'net/http'
+require 'uri'
+require 'json'
+
+module Tron
+  module Utils
+    class HTTP
+      def self.get(url, headers = {})
+        make_request(Net::HTTP::Get, url, nil, headers)
+      end
+
+      def self.post(url, body = nil, headers = {})
+        make_request(Net::HTTP::Post, url, body, headers)
+      end
+
+      private
+
+      def self.make_request(method_class, url, body, headers)
+        uri = URI(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme == 'https'
+        http.read_timeout = Tron.configuration.timeout
+
+        request = method_class.new(uri.request_uri, headers)
+        request.body = body if body
+
+        response = http.request(request)
+        
+        case response
+        when Net::HTTPSuccess
+          json_response = JSON.parse(response.body)
+          # Validate that the response is actually a hash/array before returning
+          unless json_response.is_a?(Hash) || json_response.is_a?(Array)
+            raise "Invalid response format: expected JSON object or array"
+          end
+          json_response
+        else
+          raise "API Error: #{response.code} - #{response.body}"
+        end
+      rescue JSON::ParserError
+        raise "Invalid JSON response: #{response.body}"
+      rescue => e
+        raise "HTTP Error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/tron/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# lib/tron/version.rb
+module Tron
+  VERSION = "1.0.0".freeze
+end

data/lib/tron.rb

@@ -0,0 +1,32 @@
+# lib/tron.rb
+require 'dotenv/load' if File.exist?('.env')
+
+require_relative 'tron/version'
+require_relative 'tron/client'
+require_relative 'tron/configuration'
+
+module Tron
+  class << self
+    def client
+      @client ||= Client.new
+    end
+
+    def configure(&block)
+      @client = nil # Reset client when configuration changes
+      Client.configure(&block)
+    end
+
+    # Delegate common methods to the default client
+    def method_missing(method, *args, &block)
+      if client.respond_to?(method)
+        client.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      client.respond_to?(method) || super
+    end
+  end
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: tron.rb
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Your Name
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base58
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: A Ruby gem for interacting with TRON blockchain APIs, including balance
+  checking, resource information, and token prices.
+email:
+- your.email@example.com
+executables:
+- tron-wallet
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/tron-wallet
+- lib/tron.rb
+- lib/tron/client.rb
+- lib/tron/configuration.rb
+- lib/tron/services/balance.rb
+- lib/tron/services/price.rb
+- lib/tron/services/resources.rb
+- lib/tron/utils/address.rb
+- lib/tron/utils/http.rb
+- lib/tron/version.rb
+homepage: https://github.com/yourusername/tron
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Ruby wrapper for TRON blockchain APIs
+test_files: []