trx 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dfcdbe41de11ca908dfaf1b12e58262dba9966cc7b319d57fc48c9e455d36360
+  data.tar.gz: f048ec52470a044ae883262dbfe51ee706bd2a8339a2298c014c642ac4e92e53
+SHA512:
+  metadata.gz: 870645d6c67d40a2ca3eb7f6d70186408cfd622534eb89040008683298e68ae4c84a9137f6144771afe9003844b6fb3d7339fbb0eb1085f8c9c3835464ed54cc
+  data.tar.gz: 134d7401cfd15c6192f6f8974dd3fb13bf829e7e707632dba50166ecc26a422fe081a94b2cfccc78d37c749cc90293bc08abc50d3b07c9ce51a8fa2a8dc83408

data/lib/trx/abi/contract_event.rb

@@ -0,0 +1,25 @@
+module Trx
+  module Abi
+    class ContractEvent
+
+      attr_accessor :name, :signature, :input_types, :inputs, :event_string, :address, :client
+
+      def initialize(data)
+        @name = data["name"]
+        @input_types = data.fetch("inputs", []).map {|x| x["type"]}
+        @inputs = data.fetch("inputs", []).map {|x| x["name"]}
+        @event_string = "#{@name}(#{@input_types.join(",")})"
+        @signature = Digest::Keccak.hexdigest(@event_string, 256)
+      end
+
+      def set_address(address)
+        @address = address
+      end
+
+      def set_client(client)
+        @client = client
+      end
+
+    end
+  end
+end

data/lib/trx/abi/decoder.rb

@@ -0,0 +1,101 @@
+module Trx
+  module Abi
+    class Decoder
+
+      def decode(type, value, start = 0)
+        is_array, arity, array_subtype = Abi::parse_array_type(type)
+        if is_array && arity
+          decode_static_array(arity, array_subtype, value, start)
+        elsif is_array
+          decode_dynamic_array(array_subtype, value, start)
+        else
+          value = value.gsub(/^0x/,'')
+          core, subtype = Abi::parse_type(type)
+          method_name = "decode_#{core}".to_sym
+          self.send(method_name, value, subtype, start)
+        end
+      end
+
+      def decode_static_array(arity, array_subtype, value, start)
+        (0..arity-1).map { |i| decode(array_subtype, value, start + i * 64) }
+      end
+
+      def decode_dynamic_array(array_subtype, value, start)
+        location = decode_uint(value[start..(start+63)]) * 2
+        size = decode_uint(value[location..location+63])
+        (0..size-1).map { |i| decode(array_subtype, value, location + (i+1) * 64) }
+      end
+
+      def decode_fixed(value, subtype = "128x128", start = 0)
+        decode_int(trim(value, start, fixed_bitsize(subtype))).to_f / 2**exponent(subtype)
+      end
+
+      def decode_uint(value, subtype = "256", start = 0)
+        trim(value, start, bitsize(subtype)).hex
+      end
+
+      def decode_int(value, subtype = "256", start = 0)
+        raise ArgumentError if value.nil?
+        size = bitsize(subtype)
+        value = trim(value, start, size)
+        (value[0..1] == "ff") ? (value.hex - (2 ** size)) : value.hex
+      end
+
+      def decode_bool(value, _, start)
+        value = trim(value, start, 4)
+        return true if value == "1"
+        return false if value == "0"
+        raise ArgumentError
+      end
+
+      def decode_address(value, _ = nil, start)
+        raise ArgumentError if value.size-start < 64
+        value[start+24..start+63]
+      end
+
+      def decode_bytes(value, subtype, start)
+        subtype.present? ? decode_static_bytes(value, subtype, start) : decode_dynamic_bytes(value, start)
+      end
+
+      def decode_static_bytes(value, subtype = nil, start = 0)
+        trim(value, start, subtype.to_i*8).scan(/.{2}/).map {|x| x.hex}.pack('C*').strip
+      end
+
+      def decode_dynamic_bytes(value, start = 0)
+        location = decode_uint(value[start..(start+63)]) * 2
+        size = decode_uint(value[location..location+63]) * 2
+        value[location+64..location+63+size].scan(/.{2}/).map {|x| x.hex}.pack('C*')
+      end
+
+      def decode_string(value, _ = nil, start = 0)
+        decode_dynamic_bytes(value, start).force_encoding('utf-8')
+      end
+
+      def decode_arguments(arguments, data)
+        data = data.gsub(/^0x/,'')
+        types = arguments.map { |o| o.type }
+        types.each.with_index.map { |t , i| decode(t, data, i*64) }
+      end
+
+      private
+        def trim(value, start, bitsize = 256)
+          value[start+63-(bitsize/4-1)..start+63]
+        end
+
+        def bitsize(subtype, default = 256)
+          subtype.present? ? subtype.to_i : default
+        end
+
+        def fixed_bitsize(subtype = nil)
+          subtype ||= "128x128"
+          _, x, n = /(\d+)x(\d+)/.match(subtype).to_a
+          x.to_i + n.to_i
+        end
+
+        def exponent(subtype, default = 128)
+          subtype.nil? ? default : /(\d+)x(\d+)/.match(subtype)[2].to_i
+        end
+
+    end
+  end
+end

data/lib/trx/abi/encoder.rb

@@ -0,0 +1,119 @@
+module Trx
+
+  module Abi
+    class Encoder
+
+      def encode(type, value)
+        is_array, arity, array_subtype = Abi::parse_array_type(type)
+        if is_array && arity
+          encode_static_array(arity, array_subtype, value)
+        elsif is_array
+          encode_dynamic_array(array_subtype, value)
+        else
+          core, subtype = Abi::parse_type(type)
+          method_name = "encode_#{core}".to_sym
+          self.send(method_name, value, subtype)
+        end
+      end
+
+      def encode_static_array(arity, array_subtype, array)
+        raise "Wrong number of arguments" if arity != array.size
+        array.inject("") { |a, e| a << encode(array_subtype, e) }
+      end
+
+      def encode_dynamic_array(array_subtype, array)
+        location = encode_uint(@inputs ? size_of_inputs(@inputs) + @tail.size/2 : 32)
+        size = encode_uint(array.size)
+        data = array.inject("") { |a, e| a << encode(array_subtype, e) }
+        [location, size + data]
+      end
+
+      def encode_int(value, _ = nil)
+        to_twos_complement(value).to_s(16).rjust(64, '0')
+      end
+
+      def encode_uint(value, _ = nil)
+        raise ArgumentError if value < 0
+        encode_int(value)
+      end
+
+      def encode_bool(value, _)
+        (value ? "1" : "0").rjust(64, '0')
+      end
+
+      def encode_fixed(value, subtype)
+        n = subtype.nil? ? 128 : /(\d+)x(\d+)/.match(subtype)[2].to_i
+        do_encode_fixed(value, n)
+      end
+
+      def do_encode_fixed(value, n)
+        encode_uint((value * 2**n).to_i)
+      end
+
+      def encode_ufixed(_value, _)
+        raise NotImplementedError
+      end
+
+      def encode_bytes(value, subtype)
+        subtype.nil? ? encode_dynamic_bytes(value) : encode_static_bytes(value)
+      end
+
+      def encode_static_bytes(value)
+        value.bytes.map {|x| x.to_s(16).rjust(2, '0')}.join("").ljust(64, '0')
+      end
+
+      def encode_dynamic_bytes(value)
+        location = encode_uint(@inputs ? size_of_inputs(@inputs) + @tail.size/2 : 32)
+        size = encode_uint(value.size)
+        content = encode_static_bytes(value)
+        [location, size + content]
+      end
+
+      def encode_string(value, _)
+        location = encode_uint(@inputs ? size_of_inputs(@inputs) + @tail.size/2 : 32)
+        size = encode_uint(value.bytes.size)
+        content = value.bytes.map {|x| x.to_s(16).rjust(2, '0')}.join("").ljust(64, '0')
+        [location, size + content]
+      end
+
+      def encode_address(value, _)
+        value = "0" * 24 + value.gsub(/^0x/,'')
+        raise ArgumentError if value.size != 64
+        value
+      end
+
+      def ensure_prefix(value)
+        value.start_with?("0x") ? value : ("0x" + value)
+      end
+
+      def encode_arguments(inputs, args)
+        raise "Wrong number of arguments" if inputs.length != args.length
+        @head = ""
+        @tail = ""
+        @inputs = inputs
+        inputs.each.with_index do |input, index|
+          encoded = encode(input.type, args[index])
+          if encoded.is_a? Array
+            @head << encoded[0]
+            @tail << encoded[1]
+          else
+            @head << encoded
+          end
+        end
+        @head + @tail
+      end
+
+      private
+        def to_twos_complement(number)
+          (number & ((1 << 256) - 1))
+        end
+
+        def size_of_inputs(inputs)
+          inputs.map do |input|
+            _, arity, _ = Abi::parse_array_type(input.type)
+            arity.nil? ? 32 : arity * 32
+          end.inject(:+)
+        end
+    end
+  end
+end

data/lib/trx/abi/function.rb

@@ -0,0 +1,37 @@
+module Trx
+  module Abi
+    class Function
+
+      attr_accessor :name, :inputs, :outputs, :signature, :constant, :function_string
+
+      def initialize(data)
+        @name = data["name"]
+        @constant = data["constant"]
+        @inputs = data.fetch("inputs", []).map do |input|
+          FunctionInput.new(input)
+        end
+        @outputs = data.fetch("outputs", []).map do |output|
+          FunctionOutput.new(output)
+        end
+        @function_string = self.class.calc_signature(@name, @inputs)
+        @signature = self.class.calc_id(@function_string)
+      end
+
+      def self.to_canonical_type(type)
+        type
+        .gsub(/(int)(\z|\D)/, '\1256\2')
+        .gsub(/(uint)(\z|\D)/, '\1256\2')
+        .gsub(/(fixed)(\z|\D)/, '\1128x128\2')
+        .gsub(/(ufixed)(\z|\D)/, '\1128x128\2')
+      end
+
+      def self.calc_signature(name, inputs)
+        "#{name}(#{inputs.map {|x| self.to_canonical_type(x.type) }.join(",")})"
+      end
+
+      def self.calc_id(signature)
+        Digest::Keccak.hexdigest(signature, 256)[0..7]
+      end
+    end
+  end
+end

data/lib/trx/abi/function_input.rb

@@ -0,0 +1,15 @@
+module Trx
+
+  module Abi
+    class FunctionInput
+
+      attr_accessor :type, :name
+
+      def initialize(data)
+        @type = data["type"]
+        @name = data["name"]
+      end
+
+    end
+  end
+end

data/lib/trx/abi/function_output.rb

@@ -0,0 +1,15 @@
+module Trx
+
+  module Abi
+    class FunctionOutput
+
+      attr_accessor :type, :name
+
+      def initialize(data)
+        @type = data["type"]
+        @name = data["name"]
+      end
+
+    end
+  end
+end

data/lib/trx/abi.rb

@@ -0,0 +1,33 @@
+module Trx
+  module Abi
+    extend self
+
+    def parse_abi(abi)
+      constructor = abi.detect {|x| x["type"].downcase == "constructor"}
+      if constructor.present?
+        constructor_inputs = constructor["inputs"].map { |input| FunctionInput.new(input) }
+      else
+        constructor_inputs = []
+      end
+      functions = abi.select {|x| x["type"].downcase == "function" }.map { |fun| Function.new(fun) }
+      events = abi.select {|x| x["type"].downcase == "event" }.map { |evt| ContractEvent.new(evt) }
+      [constructor_inputs, functions, events]
+    end
+
+    def parse_type(type)
+      raise NotImplementedError if type.ends_with?("]")
+      match = /(\D+)(\d.*)?/.match(type)
+      [match[1], match[2]]
+    end
+
+    def parse_array_type(type)
+      match = /(.+)\[(\d*)\]\z/.match(type)
+      if match
+        [true, match[2].present? ? match[2].to_i : nil, match[1]]
+      else
+        [false, nil, nil]
+      end
+    end
+
+  end
+end

data/lib/trx/address.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Trx
+  class Address
+    ADDRESS_PREFIX = "41"
+
+    def self.from_public_hex(public_hex)
+      raise ArgumentError, "Expected String, got #{public_hex.class}" unless public_hex.is_a?(String)
+
+      bytes = Utils.hex_to_bin(public_hex)
+      address_bytes = Utils.keccak256(bytes[1..-1])[-20..-1]
+      prefixed_address_hex = ADDRESS_PREFIX + RLP::Utils.encode_hex(address_bytes)
+      prefixed_address_bytes = Utils.hex_to_bin(prefixed_address_hex)
+      checksum = Utils.base58check(prefixed_address_bytes).hexdigest[0..7]
+      base58check_adress = Base58.encode_hex(prefixed_address_hex + checksum)
+
+      Address.new(base58check_adress)
+    end
+
+    attr_reader :address
+
+    def initialize(address)
+      raise ArgumentError, "Expected String, got #{address.class}" unless address.is_a?(String)
+
+      @address = Utils.prefix_hex(address)
+    end
+
+    def checksum_matches?
+      computed_checksum = Utils.sha256(
+        Utils.sha256(to_bytes).digest
+      ).hexdigest[0..7]
+
+      checksum_hex == computed_checksum
+    end
+    alias_method :valid?, :checksum_matches?
+
+    def to_bytes
+      Utils.hex_to_bin(to_base58_decode_hex)[0..-5]
+    end
+
+    def to_base58_decode_hex
+      Utils.base58_decode_hex(address)
+    end
+
+    def to_hex
+      Utils.base58_decode_hex(address)[0..-9]
+    end
+
+    def to_s
+      Utils.remove_hex_prefix(address)
+    end
+
+    private
+
+    def checksum_bytes
+      bytes[0..3]
+    end
+
+    def checksum_hex
+      to_base58_decode_hex[-8..-1]
+    end
+  end
+end

data/lib/trx/http_client.rb

@@ -0,0 +1,34 @@
+module Trx
+  class HttpClient
+    attr_reader :host, :timeout, :trongrig_token, :headers, :raise_error
+
+    MAINNET_HOST = "https://api.trongrid.io"
+    SHASTA_HOST = "https://api.shasta.trongrid.io"
+    NILE_HOST = "https://nile.trongrid.io"
+
+    def initialize(host = nil, timeout: 10, trongrig_token: nil, headers: {}, raise_error: true)
+      @host = host
+      @timeout = timeout
+      @trongrig_token = trongrig_token
+      @headers = headers
+      @raise_error = raise_error
+    end
+
+    def perform_command(command, params, method: :post)
+      connection.public_send(method, command, params).body
+    end
+
+    private
+
+    def connection
+      @_connection ||= Faraday.new(host) do |builder|
+        builder.options.timeout = timeout
+        builder.use Faraday::Response::RaiseError if raise_error
+        builder.request :url_encoded
+        builder.response :json
+        builder.adapter Faraday.default_adapter
+        builder.headers['TRON-PRO-API-KEY'] = trongrig_token unless trongrig_token.nil?
+      end
+    end
+  end
+end

data/lib/trx/key.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Trx
+  class Key
+    attr_reader :private_key, :public_key
+
+    def initialize(priv: nil)
+
+      # Creates a new, randomized libsecp256k1 context.
+      ctx = Secp256k1::Context.new context_randomization_bytes: SecureRandom.random_bytes(32)
+
+      key = if priv.nil?
+              # Creates a new random key pair (public, private).
+              ctx.generate_key_pair
+            else
+
+              # Converts hex private keys to binary strings.
+              priv = Utils.hex_to_bin priv if Utils.is_hex? priv
+
+              # Creates a keypair from existing private key data.
+              ctx.key_pair_from_private_key priv
+            end
+
+      # Sets the attributes.
+      @private_key = key.private_key
+      @public_key = key.public_key
+    end
+
+    def private_hex
+      Utils.bin_to_hex @private_key.data
+    end
+
+    def private_bytes
+      @private_key.data
+    end
+
+    def public_hex
+      Utils.bin_to_hex @public_key.uncompressed
+    end
+
+    def public_hex_compressed
+      Utils.bin_to_hex @public_key.compressed
+    end
+
+    def public_bytes
+      @public_key.uncompressed
+    end
+
+    def public_bytes_compressed
+      @public_key.compressed
+    end
+
+    def address
+      Address.from_public_hex public_hex
+    end
+
+    def sign(blob)
+      context = Secp256k1::Context.new
+      compact, recovery_id = context.sign_recoverable(@private_key, blob).compact
+      signature = compact.bytes
+      is_leading_zero = true
+      signature.append recovery_id
+
+      # TODO: WTF? It is necessary?
+
+      # [recovery_id].pack("N").unpack("C*").each do |byte|
+      #   is_leading_zero = false if byte > 0 and is_leading_zero
+      #   unless is_leading_zero and byte === 0
+      #     signature.append recovery_id
+      #   end
+      # end
+
+      Utils.bin_to_hex signature.pack "c*"
+    end
+
+    def personal_sign(message)
+      prefixed_message = Signature.prefix_message message
+      hashed_message = Utils.keccak256 prefixed_message
+      sign hashed_message
+    end
+  end
+end

data/lib/trx/signature.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Trx
+  module Signature
+    class SignatureError < StandardError; end
+    extend self
+
+    PREFIX_BYTE = "\x19".freeze
+
+    def prefix_message(message)
+      "#{PREFIX_BYTE}Tron Signed Message:\n#{message.size}#{message}"
+    end
+  end
+end

data/lib/trx/utils.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Trx
+  module Utils
+    extend self
+
+    def hex_to_bin(string)
+      RLP::Utils.decode_hex remove_hex_prefix(string)
+    end
+
+    def bin_to_hex(bytes)
+      RLP::Utils.encode_hex bytes
+    end
+
+    def remove_hex_prefix(string)
+      string[0, 2] == "0x" ? string[2..-1] : string
+    end
+
+    def prefix_hex(hex)
+      hex.match(/\A0x/) ? hex : "0x#{hex}"
+    end
+
+    def keccak256(value)
+      Digest::Keccak.new(256).digest(value)
+    end
+
+    def base58check(value)
+      sha256(sha256(value).digest)
+    end
+
+    def base58_decode_hex(hex)
+      Base58.decode_hex(remove_hex_prefix(hex))
+    end
+
+    def sha256(value)
+      hash = OpenSSL::Digest.new("SHA256")
+      hash.update(value)
+
+      hash
+    end
+
+    def is_hex?(str)
+      return false unless str.is_a? String
+      str = remove_hex_prefix str
+      str.match /\A[0-9a-fA-F]*\z/
+    end
+  end
+end

data/lib/trx/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Trx
+  VERSION = "0.2.2"
+end

data/lib/trx.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "digest/keccak"
+require "rlp"
+require "openssl"
+require "base58-alphabets"
+require "rbsecp256k1"
+require "securerandom"
+require "faraday"
+require "active_support"
+require "active_support/core_ext"
+
+require_relative "trx/utils"
+require_relative "trx/signature"
+require_relative "trx/key"
+require_relative "trx/address"
+require_relative "trx/version"
+require_relative "trx/http_client"
+require_relative "trx/abi"
+require_relative "trx/abi/encoder"
+require_relative "trx/abi/decoder"
+require_relative "trx/abi/function"
+require_relative "trx/abi/function_input"
+require_relative "trx/abi/function_output"
+require_relative "trx/abi/contract_event"
+
+module Trx
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification
+name: trx
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Anton Kostyuk
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: ecdsa
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: keccak
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: rlp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.3
+- !ruby/object:Gem::Dependency
+  name: rbsecp256k1
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: securerandom
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: base58-alphabets
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+description: ''
+email:
+- anton.kostuk.2012@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/trx.rb
+- lib/trx/abi.rb
+- lib/trx/abi/contract_event.rb
+- lib/trx/abi/decoder.rb
+- lib/trx/abi/encoder.rb
+- lib/trx/abi/function.rb
+- lib/trx/abi/function_input.rb
+- lib/trx/abi/function_output.rb
+- lib/trx/address.rb
+- lib/trx/http_client.rb
+- lib/trx/key.rb
+- lib/trx/signature.rb
+- lib/trx/utils.rb
+- lib/trx/version.rb
+homepage: https://github.com/RainbowPonny/trx-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/RainbowPonny/trx-rb
+  source_code_uri: https://github.com/RainbowPonny/trx-rb
+  changelog_uri: https://github.com/RainbowPonny/trx-rb
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: TRON HTTP API client
+test_files: []