nano-sdk 1.0.0

package/dist/nano/crypto/hash-block.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashBlock = hashBlock;
+const blakejs_1 = require("blakejs");
+const account_1 = require("../types/account");
+const amount_1 = require("../types/amount");
+const hash_1 = require("../types/hash");
+const hex_1 = require("../types/hex");
+const link_1 = require("../types/link");
+const account_converter_1 = require("./conversion/account-converter");
+const hash_converter_1 = require("./conversion/hash-converter");
+const hex_converter_1 = require("./conversion/hex-converter");
+const STATE_BLOCK_PREAMBLE_BYTES = new Uint8Array(32);
+STATE_BLOCK_PREAMBLE_BYTES[31] = 6;
+function hashBlockThrowing(params) {
+    const validatedAccount = (0, account_1.AccountString)().safeParse(params.account);
+    if (!validatedAccount.success) {
+        throw new Error("Invalid account value.");
+    }
+    const validatedPrevious = (0, hash_1.HashString)().safeParse(params.previous);
+    if (!validatedPrevious.success) {
+        throw new Error("Invalid previous value.");
+    }
+    const validatedRepresentative = (0, account_1.AccountString)().safeParse(params.representative);
+    if (!validatedRepresentative.success) {
+        throw new Error("Invalid representative value.");
+    }
+    const validatedBalance = (0, amount_1.RawAmountString)().safeParse(params.balance);
+    if (!validatedBalance.success) {
+        throw new Error("Invalid balance value.");
+    }
+    const validatedLink = (0, link_1.LinkString)().safeParse(params.link);
+    if (!validatedLink.success) {
+        throw new Error("Invalid link value.");
+    }
+    const accountBytes = (0, account_converter_1.accountToBytes)({ account: validatedAccount.data, throwOnError: true });
+    const previousBytes = (0, hash_converter_1.hashToBytes)({ hash: validatedPrevious.data, throwOnError: true });
+    const representativeBytes = (0, account_converter_1.accountToBytes)({ account: validatedRepresentative.data, throwOnError: true });
+    const balanceHexResult = (0, hex_1.HexString)().safeParse(BigInt(validatedBalance.data).toString(16).padStart(32, "0"));
+    if (!balanceHexResult.success) {
+        throw new Error("Failed to convert balance into hex value.");
+    }
+    const balanceBytes = (0, hex_converter_1.hexToBytes)({ hex: balanceHexResult.data, throwOnError: true });
+    const linkBytes = (0, hex_converter_1.hexToBytes)({ hex: validatedLink.data, throwOnError: true });
+    try {
+        const hashContext = (0, blakejs_1.blake2bInit)(32);
+        (0, blakejs_1.blake2bUpdate)(hashContext, STATE_BLOCK_PREAMBLE_BYTES);
+        (0, blakejs_1.blake2bUpdate)(hashContext, accountBytes);
+        (0, blakejs_1.blake2bUpdate)(hashContext, previousBytes);
+        (0, blakejs_1.blake2bUpdate)(hashContext, representativeBytes);
+        (0, blakejs_1.blake2bUpdate)(hashContext, balanceBytes);
+        (0, blakejs_1.blake2bUpdate)(hashContext, linkBytes);
+        const hashBytes = (0, blakejs_1.blake2bFinal)(hashContext);
+        return (0, hash_converter_1.bytesToHash)({ hashBytes, throwOnError: true });
+    }
+    catch (_err) {
+        throw new Error("Failed to compute hash.");
+    }
+}
+function hashBlockNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: hashBlockThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function hashBlock(params) {
+    if (params.throwOnError === false) {
+        return hashBlockNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return hashBlockThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/index.d.ts

@@ -0,0 +1,14 @@
+export { deriveAccountFromLink } from "./derive-account-from-link";
+export { deriveAccountFromPrivateKey } from "./derive-account-from-private-key";
+export { deriveAccountFromPublicKey } from "./derive-account-from-public-key";
+export { derivePrivateKeyFromSeed } from "./derive-private-key-from-seed";
+export { derivePublicKeyFromAccount } from "./derive-public-key-from-account";
+export { derivePublicKeyFromPrivateKey } from "./derive-public-key-from-private-key";
+export { generatePrivateKey } from "./generate-private-key";
+export { generatePublicKey } from "./generate-public-key";
+export { generateSeed } from "./generate-seed";
+export { hashBlock } from "./hash-block";
+export { signHash } from "./sign-hash";
+export { verifyHash } from "./verify-hash";
+export { verifySignature } from "./verify-signature";
+export { verifyWork } from "./verify-work";

package/dist/nano/crypto/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyWork = exports.verifySignature = exports.verifyHash = exports.signHash = exports.hashBlock = exports.generateSeed = exports.generatePublicKey = exports.generatePrivateKey = exports.derivePublicKeyFromPrivateKey = exports.derivePublicKeyFromAccount = exports.derivePrivateKeyFromSeed = exports.deriveAccountFromPublicKey = exports.deriveAccountFromPrivateKey = exports.deriveAccountFromLink = void 0;
+var derive_account_from_link_1 = require("./derive-account-from-link");
+Object.defineProperty(exports, "deriveAccountFromLink", { enumerable: true, get: function () { return derive_account_from_link_1.deriveAccountFromLink; } });
+var derive_account_from_private_key_1 = require("./derive-account-from-private-key");
+Object.defineProperty(exports, "deriveAccountFromPrivateKey", { enumerable: true, get: function () { return derive_account_from_private_key_1.deriveAccountFromPrivateKey; } });
+var derive_account_from_public_key_1 = require("./derive-account-from-public-key");
+Object.defineProperty(exports, "deriveAccountFromPublicKey", { enumerable: true, get: function () { return derive_account_from_public_key_1.deriveAccountFromPublicKey; } });
+var derive_private_key_from_seed_1 = require("./derive-private-key-from-seed");
+Object.defineProperty(exports, "derivePrivateKeyFromSeed", { enumerable: true, get: function () { return derive_private_key_from_seed_1.derivePrivateKeyFromSeed; } });
+var derive_public_key_from_account_1 = require("./derive-public-key-from-account");
+Object.defineProperty(exports, "derivePublicKeyFromAccount", { enumerable: true, get: function () { return derive_public_key_from_account_1.derivePublicKeyFromAccount; } });
+var derive_public_key_from_private_key_1 = require("./derive-public-key-from-private-key");
+Object.defineProperty(exports, "derivePublicKeyFromPrivateKey", { enumerable: true, get: function () { return derive_public_key_from_private_key_1.derivePublicKeyFromPrivateKey; } });
+var generate_private_key_1 = require("./generate-private-key");
+Object.defineProperty(exports, "generatePrivateKey", { enumerable: true, get: function () { return generate_private_key_1.generatePrivateKey; } });
+var generate_public_key_1 = require("./generate-public-key");
+Object.defineProperty(exports, "generatePublicKey", { enumerable: true, get: function () { return generate_public_key_1.generatePublicKey; } });
+var generate_seed_1 = require("./generate-seed");
+Object.defineProperty(exports, "generateSeed", { enumerable: true, get: function () { return generate_seed_1.generateSeed; } });
+var hash_block_1 = require("./hash-block");
+Object.defineProperty(exports, "hashBlock", { enumerable: true, get: function () { return hash_block_1.hashBlock; } });
+var sign_hash_1 = require("./sign-hash");
+Object.defineProperty(exports, "signHash", { enumerable: true, get: function () { return sign_hash_1.signHash; } });
+var verify_hash_1 = require("./verify-hash");
+Object.defineProperty(exports, "verifyHash", { enumerable: true, get: function () { return verify_hash_1.verifyHash; } });
+var verify_signature_1 = require("./verify-signature");
+Object.defineProperty(exports, "verifySignature", { enumerable: true, get: function () { return verify_signature_1.verifySignature; } });
+var verify_work_1 = require("./verify-work");
+Object.defineProperty(exports, "verifyWork", { enumerable: true, get: function () { return verify_work_1.verifyWork; } });

package/dist/nano/crypto/sign-hash.d.ts

@@ -0,0 +1,14 @@
+import { HashString } from "../types/hash";
+import { NonThrowing } from "../types/non-throwing";
+import { PrivateKeyString } from "../types/private-key";
+import { Result } from "../types/result";
+import { SignatureString } from "../types/signature";
+import { Throwing } from "../types/throwing";
+type SignHashParams = {
+    hash: HashString;
+    privateKey: PrivateKeyString;
+} & (Throwing | NonThrowing);
+export declare function signHash(params: SignHashParams & NonThrowing): Result<SignatureString>;
+export declare function signHash(params: SignHashParams & Throwing): SignatureString;
+export declare function signHash(params: SignHashParams): SignatureString | Result<SignatureString>;
+export {};

package/dist/nano/crypto/sign-hash.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signHash = signHash;
+const nacl_1 = require("../types/nacl");
+const hash_converter_1 = require("./conversion/hash-converter");
+const private_key_converter_1 = require("./conversion/private-key-converter");
+const signature_converter_1 = require("./conversion/signature-converter");
+function signHashThrowing(params) {
+    const hashBytes = (0, hash_converter_1.hashToBytes)({ hash: params.hash, throwOnError: true });
+    const privateKeyBytes = (0, private_key_converter_1.privateKeyToBytes)({ privateKey: params.privateKey, throwOnError: true });
+    try {
+        const signatureBytes = nacl_1.Nacl.signDetached(hashBytes, privateKeyBytes);
+        return (0, signature_converter_1.bytesToSignature)({ signatureBytes, throwOnError: true });
+    }
+    catch (_err) {
+        throw new Error("Failed to create a valid signature.");
+    }
+}
+function signHashNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: signHashThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function signHash(params) {
+    if (params.throwOnError === false) {
+        return signHashNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return signHashThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/verify-hash.d.ts

@@ -0,0 +1,22 @@
+import { AccountString } from "../types/account";
+import { RawAmountString } from "../types/amount";
+import { HashString } from "../types/hash";
+import { LinkString } from "../types/link";
+import { NonThrowing } from "../types/non-throwing";
+import { PredicateResult } from "../types/result";
+import { Throwing } from "../types/throwing";
+type BlockInput = {
+    account: AccountString;
+    previous: HashString;
+    representative: AccountString;
+    balance: RawAmountString;
+    link: LinkString;
+};
+type VerifyHashParams = {
+    hash: HashString;
+    block: BlockInput;
+} & (Throwing | NonThrowing);
+export declare function verifyHash(params: VerifyHashParams & NonThrowing): PredicateResult<"checked", "validHash">;
+export declare function verifyHash(params: VerifyHashParams & Throwing): boolean;
+export declare function verifyHash(params: VerifyHashParams): PredicateResult<"checked", "validHash"> | boolean;
+export {};

package/dist/nano/crypto/verify-hash.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyHash = verifyHash;
+const hash_1 = require("../types/hash");
+const hash_block_1 = require("./hash-block");
+function verifyHashThrowing(params) {
+    const validatedHash = (0, hash_1.HashString)().safeParse(params.hash);
+    if (!validatedHash.success) {
+        throw new Error("Invalid hash value.");
+    }
+    const blockHash = (0, hash_block_1.hashBlock)({ ...params.block, throwOnError: true });
+    return validatedHash.data === blockHash;
+}
+function verifyHashNonThrowing(params) {
+    try {
+        return {
+            checked: true,
+            validHash: verifyHashThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            checked: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function verifyHash(params) {
+    if (params.throwOnError === false) {
+        return verifyHashNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return verifyHashThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/verify-signature.d.ts

@@ -0,0 +1,15 @@
+import { HashString } from "../types/hash";
+import { NonThrowing } from "../types/non-throwing";
+import { PublicKeyString } from "../types/public-key";
+import { PredicateResult } from "../types/result";
+import { SignatureString } from "../types/signature";
+import { Throwing } from "../types/throwing";
+type VerifySignatureParams = {
+    hash: HashString;
+    publicKey: PublicKeyString;
+    signature: SignatureString;
+} & (Throwing | NonThrowing);
+export declare function verifySignature(params: VerifySignatureParams & NonThrowing): PredicateResult<"checked", "validSignature">;
+export declare function verifySignature(params: VerifySignatureParams & Throwing): boolean;
+export declare function verifySignature(params: VerifySignatureParams): PredicateResult<"checked", "validSignature"> | boolean;
+export {};

package/dist/nano/crypto/verify-signature.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySignature = verifySignature;
+const nacl_1 = require("../types/nacl");
+const hash_converter_1 = require("./conversion/hash-converter");
+const public_key_converter_1 = require("./conversion/public-key-converter");
+const signature_converter_1 = require("./conversion/signature-converter");
+function verifySignatureThrowing(params) {
+    const hashBytes = (0, hash_converter_1.hashToBytes)({ hash: params.hash, throwOnError: true });
+    const publicKeyBytes = (0, public_key_converter_1.publicKeyToBytes)({ publicKey: params.publicKey, throwOnError: true });
+    const signatureBytes = (0, signature_converter_1.signatureToBytes)({ signature: params.signature, throwOnError: true });
+    try {
+        return nacl_1.Nacl.verifyDetached(hashBytes, signatureBytes, publicKeyBytes);
+    }
+    catch (_err) {
+        throw new Error("Failed to verify signature.");
+    }
+}
+function verifySignatureNonThrowing(params) {
+    try {
+        return {
+            checked: true,
+            validSignature: verifySignatureThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            checked: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function verifySignature(params) {
+    if (params.throwOnError === false) {
+        return verifySignatureNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return verifySignatureThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/verify-work.d.ts

@@ -0,0 +1,14 @@
+import { HashString } from "../types/hash";
+import { NonThrowing } from "../types/non-throwing";
+import { PredicateResult } from "../types/result";
+import { Throwing } from "../types/throwing";
+import { WorkString } from "../types/work";
+type VerifyWorkParams = {
+    hash: HashString;
+    work: WorkString;
+    threshold: string;
+} & (Throwing | NonThrowing);
+export declare function verifyWork(params: VerifyWorkParams & NonThrowing): PredicateResult<"checked", "validWork">;
+export declare function verifyWork(params: VerifyWorkParams & Throwing): boolean;
+export declare function verifyWork(params: VerifyWorkParams): PredicateResult<"checked", "validWork"> | boolean;
+export {};

package/dist/nano/crypto/verify-work.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyWork = verifyWork;
+const blakejs_1 = require("blakejs");
+const work_difficulty_1 = require("../types/work-difficulty");
+const hash_converter_1 = require("./conversion/hash-converter");
+const hex_converter_1 = require("./conversion/hex-converter");
+const work_converter_1 = require("./conversion/work-converter");
+function verifyWorkThrowing(params) {
+    const hashBytes = (0, hash_converter_1.hashToBytes)({ hash: params.hash, throwOnError: true });
+    const workBytes = (0, work_converter_1.workToBytes)({ work: params.work, throwOnError: true });
+    if (!(0, work_difficulty_1.WorkDifficultyString)().safeParse(params.threshold).success) {
+        throw new Error("Invalid work threshold.");
+    }
+    try {
+        const context = (0, blakejs_1.blake2bInit)(8);
+        (0, blakejs_1.blake2bUpdate)(context, workBytes.reverse());
+        (0, blakejs_1.blake2bUpdate)(context, hashBytes);
+        const outputBytes = (0, blakejs_1.blake2bFinal)(context).reverse();
+        const outputHex = (0, hex_converter_1.bytesToHex)({ bytes: outputBytes, throwOnError: true });
+        return BigInt(`0x${outputHex}`) >= BigInt(`0x${params.threshold}`);
+    }
+    catch (_err) {
+        throw new Error("Failed to verify work.");
+    }
+}
+function verifyWorkNonThrowing(params) {
+    try {
+        return {
+            checked: true,
+            validWork: verifyWorkThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            checked: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function verifyWork(params) {
+    if (params.throwOnError === false) {
+        return verifyWorkNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return verifyWorkThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/index.d.ts

@@ -0,0 +1,7 @@
+export * as Blocks from "./blocks";
+export * as Crypto from "./crypto";
+export * as Math from "./math";
+export * as RPC from "./rpc";
+export * as Types from "./types";
+export * as WebSocket from "./web-socket";
+export { WebSocketClient } from "./web-socket/client/web-socket-client";

package/dist/nano/index.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = exports.WebSocket = exports.Types = exports.RPC = exports.Math = exports.Crypto = exports.Blocks = void 0;
+// blocks
+exports.Blocks = __importStar(require("./blocks"));
+// crypto
+exports.Crypto = __importStar(require("./crypto"));
+// math
+exports.Math = __importStar(require("./math"));
+// rpc
+exports.RPC = __importStar(require("./rpc"));
+// types
+exports.Types = __importStar(require("./types"));
+// web-socket
+exports.WebSocket = __importStar(require("./web-socket"));
+// WebSocketClient alias
+var web_socket_client_1 = require("./web-socket/client/web-socket-client");
+Object.defineProperty(exports, "WebSocketClient", { enumerable: true, get: function () { return web_socket_client_1.WebSocketClient; } });

package/dist/nano/math/comparison.d.ts

@@ -0,0 +1,6 @@
+import { RawAmount, RawAmountString } from "../types/amount";
+export type RawComparisonInputs = {
+    raw: RawAmount | RawAmountString;
+    compareTo: RawAmount | RawAmountString;
+};
+export declare function compareRawValues(leftValue: RawAmount | RawAmountString, rightValue: RawAmount | RawAmountString): number;

package/dist/nano/math/comparison.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareRawValues = compareRawValues;
+const amount_1 = require("../types/amount");
+function compareRawValues(leftValue, rightValue) {
+    const leftResult = (0, amount_1.RawAmount)().safeParse(leftValue);
+    if (!leftResult.success) {
+        throw new Error("Invalid raw value.");
+    }
+    const rightResult = (0, amount_1.RawAmount)().safeParse(rightValue);
+    if (!rightResult.success) {
+        throw new Error("Invalid compareTo value.");
+    }
+    const left = leftResult.data;
+    const right = rightResult.data;
+    if (left === right) {
+        return 0;
+    }
+    return left > right ? 1 : -1;
+}

package/dist/nano/math/format-raw.d.ts

@@ -0,0 +1,17 @@
+import { RawAmount, RawAmountString } from "../types/amount";
+import { NonThrowing } from "../types/non-throwing";
+import { Result } from "../types/result";
+import { Throwing } from "../types/throwing";
+type FormatUnit = "raw" | "nano";
+type FormatRawParams = {
+    raw: RawAmount | RawAmountString;
+    unit?: FormatUnit;
+    decimalPlaces?: number;
+    decimalSeparator?: "." | ",";
+    groupingSize?: number;
+    groupingSeparator?: "," | "." | " ";
+} & (Throwing | NonThrowing);
+export declare function formatRaw(params: FormatRawParams & NonThrowing): Result<string>;
+export declare function formatRaw(params: FormatRawParams & Throwing): string;
+export declare function formatRaw(params: FormatRawParams): string | Result<string>;
+export {};

package/dist/nano/math/format-raw.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatRaw = formatRaw;
+const amount_1 = require("../types/amount");
+function addGrouping(params) {
+    if (params.groupingSize < 0 || params.groupingSize > 39) {
+        throw new Error("Invalid grouping size value.");
+    }
+    if (!params.groupingSize) {
+        return params.integerPart;
+    }
+    if (!params.groupingSeparator) {
+        return params.integerPart;
+    }
+    let result = "";
+    for (let index = params.integerPart.length - 1, count = 0; index >= 0; index--) {
+        result = params.integerPart[index] + result;
+        count++;
+        if (count === params.groupingSize && index !== 0) {
+            result = `${params.groupingSeparator}${result}`;
+            count = 0;
+        }
+    }
+    return result;
+}
+function formatNanoFromRaw(params) {
+    if (params.decimalPlaces < 0 || params.decimalPlaces > 30) {
+        throw new Error("Invalid decimal places value.");
+    }
+    let integerPart = (params.rawValue / amount_1.RAW_SCALE).toString();
+    let fractionPart = (params.rawValue % amount_1.RAW_SCALE).toString().padStart(30, "0");
+    if (params.groupingSize) {
+        integerPart = addGrouping({
+            integerPart: integerPart,
+            groupingSize: params.groupingSize,
+            groupingSeparator: params.groupingSeparator,
+        });
+    }
+    if (params.decimalPlaces === 0) {
+        return integerPart;
+    }
+    fractionPart = fractionPart.slice(0, params.decimalPlaces);
+    fractionPart = fractionPart.padEnd(params.decimalPlaces, "0");
+    return `${integerPart}${params.decimalSeparator}${fractionPart}`;
+}
+function formatRawThrowing(params) {
+    const rawResult = (0, amount_1.RawAmount)().safeParse(params.raw);
+    if (!rawResult.success) {
+        throw new Error("Invalid raw value.");
+    }
+    const unit = params.unit ?? "raw";
+    if (unit !== "raw" && unit !== "nano") {
+        throw new Error("Invalid format unit.");
+    }
+    const rawValue = rawResult.data;
+    if (unit === "raw") {
+        return params.groupingSize
+            ? addGrouping({
+                integerPart: rawValue.toString(),
+                groupingSize: params.groupingSize,
+                groupingSeparator: params.groupingSeparator ?? ",",
+            })
+            : rawValue.toString();
+    }
+    return formatNanoFromRaw({
+        rawValue: rawValue,
+        decimalPlaces: params.decimalPlaces ?? 30,
+        decimalSeparator: params.decimalSeparator ?? ".",
+        groupingSize: params.groupingSize ?? 0,
+        groupingSeparator: params.groupingSeparator ?? ",",
+    });
+}
+function formatRawNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: formatRawThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function formatRaw(params) {
+    if (params.throwOnError === false) {
+        return formatRawNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return formatRawThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/math/index.d.ts

@@ -0,0 +1,14 @@
+export { formatRaw } from "./format-raw";
+export { nanoToRaw } from "./nano-to-raw";
+export { rawDivide } from "./raw-divide";
+export { rawIsEqualTo } from "./raw-is-equal-to";
+export { rawIsGreaterThan } from "./raw-is-greater-than";
+export { rawIsGreaterThanOrEqualTo } from "./raw-is-greater-than-or-equal-to";
+export { rawIsLessThan } from "./raw-is-less-than";
+export { rawIsLessThanOrEqualTo } from "./raw-is-less-than-or-equal-to";
+export { rawIsZero } from "./raw-is-zero";
+export { rawMinus } from "./raw-minus";
+export { rawModulo } from "./raw-modulo";
+export { rawMultiply } from "./raw-multiply";
+export { rawPlus } from "./raw-plus";
+export { rawToNano } from "./raw-to-nano";

package/dist/nano/math/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawToNano = exports.rawPlus = exports.rawMultiply = exports.rawModulo = exports.rawMinus = exports.rawIsZero = exports.rawIsLessThanOrEqualTo = exports.rawIsLessThan = exports.rawIsGreaterThanOrEqualTo = exports.rawIsGreaterThan = exports.rawIsEqualTo = exports.rawDivide = exports.nanoToRaw = exports.formatRaw = void 0;
+var format_raw_1 = require("./format-raw");
+Object.defineProperty(exports, "formatRaw", { enumerable: true, get: function () { return format_raw_1.formatRaw; } });
+var nano_to_raw_1 = require("./nano-to-raw");
+Object.defineProperty(exports, "nanoToRaw", { enumerable: true, get: function () { return nano_to_raw_1.nanoToRaw; } });
+var raw_divide_1 = require("./raw-divide");
+Object.defineProperty(exports, "rawDivide", { enumerable: true, get: function () { return raw_divide_1.rawDivide; } });
+var raw_is_equal_to_1 = require("./raw-is-equal-to");
+Object.defineProperty(exports, "rawIsEqualTo", { enumerable: true, get: function () { return raw_is_equal_to_1.rawIsEqualTo; } });
+var raw_is_greater_than_1 = require("./raw-is-greater-than");
+Object.defineProperty(exports, "rawIsGreaterThan", { enumerable: true, get: function () { return raw_is_greater_than_1.rawIsGreaterThan; } });
+var raw_is_greater_than_or_equal_to_1 = require("./raw-is-greater-than-or-equal-to");
+Object.defineProperty(exports, "rawIsGreaterThanOrEqualTo", { enumerable: true, get: function () { return raw_is_greater_than_or_equal_to_1.rawIsGreaterThanOrEqualTo; } });
+var raw_is_less_than_1 = require("./raw-is-less-than");
+Object.defineProperty(exports, "rawIsLessThan", { enumerable: true, get: function () { return raw_is_less_than_1.rawIsLessThan; } });
+var raw_is_less_than_or_equal_to_1 = require("./raw-is-less-than-or-equal-to");
+Object.defineProperty(exports, "rawIsLessThanOrEqualTo", { enumerable: true, get: function () { return raw_is_less_than_or_equal_to_1.rawIsLessThanOrEqualTo; } });
+var raw_is_zero_1 = require("./raw-is-zero");
+Object.defineProperty(exports, "rawIsZero", { enumerable: true, get: function () { return raw_is_zero_1.rawIsZero; } });
+var raw_minus_1 = require("./raw-minus");
+Object.defineProperty(exports, "rawMinus", { enumerable: true, get: function () { return raw_minus_1.rawMinus; } });
+var raw_modulo_1 = require("./raw-modulo");
+Object.defineProperty(exports, "rawModulo", { enumerable: true, get: function () { return raw_modulo_1.rawModulo; } });
+var raw_multiply_1 = require("./raw-multiply");
+Object.defineProperty(exports, "rawMultiply", { enumerable: true, get: function () { return raw_multiply_1.rawMultiply; } });
+var raw_plus_1 = require("./raw-plus");
+Object.defineProperty(exports, "rawPlus", { enumerable: true, get: function () { return raw_plus_1.rawPlus; } });
+var raw_to_nano_1 = require("./raw-to-nano");
+Object.defineProperty(exports, "rawToNano", { enumerable: true, get: function () { return raw_to_nano_1.rawToNano; } });

package/dist/nano/math/nano-to-raw.d.ts

@@ -0,0 +1,11 @@
+import { NanoAmountString, RawAmountString } from "../types/amount";
+import { NonThrowing } from "../types/non-throwing";
+import { Result } from "../types/result";
+import { Throwing } from "../types/throwing";
+type NanoToRawParams = {
+    nano: NanoAmountString;
+} & (Throwing | NonThrowing);
+export declare function nanoToRaw(params: NanoToRawParams & NonThrowing): Result<RawAmountString>;
+export declare function nanoToRaw(params: NanoToRawParams & Throwing): RawAmountString;
+export declare function nanoToRaw(params: NanoToRawParams): RawAmountString | Result<RawAmountString>;
+export {};