xrpl-ruby 0.7.0 → 0.8.0

data/lib/xrpl/client.rb

@@ -52,13 +52,18 @@ module XRPL
     # @param logger [Logger, nil] optional logger for diagnostic messages. When nil
     #   (the default), the client stays silent — a library must not write to the
     #   host application's stdout uninvited. Pass e.g. +Logger.new($stdout)+ to opt in.
-    def initialize(url, logger: nil)
+    # @param max_fee_drops [Integer] cap for the fee autofill computes, so a
+    #   spike in the open ledger fee cannot burn an account. Transactions that
+    #   cost an owner reserve (AccountDelete, AMMCreate, VaultCreate) are not
+    #   capped.
+    def initialize(url, logger: nil, max_fee_drops: Fee::MAX_FEE_DROPS)
       @url = resolve_url(url)
       @connection = nil
       @requests = {}
       @open = false
       @ready_queue = Queue.new
       @logger = logger
+      @max_fee_drops = max_fee_drops
     end
 
     # Opens the WebSocket connection.
@@ -319,13 +324,17 @@ module XRPL
     # Fills in the fields a transaction needs before signing: +Sequence+, +Fee+
     # and +LastLedgerSequence+. Existing values are never overwritten.
     #
+    # The fee follows the transaction type (see XRPL::Fee): an EscrowFinish
+    # pays for its Fulfillment, AccountDelete, AMMCreate and VaultCreate cost
+    # the owner reserve, a Batch pays for its inner transactions.
+    #
     # @param transaction [Hash, XRPL::Transaction] the transaction to complete.
     # @param signers_count [Integer] number of signatures for multisign fee scaling.
     # @return [Hash] a copy of the transaction with the missing fields filled in.
     def autofill(transaction, signers_count: 0)
       tx = self.class.to_transaction_hash(transaction).dup
       tx['Sequence'] ||= fetch_sequence(tx.fetch('Account'))
-      tx['Fee'] ||= calculate_fee(signers_count)
+      tx['Fee'] ||= calculate_fee(tx, signers_count)
       tx['LastLedgerSequence'] ||= current_ledger_index + LEDGER_OFFSET
       tx
     end
@@ -440,10 +449,14 @@ module XRPL
       Integer(sequence)
     end
 
-    def calculate_fee(signers_count)
-      base = base_fee_drops
-      total = signers_count.to_i.positive? ? base * (1 + signers_count.to_i) : base
-      total.to_s
+    def calculate_fee(tx, signers_count)
+      Fee.calculate(
+        tx,
+        base_fee: base_fee_drops,
+        signers_count: signers_count.to_i,
+        max_fee: @max_fee_drops,
+        owner_reserve: -> { owner_reserve_drops }
+      ).to_s
     end
 
     def base_fee_drops
@@ -455,6 +468,17 @@ module XRPL
       DEFAULT_FEE_DROPS
     end
 
+    # The owner reserve (reserve_inc), which AccountDelete, AMMCreate and
+    # VaultCreate cost instead of a fee. There is no sensible default: a
+    # guess would be rejected or overpay by orders of magnitude.
+    def owner_reserve_drops
+      response = request_with_retry('server_state')
+      reserve = response.dig('result', 'state', 'validated_ledger', 'reserve_inc')
+      raise TransactionError, 'Could not determine the owner reserve from server_state' unless reserve
+
+      Integer(reserve)
+    end
+
     def current_ledger_index
       response = request_with_retry('ledger_current')
       index = response.dig('result', 'ledger_current_index')

data/lib/xrpl/fee.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module XRPL
+  # The fee a transaction needs, in drops, by transaction type.
+  #
+  # rippled charges most transactions the network's base fee, but not all of
+  # them: an EscrowFinish pays for the size of its Fulfillment, AccountDelete,
+  # AMMCreate and VaultCreate cost an owner reserve rather than a fee, a Batch
+  # pays for its inner transactions, and the confidential MPT transactions
+  # cost ten base fees. Multisigning adds one base fee per signature. The
+  # rules are the ones xrpl.js applies in its autofill.
+  #
+  # This module is pure: it takes the base fee and, when a type needs it, a
+  # way to get the owner reserve. XRPL::Client wires it to the ledger.
+  module Fee
+    # Where an ordinary fee is capped, so that a spike in the open ledger fee
+    # cannot burn an account. The reserve-priced types are not capped: their
+    # cost is what it is.
+    MAX_FEE_DROPS = 2_000_000
+
+    # Types whose cost is the owner reserve (reserve_inc), not a fee.
+    RESERVE_PRICED = %w[AccountDelete AMMCreate VaultCreate].freeze
+
+    # rippled's kCONFIDENTIAL_FEE_MULTIPLIER: extra base fees on top of the
+    # standard one, so ten in total.
+    CONFIDENTIAL_MPT_MULTIPLIER = 9
+
+    CONFIDENTIAL_MPT_TYPES = %w[
+      ConfidentialMPTConvert ConfidentialMPTConvertBack ConfidentialMPTSend
+      ConfidentialMPTClawback ConfidentialMPTMergeInbox
+    ].freeze
+
+    module_function
+
+    # @param transaction [Hash, XRPL::Transaction] the transaction, with its
+    #   TransactionType
+    # @param base_fee [Integer] the network's base fee in drops
+    # @param signers_count [Integer] number of signatures for multisign scaling
+    # @param max_fee [Integer] cap for ordinary fees
+    # @param owner_reserve [Integer, #call, nil] the owner reserve in drops,
+    #   or something that fetches it; only consulted for the reserve-priced
+    #   types
+    # @return [Integer] the fee in drops, rounded up
+    def calculate(transaction, base_fee:, signers_count: 0, max_fee: MAX_FEE_DROPS, owner_reserve: nil)
+      tx = transaction.respond_to?(:to_h) ? transaction.to_h : transaction
+      type = tx['TransactionType'] || tx[:TransactionType]
+      base_fee = Integer(base_fee)
+
+      fee = Rational(base_fee)
+      reserve_priced = RESERVE_PRICED.include?(type)
+
+      if type == 'EscrowFinish' && tx['Fulfillment']
+        # Base fee × (33 + Fulfillment size in bytes / 16)
+        bytes = (tx['Fulfillment'].to_s.length + 1) / 2
+        fee = base_fee * (33 + Rational(bytes, 16))
+      elsif reserve_priced
+        fee = Rational(resolve_owner_reserve(owner_reserve, type))
+      elsif type == 'Batch'
+        inner = Array(tx['RawTransactions']).sum(0r) do |raw|
+          calculate(raw['RawTransaction'] || raw, base_fee: base_fee, max_fee: max_fee,
+                                                  owner_reserve: owner_reserve)
+        end
+        fee = base_fee * 2 + inner
+      elsif CONFIDENTIAL_MPT_TYPES.include?(type)
+        fee += base_fee * CONFIDENTIAL_MPT_MULTIPLIER
+      end
+
+      # Multisigned: base fee × (1 + number of signatures)
+      fee += base_fee * signers_count if signers_count.to_i.positive?
+
+      fee = [fee, Rational(max_fee)].min unless reserve_priced
+      fee.ceil
+    end
+
+    def resolve_owner_reserve(owner_reserve, type)
+      reserve = owner_reserve.respond_to?(:call) ? owner_reserve.call : owner_reserve
+      raise ArgumentError, "#{type} costs the owner reserve, which was not given" if reserve.nil?
+
+      Integer(reserve)
+    end
+  end
+end

data/lib/xrpl/ledger_entry.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module XRPL
+  # A ledger entry - AccountRoot, RippleState, Offer, Escrow and the other
+  # objects that make up the ledger's state - built from LEDGER_ENTRY_FORMATS
+  # in definitions.json, the same way XRPL::Transaction is built from
+  # TRANSACTION_FORMATS.
+  #
+  #     entry = XRPL::LedgerEntry.from(response.dig('result', 'node'))
+  #     entry.class          # => XRPL::LedgerEntry::AccountRoot
+  #     entry.balance        # => "370000000"
+  #     entry.flag?(:lsf_default_ripple)
+  #     entry.flag_names     # => ["lsfDefaultRipple"]
+  #
+  # Where rippled hands out the entry's own hash under "index" (ledger_entry,
+  # account_objects, ledger_data), that value is kept as #index; it is not a
+  # field of the object and is left out of #to_h.
+  class LedgerEntry < Model
+    # Fields every ledger entry carries, regardless of type.
+    COMMON_FORMAT = DEFINITIONS['LEDGER_ENTRY_FORMATS'].fetch('common').freeze
+
+    # LEDGER_ENTRY_FLAGS keys DirectoryNode's flags under rippled's short
+    # name for the type.
+    FLAG_ALIASES = { 'DirectoryNode' => 'DirNode' }.freeze
+
+    # The entry's hash, as rippled reports it under "index".
+    attr_accessor :index
+
+    class << self
+      # The ledger's name for this entry type, e.g. "AccountRoot".
+      alias ledger_entry_type type_name
+
+      def type_field
+        'LedgerEntryType'
+      end
+
+      def label
+        'ledger entry'
+      end
+    end
+
+    def []=(name, value)
+      if name.to_s == 'index'
+        @index = value
+        return
+      end
+
+      super
+    end
+
+    define_types!(DEFINITIONS['LEDGER_ENTRY_FORMATS'], DEFINITIONS['LEDGER_ENTRY_FLAGS'], FLAG_ALIASES)
+  end
+end

data/lib/xrpl/model.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module XRPL
+  # Common ground for the objects definitions.json describes field by field:
+  # transactions (TRANSACTION_FORMATS) and ledger entries (LEDGER_ENTRY_FORMATS).
+  #
+  # A family - XRPL::Transaction, XRPL::LedgerEntry - is a subclass that names
+  # the type field ("TransactionType", "LedgerEntryType") and calls
+  # .define_types! with the right tables. That creates one class per entry in
+  # the table, with an accessor for every field the type accepts and a
+  # constant for every flag it defines. None of them is written by hand, so
+  # syncing definitions.json updates them all and they cannot drift.
+  #
+  # Fields are written in snake_case and stored under the ledger's own
+  # PascalCase names, so #to_h hands the binary codec exactly what it expects.
+  class Model
+    # Raised when required fields are missing or a field is not part of the
+    # type.
+    class ValidationError < StandardError; end
+
+    # rippled's SOEStyle: what the format says about a field.
+    REQUIRED = 0
+    OPTIONAL = 1
+    DEFAULT = 2
+
+    DEFINITIONS = BinaryCodec::Definitions.instance.raw
+
+    # Ledger field name -> snake_case accessor, and back.
+    #
+    # XChain, NFToken and MPToken are brand names rather than acronyms, so they
+    # are folded to a single word the way the reference SDKs write them.
+    def self.underscore(name)
+      name
+        .sub(/\AXChain/, 'Xchain')
+        .sub(/\ANFToken/, 'Nftoken')
+        .sub(/\AMPToken/, 'Mptoken')
+        .gsub(/([A-Z]{2,})s(?=[A-Z]|\z)/) { "#{Regexp.last_match(1).capitalize}s" }
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .downcase
+    end
+
+    FIELD_TO_ACCESSOR = DEFINITIONS['FIELDS'].to_h { |name, _| [name, underscore(name)] }.freeze
+    ACCESSOR_TO_FIELD = FIELD_TO_ACCESSOR.invert.freeze
+
+    if ACCESSOR_TO_FIELD.size != FIELD_TO_ACCESSOR.size
+      raise "Ambiguous accessor names in definitions.json"
+    end
+
+    class << self
+      # The ledger's name for this type, e.g. "Payment" or "AccountRoot".
+      attr_reader :type_name
+
+      # Ledger field name -> optionality, including the common fields.
+      attr_reader :format
+
+      # Flag name -> bit, e.g. "tfPartialPayment" => 131072.
+      attr_reader :flags
+
+      # The field that names the type: "TransactionType" or "LedgerEntryType".
+      # A family defines it.
+      def type_field
+        raise NotImplementedError, "#{name}.type_field"
+      end
+
+      # How the family reads in an error message, e.g. "transaction".
+      def label
+        raise NotImplementedError, "#{name}.label"
+      end
+
+      # Required by the format, but supplied by a later step (autofill,
+      # signing) rather than by the caller. Not demanded by #validate!.
+      def supplied_later
+        []
+      end
+
+      # The class for a type name, or nil if the ledger has no such type.
+      def for(type)
+        const_get(type) if const_defined?(type, false)
+      end
+
+      # Build the right subclass from a hash, PascalCase or snake.
+      def from(hash)
+        type = hash[type_field] || hash[type_field.to_sym] || hash[underscore(type_field).to_sym]
+        raise ValidationError, "#{label.capitalize} hash has no #{type_field}" unless type
+
+        klass = self.for(type.to_s)
+        raise ValidationError, "Unknown #{label} type #{type}" unless klass
+
+        klass.new(hash)
+      end
+
+      # Translates an accessor name to the ledger's field name.
+      def resolve(name)
+        key = name.to_s
+        return key if FIELD_TO_ACCESSOR.key?(key)
+
+        ACCESSOR_TO_FIELD[key] || key
+      end
+
+      # Builds one subclass per type in +formats+, with an accessor for every
+      # field the type accepts and a constant for every flag it defines.
+      #
+      # @param formats [Hash] a *_FORMATS table, with its "common" entry
+      # @param flags [Hash] the matching *_FLAGS table
+      # @param flag_aliases [Hash] type name -> key in +flags+, where they differ
+      def define_types!(formats, flags, flag_aliases = {})
+        common = formats.fetch('common')
+
+        formats.each do |type, own_format|
+          next if type == 'common'
+
+          format = (common + own_format)
+                   .to_h { |field| [field['name'], field['optionality']] }
+                   .freeze
+
+          klass = Class.new(self)
+          klass.instance_variable_set(:@type_name, type)
+          klass.instance_variable_set(:@format, format)
+          klass.instance_variable_set(:@flags, (flags[flag_aliases.fetch(type, type)] || {}).freeze)
+
+          format.each_key do |field|
+            next if field == type_field
+
+            accessor = FIELD_TO_ACCESSOR[field] or next
+
+            klass.define_method(accessor) { self[field] }
+            klass.define_method("#{accessor}=") { |value| self[field] = value }
+          end
+
+          klass.flags.each do |flag, bit|
+            klass.const_set(underscore(flag).upcase, bit)
+          end
+
+          const_set(type, klass)
+        end
+      end
+    end
+
+    def initialize(fields = {})
+      @fields = {}
+      fields.each { |name, value| self[name] = value }
+    end
+
+    # Reads a field by accessor name, symbol or ledger name.
+    def [](name)
+      @fields[self.class.resolve(name)]
+    end
+
+    # Writes a field, rejecting anything the type does not define. The type
+    # field itself is accepted, and checked, so a hash read off the ledger can
+    # be passed in whole.
+    def []=(name, value)
+      field = self.class.resolve(name)
+
+      if field == self.class.type_field
+        return if value.to_s == self.class.type_name
+
+        raise ValidationError, "#{self.class.type_name} cannot carry #{field} #{value}"
+      end
+
+      unless self.class.format.key?(field)
+        raise ValidationError, "#{self.class.type_name} has no field #{field}"
+      end
+
+      value.nil? ? @fields.delete(field) : @fields[field] = value
+    end
+
+    # The object as the binary codec wants it: ledger field names, with the
+    # type field filled in.
+    def to_h
+      { self.class.type_field => self.class.type_name }.merge(@fields)
+    end
+    alias to_hash to_h
+
+    # Fields the format requires that have not been set, ignoring the ones a
+    # later step provides.
+    def missing_fields
+      self.class.format
+          .select { |_, optionality| optionality == REQUIRED }
+          .keys
+          .reject { |field| field == self.class.type_field }
+          .reject { |field| self.class.supplied_later.include?(field) || @fields.key?(field) }
+    end
+
+    def valid?
+      missing_fields.empty?
+    end
+
+    # Raises unless every required field is present.
+    def validate!
+      missing = missing_fields
+      return self if missing.empty?
+
+      raise ValidationError,
+            "#{self.class.type_name} is missing #{missing.join(', ')}"
+    end
+
+    # Whether a flag is set in Flags. Takes the ledger's name
+    # ("lsfDefaultRipple"), the constant's name (:lsf_default_ripple) or the
+    # bit itself.
+    def flag?(flag)
+      (self['Flags'].to_i & self.class.flag_bit(flag)) != 0
+    end
+
+    # The names of the flags set in Flags, in the ledger's spelling.
+    def flag_names
+      value = self['Flags'].to_i
+      self.class.flags.select { |_, bit| (value & bit) != 0 }.keys
+    end
+
+    # The bit for a flag given by ledger name, constant name or bit.
+    def self.flag_bit(flag)
+      return flag if flag.is_a?(Integer)
+
+      key = flag.to_s
+      _, bit = flags.find { |name, _| name == key || underscore(name) == key.downcase }
+      bit or raise ArgumentError, "#{type_name} has no flag #{flag}"
+    end
+
+    # The serialised object, as hex.
+    def to_blob
+      BinaryCodec.json_to_binary(to_h)
+    end
+
+    def ==(other)
+      other.is_a?(Model) && other.to_h == to_h
+    end
+    alias eql? ==
+
+    def hash
+      to_h.hash
+    end
+
+    def inspect
+      "#<#{self.class.name} #{to_h.inspect}>"
+    end
+  end
+end

data/lib/xrpl/transaction.rb

@@ -3,8 +3,8 @@
 module XRPL
   # A transaction, built from the field formats in definitions.json.
   #
-  # The subclasses below are not written by hand: one is created for each entry
-  # in TRANSACTION_FORMATS when this file loads, so syncing definitions.json
+  # The subclasses are not written by hand: one is created for each entry in
+  # TRANSACTION_FORMATS when this file loads, so syncing definitions.json
   # updates the models with it and they cannot drift from the ledger.
   #
   #     tx = XRPL::Transaction::Payment.new(
@@ -18,19 +18,9 @@ module XRPL
   # Fields are given in snake_case and stored under the ledger's own PascalCase
   # names, so #to_h hands the binary codec exactly what it expects. A plain
   # Hash still works everywhere a transaction is accepted; these classes are an
-  # addition, not a replacement.
-  class Transaction
-    # Raised when required fields are missing or a field is not part of the
-    # transaction type.
-    class ValidationError < StandardError; end
-
-    # rippled's SOEStyle: what the format says about a field.
-    REQUIRED = 0
-    OPTIONAL = 1
-    DEFAULT = 2
-
-    DEFINITIONS = BinaryCodec::Definitions.instance.raw
-
+  # addition, not a replacement. The machinery lives in XRPL::Model and is
+  # shared with XRPL::LedgerEntry.
+  class Transaction < Model
     # Fields every transaction carries, regardless of type.
     COMMON_FORMAT = DEFINITIONS['TRANSACTION_FORMATS'].fetch('common').freeze
 
@@ -41,162 +31,23 @@ module XRPL
       TransactionType Sequence Fee SigningPubKey TxnSignature LastLedgerSequence
     ].freeze
 
-    # Ledger field name -> snake_case accessor, and back.
-    #
-    # XChain, NFToken and MPToken are brand names rather than acronyms, so they
-    # are folded to a single word the way the reference SDKs write them.
-    def self.underscore(name)
-      name
-        .sub(/\AXChain/, 'Xchain')
-        .sub(/\ANFToken/, 'Nftoken')
-        .sub(/\AMPToken/, 'Mptoken')
-        .gsub(/([A-Z]{2,})s(?=[A-Z]|\z)/) { "#{Regexp.last_match(1).capitalize}s" }
-        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-        .downcase
-    end
-
-    FIELD_TO_ACCESSOR = DEFINITIONS['FIELDS'].to_h { |name, _| [name, underscore(name)] }.freeze
-    ACCESSOR_TO_FIELD = FIELD_TO_ACCESSOR.invert.freeze
-
-    if ACCESSOR_TO_FIELD.size != FIELD_TO_ACCESSOR.size
-      raise "Ambiguous accessor names in definitions.json"
-    end
-
     class << self
       # The ledger's name for this transaction type, e.g. "Payment".
-      attr_reader :transaction_type
-
-      # Ledger field name -> optionality, including the common fields.
-      attr_reader :format
-
-      # Flag name -> bit, e.g. "tfPartialPayment" => 131072.
-      attr_reader :flags
-    end
-
-    # The class for a transaction type name, or nil if the ledger has no such
-    # type.
-    def self.for(type)
-      const_get(type) if const_defined?(type, false)
-    end
+      alias transaction_type type_name
 
-    # Build the right subclass from a transaction hash, PascalCase or snake.
-    def self.from(hash)
-      type = hash['TransactionType'] || hash[:TransactionType] || hash[:transaction_type]
-      raise ValidationError, 'Transaction hash has no TransactionType' unless type
-
-      klass = self.for(type.to_s)
-      raise ValidationError, "Unknown transaction type #{type}" unless klass
-
-      klass.new(hash)
-    end
-
-    def initialize(fields = {})
-      @fields = {}
-      fields.each { |name, value| self[name] = value }
-    end
-
-    # Reads a field by accessor name, symbol or ledger name.
-    def [](name)
-      @fields[self.class.resolve(name)]
-    end
-
-    # Writes a field, rejecting anything the type does not define.
-    def []=(name, value)
-      field = self.class.resolve(name)
-
-      unless self.class.format.key?(field)
-        raise ValidationError, "#{self.class.transaction_type} has no field #{field}"
+      def type_field
+        'TransactionType'
       end
 
-      value.nil? ? @fields.delete(field) : @fields[field] = value
-    end
-
-    # Translates an accessor name to the ledger's field name.
-    def self.resolve(name)
-      key = name.to_s
-      return key if FIELD_TO_ACCESSOR.key?(key)
-
-      ACCESSOR_TO_FIELD[key] || key
-    end
-
-    # The transaction as the binary codec wants it: ledger field names, with
-    # TransactionType filled in.
-    def to_h
-      { 'TransactionType' => self.class.transaction_type }.merge(@fields)
-    end
-    alias to_hash to_h
-
-    # Fields the format requires that have not been set, ignoring the ones
-    # autofill and signing provide.
-    def missing_fields
-      self.class.format
-          .select { |field, optionality| optionality == REQUIRED }
-          .keys
-          .reject { |field| SUPPLIED_LATER.include?(field) || @fields.key?(field) }
-    end
-
-    def valid?
-      missing_fields.empty?
-    end
-
-    # Raises unless every required field is present.
-    def validate!
-      missing = missing_fields
-      return self if missing.empty?
-
-      raise ValidationError,
-            "#{self.class.transaction_type} is missing #{missing.join(', ')}"
-    end
-
-    # The serialised transaction, as hex.
-    def to_blob
-      BinaryCodec.json_to_binary(to_h)
-    end
-
-    def ==(other)
-      other.is_a?(Transaction) && other.to_h == to_h
-    end
-    alias eql? ==
-
-    def hash
-      to_h.hash
-    end
-
-    def inspect
-      "#<#{self.class.name} #{to_h.inspect}>"
-    end
-
-    # Builds one subclass per transaction type, with an accessor for every
-    # field the type accepts and a constant for every flag it defines.
-    def self.define_types!
-      DEFINITIONS['TRANSACTION_FORMATS'].each do |type, own_format|
-        next if type == 'common'
-
-        format = (COMMON_FORMAT + own_format)
-                 .to_h { |field| [field['name'], field['optionality']] }
-                 .freeze
-
-        klass = Class.new(self)
-        klass.instance_variable_set(:@transaction_type, type)
-        klass.instance_variable_set(:@format, format)
-        klass.instance_variable_set(:@flags, (DEFINITIONS['TRANSACTION_FLAGS'][type] || {}).freeze)
-
-        format.each_key do |field|
-          accessor = FIELD_TO_ACCESSOR[field] or next
-
-          klass.define_method(accessor) { self[field] }
-          klass.define_method("#{accessor}=") { |value| self[field] = value }
-        end
-
-        klass.flags.each do |name, bit|
-          klass.const_set(underscore(name).upcase, bit)
-        end
+      def label
+        'transaction'
+      end
 
-        const_set(type, klass)
+      def supplied_later
+        SUPPLIED_LATER
       end
     end
 
-    define_types!
+    define_types!(DEFINITIONS['TRANSACTION_FORMATS'], DEFINITIONS['TRANSACTION_FLAGS'])
   end
 end

data/lib/xrpl/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module XRPL
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/lib/xrpl-ruby.rb

@@ -40,6 +40,9 @@ require_relative 'key-pairs/ed25519'
 require_relative 'key-pairs/secp256k1'
 require_relative 'key-pairs/key_pairs'
 
+require_relative 'xrpl/model'
 require_relative 'xrpl/transaction'
+require_relative 'xrpl/ledger_entry'
+require_relative 'xrpl/fee'
 require_relative 'xrpl/client'
 require_relative 'xrpl/faucet'