amounts 0.0.7 → 0.1.0

data/lib/amount/active_record.rb

@@ -24,6 +24,17 @@ class Amount
   #     has_amount :fee, symbol: :SOL
   #   end
   module ActiveRecord
+    # English defaults for the validator's error keys. Apps override them in
+    # their own locale files.
+    LOCALE_PATH = File.expand_path("active_record/locale/en.yml", __dir__).freeze
+
+    # Registers the gem's locale file with I18n, once.
+    #
+    # @return [void]
+    def self.install_locale!
+      ::I18n.load_path << LOCALE_PATH unless ::I18n.load_path.include?(LOCALE_PATH)
+    end
+
     # Installs the migration DSL and model macros into ActiveRecord.
     #
     # This is called automatically when the file is required.
@@ -41,4 +52,5 @@ class Amount
   end
 end
 
+Amount::ActiveRecord.install_locale!
 Amount::ActiveRecord.install!

data/lib/amount/compact.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+class Amount
+  # Internal: compact notation for large numbers, used by `ui(compact: true)`.
+  #
+  # A number of at least one thousand is divided by the largest scale it
+  # reaches (thousand, million, ... up to decillion, 10**33), rounded to a number of
+  # significant digits in the given direction, trimmed of trailing zeros and
+  # joined with a scale word:
+  #
+  # - when localizing, the word is `number.human.decimal_units.units.<scale>`
+  #   (pluralized with the compacted number) joined by
+  #   `number.human.decimal_units.format` (default `"%n %u"`), the keys Rails'
+  #   `number_to_human` uses. A scale without a translation falls back to the
+  #   short form below.
+  # - otherwise the word is `K`, `M`, `B`, `T`, `Qa`, `Qi`, `Sx`, `Sp`, `Oc`,
+  #   `No` or `Dc`, joined as `"%n%u"`.
+  #
+  # Numbers past decillions stay in decillions (`1500Dc`).
+  #
+  # Numbers below one thousand are not compacted; {Display} formats them as
+  # usual.
+  #
+  # @example
+  #   Amount::Compact.format(BigDecimal("1999999"), precision: 3, direction: :floor, locale: nil)
+  #   # => "1.99M"
+  module Compact
+    DEFAULT_PRECISION = 3
+    SHORT_FORMAT = "%n%u"
+    LOCALE_FORMAT = "%n %u"
+    LOCALE_FORMAT_KEY = "number.human.decimal_units.format"
+    LOCALE_UNITS_KEY = "number.human.decimal_units.units"
+
+    # [exponent, I18n key, short form], smallest first.
+    SCALES = [
+      [3, :thousand, "K"],
+      [6, :million, "M"],
+      [9, :billion, "B"],
+      [12, :trillion, "T"],
+      [15, :quadrillion, "Qa"],
+      [18, :quintillion, "Qi"],
+      [21, :sextillion, "Sx"],
+      [24, :septillion, "Sp"],
+      [27, :octillion, "Oc"],
+      [30, :nonillion, "No"],
+      [33, :decillion, "Dc"]
+    ].freeze
+
+    module_function
+
+    # Reads the `compact:` option of `ui`.
+    # @param option [Boolean, Hash, nil] `true`, `false`/`nil`, or
+    #   `{ precision: Integer }`
+    # @return [Integer, nil] significant digits, or `nil` when compact
+    #   notation is off
+    # @raise [ArgumentError] for anything else
+    def precision(option)
+      case option
+      when nil, false then nil
+      when true then DEFAULT_PRECISION
+      when Hash then precision_from_hash(option)
+      else raise ArgumentError, "compact: must be true, false or { precision: Integer }, got #{option.inspect}"
+      end
+    end
+
+    # @param value [BigDecimal]
+    # @return [Boolean] whether the number is large enough to compact
+    def applies?(value)
+      value.abs >= BigDecimal(10)**SCALES.first[0]
+    end
+
+    # The compacted number with its scale word, e.g. `"1.5M"` or
+    # `"1,5 Mio."`. Call only when {applies?} is true.
+    # @param value [BigDecimal]
+    # @param precision [Integer] significant digits
+    # @param direction [Symbol] `:floor` or `:ceil`, as in `ui`
+    # @param locale [Symbol, String, nil]
+    # @return [String]
+    def format(value, precision:, direction:, locale:)
+      index = SCALES.rindex { |exponent, _, _| value.abs >= BigDecimal(10)**exponent }
+      loop do
+        mantissa, decimals = round(value, SCALES[index][0], precision, direction)
+        # Rounding up can reach the next scale: 999,999 ceils to 1000K, shown as 1M.
+        if mantissa.abs >= 1000 && index < SCALES.length - 1
+          index += 1
+          next
+        end
+
+        return join(number(mantissa, decimals, locale), mantissa, SCALES[index], locale)
+      end
+    end
+
+    # Divides by 10**exponent and rounds to `precision` significant digits.
+    # Returns the mantissa and how many decimals it may show.
+    def round(value, exponent, precision, direction)
+      mantissa = value / (BigDecimal(10)**exponent)
+      digits = [mantissa.abs.to_i.to_s.length, 1].max
+      decimals = precision - digits
+      [Display.round(mantissa, decimals, direction), [decimals, 0].max]
+    end
+
+    def number(mantissa, decimals, locale)
+      str = mantissa.to_s("F")
+      int, frac = str.split(".", 2)
+      frac = frac.to_s[0, decimals].sub(/0+\z/, "")
+      str = frac.empty? ? int : "#{int}.#{frac}"
+      locale ? Locale.apply(str, locale) : str
+    end
+
+    def join(number, mantissa, scale, locale)
+      _, key, short = scale
+      word = locale && Locale.translate("#{LOCALE_UNITS_KEY}.#{key}", locale, "", mantissa)
+      return Formattable.fill(SHORT_FORMAT, number:, label: short) if word.nil? || word.empty?
+
+      Formattable.fill(locale_format(locale), number:, label: word)
+    end
+
+    def locale_format(locale)
+      found = Locale.translate(LOCALE_FORMAT_KEY, locale, LOCALE_FORMAT)
+      Formattable.valid_template?(found) ? found : LOCALE_FORMAT
+    end
+
+    def precision_from_hash(option)
+      unknown = option.keys - [:precision]
+      raise ArgumentError, "unknown compact: option(s) #{unknown.map(&:inspect).join(', ')}" unless unknown.empty?
+
+      digits = option.fetch(:precision, DEFAULT_PRECISION)
+      return digits if digits.is_a?(Integer) && digits.positive?
+
+      raise ArgumentError, "compact: precision must be a positive Integer, got #{digits.inspect}"
+    end
+
+    private_class_method :round, :number, :join, :locale_format, :precision_from_hash
+  end
+end

data/lib/amount/{allocation.rb → concerns/allocatable.rb}

@@ -5,7 +5,7 @@ class Amount
   # `[parts, remainder]`, preserving the invariant that the parts plus
   # remainder always sum back to the receiver's atomic value (including
   # the sign).
-  module Allocation
+  module Allocatable
     # Splits into equal parts and returns the leftover explicitly.
     #
     # @param n [Integer]

data/lib/amount/{arithmetic.rb → concerns/calculable.rb}

@@ -6,10 +6,10 @@ class Amount
   #
   # All operators preserve the receiver's class via `build`, so subclass
   # identity (`GoldAmount`) survives through `+`, `-`, `*`, `/`, `abs`, `-@`.
-  module Arithmetic
+  module Calculable
     # @return [Amount]
     # @example
-    #   Amount.usdc("-1").abs
+    #   Amount.of_usdc("-1").abs
     #   # => #<Amount USDC $1.00>
     def abs
       build(@atomic.abs)
@@ -17,7 +17,7 @@ class Amount
 
     # @return [Amount]
     # @example
-    #   -Amount.usdc("1")
+    #   -Amount.of_usdc("1")
     #   # => #<Amount USDC -$1.00>
     def -@
       build(-@atomic)
@@ -27,11 +27,11 @@ class Amount
     # @return [Amount]
     # @raise [TypeMismatch]
     # @example Same-type addition
-    #   Amount.usdc("1.50") + Amount.usdc("0.50")
+    #   Amount.of_usdc("1.50") + Amount.of_usdc("0.50")
     #
     # @example Cross-type addition using a registered directional rate
     #   Amount.register_default_rate :USD, :USDC, "1"
-    #   Amount.usdc("10.00") + Amount.new("5.00", :USD)
+    #   Amount.of_usdc("10.00") + Amount.new("5.00", :USD)
     def +(other)
       rhs = coerce_other_to_self_type!(other)
       build(@atomic + rhs.atomic)
@@ -41,7 +41,7 @@ class Amount
     # @return [Amount]
     # @raise [TypeMismatch]
     # @example
-    #   Amount.usdc("2.00") - Amount.usdc("0.50")
+    #   Amount.of_usdc("2.00") - Amount.of_usdc("0.50")
     def -(other)
       rhs = coerce_other_to_self_type!(other)
       build(@atomic - rhs.atomic)
@@ -51,7 +51,7 @@ class Amount
     # @return [Amount]
     # @raise [TypeMismatch]
     # @example
-    #   Amount.usdc("1.25") * 2
+    #   Amount.of_usdc("1.25") * 2
     def *(scalar)
       ensure_scalar!(scalar)
       build((BigDecimal(@atomic) * Amount.coerce_decimal(scalar)).to_i)
@@ -61,10 +61,10 @@ class Amount
     # @return [Amount, BigDecimal]
     # @raise [TypeMismatch, ZeroDivisionError]
     # @example Dividing by a scalar returns an amount
-    #   Amount.usdc("1.00") / 2
+    #   Amount.of_usdc("1.00") / 2
     #
     # @example Dividing by an amount returns a ratio
-    #   Amount.usdc("10.00") / Amount.usdc("2.00")
+    #   Amount.of_usdc("10.00") / Amount.of_usdc("2.00")
     def /(other)
       if other.is_a?(Amount)
         ensure_same_type!(other)

data/lib/amount/concerns/coercible.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+class Amount
+  # Concern: bringing the other side of an operation into a usable form.
+  #
+  # - {ClassMethods#coerce_decimal} turns a scalar, rate or display-unit scale
+  #   into a `BigDecimal` without losing a `Rational`.
+  # - The private instance helpers bring another amount to the receiver's
+  #   type. They only cross types through a registered directional default
+  #   rate; without one they raise {TypeMismatch} (or return `nil` for
+  #   comparisons). There is no implicit conversion.
+  module Coercible
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class-level methods extended onto any class that does `include Coercible`.
+    module ClassMethods
+      # Coerces a numeric input to BigDecimal in a way that preserves Rational
+      # values. `BigDecimal(value.to_s)` raises `ArgumentError` for Rational
+      # because `Rational#to_s` produces strings like `"3/2"`. This helper is
+      # the single place every call site should use to convert a scalar / rate
+      # / display-unit scale into a BigDecimal.
+      #
+      # @param value [Numeric, BigDecimal, Rational, String]
+      # @return [BigDecimal]
+      def coerce_decimal(value)
+        case value
+        when BigDecimal then value
+        when Rational then BigDecimal(value, Float::DIG + 4)
+        else BigDecimal(value.to_s)
+        end
+      end
+    end
+
+    private
+
+    def ensure_same_type!(other)
+      return if same_type?(other)
+
+      raise TypeMismatch, type_mismatch_message(other)
+    end
+
+    # The other amount in the receiver's type: itself when the types match,
+    # converted through a registered default rate when one exists, else `nil`.
+    def coerce_other_to_self_type(other)
+      return other if same_type?(other)
+      return unless other.is_a?(Amount)
+
+      other.to(symbol)
+    rescue Registry::NoDefaultRate
+      nil
+    end
+
+    def coerce_other_to_self_type!(other)
+      coerce_other_to_self_type(other) || raise(TypeMismatch, type_mismatch_message(other))
+    end
+
+    def type_mismatch_message(other)
+      "type mismatch: #{symbol} vs #{other.is_a?(Amount) ? other.symbol : other.class}"
+    end
+  end
+end

data/lib/amount/concerns/constructible.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+class Amount
+  # Concern: how a constructor input becomes an atomic `Integer`, and which
+  # class an amount is built as.
+  #
+  # Input inference rules:
+  # - `Integer` => atomic units
+  # - `String` => UI decimal value
+  # - `Float`, `BigDecimal`, `Rational` => UI decimal value (a `Float` goes
+  #   through its string form, never through float math)
+  # - `from:` (`:atomic`, `:ui`, `:float`) overrides inference
+  #
+  # Class identity: a type registered with `class:` is always built as that
+  # class. `Amount.new` dispatches to it, and every operator that returns an
+  # amount goes through {#build} so the receiver's class carries through.
+  module Constructible
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class-level methods extended onto any class that does
+    # `include Constructible`.
+    module ClassMethods
+      # When called as `Amount.new` for a symbol whose registry entry binds a
+      # custom class, dispatch the construction to that class instead of
+      # raising. Direct calls to a subclass (`GoldAmount.new(...)`) still go
+      # through the default `Class.new` path. Calls that target the wrong
+      # subclass continue to raise from `#initialize`.
+      #
+      # @param value [Integer, String, Float, BigDecimal, Rational]
+      # @param symbol [Symbol, String]
+      # @param from [Symbol, nil]
+      # @return [Amount]
+      def new(value, symbol, from: nil)
+        if equal?(::Amount)
+          entry_class = registry.lookup(symbol.to_sym).amount_class
+          return entry_class.new(value, symbol, from:) if entry_class && entry_class != ::Amount
+        end
+        super
+      end
+    end
+
+    private
+
+    # Builds a same-symbol amount in the receiver's class. Used by every
+    # operator that returns an Amount so subclass identity propagates.
+    def build(atomic_value)
+      self.class.new(atomic_value, symbol, from: :atomic)
+    end
+
+    # A type registered with `class: GoldAmount` must be built as
+    # `GoldAmount` (or dispatched there by `Amount.new`), never as another
+    # subclass.
+    def ensure_registered_class!
+      expected = registry_entry.amount_class
+      return unless expected && expected != Amount && self.class != Amount && !instance_of?(expected)
+
+      raise InvalidInput, "use #{expected}.new for #{symbol}"
+    end
+
+    def infer_value(from, value)
+      case from || infer_type(value)
+      when :atomic then value.to_i
+      when :ui then ui_to_atomic(value)
+      when :float then ui_to_atomic(value.is_a?(Rational) ? value : value.to_s)
+      else
+        raise InvalidInput, "unknown amount format: #{value.inspect}"
+      end
+    end
+
+    def infer_type(value)
+      case value
+      when Integer then :atomic
+      when String then :ui
+      when Float, BigDecimal, Rational then :float
+      else
+        raise InvalidInput, "cannot infer type for #{value.class}"
+      end
+    end
+
+    def ui_to_atomic(value)
+      return (value * (10**decimals)).to_i if value.is_a?(Rational)
+
+      (BigDecimal(value.to_s) * (BigDecimal(10)**decimals)).to_i
+    rescue ArgumentError
+      raise InvalidInput, "cannot parse #{value.inspect} as #{symbol}"
+    end
+  end
+end

data/lib/amount/{conversion.rb → concerns/convertible.rb}

@@ -6,17 +6,17 @@ class Amount
   # default rate. The result class is taken from the target symbol's registry
   # entry, so a `class:`-registered subclass becomes the natural identity for
   # conversion outputs.
-  module Conversion
+  module Convertible
     # @param target_symbol [Symbol, String]
     # @param rate [String, Numeric, BigDecimal, nil]
     # @return [Amount]
     # @raise [Amount::Registry::NoDefaultRate] if no explicit or registered rate is available
     # @example Using an explicit one-off rate
-    #   Amount.usdc("100").to(:GOLD, rate: "0.00042")
+    #   Amount.of_usdc("100").to(:GOLD, rate: "0.00042")
     #
     # @example Using a registered default rate
     #   Amount.register_default_rate :USDC, :USD, "1"
-    #   Amount.usdc("1.50").to(:USD)
+    #   Amount.of_usdc("1.50").to(:USD)
     def to(target_symbol, rate: nil)
       target_symbol = target_symbol.to_sym
       return self.class.new(@atomic, symbol, from: :atomic) if target_symbol == symbol

data/lib/amount/concerns/formattable.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+class Amount
+  # Concern: where the number and its unit label go in decorated output.
+  #
+  # A format is a template in the style of Rails' `number.currency.format.format`:
+  # `%n` is the formatted number (sign included) and `%u` the unit label.
+  # Everything else is copied as given, so a non-breaking space in
+  # `"%n %u"` stays non-breaking.
+  #
+  # Included in {Amount}, it answers one question per amount, {#display_format}:
+  # which template does decorated `ui` output use, for this type or one of its
+  # display units, in this locale? The module functions are the template
+  # primitives the registry (validation) and {Display} (filling) share.
+  #
+  # A template is resolved, first match wins:
+  #
+  # - type: `amounts.formats.<symbol downcased>` (when localizing), then the
+  #   registered `display_format`, which the registry derives from
+  #   `display_position` when no template was given.
+  # - display unit: `amounts.display_unit_formats.<symbol downcased>.<unit>`
+  #   (when localizing), then the unit's `:format`, then its `:position`, then
+  #   the type's template as above.
+  #
+  # A locale template without `%n` is ignored, so a typo in a locale file can't
+  # drop the amount from the output.
+  #
+  # @example
+  #   Amount.register :EUR, decimals: 2, display_symbol: "€", display_format: "%u%n"
+  #   # de.yml: amounts.formats.eur: "%n %u"
+  #
+  #   Amount.of_eur("1").display_format               # => "%u%n"
+  #   Amount.of_eur("1").display_format(locale: :de)  # => "%n %u"
+  #   Amount::Formattable.fill("%n %u", number: "12,50", label: "€")
+  #   # => "12,50 €"
+  module Formattable
+    NUMBER = "%n"
+    LABEL = "%u"
+    PREFIX = "%u%n"
+    SUFFIX = "%n %u"
+
+    PLACEHOLDER = /%[nu]/
+    private_constant :PLACEHOLDER
+
+    # The template a `display_position` stands for: `:prefix` is `"%u%n"`,
+    # anything else `"%n %u"`, matching the output before templates existed.
+    # @param position [Symbol, nil]
+    # @return [String]
+    def self.template_for(position)
+      position == :prefix ? PREFIX : SUFFIX
+    end
+
+    # A usable template is a String that places the number.
+    # @param template [Object]
+    # @return [Boolean]
+    def self.valid_template?(template)
+      template.is_a?(String) && template.include?(NUMBER)
+    end
+
+    # Fills a template in one pass, so a `%` inside the number or label is
+    # never read as a placeholder.
+    # @param template [String]
+    # @param number [String] the formatted number
+    # @param label [String] the unit label
+    # @return [String]
+    def self.fill(template, number:, label:)
+      template.gsub(PLACEHOLDER, NUMBER => number, LABEL => label)
+    end
+
+    # The template decorated `ui` output uses for this amount.
+    #
+    # @param unit [Symbol, nil] a display unit, or `nil` for the type itself
+    # @param locale [Symbol, String, nil] look for a locale template too
+    #   (requires I18n). When `nil`, uses `I18n.locale` if `Amount.localize`
+    #   is true, else only the registered templates.
+    # @return [String]
+    # @raise [Registry::InvalidDisplayUnit] for an unknown display unit
+    # @example
+    #   Amount.of_usd("1").display_format                    # => "%u%n"
+    #   Amount.of_gold("1").display_format(unit: :gram)      # => "%n %u"
+    def display_format(unit: nil, locale: nil)
+      locale = Locale.effective(locale)
+      return type_display_format(locale) unless unit
+
+      spec = registry_entry.display_unit(unit)
+      (locale && locale_display_format(unit_format_key(unit), locale)) ||
+        spec[:format] ||
+        (spec[:position] && Formattable.template_for(spec[:position])) ||
+        type_display_format(locale)
+    end
+
+    private
+
+    def type_display_format(locale)
+      (locale && locale_display_format(type_format_key, locale)) ||
+        registry_entry.display_format
+    end
+
+    def locale_display_format(key, locale)
+      found = Locale.translate(key, locale, nil)
+      found if Formattable.valid_template?(found)
+    end
+
+    def type_format_key
+      "amounts.formats.#{symbol.to_s.downcase}"
+    end
+
+    def unit_format_key(unit)
+      "amounts.display_unit_formats.#{symbol.to_s.downcase}.#{unit}"
+    end
+  end
+end

data/lib/amount/concerns/localizable.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class Amount
+  # Concern: the global switch that makes output and input follow
+  # `I18n.locale` when no `locale:` is given.
+  #
+  # Every locale-aware method (`ui`, `unit_label`, `display_format`,
+  # `Amount.parse_ui`) resolves its locale through {Locale.effective}, which
+  # reads this switch.
+  #
+  # @example
+  #   Amount.localize = true
+  #   I18n.locale = :de
+  #   Amount.of_usd("1500.5").ui # formatted with de's number.format
+  module Localizable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class-level methods extended onto any class that does
+    # `include Localizable`.
+    module ClassMethods
+      # Whether `ui` formats numbers for `I18n.locale` when no `locale:` is
+      # given. Defaults to `false`.
+      # @return [Boolean]
+      def localize?
+        @localize ? true : false
+      end
+      alias localize localize?
+
+      # @param value [Boolean]
+      # @raise [ArgumentError] when enabling without I18n loaded
+      def localize=(value)
+        Locale.require_i18n! if value
+        @localize = value ? true : false
+      end
+    end
+  end
+end

data/lib/amount/{comparison.rb → concerns/orderable.rb}

@@ -3,15 +3,15 @@
 class Amount
   # Comparison, equality, hashing, and sign predicates for `Amount`.
   #
-  # Pulls in `Comparable` itself so consumers only need `include Comparison`
+  # Pulls in `Comparable` itself so consumers only need `include Orderable`
   # to get `<`, `<=`, `>`, `>=`, `between?`, `clamp`, and `Enumerable#min`/
   # `#max` alongside the explicit `<=>` / `==` / `eql?` / `hash` defined here.
-  module Comparison
+  module Orderable
     include Comparable
     # @param other [Object]
     # @return [Boolean]
     # @example
-    #   Amount.usdc("1").same_type?(Amount.usdc("2"))
+    #   Amount.of_usdc("1").same_type?(Amount.of_usdc("2"))
     #   # => true
     def same_type?(other)
       other.is_a?(Amount) && other.symbol == symbol
@@ -19,26 +19,26 @@ class Amount
 
     # @return [Boolean]
     # @example
-    #   Amount.usdc(0, from: :atomic).zero?
+    #   Amount.of_usdc(0, from: :atomic).zero?
     #   # => true
     def zero? = @atomic.zero?
 
     # @return [Boolean]
     # @example
-    #   Amount.usdc("1").positive?
+    #   Amount.of_usdc("1").positive?
     #   # => true
     def positive? = @atomic.positive?
 
     # @return [Boolean]
     # @example
-    #   Amount.usdc("-1").negative?
+    #   Amount.of_usdc("-1").negative?
     #   # => true
     def negative? = @atomic.negative?
 
     # @param other [Object]
     # @return [-1, 0, 1, nil]
     # @example
-    #   Amount.usdc("1") <=> Amount.usdc("2")
+    #   Amount.of_usdc("1") <=> Amount.of_usdc("2")
     #   # => -1
     def <=>(other)
       return nil unless other.is_a?(Amount)
@@ -52,7 +52,7 @@ class Amount
     # @param other [Object]
     # @return [Boolean]
     # @example
-    #   Amount.usdc("1.50") == Amount.usdc("1.50")
+    #   Amount.of_usdc("1.50") == Amount.of_usdc("1.50")
     #   # => true
     def ==(other)
       same_type?(other) && @atomic == other.atomic
@@ -61,7 +61,7 @@ class Amount
     # @param other [Object]
     # @return [Boolean]
     # @example Hash-key equality keeps class and symbol identity
-    #   Amount.usdc("1").eql?(Amount.usdc("1"))
+    #   Amount.of_usdc("1").eql?(Amount.of_usdc("1"))
     #   # => true
     def eql?(other)
       other.class == self.class && symbol == other.symbol && @atomic == other.atomic
@@ -69,7 +69,7 @@ class Amount
 
     # @return [Integer]
     # @example
-    #   { Amount.usdc("1") => :ok }[Amount.usdc("1")]
+    #   { Amount.of_usdc("1") => :ok }[Amount.of_usdc("1")]
     #   # => :ok
     def hash
       [self.class, symbol, @atomic].hash