Files
hash-wallet/cw_core/test/amount/money_test.dart
T
75f3fe735b Introduce Money class and refactor currency handling (#3157)
* feat: add `Money` class for precise currency handling and amount parsing

- Introduced `Money` class for handling money values with fixed-point precision.
- Added parsing and comparison methods to `CryptoCurrency` and `FiatCurrency` interfaces.
- Implemented `smartAmountSanitizer` for format normalization.

Includes extensive unit tests for validation.

* refactor: optimize Money class with new factories and string formatting improvements

* refactor: unify balance handling with `Money` refactor

* refactor: update `ElectrumBalance` and transaction logic to use `Money` for currency precision

* refactor: standardize balance handling with `Money` across `Monero`, `Wownero`, and `Zano` wallets

* refactor: migrate EVM balance and transaction handling to `Money` for consistent currency precision

* refactor: migrate Decred balance and transaction handling to `Money` for consistent currency precision

* refactor: migrate nano balance and transaction handling to `Money` for consistent currency precision

* refactor: migrate Solana balance and transaction logic to `Money` for precise currency handling

* refactor: migrate Tron balance and transaction handling to `Money` for consistent currency precision

* refactor: migrate Zcash balance and transaction handling to `Money` for consistent currency precision

* refactor: adjust lib to handle money

* refactor: remove legacy Decred amount formatting and migrate to `Money`

* refactor: migrate pending transaction amount and fee to `Money`

* refactor: migrate dEuro savings and transaction logic to `Money` for improved precision and consistency

* refactor: migrate Bitcoin and lightning transaction logic to `Money` for consistent currency precision

* refactor: migrate Wownero, EVM, Zano, and Zcash transaction logic to `Money` for consistent and precise currency handling

* refactor: standardize balance handling across wallets, migrate to `Money.zero` and refine `Balance` class for consistency

* refactor: migrate Solana transaction and wallet logic to `Money` for consistent and precise currency handling

* refactor: improve fiat balance and formatting for consistency on dashboard

* fix: fiat input mode switching and standardize crypto amount display logic

* fix: cw_evm generator

* refactor: migrate exchange amount handling to `Money` for improved precision and consistency

* test: remove redundant and commented-out tests, tidy test cases, and apply minor formatting adjustments

* fix using Money wrapper in BridgeViewModel and USDT0Service

* refactor: streamline `AmountConverter` and `LightningWallet`, add `cw_core` tests to GitHub workflow, and remove unused/deprecated logic

* refactor: enhance `changeReceiveAmount` with `isCanonical` support, improve null handling, and refine amount parsing logic

* minor fix

* try/catch the lightning log file error

* feat: add copy-to-clipboard functionality for transaction amounts, fix typo in trailing widget method name (#3219)

* Cw 1234 disallow sp and mweb addresses as refund for swaps (#3187)

* disallow SP and MWEB for swaps

* Simplify address selection in addressForExchange

Refactor addressForExchange method to simplify address selection logic.

* validate refund and receive address types

* localize address validation messages

* minor ui fix [skip ci]

* minor fix [skip ci]

* Revert "localize address validation messages"

* fix translations

---------

Co-authored-by: Omar Hatem <omarh.ismail1@gmail.com>

* refactor: replace manual amount sanitization with `sanitized()` extension across the codebase, add unit tests for `AmountSanitizer`

* fix: correct `sanitized()` test expectations for decimal handling in `amount_sanitizer_test.dart`

* refactor: fee display logic and append currency symbol in `send_confirm_sheet.dart`

* refactor: simplify `ZcashBalance` class by replacing custom fields with inherited properties, update references accordingly

* refactor: replace hardcoded USDT contract address with `DefaultTronTokens` lookup, improve maintainability

* refactor: replace `currency` with `inputAmount.currency` in Solana transaction signing methods to avoid inconsistency

* fix: handle null `fee` in `electrum_transaction_info.dart` to prevent potential runtime errors

* refactor: replace raw fee and amount handling with `Money` object for improved consistency and maintainability

* fix: limit fiat balance display to 2 decimal places in `balance_view_model.dart`

* refactor: replace raw `amount` and `fee` types with `Money` in Solana transaction methods for consistency and precision

* refactor: replace raw `amount` and `fee` handling with `Money` and improve balance calculation consistency across view models

* refactor: replace raw balance strings with `Money` and simplify `UnconfirmedBalanceModal` widget logic

* refactor: replace `print` with `printV` for better logging, add equality and hashCode overrides to `ERC20Currency` for object comparison

* feat: prepare deuro savings migration

* feat: add V1 savings migration support and improve formatting consistency in DEuro view model

* feat: add V1 savings withdrawal support and update associated UI components and logic

* refactor: replace `Image.asset` with `CakeImageWidget`, update balance string handling, and streamline address validation logic

* refactor: use `Money.tryParse` with fallback to `Money.zero` in `NanoBalance.fromRawString` for safer balance parsing

* refactor: replace `ERC20Currency` with `Erc20Token` for consistency and remove unused `evm_erc20_currency.dart` file

* refactor: add computed `hasDepositAmount` for deposit null-checks, optimize balance handling in `zano_wallet`, update Breez SDK to v0.14.0, and implement equality/hashCode for `Currency`

* refactor: rename `amountSats` to `amount` in `PrepareLnurlPayRequest` for consistency

* revert: downgrade Breez SDK to v0.11.0 in `pubspec.yaml` and update relevant references in `pubspec.lock`

* fix: use `cryptoAmount.copyWith` for currency consistency and replace `Image.asset` with `CakeImageWidget` in swap address modal

* fix: ensure currency consistency by using `cryptoAmount.copyWith` in Solana and EVM wallet transactions

* refactor: simplify CSV row generation logic by removing `_splitAmountCurrency` and streamlining amount/fee handling

* fix: LateInitializationError Field 'sdk' has not been initialized

* fix: use `Money.tryParse` for safer parsing of deposit and receive amounts

* chore: remove debug print statement

* refactor: update transaction processing to consistently use `Money` for amounts and fees

* refactor: improve currency and amount handling, simplify logic, and enhance code readability in Send and Swap pages

* refactor: integrate `DecimalInputFormatter` for consistent decimal input across Send and Swap pages, simplify input handling logic

* fix: "fiatMode" per output on sendPage

* refactor: make transaction_details_height applicable more readable

* fix: use correct base unit for deposit

* refactor: use Money in estimateFakeSendAllTxAmount method

* fix decred frozen balance
minor fixes

* fix decred frozen balance
minor fixes

* fix: automatically switch to lightning if lnurl or invoice detected

* fix: getBolt11Amount test cases

* fix: standardise crypto amount formatting and display

* fix: use base unit for Tron transaction fee parsing
* refactor: hardcode fractional digits to 8 in `AmountParsingProxy` display methods
* refactor: ensure consistent 8-decimal precision for fee formatting in `PendingTransaction`
* fix: use `AmountParsingProxy` for available balance display in exchange view model
* fix: improve amount formatting and layout in swap and send confirmation sheets
* chore: remove redundant decimal truncation in balance view model and send confirmation sheet

* fix: allow for editing text field if it is filled with "ALL"

* fix: allow for editing text field if it is filled with "ALL"

* fix: update currency detection logic for lightning mode

* avoid potential infinite loop [skip ci]

* fix: getDisplayCryptoAmount

* fix: update estimated fee calculation

* chore: simplify fee calculation logic [skip-ci]

* fix value display in hidden mode

* fix stale state in send confirm sheet

* fix decimals for mweb

* fix available balance display for sol/trx on swap

* restore proper hint text

* fix swap receive amount calculation for xno

---------

Co-authored-by: Omar Hatem <omarh.ismail1@gmail.com>
Co-authored-by: Serhii <17529954+serhii-bor@users.noreply.github.com>
Co-authored-by: Robert Malikowski <malikowskirobert@gmail.com>
2026-06-30 02:45:44 +03:00

352 lines
13 KiB
Dart

import "package:cw_core/amount/money.dart";
import "package:cw_core/crypto_currency.dart";
import "package:flutter_test/flutter_test.dart";
void main() {
group("Money", () {
test("parse", () {
var money = Money.parse("1", CryptoCurrency.btc);
expect(money.amount, BigInt.from(100000000));
money = Money.parse("-1", CryptoCurrency.btc);
expect(money.amount, BigInt.from(-100000000));
money = Money.parse("1.11", CryptoCurrency.btc);
expect(money.amount, BigInt.from(111000000));
money = Money.parse("-1.11", CryptoCurrency.btc);
expect(money.amount, BigInt.from(-111000000));
money = Money.parse("-.11", CryptoCurrency.btc);
expect(money.amount, BigInt.from(-11000000));
money = Money.parse(".11", CryptoCurrency.btc);
expect(money.amount, BigInt.from(11000000));
// Invalid representation
expect(() => Money.parse("1,11", CryptoCurrency.btc), throwsFormatException);
// To many decimals
expect(() => Money.parse("-1.000000000000000", CryptoCurrency.btc), throwsFormatException);
money = Money.parse("1", CryptoCurrency.btc, isBaseUnit: true);
expect(money.amount, BigInt.from(1));
money = Money.parse("0", CryptoCurrency.btc, isBaseUnit: true);
expect(money.amount, BigInt.from(0));
money = Money.parse("-1", CryptoCurrency.btc, isBaseUnit: true);
expect(money.amount, BigInt.from(-1));
// canonical representation when expecting base units
expect(() => Money.parse("1.0", CryptoCurrency.btc, isBaseUnit: true), throwsFormatException);
});
test("tryParse", () {
var money = Money.tryParse("1", CryptoCurrency.btc);
expect(money?.amount, BigInt.from(100000000));
money = Money.tryParse("-1", CryptoCurrency.btc);
expect(money?.amount, BigInt.from(-100000000));
money = Money.tryParse("1.11", CryptoCurrency.btc);
expect(money?.amount, BigInt.from(111000000));
money = Money.tryParse("-1.11", CryptoCurrency.btc);
expect(money?.amount, BigInt.from(-111000000));
money = Money.tryParse("-.11", CryptoCurrency.btc);
expect(money?.amount, BigInt.from(-11000000));
money = Money.tryParse(".11", CryptoCurrency.btc);
expect(money?.amount, BigInt.from(11000000));
// Invalid representation
money = Money.tryParse("1,11", CryptoCurrency.btc);
expect(money?.amount, isNull);
// To many decimals
money = Money.tryParse("-1.000000000000000", CryptoCurrency.btc);
expect(money?.amount, isNull);
money = Money.tryParse("1", CryptoCurrency.btc, isBaseUnit: true);
expect(money?.amount, BigInt.from(1));
money = Money.tryParse("0", CryptoCurrency.btc, isBaseUnit: true);
expect(money?.amount, BigInt.from(0));
money = Money.tryParse("-1", CryptoCurrency.btc, isBaseUnit: true);
expect(money?.amount, BigInt.from(-1));
// canonical representation when expecting base units
money = Money.tryParse("1.0", CryptoCurrency.btc, isBaseUnit: true);
expect(money?.amount, isNull);
});
test("sign", () {
expect(Money(BigInt.from(0), CryptoCurrency.btc).sign, 0);
expect(Money(BigInt.from(1), CryptoCurrency.btc).sign, 1);
expect(Money(BigInt.from(10), CryptoCurrency.btc).sign, 1);
expect(Money(BigInt.from(-1), CryptoCurrency.btc).sign, -1);
expect(Money(BigInt.from(-10), CryptoCurrency.btc).sign, -1);
});
test("isZero", () {
expect(Money(BigInt.from(0), CryptoCurrency.btc).isZero, isTrue);
expect(Money(BigInt.from(1), CryptoCurrency.btc).isZero, isFalse);
expect(Money(BigInt.from(-1), CryptoCurrency.btc).isZero, isFalse);
});
test("isNegative", () {
expect(Money(BigInt.from(0), CryptoCurrency.btc).isNegative, isFalse);
expect(Money(BigInt.from(1), CryptoCurrency.btc).isNegative, isFalse);
expect(Money(BigInt.from(-1), CryptoCurrency.btc).isNegative, isTrue);
});
group("Comparison", () {
final fourBitcoin = Money(BigInt.from(400000000), CryptoCurrency.btc);
final fiveBitcoin = Money(BigInt.from(500000000), CryptoCurrency.btc);
final sixBitcoin = Money(BigInt.from(600000000), CryptoCurrency.btc);
final fiveMonero = Money.parse("5", CryptoCurrency.xmr);
test("==", () {
expect(fiveBitcoin, equals(Money(BigInt.from(500000000), CryptoCurrency.btc)));
expect(fiveBitcoin, isNot(equals(fourBitcoin)));
expect(fiveBitcoin, isNot(equals(sixBitcoin)));
expect(fiveBitcoin, isNot(equals(fiveMonero)));
// intentional check of incompatible types.
// ignore: unrelated_type_equality_checks
expect(fiveBitcoin == "Not money", equals(false));
});
test("<", () {
expect(fiveBitcoin < sixBitcoin, isTrue);
expect(fiveBitcoin < fiveBitcoin, isFalse);
expect(fiveBitcoin < fourBitcoin, isFalse);
// Cannot compare money in different currencies:
expect(() => fiveBitcoin < fiveMonero, throwsArgumentError);
});
test("<=", () {
expect(fiveBitcoin <= sixBitcoin, isTrue);
expect(fiveBitcoin <= fiveBitcoin, isTrue);
expect(fiveBitcoin <= fourBitcoin, isFalse);
// Cannot compare money in different currencies:
expect(() => fiveBitcoin <= fiveMonero, throwsArgumentError);
});
test(">", () {
expect(fiveBitcoin > fourBitcoin, isTrue);
expect(fiveBitcoin > fiveBitcoin, isFalse);
expect(fiveBitcoin > sixBitcoin, isFalse);
// Cannot compare money in different currencies:
expect(() => fiveBitcoin > fiveMonero, throwsArgumentError);
});
test(">=", () {
expect(fiveBitcoin >= fourBitcoin, isTrue);
expect(fiveBitcoin >= fiveBitcoin, isTrue);
expect(fiveBitcoin >= sixBitcoin, isFalse);
// Cannot compare money in different currencies:
expect(() => fiveBitcoin >= fiveMonero, throwsArgumentError);
});
test("conformance to Comparable", () {
expect(fiveBitcoin, isA<Comparable<Money>>());
expect(fiveBitcoin.compareTo(fiveBitcoin), isZero);
expect(fiveBitcoin.compareTo(fourBitcoin), isPositive);
expect(fiveBitcoin.compareTo(sixBitcoin), isNegative);
expect(() => fiveBitcoin.compareTo(fiveMonero), throwsArgumentError);
});
});
group("Math", () {
test("+", () {
final oneBitcoin = Money.parse("1", CryptoCurrency.btc);
final twoBitcoin = Money.parse("2", CryptoCurrency.btc);
final threeBitcoin = Money.parse("3", CryptoCurrency.btc);
expect(oneBitcoin + twoBitcoin, equals(threeBitcoin));
});
test("cannot add different currencies", () {
final oneBitcoin = Money(BigInt.one, CryptoCurrency.btc);
final oneMonero = Money(BigInt.one, CryptoCurrency.xmr);
expect(() => oneBitcoin + oneMonero, throwsArgumentError);
});
test("invert money", () {
final oneSatoshi = Money(BigInt.one, CryptoCurrency.btc);
final negativeOneSatoshi = Money(BigInt.from(-1), CryptoCurrency.btc);
expect(-oneSatoshi, equals(negativeOneSatoshi));
expect(-negativeOneSatoshi, equals(oneSatoshi));
});
test("-", () {
final oneSatoshi = Money(BigInt.one, CryptoCurrency.btc);
final twoSatoshi = Money(BigInt.two, CryptoCurrency.btc);
final threeSatoshi = Money(BigInt.from(3), CryptoCurrency.btc);
expect(threeSatoshi - oneSatoshi, equals(twoSatoshi));
});
test("cannot subtract different currencies", () {
final oneSatoshi = Money(BigInt.one, CryptoCurrency.btc);
final oneMonero = Money(BigInt.one, CryptoCurrency.xmr);
expect(() => oneSatoshi - oneMonero, throwsArgumentError);
});
test("*", () {
final zeroSatoshi = Money(BigInt.zero, CryptoCurrency.btc);
final oneSatoshi = Money(BigInt.one, CryptoCurrency.btc);
final twoSatoshi = Money(BigInt.two, CryptoCurrency.btc);
expect(oneSatoshi * BigInt.zero, equals(zeroSatoshi));
expect(oneSatoshi * BigInt.two, equals(twoSatoshi));
expect(oneSatoshi * BigInt.from(-2), equals(-twoSatoshi));
});
group("/", () {
final threeBI = BigInt.from(3);
final fourBI = BigInt.from(4);
final negThreeBI = BigInt.from(-3);
final negFourBI = BigInt.from(-4);
test("rounds down when fractional part is < 0.5", () {
expect((Money(BigInt.from(10), CryptoCurrency.btc) / threeBI).amount, threeBI);
expect((Money(BigInt.from(-10), CryptoCurrency.btc) / threeBI).amount, negThreeBI);
expect((Money(BigInt.from(10), CryptoCurrency.btc) / negThreeBI).amount, negThreeBI);
expect((Money(BigInt.from(-10), CryptoCurrency.btc) / negThreeBI).amount, threeBI);
});
test("rounds up when fractional part is > 0.5", () {
expect((Money(BigInt.from(11), CryptoCurrency.btc) / threeBI).amount, fourBI); // 3.66...
expect((Money(BigInt.from(-11), CryptoCurrency.btc) / threeBI).amount, negFourBI);
expect((Money(BigInt.from(11), CryptoCurrency.btc) / negThreeBI).amount, negFourBI);
expect((Money(BigInt.from(-11), CryptoCurrency.btc) / negThreeBI).amount, fourBI);
});
test("rounds AWAY from zero when fractional part is exactly 0.5 (Ties)", () {
// 5 / 2 = 2.5 -> 3
expect((Money(BigInt.from(5), CryptoCurrency.btc) / BigInt.two).amount, threeBI);
// -5 / 2 = -2.5 -> -3
expect((Money(BigInt.from(-5), CryptoCurrency.btc) / BigInt.two).amount, negThreeBI);
// 5 / -2 = -2.5 -> -3
expect((Money(BigInt.from(5), CryptoCurrency.btc) / -BigInt.two).amount, negThreeBI);
// -5 / -2 = 2.5 -> 3
expect((Money(BigInt.from(-5), CryptoCurrency.btc) / -BigInt.two).amount, threeBI);
});
test("handles zero numerator correctly", () {
expect((Money(BigInt.zero, CryptoCurrency.btc) / BigInt.from(5)).amount, BigInt.zero);
expect((Money(BigInt.zero, CryptoCurrency.btc) / BigInt.from(-5)).amount, BigInt.zero);
});
test("throws Exception on division by zero", () {
expect(
() => Money(BigInt.from(5), CryptoCurrency.btc) / BigInt.zero,
throwsA(isA<Exception>()),
);
});
test("handles very large BigInts without precision loss", () {
// A number that would lose precision if converted to a standard double
final hugeA = BigInt.parse("10000000000000000000000000000000000005");
final hugeB = BigInt.parse("10");
// 1000...005 / 10 = 1000...000.5 -> Should round up to 1000...001
final expected = BigInt.parse("1000000000000000000000000000000000001");
expect((Money(hugeA, CryptoCurrency.btc) / hugeB).amount, expected);
});
test("handles exact division perfectly", () {
expect((Money(BigInt.from(100), CryptoCurrency.btc) / BigInt.from(20)).amount,
BigInt.from(5));
expect((Money(BigInt.from(-100), CryptoCurrency.btc) / BigInt.from(20)).amount,
BigInt.from(-5));
});
});
});
group("copyWith", () {
final money = Money.parse("1", CryptoCurrency.btc);
test("currency", () {
final copy = money.copyWith(currency: CryptoCurrency.eth);
expect(copy.amount, equals(BigInt.parse("1000000000000000000")));
expect(copy.currency.decimals, equals(18));
expect(copy.toString(), "1");
});
test("currency nano", () {
final copy = money.copyWith(currency: CryptoCurrency.nano);
expect(copy.amount, equals(BigInt.parse("1000000000000000000000000000000")));
expect(copy.currency.decimals, equals(30));
expect(copy.toString(), "1");
});
test("amount", () {
final copy = money.copyWith(amount: BigInt.one);
expect(copy.amount, BigInt.one);
expect(copy.currency.decimals, 8);
});
test("amount and currency", () {
final copy = money.copyWith(amount: BigInt.one);
expect(copy.amount, BigInt.one);
expect(copy.currency.decimals, 8);
});
});
group("toStringWithPrecision", (){
test("with fractionalDigits and padded with zeros", () {
final money = Money.parse("1", CryptoCurrency.btc);
expect(money.amount, equals(BigInt.parse("100000000")));
expect(money.currency.decimals, equals(8));
expect(money.toStringWithPrecision(fractionalDigits: 5, trimZeros: false), "1.00000");
});
test("using base unit sats", () {
final money = Money.parse("1", CryptoCurrency.btc);
expect(money.amount, equals(BigInt.parse("100000000")));
expect(money.currency.decimals, equals(8));
expect(money.toStringWithPrecision(useBaseUnit: true), "100000000");
});
});
group("toStringWithSymbol", (){
test("with fractionalDigits and padded with zeros", () {
final money = Money.parse("1", CryptoCurrency.btc);
expect(money.amount, equals(BigInt.parse("100000000")));
expect(money.currency.decimals, equals(8));
expect(money.toStringWithSymbol(fractionalDigits: 5, trimZeros: false), "1.00000 BTC");
});
test("using base unit sats", () {
final money = Money.parse("1", CryptoCurrency.btc);
expect(money.amount, equals(BigInt.parse("100000000")));
expect(money.currency.decimals, equals(8));
expect(money.toStringWithSymbol(useBaseUnit: true), "100000000 sats");
});
});
});
}