tronzap-sdk 1.0.0

data/lib/tronzap/response_decoder.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Tronzap
+  # Turns an HTTP response into a result or the matching {Error}.
+  #
+  # @api private
+  module ResponseDecoder
+    UNKNOWN_API_ERROR = "Unknown API error"
+    private_constant :UNKNOWN_API_ERROR
+
+    module_function
+
+    # The API code takes precedence over the HTTP status: some API errors arrive with 2xx, others with 4xx/5xx.
+    #
+    # @param response [#status, #headers, #body]
+    # @yieldparam result [Object] the parsed +result+ field
+    # @return [Object] what the block returns
+    def decode(response)
+      status = response.status.to_i
+      body = text(response.body)
+      document, parse_error = parse(body)
+
+      check_api_error(document, status, body) unless parse_error
+      raise http_error(status, body, response.headers) unless (200..299).cover?(status)
+
+      result = result(document, parse_error, status, body)
+      begin
+        yield result
+      rescue Coerce::Error => e
+        raise invalid("Unexpected result in response: #{e.message}", status, body)
+      end
+    end
+
+    def result(document, parse_error, status, body)
+      raise invalid("Invalid JSON response: #{parse_error.message}", status, body) if parse_error
+
+      result = document["result"]
+      raise invalid("Missing result in response", status, body) if result.nil?
+
+      result
+    end
+
+    def invalid(message, status, body)
+      InvalidResponseError.new(message, status: status, response_body: body)
+    end
+
+    def text(body)
+      text = body.to_s.dup.force_encoding(Encoding::UTF_8)
+      text.valid_encoding? ? text.freeze : text.scrub.freeze
+    end
+
+    def parse(body)
+      [JSON.parse(body, decimal_class: BigDecimal), nil]
+    rescue JSON::ParserError, EncodingError => e
+      [nil, e]
+    end
+
+    def check_api_error(document, status, body)
+      unless document.is_a?(Hash)
+        raise ApiError.new(UNKNOWN_API_ERROR, code: ErrorCode::AUTH_ERROR, status: status, response_body: body)
+      end
+
+      code = code(document["code"])
+      return if code&.zero?
+
+      raise ApiError.new(
+        string(document["error"]) || UNKNOWN_API_ERROR,
+        code: code || ErrorCode::AUTH_ERROR,
+        status: status,
+        response_body: body,
+        error_key: string(document["key"]),
+        request_id: string(document["request_id"])
+      )
+    end
+
+    def code(value)
+      case value
+      when Integer then value
+      when String then value.strip.match?(/\A[+-]?\d+\z/) ? value.to_i : nil
+      end
+    end
+
+    def string(value)
+      case value
+      when String then value
+      when Integer then value.to_s
+      when BigDecimal then value.to_s("F")
+      end
+    end
+
+    def http_error(status, body, headers)
+      case status
+      when 429
+        RateLimitError.new("Too many requests (HTTP 429)", status: status, response_body: body,
+                                                           retry_after: retry_after(headers))
+      when 401, 403 then UnauthorizedError.new("Unauthorized (HTTP #{status})", status: status, response_body: body)
+      when 500.. then ServerError.new("Server error (HTTP #{status})", status: status, response_body: body)
+      else HttpError.new("HTTP error #{status}", status: status, response_body: body)
+      end
+    end
+
+    def retry_after(headers)
+      value = headers.to_h.find { |name, _| name.to_s.casecmp?("retry-after") }&.last
+      value = value.first if value.is_a?(Array)
+      return nil unless value.is_a?(String)
+
+      value = value.strip
+      return value.to_f if value.match?(/\A\d+(\.\d+)?\z/)
+
+      [Time.httpdate(value) - Time.now, 0.0].max
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/tronzap/responses/account_balance.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Tronzap
+  # Results returned by {Client} methods. They are immutable; collections are frozen and never +nil+.
+  module Responses
+    # The account balance and the address that tops it up.
+    #
+    # @!attribute [r] balance
+    #   @return [BigDecimal] available balance, in TRX
+    # @!attribute [r] address
+    #   @return [String] the TRON address to send TRX to in order to top up the balance
+    AccountBalance = Data.define(:balance, :address) do
+      # @api private
+      def self.from_api(value)
+        data = Coerce.object(value, "result")
+        new(balance: Coerce.decimal(data["balance"], "balance"), address: Coerce.text(data["address"], "address"))
+      end
+    end
+  end
+end

data/lib/tronzap/responses/address_info.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Tronzap
+  module Responses
+    # The on-chain resources and token balances of a TRON address.
+    #
+    # @!attribute [r] resources
+    #   @return [Models::AddressResources] available energy and bandwidth
+    # @!attribute [r] balances
+    #   @return [Hash{String => BigDecimal}] token balances by token symbol, for example +TRX+ and +USDT+
+    AddressInfo = Data.define(:resources, :balances) do
+      # @api private
+      def self.from_api(value)
+        data = Coerce.object(value, "result")
+        resources = Coerce.object(data["resources"], "resources")
+        new(
+          resources: Models::AddressResources.new(
+            energy: Coerce.integer(resources["energy"], "resources.energy"),
+            bandwidth: Coerce.integer(resources["bandwidth"], "resources.bandwidth")
+          ),
+          balances: Coerce.decimal_map(data["balances"], "balances")
+        )
+      end
+    end
+  end
+end

data/lib/tronzap/responses/aml_check.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Tronzap
+  module Responses
+    # An AML screening of an address or a transaction hash.
+    #
+    # @!attribute [r] id
+    #   @return [String] the AML check ID
+    # @!attribute [r] type
+    #   @return [Symbol] what is screened, one of {Models::AML_CHECK_TYPES} or +:unknown+
+    # @!attribute [r] address
+    #   @return [String] the screened wallet address
+    # @!attribute [r] transaction_hash
+    #   @return [String, nil] the screened transaction hash, +nil+ for an address check
+    # @!attribute [r] direction
+    #   @return [Symbol, nil] the direction of the screened transaction, one of {Models::AML_DIRECTIONS} or
+    #     +:unknown+, +nil+ when not given
+    # @!attribute [r] network
+    #   @return [String] the network code, for example +TRX+, +BTC+ or +ETH+
+    # @!attribute [r] status
+    #   @return [Symbol] the state of the check, one of {Models::AML_STATUSES} or +:unknown+
+    # @!attribute [r] risk_score
+    #   @return [BigDecimal, nil] the risk score, +nil+ until the check completes. A completed check can have a
+    #     score of 0, which is not the same as having no score yet.
+    # @!attribute [r] risk_level
+    #   @return [Symbol, nil] the risk level, one of {Models::AML_RISK_LEVELS} or +:unknown+, +nil+ until the
+    #     check completes
+    # @!attribute [r] blacklist
+    #   @return [Boolean] whether the subject is blacklisted
+    # @!attribute [r] risk_factors
+    #   @return [Array<Models::AmlRiskFactor>] the factors that contributed to the risk score
+    # @!attribute [r] checked_at
+    #   @return [Models::Timestamp, nil] when the check completed, +nil+ when the API did not report it
+    AmlCheck = Data.define(:id, :type, :address, :transaction_hash, :direction, :network, :status,
+                           :risk_score, :risk_level, :blacklist, :risk_factors, :checked_at) do
+      # @api private
+      def self.from_api(value)
+        data = Coerce.object(value, "AML check")
+        new(
+          id: Coerce.text(data["id"], "id"),
+          type: Coerce.enum(data["type"], Models::AML_CHECK_TYPES, "type"),
+          address: Coerce.text(data["address"], "address"),
+          transaction_hash: Coerce.optional_text(data["hash"], "hash"),
+          direction: Coerce.optional_enum(data["direction"], Models::AML_DIRECTIONS, "direction"),
+          network: Coerce.text(data["network"], "network"),
+          status: Coerce.enum(data["status"], Models::AML_STATUSES, "status"),
+          risk_score: Coerce.optional_decimal(data["risk_score"], "risk_score"),
+          risk_level: Coerce.optional_enum(data["risk_level"], Models::AML_RISK_LEVELS, "risk_level"),
+          blacklist: Coerce.boolean(data["blacklist"], "blacklist"),
+          risk_factors: Coerce.list(data["risk_factors"], "risk_factors") { Models::AmlRiskFactor.from_api(_1) },
+          checked_at: Coerce.timestamp(data["checked_at"], "checked_at")
+        )
+      end
+    end
+  end
+end

data/lib/tronzap/responses/aml_history.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Tronzap
+  module Responses
+    # One page of past AML checks, newest first.
+    #
+    # @!attribute [r] page
+    #   @return [Integer] the page number, starting at 1
+    # @!attribute [r] per_page
+    #   @return [Integer] the page size
+    # @!attribute [r] total
+    #   @return [Integer] the number of checks across all pages
+    # @!attribute [r] items
+    #   @return [Array<AmlCheck>] the checks on this page
+    AmlHistory = Data.define(:page, :per_page, :total, :items) do
+      # @api private
+      def self.from_api(value)
+        data = Coerce.object(value, "result")
+        new(
+          page: Coerce.integer(data["page"], "page"),
+          per_page: Coerce.integer(data["per_page"], "per_page"),
+          total: Coerce.integer(data["total"], "total"),
+          items: Coerce.list(data["items"], "items") { AmlCheck.from_api(_1) }
+        )
+      end
+    end
+  end
+end

data/lib/tronzap/responses/aml_service.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Tronzap
+  module Responses
+    # An AML screening product and its price.
+    #
+    # @!attribute [r] id
+    #   @return [String] the service ID
+    # @!attribute [r] type
+    #   @return [Symbol] what the service screens, one of {Models::AML_CHECK_TYPES} or +:unknown+
+    # @!attribute [r] price
+    #   @return [BigDecimal] price of one check, in TRX
+    AmlService = Data.define(:id, :type, :price) do
+      # @api private
+      def self.from_api(value)
+        data = Coerce.object(value, "AML service")
+        new(
+          id: Coerce.text(data["id"], "id"),
+          type: Coerce.enum(data["type"], Models::AML_CHECK_TYPES, "type"),
+          price: Coerce.decimal(data["price"], "price")
+        )
+      end
+
+      # @api private
+      def self.list_from_api(value)
+        Coerce.list(value, "result") { from_api(_1) }
+      end
+    end
+  end
+end

data/lib/tronzap/responses/calculation.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Tronzap
+  module Responses
+    # The price of an energy purchase.
+    #
+    # @!attribute [r] address
+    #   @return [String] the TRON address that would receive the energy
+    # @!attribute [r] service
+    #   @return [Symbol] the service the price is for, one of {Models::SERVICES} or +:unknown+
+    # @!attribute [r] amount
+    #   @return [Integer] the amount priced
+    # @!attribute [r] energy
+    #   @return [Integer] the energy priced
+    # @!attribute [r] duration
+    #   @return [Integer] rental duration in hours
+    # @!attribute [r] price
+    #   @return [BigDecimal] price of the energy, in TRX
+    # @!attribute [r] activation_fee
+    #   @return [BigDecimal] address activation fee, in TRX
+    # @!attribute [r] total
+    #   @return [BigDecimal] total cost, in TRX
+    Calculation = Data.define(:address, :service, :amount, :energy, :duration, :price, :activation_fee, :total) do
+      # @api private
+      def self.from_api(value)
+        data = Coerce.object(value, "result")
+        new(
+          address: Coerce.text(data["address"], "address"),
+          service: Coerce.enum(data["type"], Models::SERVICES, "type"),
+          amount: Coerce.integer(data["amount"], "amount"),
+          energy: Coerce.integer(data["energy"], "energy"),
+          duration: Coerce.integer(data["duration"], "duration"),
+          price: Coerce.decimal(data["price"], "price"),
+          activation_fee: Coerce.decimal(data["activation_fee"], "activation_fee"),
+          total: Coerce.decimal(data["total"], "total")
+        )
+      end
+    end
+  end
+end

data/lib/tronzap/responses/direct_recharge_info.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Tronzap
+  module Responses
+    # The address to pay for a direct energy recharge and the rates energy is delivered at.
+    #
+    # @!attribute [r] address
+    #   @return [String] the TRON address to send TRX to
+    # @!attribute [r] rates
+    #   @return [Array<Models::DirectRechargeRate>] the rates energy is delivered at
+    DirectRechargeInfo = Data.define(:address, :rates) do
+      # @api private
+      def self.from_api(value)
+        data = Coerce.object(value, "result")
+        new(
+          address: Coerce.text(data["address"], "address"),
+          rates: Coerce.list(data["rates"], "rates") { Models::DirectRechargeRate.from_api(_1) }
+        )
+      end
+    end
+  end
+end

data/lib/tronzap/responses/energy_estimate.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Tronzap
+  module Responses
+    # The energy a token transfer needs and what that energy costs.
+    #
+    # @!attribute [r] amount
+    #   @return [Integer] the amount of energy the price applies to
+    # @!attribute [r] energy
+    #   @return [Integer] the energy the transfer needs
+    # @!attribute [r] duration
+    #   @return [Integer] rental duration in hours
+    # @!attribute [r] price
+    #   @return [BigDecimal] price of the energy, in TRX
+    # @!attribute [r] activation_fee
+    #   @return [BigDecimal] address activation fee, in TRX
+    # @!attribute [r] total
+    #   @return [BigDecimal] total cost, in TRX
+    # @!attribute [r] from_address
+    #   @return [String] the sender address
+    # @!attribute [r] to_address
+    #   @return [String] the recipient address
+    # @!attribute [r] contract_address
+    #   @return [String] the token contract the estimate is for
+    EnergyEstimate = Data.define(:amount, :energy, :duration, :price, :activation_fee, :total,
+                                 :from_address, :to_address, :contract_address) do
+      # @api private
+      def self.from_api(value)
+        data = Coerce.object(value, "result")
+        new(
+          amount: Coerce.integer(data["amount"], "amount"),
+          energy: Coerce.integer(data["energy"], "energy"),
+          duration: Coerce.integer(data["duration"], "duration"),
+          price: Coerce.decimal(data["price"], "price"),
+          activation_fee: Coerce.decimal(data["activation_fee"], "activation_fee"),
+          total: Coerce.decimal(data["total"], "total"),
+          from_address: Coerce.text(data["from_address"], "from_address"),
+          to_address: Coerce.text(data["to_address"], "to_address"),
+          contract_address: Coerce.text(data["contract_address"], "contract_address")
+        )
+      end
+    end
+  end
+end

data/lib/tronzap/responses/service_rates.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Tronzap
+  module Responses
+    # The resources on sale and their current prices.
+    #
+    # Energy is priced per unit and bandwidth per 1000 units: {Models::EnergyRate#price} × 65000 is the cost of
+    # 65000 energy, while 345 bandwidth at a {Models::BandwidthRate#price} of 1 costs 0.345.
+    #
+    # @!attribute [r] energy
+    #   @return [Array<Models::EnergyRate>] energy price tiers
+    # @!attribute [r] bandwidth
+    #   @return [Array<Models::BandwidthRate>] bandwidth price tiers
+    # @!attribute [r] activate_address
+    #   @return [Models::ActivateAddressRate, nil] the address activation price, +nil+ when the API did not
+    #     report one
+    ServiceRates = Data.define(:energy, :bandwidth, :activate_address) do
+      # @api private
+      def self.from_api(value)
+        data = Coerce.object(value, "result")
+        activation = data["activate_address"]
+        new(
+          energy: Coerce.list(data["energy"], "energy") { Models::EnergyRate.from_api(_1) },
+          bandwidth: Coerce.list(data["bandwidth"], "bandwidth") { Models::BandwidthRate.from_api(_1) },
+          activate_address: activation.nil? ? nil : activation_rate(activation)
+        )
+      end
+
+      def self.activation_rate(value)
+        data = Coerce.object(value, "activate_address")
+        Models::ActivateAddressRate.new(price: Coerce.decimal(data["price"], "activate_address.price"))
+      end
+      private_class_method :activation_rate
+    end
+  end
+end

data/lib/tronzap/responses/transaction.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Tronzap
+  module Responses
+    # A purchase of energy, bandwidth or address activation.
+    #
+    # @!attribute [r] id
+    #   @return [String] the transaction ID assigned by TronZap
+    # @!attribute [r] external_id
+    #   @return [String, nil] the ID you passed when creating the transaction
+    # @!attribute [r] service
+    #   @return [Symbol] the service of the transaction, one of {Models::SERVICES} or +:unknown+. The API currently
+    #     reports a resource bundle as +:energy+; read {Models::TransactionParams#amounts} to see which resources
+    #     it contains.
+    # @!attribute [r] params
+    #   @return [Models::TransactionParams] the parameters the transaction was created with
+    # @!attribute [r] status
+    #   @return [Symbol] the current state, one of {Models::TRANSACTION_STATUSES} or +:unknown+
+    # @!attribute [r] amount
+    #   @return [BigDecimal] the amount charged, in TRX
+    # @!attribute [r] created_at
+    #   @return [Models::Timestamp, nil] when the transaction was created, +nil+ when the API did not report it
+    # @!attribute [r] transaction_hash
+    #   @return [String, nil] the on-chain transaction hash, +nil+ when the API did not report one
+    Transaction = Data.define(:id, :external_id, :service, :params, :status, :amount, :created_at,
+                              :transaction_hash) do
+      # @api private
+      def self.from_api(value)
+        data = Coerce.object(value, "result")
+        service = Coerce.enum(data["service"], Models::SERVICES, "service")
+        new(
+          id: Coerce.text(data["id"], "id"),
+          external_id: Coerce.optional_text(data["external_id"], "external_id"),
+          service: service,
+          params: Models::TransactionParams.from_api(data["params"], service),
+          status: Coerce.enum(data["status"], Models::TRANSACTION_STATUSES, "status"),
+          amount: Coerce.decimal(data["amount"], "amount"),
+          created_at: Coerce.timestamp(data["created_at"], "created_at"),
+          transaction_hash: Coerce.optional_text(data["hash"], "hash")
+        )
+      end
+    end
+  end
+end

data/lib/tronzap/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Tronzap
+  # The SDK version, reported in the default +User-Agent+ header.
+  VERSION = "1.0.0"
+end

data/lib/tronzap-sdk.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Bundler.require loads a gem by its name, so `gem "tronzap-sdk"` needs this file to load the library.
+require_relative "tronzap"

data/lib/tronzap.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "json"
+require "time"
+
+require_relative "tronzap/version"
+require_relative "tronzap/errors"
+require_relative "tronzap/coerce"
+require_relative "tronzap/models/enums"
+require_relative "tronzap/models/timestamp"
+require_relative "tronzap/models/resource_amounts"
+require_relative "tronzap/models/transaction_params"
+require_relative "tronzap/models/address_resources"
+require_relative "tronzap/models/energy_rate"
+require_relative "tronzap/models/bandwidth_rate"
+require_relative "tronzap/models/activate_address_rate"
+require_relative "tronzap/models/direct_recharge_rate"
+require_relative "tronzap/models/aml_risk_factor"
+require_relative "tronzap/requests/validation"
+require_relative "tronzap/requests/estimate_energy"
+require_relative "tronzap/requests/calculate"
+require_relative "tronzap/requests/energy_transaction"
+require_relative "tronzap/requests/bandwidth_transaction"
+require_relative "tronzap/requests/resource_bundle_transaction"
+require_relative "tronzap/requests/address_activation"
+require_relative "tronzap/requests/check_transaction"
+require_relative "tronzap/requests/aml_check"
+require_relative "tronzap/requests/aml_history"
+require_relative "tronzap/responses/account_balance"
+require_relative "tronzap/responses/address_info"
+require_relative "tronzap/responses/aml_check"
+require_relative "tronzap/responses/aml_history"
+require_relative "tronzap/responses/aml_service"
+require_relative "tronzap/responses/calculation"
+require_relative "tronzap/responses/direct_recharge_info"
+require_relative "tronzap/responses/energy_estimate"
+require_relative "tronzap/responses/service_rates"
+require_relative "tronzap/responses/transaction"
+require_relative "tronzap/http_adapter"
+require_relative "tronzap/response_decoder"
+require_relative "tronzap/configuration"
+require_relative "tronzap/client"
+
+# Official Ruby SDK for the {https://docs.tronzap.com/ TronZap API}. Start with {Tronzap::Client}.
+module Tronzap
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: tronzap-sdk
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- TronZap
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: Official Ruby SDK for TronZap.com. The TRON Energy API lets you buy energy
+  and bandwidth to lower USDT (TRC20) transfer fees, activate TRON addresses and run
+  AML checks.
+email:
+- support@tronzap.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.es.md
+- README.md
+- README.pt-br.md
+- README.ru.md
+- lib/tronzap-sdk.rb
+- lib/tronzap.rb
+- lib/tronzap/client.rb
+- lib/tronzap/coerce.rb
+- lib/tronzap/configuration.rb
+- lib/tronzap/errors.rb
+- lib/tronzap/http_adapter.rb
+- lib/tronzap/models/activate_address_rate.rb
+- lib/tronzap/models/address_resources.rb
+- lib/tronzap/models/aml_risk_factor.rb
+- lib/tronzap/models/bandwidth_rate.rb
+- lib/tronzap/models/direct_recharge_rate.rb
+- lib/tronzap/models/energy_rate.rb
+- lib/tronzap/models/enums.rb
+- lib/tronzap/models/resource_amounts.rb
+- lib/tronzap/models/timestamp.rb
+- lib/tronzap/models/transaction_params.rb
+- lib/tronzap/requests/address_activation.rb
+- lib/tronzap/requests/aml_check.rb
+- lib/tronzap/requests/aml_history.rb
+- lib/tronzap/requests/bandwidth_transaction.rb
+- lib/tronzap/requests/calculate.rb
+- lib/tronzap/requests/check_transaction.rb
+- lib/tronzap/requests/energy_transaction.rb
+- lib/tronzap/requests/estimate_energy.rb
+- lib/tronzap/requests/resource_bundle_transaction.rb
+- lib/tronzap/requests/validation.rb
+- lib/tronzap/response_decoder.rb
+- lib/tronzap/responses/account_balance.rb
+- lib/tronzap/responses/address_info.rb
+- lib/tronzap/responses/aml_check.rb
+- lib/tronzap/responses/aml_history.rb
+- lib/tronzap/responses/aml_service.rb
+- lib/tronzap/responses/calculation.rb
+- lib/tronzap/responses/direct_recharge_info.rb
+- lib/tronzap/responses/energy_estimate.rb
+- lib/tronzap/responses/service_rates.rb
+- lib/tronzap/responses/transaction.rb
+- lib/tronzap/version.rb
+homepage: https://tronzap.com/
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://tronzap.com/
+  documentation_uri: https://docs.tronzap.com/
+  source_code_uri: https://github.com/tron-energy-market/tronzap-sdk-ruby
+  changelog_uri: https://github.com/tron-energy-market/tronzap-sdk-ruby/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/tron-energy-market/tronzap-sdk-ruby/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: 'Official Ruby SDK for the TronZap API: buy TRON energy and bandwidth.'
+test_files: []