wallet-core/packages/taler-util/src/amounts.ts

440 lines
11 KiB
TypeScript
Raw Normal View History

/*
This file is part of GNU Taler
(C) 2019 Taler Systems S.A.
GNU Taler is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 3, or (at your option) any later version.
GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
GNU Taler; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
*/
/**
* Types and helper functions for dealing with Taler amounts.
*/
/**
* Imports.
*/
import {
2020-08-12 12:32:58 +02:00
buildCodecForObject,
codecForString,
codecForNumber,
2020-04-06 20:02:01 +02:00
Codec,
} from "./codec.js";
import { AmountString } from "./talerTypes.js";
2018-04-09 00:41:14 +02:00
/**
* Number of fractional units that one value unit represents.
*/
2021-03-17 18:21:43 +01:00
export const amountFractionalBase = 1e8;
/**
* How many digits behind the comma are required to represent the
* fractional value in human readable decimal format? Must match
* lg(fractionalBase)
*/
2021-03-17 18:21:43 +01:00
export const amountFractionalLength = 8;
/**
* Maximum allowed value field of an amount.
*/
2021-03-17 18:21:43 +01:00
export const amountMaxValue = 2 ** 52;
/**
* Non-negative financial amount. Fractional values are expressed as multiples
* of 1e-8.
*/
export interface AmountJson {
/**
* Value, must be an integer.
*/
readonly value: number;
/**
* Fraction, must be an integer. Represent 1/1e8 of a unit.
*/
readonly fraction: number;
/**
* Currency of the amount.
*/
readonly currency: string;
}
2020-04-06 20:02:01 +02:00
export const codecForAmountJson = (): Codec<AmountJson> =>
2020-08-12 12:32:58 +02:00
buildCodecForObject<AmountJson>()
.property("currency", codecForString())
.property("value", codecForNumber())
.property("fraction", codecForNumber())
2020-04-07 10:07:32 +02:00
.build("AmountJson");
2020-08-12 12:32:58 +02:00
export const codecForAmountString = (): Codec<AmountString> => codecForString();
2020-08-12 12:18:02 +02:00
/**
* Result of a possibly overflowing operation.
*/
export interface Result {
/**
* Resulting, possibly saturated amount.
*/
amount: AmountJson;
/**
* Was there an over-/underflow?
*/
saturated: boolean;
}
/**
2021-03-17 18:21:43 +01:00
* Type for things that are treated like amounts.
*/
export type AmountLike = AmountString | AmountJson;
/**
2021-03-17 18:21:43 +01:00
* Helper class for dealing with amounts.
*/
2021-03-17 18:21:43 +01:00
export class Amounts {
private constructor() {
throw Error("not instantiable");
}
/**
* Get an amount that represents zero units of a currency.
*/
static getZero(currency: string): AmountJson {
return {
2021-03-17 18:21:43 +01:00
currency,
fraction: 0,
value: 0,
};
}
2021-03-17 18:21:43 +01:00
static jsonifyAmount(amt: AmountLike): AmountJson {
if (typeof amt === "string") {
return Amounts.parseOrThrow(amt);
}
return amt;
}
static sum(amounts: AmountLike[]): Result {
if (amounts.length <= 0) {
throw Error("can't sum zero amounts");
}
2021-03-17 18:21:43 +01:00
const jsonAmounts = amounts.map((x) => Amounts.jsonifyAmount(x));
return Amounts.add(jsonAmounts[0], ...jsonAmounts.slice(1));
}
2021-03-17 18:21:43 +01:00
/**
* Add two amounts. Return the result and whether
* the addition overflowed. The overflow is always handled
* by saturating and never by wrapping.
*
* Throws when currencies don't match.
*/
static add(first: AmountJson, ...rest: AmountJson[]): Result {
const currency = first.currency;
let value = first.value + Math.floor(first.fraction / amountFractionalBase);
if (value > amountMaxValue) {
return {
2019-12-14 18:46:42 +01:00
amount: {
currency,
2021-03-17 18:21:43 +01:00
value: amountMaxValue,
fraction: amountFractionalBase - 1,
2019-12-14 18:46:42 +01:00
},
saturated: true,
};
}
2021-03-17 18:21:43 +01:00
let fraction = first.fraction % amountFractionalBase;
for (const x of rest) {
if (x.currency.toUpperCase() !== currency.toUpperCase()) {
2021-03-17 18:21:43 +01:00
throw Error(`Mismatched currency: ${x.currency} and ${currency}`);
}
2021-03-17 18:21:43 +01:00
value =
value +
x.value +
Math.floor((fraction + x.fraction) / amountFractionalBase);
fraction = Math.floor((fraction + x.fraction) % amountFractionalBase);
if (value > amountMaxValue) {
return {
amount: {
currency,
value: amountMaxValue,
fraction: amountFractionalBase - 1,
},
saturated: true,
};
}
}
2021-03-17 18:21:43 +01:00
return { amount: { currency, value, fraction }, saturated: false };
}
2021-03-17 18:21:43 +01:00
/**
* Subtract two amounts. Return the result and whether
* the subtraction overflowed. The overflow is always handled
* by saturating and never by wrapping.
*
* Throws when currencies don't match.
*/
static sub(a: AmountJson, ...rest: AmountJson[]): Result {
const currency = a.currency;
let value = a.value;
let fraction = a.fraction;
for (const b of rest) {
if (b.currency.toUpperCase() !== a.currency.toUpperCase()) {
2021-03-17 18:21:43 +01:00
throw Error(`Mismatched currency: ${b.currency} and ${currency}`);
}
if (fraction < b.fraction) {
if (value < 1) {
return {
amount: { currency, value: 0, fraction: 0 },
saturated: true,
};
}
value--;
fraction += amountFractionalBase;
}
console.assert(fraction >= b.fraction);
fraction -= b.fraction;
if (value < b.value) {
return { amount: { currency, value: 0, fraction: 0 }, saturated: true };
}
value -= b.value;
}
2021-03-17 18:21:43 +01:00
return { amount: { currency, value, fraction }, saturated: false };
}
2021-03-17 18:21:43 +01:00
/**
* Compare two amounts. Returns 0 when equal, -1 when a < b
* and +1 when a > b. Throws when currencies don't match.
*/
static cmp(a: AmountLike, b: AmountLike): -1 | 0 | 1 {
a = Amounts.jsonifyAmount(a);
b = Amounts.jsonifyAmount(b);
if (a.currency !== b.currency) {
throw Error(`Mismatched currency: ${a.currency} and ${b.currency}`);
}
const av = a.value + Math.floor(a.fraction / amountFractionalBase);
const af = a.fraction % amountFractionalBase;
const bv = b.value + Math.floor(b.fraction / amountFractionalBase);
const bf = b.fraction % amountFractionalBase;
switch (true) {
case av < bv:
return -1;
case av > bv:
return 1;
case af < bf:
return -1;
case af > bf:
return 1;
case af === bf:
return 0;
default:
throw Error("assertion failed");
}
}
2019-12-25 19:11:20 +01:00
2021-03-17 18:21:43 +01:00
/**
* Create a copy of an amount.
*/
static copy(a: AmountJson): AmountJson {
return {
currency: a.currency,
fraction: a.fraction,
value: a.value,
};
}
2021-03-17 18:21:43 +01:00
/**
* Divide an amount. Throws on division by zero.
*/
static divide(a: AmountJson, n: number): AmountJson {
if (n === 0) {
throw Error(`Division by 0`);
}
if (n === 1) {
return { value: a.value, fraction: a.fraction, currency: a.currency };
}
const r = a.value % n;
return {
currency: a.currency,
fraction: Math.floor((r * amountFractionalBase + a.fraction) / n),
value: Math.floor(a.value / n),
};
}
2021-03-17 18:21:43 +01:00
/**
* Check if an amount is non-zero.
*/
static isNonZero(a: AmountJson): boolean {
return a.value > 0 || a.fraction > 0;
}
2021-03-17 18:21:43 +01:00
static isZero(a: AmountLike): boolean {
a = Amounts.jsonifyAmount(a);
return a.value === 0 && a.fraction === 0;
}
2021-03-17 18:21:43 +01:00
/**
* Parse an amount like 'EUR:20.5' for 20 Euros and 50 ct.
*/
static parse(s: string): AmountJson | undefined {
const res = s.match(/^([a-zA-Z0-9_*-]+):([0-9]+)([.][0-9]+)?$/);
if (!res) {
return undefined;
}
const tail = res[3] || ".0";
if (tail.length > amountFractionalLength + 1) {
return undefined;
}
2021-03-17 18:21:43 +01:00
const value = Number.parseInt(res[2]);
if (value > amountMaxValue) {
return undefined;
}
return {
currency: res[1].toUpperCase(),
2021-03-17 18:21:43 +01:00
fraction: Math.round(amountFractionalBase * Number.parseFloat(tail)),
value,
};
}
2021-03-17 18:21:43 +01:00
/**
* Parse amount in standard string form (like 'EUR:20.5'),
* throw if the input is not a valid amount.
*/
static parseOrThrow(s: string): AmountJson {
const res = Amounts.parse(s);
if (!res) {
throw Error(`Can't parse amount: "${s}"`);
}
return res;
}
2021-03-17 18:21:43 +01:00
/**
* Convert a float to a Taler amount.
* Loss of precision possible.
*/
static fromFloat(floatVal: number, currency: string): AmountJson {
return {
currency,
fraction: Math.floor(
(floatVal - Math.floor(floatVal)) * amountFractionalBase,
),
value: Math.floor(floatVal),
};
}
2021-03-17 18:21:43 +01:00
static min(a: AmountLike, b: AmountLike): AmountJson {
const cr = Amounts.cmp(a, b);
if (cr >= 0) {
return Amounts.jsonifyAmount(b);
} else {
return Amounts.jsonifyAmount(a);
}
}
2021-03-17 18:21:43 +01:00
static max(a: AmountLike, b: AmountLike): AmountJson {
const cr = Amounts.cmp(a, b);
if (cr >= 0) {
return Amounts.jsonifyAmount(a);
} else {
2021-03-17 18:21:43 +01:00
return Amounts.jsonifyAmount(b);
}
}
2021-11-02 17:02:04 +01:00
static mult(a: AmountLike, n: number): Result {
a = this.jsonifyAmount(a);
2021-03-17 18:21:43 +01:00
if (!Number.isInteger(n)) {
throw Error("amount can only be multipied by an integer");
}
if (n < 0) {
throw Error("amount can only be multiplied by a positive integer");
}
if (n == 0) {
return { amount: Amounts.getZero(a.currency), saturated: false };
}
let x = a;
let acc = Amounts.getZero(a.currency);
while (n > 1) {
if (n % 2 == 0) {
n = n / 2;
} else {
n = (n - 1) / 2;
const r2 = Amounts.add(acc, x);
if (r2.saturated) {
return r2;
}
acc = r2.amount;
}
const r2 = Amounts.add(x, x);
2020-07-16 13:51:12 +02:00
if (r2.saturated) {
return r2;
}
2021-03-17 18:21:43 +01:00
x = r2.amount;
}
2021-03-17 18:21:43 +01:00
return Amounts.add(acc, x);
}
2021-03-17 18:21:43 +01:00
/**
* Check if the argument is a valid amount in string form.
*/
static check(a: any): boolean {
if (typeof a !== "string") {
return false;
}
try {
const parsedAmount = Amounts.parse(a);
return !!parsedAmount;
} catch {
return false;
}
}
2021-03-17 18:21:43 +01:00
/**
* Convert to standard human-readable string representation that's
* also used in JSON formats.
*/
static stringify(a: AmountLike): string {
a = Amounts.jsonifyAmount(a);
const s = this.stringifyValue(a);
2021-08-24 20:16:11 +02:00
return `${a.currency}:${s}`;
}
static isSameCurrency(a1: AmountLike, a2: AmountLike): boolean {
const x1 = this.jsonifyAmount(a1);
const x2 = this.jsonifyAmount(a2);
return x1.currency.toUpperCase() === x2.currency.toUpperCase();
}
2021-09-27 18:06:50 +02:00
static stringifyValue(a: AmountJson, minFractional: number = 0): string {
2021-03-17 18:21:43 +01:00
const av = a.value + Math.floor(a.fraction / amountFractionalBase);
const af = a.fraction % amountFractionalBase;
let s = av.toString();
if (af) {
s = s + ".";
let n = af;
for (let i = 0; i < amountFractionalLength; i++) {
2021-09-27 18:06:50 +02:00
if (!n && i >= minFractional) {
2021-03-17 18:21:43 +01:00
break;
}
s = s + Math.floor((n / amountFractionalBase) * 10).toString();
n = (n * 10) % amountFractionalBase;
}
}
2022-01-10 19:07:35 +01:00
const currencyFormatter = new Intl.NumberFormat("en-US", {
minimumFractionDigits: minFractional,
});
return currencyFormatter.format(s as any);
}
}