refactor: remove BigNumber

packages/api-database/source/search/filters/wallet-filter.ts

@@ -106,7 +106,7 @@ export class WalletFilter {
 		walletAttributeRepository.set("publicKey", Contracts.State.AttributeType.String);
 		walletAttributeRepository.set("username", Contracts.State.AttributeType.String);
 		walletAttributeRepository.set("validatorPublicKey", Contracts.State.AttributeType.String);
-		walletAttributeRepository.set("validatorRank", Contracts.State.AttributeType.Number);
+		walletAttributeRepository.set("validatorRank", Contracts.State.AttributeType.Number); 
 		walletAttributeRepository.set("validatorVoteBalance", Contracts.State.AttributeType.BigNumber);
 		walletAttributeRepository.set("validatorLastBlock", Contracts.State.AttributeType.Object);
 		walletAttributeRepository.set("validatorForgedFees", Contracts.State.AttributeType.BigNumber);

packages/api-development/source/controllers/round.ts

@@ -32,7 +32,7 @@ export class RoundController extends Controller {
 			...this.roundCalculator.calculateRound(blockNumber),
 			// Map the round validator set (static, vote-weighted, etc.) to actual proposal order
 			validators: orderedValidators.map((validator) => ({
-				voteBalance: validator.voteBalance.toFixed(),
+				voteBalance: validator.voteBalance.toString(),
 
 				wallet: validator,
 			})),

packages/api-http/source/controllers/commits.ts

@@ -3,7 +3,7 @@ import type { Types } from "@mainsail/api-common";
 import Boom from "@hapi/boom";
 import { Contracts as ApiDatabaseContracts, Identifiers as ApiDatabaseIdentifiers } from "@mainsail/api-database";
 import { inject, injectable } from "@mainsail/container";
-import { BigNumber, validatorSetUnpack } from "@mainsail/utils";
+import { validatorSetUnpack } from "@mainsail/utils";
 
 import { Controller } from "./controller.js";
 
@@ -35,7 +35,7 @@ export class CommitsController extends Controller {
 
 		if (round) {
 			// map bitmask -> indexes -> round.validators
-			const packed = BigNumber.make(block.validatorSet).toBigInt();
+			const packed = BigInt(block.validatorSet);
 			const unpacked = validatorSetUnpack(packed, round.validators.length);
 			validators = unpacked.filter(Boolean).map((_, index) => round.validators[index]);
 		}

packages/api-http/source/resources/block.ts

@@ -2,7 +2,6 @@ import type { Contracts } from "@mainsail/contracts";
 
 import { Models } from "@mainsail/api-database";
 import { injectable } from "@mainsail/container";
-import { BigNumber } from "@mainsail/utils";
 
 export interface EnrichedBlock extends Models.Block {
 	state: Models.State;
@@ -32,7 +31,7 @@ export class BlockResource implements Contracts.Api.Resource {
 			round: resource.round,
 			signature: resource.signature,
 			timestamp: resource.timestamp,
-			total: BigNumber.make(resource.reward).plus(resource.fee).toFixed(),
+			total: (BigInt(resource.reward) + BigInt(resource.fee)).toString(),
 			transactionsCount: resource.transactionsCount,
 			transactionsRoot: resource.transactionsRoot,
 			username: resource.generator.attributes?.["username"] ?? undefined,

packages/api-sync/source/restore.ts

@@ -9,7 +9,7 @@ import { Identifiers } from "@mainsail/constants";
 import { inject, injectable, optional, tagged } from "@mainsail/container";
 import { Deployer, Identifiers as EvmConsensusIdentifiers } from "@mainsail/evm-consensus";
 import { parseTransactionError } from "@mainsail/evm-contracts";
-import { assert, BigNumber, chunk, formatEcdsaSignature, validatorSetPack } from "@mainsail/utils";
+import { assert, chunk, formatEcdsaSignature, validatorSetPack } from "@mainsail/utils";
 import { performance } from "perf_hooks";
 
 import { TokenParser } from "./contracts.js";
@@ -42,7 +42,7 @@ interface RestoreContext extends RepositoryContext {
 	mostRecentCommit: Contracts.Crypto.Commit;
 
 	lastBlockNumber: number;
-	totalSupply: BigNumber;
+	totalSupply: bigint;
 
 	validatorAttributes: Record<string, ValidatorAttributes>;
 	userAttributes: Record<string, UserAttributes>;
@@ -52,12 +52,12 @@ interface RestoreContext extends RepositoryContext {
 
 interface ValidatorAttributes {
 	lastBlock?: Contracts.Crypto.BlockHeader;
-	totalForgedFees: BigNumber;
-	totalForgedRewards: BigNumber;
+	totalForgedFees: bigint;
+	totalForgedRewards: bigint;
 	producedBlocks: number;
 
-	voteBalance: BigNumber;
-	fee: BigNumber;
+	voteBalance: bigint;
+	fee: bigint;
 	votersCount: number;
 	blsPublicKey: string;
 	isResigned: boolean;
@@ -203,7 +203,7 @@ export class Restore {
 				tokenHolderRepository: this.tokenHolderRepositoryFactory(entityManager),
 				tokenRepository: this.tokenRepositoryFactory(entityManager),
 
-				totalSupply: BigNumber.ZERO,
+				totalSupply: 0n,
 				transactionRepository: this.transactionRepositoryFactory(entityManager),
 				userAttributes: {},
 				validatorAttributes: {},
@@ -414,8 +414,8 @@ export class Restore {
 					}
 				} else {
 					validatorAttributes.producedBlocks += 1;
-					validatorAttributes.totalForgedFees = validatorAttributes.totalForgedFees.plus(block.fee);
-					validatorAttributes.totalForgedRewards = validatorAttributes.totalForgedRewards.plus(block.reward);
+					validatorAttributes.totalForgedFees += block.fee;
+					validatorAttributes.totalForgedRewards += block.reward;
 					validatorAttributes.lastBlock = block;
 				}
 
@@ -571,8 +571,8 @@ export class Restore {
 				fee: validator.fee,
 				isResigned: validator.isResigned,
 				producedBlocks: 0,
-				totalForgedFees: BigNumber.ZERO,
-				totalForgedRewards: BigNumber.ZERO,
+				totalForgedFees: 0n,
+				totalForgedRewards: 0n,
 				voteBalance: validator.voteBalance,
 				votersCount: validator.votersCount,
 			};
@@ -648,25 +648,25 @@ export class Restore {
 					attributes: {
 						...(validatorAttributes
 							? {
-									validatorFee: validatorAttributes.fee,
+									validatorFee: validatorAttributes.fee.toString(),
 									validatorPublicKey: validatorAttributes.blsPublicKey,
 									validatorResigned: validatorAttributes.isResigned,
-									validatorVoteBalance: validatorAttributes.voteBalance,
+									validatorVoteBalance: validatorAttributes.voteBalance.toString(),
 									validatorVotersCount: validatorAttributes.votersCount,
 
-									...(validatorAttributes.totalForgedFees.isGreaterThan(0)
-										? { validatorForgedFees: validatorAttributes.totalForgedFees.toFixed() }
+									...(validatorAttributes.totalForgedFees > 0n
+										? { validatorForgedFees: validatorAttributes.totalForgedFees.toString() }
 										: {}),
-									...(validatorAttributes.totalForgedRewards.isGreaterThan(0)
-										? { validatorForgedRewards: validatorAttributes.totalForgedRewards.toFixed() }
+									...(validatorAttributes.totalForgedRewards > 0n
+										? { validatorForgedRewards: validatorAttributes.totalForgedRewards.toString() }
 										: {}),
-									...(validatorAttributes.totalForgedFees
-										.plus(validatorAttributes.totalForgedRewards)
-										.isGreaterThan(0)
+									...(validatorAttributes.totalForgedFees + validatorAttributes.totalForgedRewards >
+									0n
 										? {
-												validatorForgedTotal: validatorAttributes.totalForgedFees
-													.plus(validatorAttributes.totalForgedRewards)
-													.toFixed(),
+												validatorForgedTotal: (
+													validatorAttributes.totalForgedFees +
+													validatorAttributes.totalForgedRewards
+												).toString(),
 											}
 										: {}),
 									...(validatorAttributes.producedBlocks > 0
@@ -720,8 +720,8 @@ export class Restore {
 								}
 							: {}),
 					} as string, // is converted into JSONB column
-					balance: BigNumber.make(account.balance).toFixed(),
-					nonce: BigNumber.make(account.nonce).toFixed(),
+					balance: account.balance.toString(),
+					nonce: account.nonce.toString(),
 					publicKey: context.addressToPublicKey[account.address] ?? null,
 					updated_at: "0",
 				});
@@ -737,7 +737,7 @@ export class Restore {
 			offset = result.nextOffset;
 		} while (offset);
 
-		context.totalSupply = context.totalSupply.plus(totalAccountBalance);
+		context.totalSupply += totalAccountBalance;
 
 		const t1 = performance.now();
 		this.logger.info(`Restored ${totalAccounts.toLocaleString()} wallets in ${t1 - t0}ms`);
@@ -761,7 +761,7 @@ export class Restore {
 			for (const wallet of result.wallets) {
 				legacyColdWallets.push({
 					address: wallet.address,
-					balance: BigNumber.make(wallet.balance).toFixed(),
+					balance: wallet.balance.toString(),
 					...(Object.keys(wallet.legacyAttributes).length > 0
 						? {
 								attributes: {
@@ -804,7 +804,7 @@ export class Restore {
 			offset = result.nextOffset;
 		} while (offset);
 
-		context.totalSupply = context.totalSupply.plus(totalLegacyAccountBalance);
+		context.totalSupply += totalLegacyAccountBalance;
 
 		const t1 = performance.now();
 		this.logger.info(`Restored ${totalLegacyAccounts.toLocaleString()} legacy cold wallets in ${t1 - t0}ms`);
@@ -855,7 +855,7 @@ export class Restore {
 
 				const proposer = validators[proposerIndex];
 				validatorAddresses[index] = proposer.address;
-				votes[index] = proposer.voteBalance.toFixed();
+				votes[index] = proposer.voteBalance.toString();
 			}
 
 			validatorRoundsToIngest.push({
@@ -899,7 +899,7 @@ export class Restore {
 			.values({
 				blockNumber: context.lastBlockNumber.toFixed(),
 				id: 1,
-				supply: context.totalSupply.toFixed(),
+				supply: context.totalSupply.toString(),
 			})
 			.execute();
 	}

packages/api-sync/source/service.ts

@@ -10,7 +10,7 @@ import { Identifiers } from "@mainsail/constants";
 import { inject, injectable, tagged } from "@mainsail/container";
 import { Identifiers as EvmConsensusIdentifiers } from "@mainsail/evm-consensus";
 import { parseTransactionError } from "@mainsail/evm-contracts";
-import { assert, BigNumber, chunk, formatEcdsaSignature, sleep, validatorSetPack } from "@mainsail/utils";
+import { assert, chunk, formatEcdsaSignature, sleep, validatorSetPack } from "@mainsail/utils";
 import { performance } from "perf_hooks";
 
 import { Listeners, TokenParser } from "./contracts.js";
@@ -263,10 +263,10 @@ export class Sync implements Contracts.ApiSync.Service {
 			return {
 				...(dirtyValidator
 					? {
-							validatorFee: dirtyValidator.fee,
+							validatorFee: dirtyValidator.fee.toString(),
 							validatorPublicKey: dirtyValidator.blsPublicKey,
 							validatorResigned: dirtyValidator.isResigned,
-							validatorVoteBalance: dirtyValidator.voteBalance,
+							validatorVoteBalance: dirtyValidator.voteBalance.toString(),
 							validatorVotersCount: dirtyValidator.votersCount,
 							// updated at end of db transaction
 							// - validatorRank
@@ -313,8 +313,8 @@ export class Sync implements Contracts.ApiSync.Service {
 			return [
 				account.address,
 				addressToPublicKey[account.address] ?? null,
-				BigNumber.make(account.balance).toFixed(),
-				BigNumber.make(account.nonce).toFixed(),
+				account.balance.toString(),
+				account.nonce.toString(),
 				attributes,
 				header.number.toFixed(),
 			];
@@ -400,7 +400,7 @@ export class Sync implements Contracts.ApiSync.Service {
 		return {
 			...this.roundCalculator.calculateRound(number),
 			validators: validatorWallets.map((v) => v.address),
-			votes: validatorWallets.map((v) => v.voteBalance.toFixed()),
+			votes: validatorWallets.map((v) => v.voteBalance.toString()),
 		};
 	}
 
@@ -470,7 +470,7 @@ export class Sync implements Contracts.ApiSync.Service {
 				})
 				.where("id = :id", { id: 1 })
 				.andWhere("blockNumber = :previousBlockNumber", {
-					previousBlockNumber: BigNumber.make(deferred.block.number).minus(1).toFixed(),
+					previousBlockNumber: (BigInt(deferred.block.number) - 1n).toString(),
 				})
 				.execute();
 

packages/blockchain-utils/source/fee-calculator.test.ts

@@ -7,10 +7,10 @@ describe("FeeCalculator", ({ assert, it }) => {
 	it("should calculate gas consumed", async () => {
 		const feeCalculator = new FeeCalculator();
 
-		assert.equal(feeCalculator.calculateConsumed(5 * 1e9, 21_000).toBigInt(), 105_000_000_000_000n);
+		assert.equal(feeCalculator.calculateConsumed(5 * 1e9, 21_000n), 105_000_000_000_000n);
 
 		assert.equal(
-			feeCalculator.calculate({ gasLimit: 21_000, gasPrice: 5 * 1e9 } as Contracts.Crypto.Transaction).toBigInt(),
+			feeCalculator.calculate({ gasLimit: 21_000, gasPrice: 5 * 1e9 } as Contracts.Crypto.Transaction),
 			105_000_000_000_000n,
 		);
 	});

packages/blockchain-utils/source/fee-calculator.ts

@@ -1,15 +1,14 @@
 import type { Contracts } from "@mainsail/contracts";
 
 import { injectable } from "@mainsail/container";
-import { BigNumber } from "@mainsail/utils";
 
 @injectable()
 export class FeeCalculator implements Contracts.BlockchainUtils.FeeCalculator {
-	public calculate(transaction: Contracts.Crypto.Transaction): BigNumber {
-		return BigNumber.make(transaction.gasPrice).times(transaction.gasLimit);
+	public calculate(transaction: Contracts.Crypto.Transaction): bigint {
+		return BigInt(transaction.gasPrice) * BigInt(transaction.gasLimit);
 	}
 
-	public calculateConsumed(gasPrice: number, gasUsed: number): BigNumber {
-		return BigNumber.make(gasPrice).times(gasUsed);
+	public calculateConsumed(gasPrice: number, gasUsed: bigint): bigint {
+		return BigInt(gasPrice) * gasUsed;
 	}
 }

packages/blockchain-utils/source/format.test.ts

@@ -1,5 +1,4 @@
 import { Identifiers } from "@mainsail/constants";
-import { BigNumber } from "@mainsail/utils";
 import { ServiceProvider as ValidationServiceProvider } from "@mainsail/validation";
 import { ServiceProvider as CryptoConfigServiceProvider } from "@mainsail/crypto-config";
 import crypto from "../../core/bin/config/devnet/core/crypto.json";
@@ -23,9 +22,9 @@ describe<{
 	});
 
 	it("should format currency", ({ configuration }) => {
-		assert.equal(formatCurrency(configuration, BigNumber.ONE), "0.000000000000000001 TѦ");
-		assert.equal(formatCurrency(configuration, BigNumber.ZERO), "0 TѦ");
-		assert.equal(formatCurrency(configuration, BigNumber.make(1e18)), "1 TѦ");
-		assert.equal(formatCurrency(configuration, BigNumber.make(1e18).times(100)), "100 TѦ");
+		assert.equal(formatCurrency(configuration, 1n), "0.000000000000000001 TѦ");
+		assert.equal(formatCurrency(configuration, 0n), "0 TѦ");
+		assert.equal(formatCurrency(configuration, BigInt(1e18)), "1 TѦ");
+		assert.equal(formatCurrency(configuration, BigInt(1e18) * 100n), "100 TѦ");
 	});
 });

packages/blockchain-utils/source/format.ts

@@ -1,10 +1,19 @@
 import type { Contracts } from "@mainsail/contracts";
-import type { BigNumber } from "@mainsail/utils";
 
-export const formatCurrency = (configuration: Contracts.Crypto.Configuration, amount: BigNumber): string => {
+type FractionDigit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20;
+
+function isFractionDigit(n: number): n is FractionDigit {
+	return n >= 0 && n <= 20 && Number.isInteger(n);
+}
+
+export const formatCurrency = (configuration: Contracts.Crypto.Configuration, amount: bigint): string => {
 	const { decimals, denomination } = configuration.getMilestone().satoshi;
 
-	const localeString = (+amount / denomination).toLocaleString("en", {
+	if (!isFractionDigit(decimals)) {
+		throw new Error("Invalid decimals");
+	}
+
+	const localeString = (Number(amount) / denomination).toLocaleString("en", {
 		maximumFractionDigits: decimals,
 		minimumFractionDigits: 0,
 	});

packages/configuration-generator/source/configuration-generator.test.ts

@@ -1,5 +1,4 @@
 import { Application } from "@mainsail/kernel";
-import { BigNumber } from "@mainsail/utils";
 import envPaths from "env-paths";
 import fs from "fs-extra/esm";
 import { join } from "path";
@@ -53,10 +52,10 @@ describe<{
 						payloadHash: match.string,
 						payloadLength: match.number,
 						previousBlock: "0000000000000000000000000000000000000000000000000000000000000000",
-						reward: BigNumber.ZERO,
+						reward: 0n,
 						timestamp: match.number,
-						totalAmount: BigNumber.make("12500000000000000"),
-						totalFee: BigNumber.ZERO,
+						totalAmount: 12500000000000000n,
+						totalFee: 0n,
 						transactions: match.array,
 						version: 1,
 					},
@@ -189,10 +188,10 @@ describe<{
 						payloadHash: match.string,
 						payloadLength: match.number,
 						previousBlock: "0000000000000000000000000000000000000000000000000000000000000000",
-						reward: BigNumber.ZERO,
+						reward: 0n,
 						timestamp: match.number,
-						totalAmount: BigNumber.make("12499999999999969"),
-						totalFee: BigNumber.ZERO,
+						totalAmount: 12499999999999969n,
+						totalFee: 0n,
 						transactions: match.array,
 						version: 1,
 					},