nano-sdk 1.0.0

package/dist/nano/crypto/conversion/base32-converter.d.ts

@@ -0,0 +1,16 @@
+import { NonThrowing } from "../../types/non-throwing";
+import { Result } from "../../types/result";
+import { Throwing } from "../../types/throwing";
+type EncodeBase32Params = {
+    bytes: Uint8Array;
+} & (Throwing | NonThrowing);
+export declare function encodeBase32(params: EncodeBase32Params & NonThrowing): Result<string>;
+export declare function encodeBase32(params: EncodeBase32Params & Throwing): string;
+export declare function encodeBase32(params: EncodeBase32Params): string | Result<string>;
+type DecodeBase32Params = {
+    encoded: string;
+} & (Throwing | NonThrowing);
+export declare function decodeBase32(params: DecodeBase32Params & NonThrowing): Result<Uint8Array>;
+export declare function decodeBase32(params: DecodeBase32Params & Throwing): Uint8Array;
+export declare function decodeBase32(params: DecodeBase32Params): Uint8Array | Result<Uint8Array>;
+export {};

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeBase32 = encodeBase32;
+exports.decodeBase32 = decodeBase32;
+const alphabet = "13456789abcdefghijkmnopqrstuwxyz";
+function encodeBase32Throwing(params) {
+    const inputLength = params.bytes.length;
+    const totalBits = inputLength * 8;
+    const remainingBits = totalBits % 5;
+    const paddingBits = remainingBits === 0 ? 0 : 5 - remainingBits;
+    let buffer = 0;
+    let encoded = "";
+    let bufferBits = 0;
+    for (let index = 0; index < inputLength; index++) {
+        buffer = (buffer << 8) | params.bytes[index];
+        bufferBits += 8;
+        while (bufferBits >= 5) {
+            encoded += alphabet[(buffer >>> (bufferBits + paddingBits - 5)) & 31];
+            bufferBits -= 5;
+        }
+    }
+    if (bufferBits > 0) {
+        encoded += alphabet[(buffer << (5 - (bufferBits + paddingBits))) & 31];
+    }
+    return encoded;
+}
+function encodeBase32NonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: encodeBase32Throwing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function encodeBase32(params) {
+    if (params.throwOnError === false) {
+        return encodeBase32NonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return encodeBase32Throwing({ ...params, throwOnError: true });
+    }
+}
+function decodeBase32Throwing(params) {
+    const inputLength = params.encoded.length;
+    const remainingBits = (inputLength * 5) % 8;
+    const paddingBits = remainingBits === 0 ? 0 : 8 - remainingBits;
+    let bufferBits = 0;
+    let buffer = 0;
+    let outputIndex = 0;
+    let decodedBytes = new Uint8Array(Math.ceil((inputLength * 5) / 8));
+    for (let position = 0; position < inputLength; position++) {
+        const alphabetIndex = alphabet.indexOf(params.encoded[position]);
+        if (alphabetIndex === -1) {
+            throw new Error(`Found invalid character: ${params.encoded[position]}!`);
+        }
+        buffer = (buffer << 5) | alphabetIndex;
+        bufferBits += 5;
+        if (bufferBits >= 8) {
+            decodedBytes[outputIndex++] = (buffer >>> (bufferBits + paddingBits - 8)) & 255;
+            bufferBits -= 8;
+        }
+    }
+    if (bufferBits > 0) {
+        decodedBytes[outputIndex++] = (buffer << (bufferBits + paddingBits - 8)) & 255;
+    }
+    if (remainingBits !== 0) {
+        decodedBytes = decodedBytes.slice(1);
+    }
+    return decodedBytes;
+}
+function decodeBase32NonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: decodeBase32Throwing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function decodeBase32(params) {
+    if (params.throwOnError === false) {
+        return decodeBase32NonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return decodeBase32Throwing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/conversion/hash-converter.d.ts

@@ -0,0 +1,17 @@
+import { HashString } from "../../types/hash";
+import { NonThrowing } from "../../types/non-throwing";
+import { Result } from "../../types/result";
+import { Throwing } from "../../types/throwing";
+type HashToBytesParams = {
+    hash: HashString;
+} & (Throwing | NonThrowing);
+export declare function hashToBytes(params: HashToBytesParams & NonThrowing): Result<Uint8Array>;
+export declare function hashToBytes(params: HashToBytesParams & Throwing): Uint8Array;
+export declare function hashToBytes(params: HashToBytesParams): Uint8Array | Result<Uint8Array>;
+type BytesToHashParams = {
+    hashBytes: Uint8Array;
+} & (Throwing | NonThrowing);
+export declare function bytesToHash(params: BytesToHashParams & NonThrowing): Result<HashString>;
+export declare function bytesToHash(params: BytesToHashParams & Throwing): HashString;
+export declare function bytesToHash(params: BytesToHashParams): HashString | Result<HashString>;
+export {};

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashToBytes = hashToBytes;
+exports.bytesToHash = bytesToHash;
+const hash_1 = require("../../types/hash");
+const hex_converter_1 = require("./hex-converter");
+function hashToBytesThrowing(params) {
+    const validatedHash = (0, hash_1.HashString)().safeParse(params.hash);
+    if (!validatedHash.success) {
+        throw new Error("Invalid hash value.");
+    }
+    return (0, hex_converter_1.hexToBytes)({ hex: validatedHash.data, throwOnError: true });
+}
+function hashToBytesNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: hashToBytesThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function hashToBytes(params) {
+    if (params.throwOnError === false) {
+        return hashToBytesNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return hashToBytesThrowing({ ...params, throwOnError: true });
+    }
+}
+function bytesToHashThrowing(params) {
+    const hexResult = (0, hex_converter_1.bytesToHex)({ bytes: params.hashBytes, throwOnError: true });
+    const validatedHash = (0, hash_1.HashString)().safeParse(hexResult);
+    if (!validatedHash.success) {
+        throw new Error("Invalid hash byte array.");
+    }
+    return validatedHash.data;
+}
+function bytesToHashNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: bytesToHashThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function bytesToHash(params) {
+    if (params.throwOnError === false) {
+        return bytesToHashNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return bytesToHashThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/conversion/hex-converter.d.ts

@@ -0,0 +1,17 @@
+import { HexString } from "../../types/hex";
+import { NonThrowing } from "../../types/non-throwing";
+import { Result } from "../../types/result";
+import { Throwing } from "../../types/throwing";
+type HexToBytesParams = {
+    hex: string;
+} & (Throwing | NonThrowing);
+export declare function hexToBytes(params: HexToBytesParams & NonThrowing): Result<Uint8Array>;
+export declare function hexToBytes(params: HexToBytesParams & Throwing): Uint8Array;
+export declare function hexToBytes(params: HexToBytesParams): Uint8Array | Result<Uint8Array>;
+type BytesToHexParams = {
+    bytes: Uint8Array;
+} & (Throwing | NonThrowing);
+export declare function bytesToHex(params: BytesToHexParams & NonThrowing): Result<HexString>;
+export declare function bytesToHex(params: BytesToHexParams & Throwing): HexString;
+export declare function bytesToHex(params: BytesToHexParams): HexString | Result<HexString>;
+export {};

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexToBytes = hexToBytes;
+exports.bytesToHex = bytesToHex;
+const byte_array_1 = require("../../types/byte-array");
+const hex_1 = require("../../types/hex");
+function hexToBytesThrowing(params) {
+    const validatedHex = (0, hex_1.HexString)().safeParse(params.hex);
+    if (!validatedHex.success) {
+        throw new Error("Invalid hex string.");
+    }
+    const normalizedHex = validatedHex.data.toUpperCase();
+    if (normalizedHex.length % 2 !== 0) {
+        throw new Error(`Hex value [${normalizedHex}] must contain a multiple of 2 characters.`);
+    }
+    const byteValues = [];
+    for (let index = 0; index < normalizedHex.length; index += 2) {
+        byteValues.push(parseInt(normalizedHex.substring(index, index + 2), 16));
+    }
+    return new Uint8Array(byteValues);
+}
+function hexToBytesNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: hexToBytesThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function hexToBytes(params) {
+    if (params.throwOnError === false) {
+        return hexToBytesNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return hexToBytesThrowing({ ...params, throwOnError: true });
+    }
+}
+function bytesToHexThrowing(params) {
+    const validatedBytes = (0, byte_array_1.ByteArray)().safeParse(params.bytes);
+    if (!validatedBytes.success) {
+        throw new Error("Invalid bytes value.");
+    }
+    let hexString = "";
+    for (let index = 0; index < validatedBytes.data.length; index++) {
+        let byteHex = (validatedBytes.data[index] & 0xff).toString(16);
+        byteHex = byteHex.length === 1 ? `0${byteHex}` : byteHex;
+        hexString += byteHex;
+    }
+    const hexResult = (0, hex_1.HexString)().safeParse(hexString.toUpperCase());
+    if (!hexResult.success) {
+        throw new Error("Invalid hex value derived from byte array.");
+    }
+    return hexResult.data;
+}
+function bytesToHexNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: bytesToHexThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function bytesToHex(params) {
+    if (params.throwOnError === false) {
+        return bytesToHexNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return bytesToHexThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/conversion/private-key-converter.d.ts

@@ -0,0 +1,17 @@
+import { NonThrowing } from "../../types/non-throwing";
+import { PrivateKeyString } from "../../types/private-key";
+import { Result } from "../../types/result";
+import { Throwing } from "../../types/throwing";
+type PrivateKeyToBytesParams = {
+    privateKey: PrivateKeyString;
+} & (Throwing | NonThrowing);
+export declare function privateKeyToBytes(params: PrivateKeyToBytesParams & NonThrowing): Result<Uint8Array>;
+export declare function privateKeyToBytes(params: PrivateKeyToBytesParams & Throwing): Uint8Array;
+export declare function privateKeyToBytes(params: PrivateKeyToBytesParams): Uint8Array | Result<Uint8Array>;
+type BytesToPrivateKeyParams = {
+    privateKeyBytes: Uint8Array;
+} & (Throwing | NonThrowing);
+export declare function bytesToPrivateKey(params: BytesToPrivateKeyParams & NonThrowing): Result<PrivateKeyString>;
+export declare function bytesToPrivateKey(params: BytesToPrivateKeyParams & Throwing): PrivateKeyString;
+export declare function bytesToPrivateKey(params: BytesToPrivateKeyParams): PrivateKeyString | Result<PrivateKeyString>;
+export {};

package/dist/nano/crypto/conversion/private-key-converter.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.privateKeyToBytes = privateKeyToBytes;
+exports.bytesToPrivateKey = bytesToPrivateKey;
+const private_key_1 = require("../../types/private-key");
+const hex_converter_1 = require("./hex-converter");
+function privateKeyToBytesThrowing(params) {
+    const validatedPrivateKey = (0, private_key_1.PrivateKeyString)().safeParse(params.privateKey);
+    if (!validatedPrivateKey.success) {
+        throw new Error("Invalid private key value.");
+    }
+    return (0, hex_converter_1.hexToBytes)({ hex: validatedPrivateKey.data, throwOnError: true });
+}
+function privateKeyToBytesNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: privateKeyToBytesThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function privateKeyToBytes(params) {
+    if (params.throwOnError === false) {
+        return privateKeyToBytesNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return privateKeyToBytesThrowing({ ...params, throwOnError: true });
+    }
+}
+function bytesToPrivateKeyThrowing(params) {
+    const hexResult = (0, hex_converter_1.bytesToHex)({ bytes: params.privateKeyBytes, throwOnError: true });
+    const privateKeyResult = (0, private_key_1.PrivateKeyString)().safeParse(hexResult);
+    if (!privateKeyResult.success) {
+        throw new Error("Invalid private key byte array.");
+    }
+    return privateKeyResult.data;
+}
+function bytesToPrivateKeyNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: bytesToPrivateKeyThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function bytesToPrivateKey(params) {
+    if (params.throwOnError === false) {
+        return bytesToPrivateKeyNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return bytesToPrivateKeyThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/conversion/public-key-converter.d.ts

@@ -0,0 +1,17 @@
+import { NonThrowing } from "../../types/non-throwing";
+import { PublicKeyString } from "../../types/public-key";
+import { Result } from "../../types/result";
+import { Throwing } from "../../types/throwing";
+type PublicKeyToBytesParams = {
+    publicKey: PublicKeyString;
+} & (Throwing | NonThrowing);
+export declare function publicKeyToBytes(params: PublicKeyToBytesParams & NonThrowing): Result<Uint8Array>;
+export declare function publicKeyToBytes(params: PublicKeyToBytesParams & Throwing): Uint8Array;
+export declare function publicKeyToBytes(params: PublicKeyToBytesParams): Uint8Array | Result<Uint8Array>;
+type BytesToPublicKeyParams = {
+    publicKeyBytes: Uint8Array;
+} & (Throwing | NonThrowing);
+export declare function bytesToPublicKey(params: BytesToPublicKeyParams & NonThrowing): Result<PublicKeyString>;
+export declare function bytesToPublicKey(params: BytesToPublicKeyParams & Throwing): PublicKeyString;
+export declare function bytesToPublicKey(params: BytesToPublicKeyParams): PublicKeyString | Result<PublicKeyString>;
+export {};

package/dist/nano/crypto/conversion/public-key-converter.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicKeyToBytes = publicKeyToBytes;
+exports.bytesToPublicKey = bytesToPublicKey;
+const public_key_1 = require("../../types/public-key");
+const hex_converter_1 = require("./hex-converter");
+function publicKeyToBytesThrowing(params) {
+    const validatedPublicKey = (0, public_key_1.PublicKeyString)().safeParse(params.publicKey);
+    if (!validatedPublicKey.success) {
+        throw new Error("Invalid public key value.");
+    }
+    return (0, hex_converter_1.hexToBytes)({ hex: validatedPublicKey.data, throwOnError: true });
+}
+function publicKeyToBytesNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: publicKeyToBytesThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function publicKeyToBytes(params) {
+    if (params.throwOnError === false) {
+        return publicKeyToBytesNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return publicKeyToBytesThrowing({ ...params, throwOnError: true });
+    }
+}
+function bytesToPublicKeyThrowing(params) {
+    const hexResult = (0, hex_converter_1.bytesToHex)({ bytes: params.publicKeyBytes, throwOnError: true });
+    const publicKeyResult = (0, public_key_1.PublicKeyString)().safeParse(hexResult);
+    if (!publicKeyResult.success) {
+        throw new Error("Invalid public key byte array.");
+    }
+    return publicKeyResult.data;
+}
+function bytesToPublicKeyNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: bytesToPublicKeyThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function bytesToPublicKey(params) {
+    if (params.throwOnError === false) {
+        return bytesToPublicKeyNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return bytesToPublicKeyThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/conversion/seed-converter.d.ts

@@ -0,0 +1,17 @@
+import { NonThrowing } from "../../types/non-throwing";
+import { Result } from "../../types/result";
+import { SeedString } from "../../types/seed";
+import { Throwing } from "../../types/throwing";
+type SeedToBytesParams = {
+    seed: SeedString;
+} & (Throwing | NonThrowing);
+export declare function seedToBytes(params: SeedToBytesParams & NonThrowing): Result<Uint8Array>;
+export declare function seedToBytes(params: SeedToBytesParams & Throwing): Uint8Array;
+export declare function seedToBytes(params: SeedToBytesParams): Uint8Array | Result<Uint8Array>;
+type BytesToSeedParams = {
+    seedBytes: Uint8Array;
+} & (Throwing | NonThrowing);
+export declare function bytesToSeed(params: BytesToSeedParams & NonThrowing): Result<SeedString>;
+export declare function bytesToSeed(params: BytesToSeedParams & Throwing): SeedString;
+export declare function bytesToSeed(params: BytesToSeedParams): SeedString | Result<SeedString>;
+export {};

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seedToBytes = seedToBytes;
+exports.bytesToSeed = bytesToSeed;
+const seed_1 = require("../../types/seed");
+const hex_converter_1 = require("./hex-converter");
+function seedToBytesThrowing(params) {
+    const validatedSeed = (0, seed_1.SeedString)().safeParse(params.seed);
+    if (!validatedSeed.success) {
+        throw new Error("Invalid seed value.");
+    }
+    return (0, hex_converter_1.hexToBytes)({ hex: validatedSeed.data, throwOnError: true });
+}
+function seedToBytesNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: seedToBytesThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function seedToBytes(params) {
+    if (params.throwOnError === false) {
+        return seedToBytesNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return seedToBytesThrowing({ ...params, throwOnError: true });
+    }
+}
+function bytesToSeedThrowing(params) {
+    const hexResult = (0, hex_converter_1.bytesToHex)({ bytes: params.seedBytes, throwOnError: true });
+    const seedResult = (0, seed_1.SeedString)().safeParse(hexResult);
+    if (!seedResult.success) {
+        throw new Error("Invalid seed byte array.");
+    }
+    return seedResult.data;
+}
+function bytesToSeedNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: bytesToSeedThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function bytesToSeed(params) {
+    if (params.throwOnError === false) {
+        return bytesToSeedNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return bytesToSeedThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/conversion/signature-converter.d.ts

@@ -0,0 +1,17 @@
+import { NonThrowing } from "../../types/non-throwing";
+import { Result } from "../../types/result";
+import { SignatureString } from "../../types/signature";
+import { Throwing } from "../../types/throwing";
+type SignatureToBytesParams = {
+    signature: SignatureString;
+} & (Throwing | NonThrowing);
+export declare function signatureToBytes(params: SignatureToBytesParams & NonThrowing): Result<Uint8Array>;
+export declare function signatureToBytes(params: SignatureToBytesParams & Throwing): Uint8Array;
+export declare function signatureToBytes(params: SignatureToBytesParams): Uint8Array | Result<Uint8Array>;
+type BytesToSignatureParams = {
+    signatureBytes: Uint8Array;
+} & (Throwing | NonThrowing);
+export declare function bytesToSignature(params: BytesToSignatureParams & NonThrowing): Result<SignatureString>;
+export declare function bytesToSignature(params: BytesToSignatureParams & Throwing): SignatureString;
+export declare function bytesToSignature(params: BytesToSignatureParams): SignatureString | Result<SignatureString>;
+export {};

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signatureToBytes = signatureToBytes;
+exports.bytesToSignature = bytesToSignature;
+const signature_1 = require("../../types/signature");
+const hex_converter_1 = require("./hex-converter");
+function signatureToBytesThrowing(params) {
+    const validatedSignature = (0, signature_1.SignatureString)().safeParse(params.signature);
+    if (!validatedSignature.success) {
+        throw new Error("Invalid signature value.");
+    }
+    return (0, hex_converter_1.hexToBytes)({ hex: validatedSignature.data, throwOnError: true });
+}
+function signatureToBytesNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: signatureToBytesThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function signatureToBytes(params) {
+    if (params.throwOnError === false) {
+        return signatureToBytesNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return signatureToBytesThrowing({ ...params, throwOnError: true });
+    }
+}
+function bytesToSignatureThrowing(params) {
+    const hexResult = (0, hex_converter_1.bytesToHex)({ bytes: params.signatureBytes, throwOnError: true });
+    const signatureResult = (0, signature_1.SignatureString)().safeParse(hexResult);
+    if (!signatureResult.success) {
+        throw new Error("Invalid signature byte array.");
+    }
+    return signatureResult.data;
+}
+function bytesToSignatureNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: bytesToSignatureThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function bytesToSignature(params) {
+    if (params.throwOnError === false) {
+        return bytesToSignatureNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return bytesToSignatureThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/crypto/conversion/work-converter.d.ts

@@ -0,0 +1,17 @@
+import { NonThrowing } from "../../types/non-throwing";
+import { Result } from "../../types/result";
+import { Throwing } from "../../types/throwing";
+import { WorkString } from "../../types/work";
+type WorkToBytesParams = {
+    work: WorkString;
+} & (Throwing | NonThrowing);
+export declare function workToBytes(params: WorkToBytesParams & NonThrowing): Result<Uint8Array>;
+export declare function workToBytes(params: WorkToBytesParams & Throwing): Uint8Array;
+export declare function workToBytes(params: WorkToBytesParams): Uint8Array | Result<Uint8Array>;
+type BytesToWorkParams = {
+    workBytes: Uint8Array;
+} & (Throwing | NonThrowing);
+export declare function bytesToWork(params: BytesToWorkParams & NonThrowing): Result<WorkString>;
+export declare function bytesToWork(params: BytesToWorkParams & Throwing): WorkString;
+export declare function bytesToWork(params: BytesToWorkParams): WorkString | Result<WorkString>;
+export {};