nano-sdk 1.0.0

package/dist/nano/crypto/conversion/work-converter.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workToBytes = workToBytes;
+exports.bytesToWork = bytesToWork;
+const work_1 = require("../../types/work");
+const hex_converter_1 = require("./hex-converter");
+function workToBytesThrowing(params) {
+    const validatedWork = (0, work_1.WorkString)().safeParse(params.work);
+    if (!validatedWork.success) {
+        throw new Error("Invalid work value.");
+    }
+    return (0, hex_converter_1.hexToBytes)({ hex: validatedWork.data, throwOnError: true });
+}
+function workToBytesNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: workToBytesThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function workToBytes(params) {
+    if (params.throwOnError === false) {
+        return workToBytesNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return workToBytesThrowing({ ...params, throwOnError: true });
+    }
+}
+function bytesToWorkThrowing(params) {
+    const hexResult = (0, hex_converter_1.bytesToHex)({ bytes: params.workBytes, throwOnError: true });
+    const workResult = (0, work_1.WorkString)().safeParse(hexResult);
+    if (!workResult.success) {
+        throw new Error("Invalid work byte array.");
+    }
+    return workResult.data;
+}
+function bytesToWorkNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: bytesToWorkThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function bytesToWork(params) {
+    if (params.throwOnError === false) {
+        return bytesToWorkNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return bytesToWorkThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/derive-account-from-link.d.ts

@@ -0,0 +1,12 @@
+import { AccountString } from "../types/account";
+import { LinkString } from "../types/link";
+import { NonThrowing } from "../types/non-throwing";
+import { Result } from "../types/result";
+import { Throwing } from "../types/throwing";
+type DeriveAccountFromLinkParams = {
+    link: LinkString;
+} & (Throwing | NonThrowing);
+export declare function deriveAccountFromLink(params: DeriveAccountFromLinkParams & NonThrowing): Result<AccountString>;
+export declare function deriveAccountFromLink(params: DeriveAccountFromLinkParams & Throwing): AccountString;
+export declare function deriveAccountFromLink(params: DeriveAccountFromLinkParams): AccountString | Result<AccountString>;
+export {};

package/dist/nano/crypto/derive-account-from-link.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveAccountFromLink = deriveAccountFromLink;
+const public_key_1 = require("../types/public-key");
+const derive_account_from_public_key_1 = require("./derive-account-from-public-key");
+function deriveAccountFromLinkThrowing(params) {
+    const publicKeyResult = (0, public_key_1.PublicKeyString)().safeParse(params.link);
+    if (!publicKeyResult.success) {
+        throw new Error("Invalid link: cannot convert to public key.");
+    }
+    return (0, derive_account_from_public_key_1.deriveAccountFromPublicKey)({ publicKey: publicKeyResult.data, throwOnError: true });
+}
+function deriveAccountFromLinkNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: deriveAccountFromLinkThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function deriveAccountFromLink(params) {
+    if (params.throwOnError === false) {
+        return deriveAccountFromLinkNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return deriveAccountFromLinkThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/derive-account-from-private-key.d.ts

@@ -0,0 +1,12 @@
+import { AccountString } from "../types/account";
+import { NonThrowing } from "../types/non-throwing";
+import { PrivateKeyString } from "../types/private-key";
+import { Result } from "../types/result";
+import { Throwing } from "../types/throwing";
+type DeriveAccountFromPrivateKeyParams = {
+    privateKey: PrivateKeyString;
+} & (Throwing | NonThrowing);
+export declare function deriveAccountFromPrivateKey(params: DeriveAccountFromPrivateKeyParams & NonThrowing): Result<AccountString>;
+export declare function deriveAccountFromPrivateKey(params: DeriveAccountFromPrivateKeyParams & Throwing): AccountString;
+export declare function deriveAccountFromPrivateKey(params: DeriveAccountFromPrivateKeyParams): AccountString | Result<AccountString>;
+export {};

package/dist/nano/crypto/derive-account-from-private-key.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveAccountFromPrivateKey = deriveAccountFromPrivateKey;
+const derive_account_from_public_key_1 = require("./derive-account-from-public-key");
+const derive_public_key_from_private_key_1 = require("./derive-public-key-from-private-key");
+function deriveAccountFromPrivateKeyThrowing(params) {
+    const publicKey = (0, derive_public_key_from_private_key_1.derivePublicKeyFromPrivateKey)({ privateKey: params.privateKey, throwOnError: true });
+    return (0, derive_account_from_public_key_1.deriveAccountFromPublicKey)({ publicKey, throwOnError: true });
+}
+function deriveAccountFromPrivateKeyNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: deriveAccountFromPrivateKeyThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function deriveAccountFromPrivateKey(params) {
+    if (params.throwOnError === false) {
+        return deriveAccountFromPrivateKeyNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return deriveAccountFromPrivateKeyThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/derive-account-from-public-key.d.ts

@@ -0,0 +1,13 @@
+import { AccountPrefix, AccountString } from "../types/account";
+import { NonThrowing } from "../types/non-throwing";
+import { PublicKeyString } from "../types/public-key";
+import { Result } from "../types/result";
+import { Throwing } from "../types/throwing";
+type DeriveAccountFromPublicKeyParams = {
+    publicKey: PublicKeyString;
+    accountPrefix?: AccountPrefix;
+} & (Throwing | NonThrowing);
+export declare function deriveAccountFromPublicKey(params: DeriveAccountFromPublicKeyParams & NonThrowing): Result<AccountString>;
+export declare function deriveAccountFromPublicKey(params: DeriveAccountFromPublicKeyParams & Throwing): AccountString;
+export declare function deriveAccountFromPublicKey(params: DeriveAccountFromPublicKeyParams): AccountString | Result<AccountString>;
+export {};

package/dist/nano/crypto/derive-account-from-public-key.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveAccountFromPublicKey = deriveAccountFromPublicKey;
+const blakejs_1 = require("blakejs");
+const account_1 = require("../types/account");
+const public_key_1 = require("../types/public-key");
+const base32_converter_1 = require("./conversion/base32-converter");
+const public_key_converter_1 = require("./conversion/public-key-converter");
+function deriveAccountFromPublicKeyThrowing(params) {
+    const validatedPublicKey = (0, public_key_1.PublicKeyString)().safeParse(params.publicKey);
+    if (!validatedPublicKey.success) {
+        throw new Error("Invalid public key value.");
+    }
+    const accountPrefix = params.accountPrefix ?? "nano_";
+    const validatedAccountPrefix = (0, account_1.AccountPrefix)({ prefix: accountPrefix }).safeParse(accountPrefix);
+    if (!validatedAccountPrefix.success) {
+        throw new Error("Invalid account prefix value.");
+    }
+    const publicKeyBytes = (0, public_key_converter_1.publicKeyToBytes)({ publicKey: validatedPublicKey.data, throwOnError: true });
+    let checksumBytes;
+    try {
+        checksumBytes = (0, blakejs_1.blake2b)(publicKeyBytes, undefined, 5).reverse();
+    }
+    catch (_err) {
+        throw new Error("Failed to determine checksum bytes.");
+    }
+    const encodedPublicKey = (0, base32_converter_1.encodeBase32)({ bytes: publicKeyBytes, throwOnError: true });
+    const encodedChecksum = (0, base32_converter_1.encodeBase32)({ bytes: checksumBytes, throwOnError: true });
+    const accountResult = (0, account_1.AccountString)().safeParse(validatedAccountPrefix.data + encodedPublicKey + encodedChecksum);
+    if (!accountResult.success) {
+        throw new Error("Failed to derive account from public key.");
+    }
+    return accountResult.data;
+}
+function deriveAccountFromPublicKeyNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: deriveAccountFromPublicKeyThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function deriveAccountFromPublicKey(params) {
+    if (params.throwOnError === false) {
+        return deriveAccountFromPublicKeyNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return deriveAccountFromPublicKeyThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/derive-private-key-from-seed.d.ts

@@ -0,0 +1,13 @@
+import { NonThrowing } from "../types/non-throwing";
+import { PrivateKeyString } from "../types/private-key";
+import { Result } from "../types/result";
+import { SeedIndex, SeedString } from "../types/seed";
+import { Throwing } from "../types/throwing";
+type DerivePrivateKeyFromSeedParams = {
+    seed: SeedString;
+    seedIndex: SeedIndex;
+} & (Throwing | NonThrowing);
+export declare function derivePrivateKeyFromSeed(params: DerivePrivateKeyFromSeedParams & NonThrowing): Result<PrivateKeyString>;
+export declare function derivePrivateKeyFromSeed(params: DerivePrivateKeyFromSeedParams & Throwing): PrivateKeyString;
+export declare function derivePrivateKeyFromSeed(params: DerivePrivateKeyFromSeedParams): PrivateKeyString | Result<PrivateKeyString>;
+export {};

package/dist/nano/crypto/derive-private-key-from-seed.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.derivePrivateKeyFromSeed = derivePrivateKeyFromSeed;
+const blakejs_1 = require("blakejs");
+const seed_1 = require("../types/seed");
+const hex_converter_1 = require("./conversion/hex-converter");
+const private_key_converter_1 = require("./conversion/private-key-converter");
+function derivePrivateKeyFromSeedThrowing(params) {
+    const validatedSeed = (0, seed_1.SeedString)().safeParse(params.seed);
+    if (!validatedSeed.success) {
+        throw new Error("Invalid seed value.");
+    }
+    const validatedIndex = (0, seed_1.SeedIndex)().safeParse(params.seedIndex);
+    if (!validatedIndex.success) {
+        throw new Error("Invalid seed index.");
+    }
+    const seedBytes = (0, hex_converter_1.hexToBytes)({ hex: validatedSeed.data, throwOnError: true });
+    let privateKeyBytes;
+    try {
+        const indexBuffer = new ArrayBuffer(4);
+        const indexDataView = new DataView(indexBuffer);
+        indexDataView.setUint32(0, validatedIndex.data);
+        const indexBytes = new Uint8Array(indexBuffer);
+        const hashContext = (0, blakejs_1.blake2bInit)(32);
+        (0, blakejs_1.blake2bUpdate)(hashContext, seedBytes);
+        (0, blakejs_1.blake2bUpdate)(hashContext, indexBytes);
+        privateKeyBytes = (0, blakejs_1.blake2bFinal)(hashContext);
+    }
+    catch (_err) {
+        throw new Error("Failed to derive private key bytes from seed.");
+    }
+    try {
+        return (0, private_key_converter_1.bytesToPrivateKey)({ privateKeyBytes, throwOnError: true });
+    }
+    catch (_err) {
+        throw new Error("Derived private key is invalid.");
+    }
+}
+function derivePrivateKeyFromSeedNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: derivePrivateKeyFromSeedThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function derivePrivateKeyFromSeed(params) {
+    if (params.throwOnError === false) {
+        return derivePrivateKeyFromSeedNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return derivePrivateKeyFromSeedThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/derive-public-key-from-account.d.ts

@@ -0,0 +1,12 @@
+import { AccountString } from "../types/account";
+import { NonThrowing } from "../types/non-throwing";
+import { PublicKeyString } from "../types/public-key";
+import { Result } from "../types/result";
+import { Throwing } from "../types/throwing";
+type DerivePublicKeyFromAccountParams = {
+    account: AccountString;
+} & (Throwing | NonThrowing);
+export declare function derivePublicKeyFromAccount(params: DerivePublicKeyFromAccountParams & NonThrowing): Result<PublicKeyString>;
+export declare function derivePublicKeyFromAccount(params: DerivePublicKeyFromAccountParams & Throwing): PublicKeyString;
+export declare function derivePublicKeyFromAccount(params: DerivePublicKeyFromAccountParams): PublicKeyString | Result<PublicKeyString>;
+export {};

package/dist/nano/crypto/derive-public-key-from-account.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.derivePublicKeyFromAccount = derivePublicKeyFromAccount;
+const account_1 = require("../types/account");
+const account_converter_1 = require("./conversion/account-converter");
+const public_key_converter_1 = require("./conversion/public-key-converter");
+function derivePublicKeyFromAccountThrowing(params) {
+    const validatedAccount = (0, account_1.AccountString)().safeParse(params.account);
+    if (!validatedAccount.success) {
+        throw new Error("Invalid account value.");
+    }
+    const publicKeyBytes = (0, account_converter_1.accountToBytes)({ account: validatedAccount.data, throwOnError: true });
+    try {
+        return (0, public_key_converter_1.bytesToPublicKey)({ publicKeyBytes, throwOnError: true });
+    }
+    catch (_err) {
+        throw new Error("Failed to derive public key from account.");
+    }
+}
+function derivePublicKeyFromAccountNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: derivePublicKeyFromAccountThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function derivePublicKeyFromAccount(params) {
+    if (params.throwOnError === false) {
+        return derivePublicKeyFromAccountNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return derivePublicKeyFromAccountThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/derive-public-key-from-private-key.d.ts

@@ -0,0 +1,12 @@
+import { NonThrowing } from "../types/non-throwing";
+import { PrivateKeyString } from "../types/private-key";
+import { PublicKeyString } from "../types/public-key";
+import { Result } from "../types/result";
+import { Throwing } from "../types/throwing";
+type DerivePublicKeyFromPrivateKeyParams = {
+    privateKey: PrivateKeyString;
+} & (Throwing | NonThrowing);
+export declare function derivePublicKeyFromPrivateKey(params: DerivePublicKeyFromPrivateKeyParams & NonThrowing): Result<PublicKeyString>;
+export declare function derivePublicKeyFromPrivateKey(params: DerivePublicKeyFromPrivateKeyParams & Throwing): PublicKeyString;
+export declare function derivePublicKeyFromPrivateKey(params: DerivePublicKeyFromPrivateKeyParams): PublicKeyString | Result<PublicKeyString>;
+export {};

package/dist/nano/crypto/derive-public-key-from-private-key.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.derivePublicKeyFromPrivateKey = derivePublicKeyFromPrivateKey;
+const nacl_1 = require("../types/nacl");
+const private_key_1 = require("../types/private-key");
+const private_key_converter_1 = require("./conversion/private-key-converter");
+const public_key_converter_1 = require("./conversion/public-key-converter");
+function derivePublicKeyFromPrivateKeyThrowing(params) {
+    const validatedPrivateKey = (0, private_key_1.PrivateKeyString)().safeParse(params.privateKey);
+    if (!validatedPrivateKey.success) {
+        throw new Error("Invalid private key value.");
+    }
+    const privateKeyBytes = (0, private_key_converter_1.privateKeyToBytes)({ privateKey: validatedPrivateKey.data, throwOnError: true });
+    try {
+        return (0, public_key_converter_1.bytesToPublicKey)({ publicKeyBytes: nacl_1.Nacl.derivePublicFromSecret(privateKeyBytes), throwOnError: true });
+    }
+    catch (_err) {
+        throw new Error("Failed to derive public key from private key.");
+    }
+}
+function derivePublicKeyFromPrivateKeyNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: derivePublicKeyFromPrivateKeyThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function derivePublicKeyFromPrivateKey(params) {
+    if (params.throwOnError === false) {
+        return derivePublicKeyFromPrivateKeyNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return derivePublicKeyFromPrivateKeyThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/generate-private-key.d.ts

@@ -0,0 +1,10 @@
+import { NonThrowing } from "../types/non-throwing";
+import { PrivateKeyString } from "../types/private-key";
+import { Result } from "../types/result";
+import { Throwing } from "../types/throwing";
+type GeneratePrivateKeyParams = {} & (Throwing | NonThrowing);
+export declare function generatePrivateKey(): PrivateKeyString;
+export declare function generatePrivateKey(params: GeneratePrivateKeyParams & NonThrowing): Result<PrivateKeyString>;
+export declare function generatePrivateKey(params: GeneratePrivateKeyParams & Throwing): PrivateKeyString;
+export declare function generatePrivateKey(params: GeneratePrivateKeyParams): PrivateKeyString | Result<PrivateKeyString>;
+export {};

package/dist/nano/crypto/generate-private-key.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePrivateKey = generatePrivateKey;
+const private_key_1 = require("../types/private-key");
+const generate_seed_1 = require("./generate-seed");
+function generatePrivateKeyThrowing(_params) {
+    const privateKeyResult = (0, private_key_1.PrivateKeyString)().safeParse((0, generate_seed_1.generateSeed)({ throwOnError: true }));
+    if (!privateKeyResult.success) {
+        throw new Error("Generated private key is invalid.");
+    }
+    return privateKeyResult.data;
+}
+function generatePrivateKeyNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: generatePrivateKeyThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function generatePrivateKey(params) {
+    if (params?.throwOnError === false) {
+        return generatePrivateKeyNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return generatePrivateKeyThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/generate-public-key.d.ts

@@ -0,0 +1,10 @@
+import { NonThrowing } from "../types/non-throwing";
+import { PublicKeyString } from "../types/public-key";
+import { Result } from "../types/result";
+import { Throwing } from "../types/throwing";
+type GeneratePublicKeyParams = {} & (Throwing | NonThrowing);
+export declare function generatePublicKey(): PublicKeyString;
+export declare function generatePublicKey(params: GeneratePublicKeyParams & NonThrowing): Result<PublicKeyString>;
+export declare function generatePublicKey(params: GeneratePublicKeyParams & Throwing): PublicKeyString;
+export declare function generatePublicKey(params: GeneratePublicKeyParams): PublicKeyString | Result<PublicKeyString>;
+export {};

package/dist/nano/crypto/generate-public-key.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePublicKey = generatePublicKey;
+const derive_public_key_from_private_key_1 = require("./derive-public-key-from-private-key");
+const generate_private_key_1 = require("./generate-private-key");
+function generatePublicKeyThrowing(_params) {
+    const privateKey = (0, generate_private_key_1.generatePrivateKey)({ throwOnError: true });
+    return (0, derive_public_key_from_private_key_1.derivePublicKeyFromPrivateKey)({ privateKey, throwOnError: true });
+}
+function generatePublicKeyNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: generatePublicKeyThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function generatePublicKey(params) {
+    if (params?.throwOnError === false) {
+        return generatePublicKeyNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return generatePublicKeyThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/generate-random-bytes.d.ts

@@ -0,0 +1,10 @@
+import { NonThrowing } from "../types/non-throwing";
+import { Result } from "../types/result";
+import { Throwing } from "../types/throwing";
+type GenerateRandomBytesParams = {
+    count: number;
+} & (Throwing | NonThrowing);
+export declare function generateRandomBytes(params: GenerateRandomBytesParams & NonThrowing): Result<Uint8Array>;
+export declare function generateRandomBytes(params: GenerateRandomBytesParams & Throwing): Uint8Array;
+export declare function generateRandomBytes(params: GenerateRandomBytesParams): Uint8Array | Result<Uint8Array>;
+export {};

package/dist/nano/crypto/generate-random-bytes.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomBytes = generateRandomBytes;
+function generateRandomBytesThrowing(params) {
+    if (!Number.isInteger(params.count) || params.count <= 0) {
+        throw new Error("count must be a positive integer");
+    }
+    const byteArray = new Uint8Array(params.count);
+    try {
+        const globalCrypto = globalThis.crypto;
+        if (globalCrypto && typeof globalCrypto.getRandomValues === "function") {
+            globalCrypto.getRandomValues(byteArray);
+            return byteArray;
+        }
+    }
+    catch (_) {
+        // Do nothing
+    }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const nodeCrypto = require("crypto");
+        if (typeof nodeCrypto.randomFillSync === "function") {
+            nodeCrypto.randomFillSync(byteArray);
+            return byteArray;
+        }
+        if (typeof nodeCrypto.randomBytes === "function") {
+            byteArray.set(nodeCrypto.randomBytes(byteArray.length));
+            return byteArray;
+        }
+    }
+    catch (_) {
+        // Do nothing
+    }
+    throw new Error("Unable to access a secure random source.");
+}
+function generateRandomBytesNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: generateRandomBytesThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function generateRandomBytes(params) {
+    if (params.throwOnError === false) {
+        return generateRandomBytesNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return generateRandomBytesThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/generate-seed.d.ts

@@ -0,0 +1,10 @@
+import { NonThrowing } from "../types/non-throwing";
+import { Result } from "../types/result";
+import { SeedString } from "../types/seed";
+import { Throwing } from "../types/throwing";
+type GenerateSeedParams = {} & (Throwing | NonThrowing);
+export declare function generateSeed(): SeedString;
+export declare function generateSeed(params: GenerateSeedParams & NonThrowing): Result<SeedString>;
+export declare function generateSeed(params: GenerateSeedParams & Throwing): SeedString;
+export declare function generateSeed(params: GenerateSeedParams): SeedString | Result<SeedString>;
+export {};

package/dist/nano/crypto/generate-seed.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSeed = generateSeed;
+const seed_converter_1 = require("./conversion/seed-converter");
+const generate_random_bytes_1 = require("./generate-random-bytes");
+function generateSeedThrowing(_params) {
+    const randomSeedBytes = (0, generate_random_bytes_1.generateRandomBytes)({ count: 32, throwOnError: true });
+    return (0, seed_converter_1.bytesToSeed)({ seedBytes: randomSeedBytes, throwOnError: true });
+}
+function generateSeedNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: generateSeedThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function generateSeed(params) {
+    if (params?.throwOnError === false) {
+        return generateSeedNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return generateSeedThrowing({ ...params, throwOnError: true });
+    }
+}

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

@@ -0,0 +1,18 @@
+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 { Result } from "../types/result";
+import { Throwing } from "../types/throwing";
+type HashBlockParams = {
+    account: AccountString;
+    previous: HashString;
+    representative: AccountString;
+    balance: RawAmountString;
+    link: LinkString;
+} & (Throwing | NonThrowing);
+export declare function hashBlock(params: HashBlockParams & NonThrowing): Result<HashString>;
+export declare function hashBlock(params: HashBlockParams & Throwing): HashString;
+export declare function hashBlock(params: HashBlockParams): HashString | Result<HashString>;
+export {};