nano-sdk 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Andreas Lichnovsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,262 @@
+<a name="nano-sdk"></a>
+# nano-sdk
+
+Production-grade TypeScript SDK for interacting with a **Nano** node, providing fully typed and runtime-validated RPC and WebSocket APIs, a built-in WebSocket client with typed ack and topic listeners, and utilities for blocks, cryptography, and safe raw amount arithmetic.
+
+<a name="installation"></a>
+## Installation
+
+```bash
+npm i nano-sdk zod
+```
+
+<a name="quick-start"></a>
+## Quick Start
+
+```ts
+import { Nano } from "nano-sdk";
+
+const nanoRpcUrl = "http://127.0.0.1:7076";
+
+// Alias
+type AccountString = Nano.Types.AccountString;
+const AccountString = Nano.Types.AccountString();
+
+async function fetchAccountBalance(account: AccountString) {
+  // 1) Validate user input
+  const validatedAccount = AccountString.parse(account);
+
+  // 2) Typed RPC call
+  const response = await Nano.RPC.account_balance(
+    nanoRpcUrl,
+    {
+      action: "account_balance",
+      account: validatedAccount,
+      include_only_confirmed: true,
+    },
+    { timeoutInMs: 2000 }
+  );
+
+  // 3) Convert and format raw balance
+  const balanceInNano = Nano.Math.rawToNano({ raw: response.balance, decimalPlaces: 6 });
+
+  // 4) Output balanceInNano
+  console.log("Balance (Nano):", balanceInNano);
+}
+
+fetchAccountBalance("nano_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3").catch((err) => console.error("Unexpected failure:", err));
+```
+
+<a name="typed-rpc-example"></a>
+## Typed & Runtime-Validated RPC
+
+RPC requests and responses are fully typed and validated at runtime. Response types are derived from the corresponding request parameters, meaning the shape of the response object adapts based on the options you provide.
+
+![Typed RPC Response IntelliSense](./images/rpc-response-intellisense.gif)
+
+<a name="overview"></a>
+## Overview & Features
+
+The SDK uses a single root namespace (**Nano**), organized into sub-namespaces, each focused on a specific responsibility:
+
+- `Nano.Blocks`: Block schemas (**Zod**) for validating and composing **Nano** blocks
+- `Nano.Crypto`: Key derivation, block hashing, signing, and verification utilities
+- `Nano.Math`: Raw amount conversion, formatting, and safe raw arithmetic
+- `Nano.RPC`: **Nano** node RPC methods (HTTP POST), with typed requests and typed responses
+- `Nano.Types`: Runtime validators for common **Nano** primitives (account, hash, keys, raw amounts, etc.)
+- `Nano.WebSocket`: Fully typed **Nano** node WebSocket request and response schemas, including acknowledgement and topic message definitions
+- `Nano.WebSocketClient`: Instantiable WebSocket client providing fully typed acknowledgement and topic-based message handling using the `Nano.WebSocket` schemas
+
+<a name="rpc"></a>
+## RPC Usage
+
+All RPC methods:
+
+- validate requests using **Zod**
+- perform an HTTP POST (default: native `fetch`)
+- detect and handle post errors
+- validate responses using **Zod**
+
+All RPC methods follow a consistent signature:
+
+`Nano.RPC.<method>(rpcUrl, request, config?)`
+
+- `rpcUrl` – **Nano** node RPC endpoint
+- `request` – typed request object (including `action`)
+- `config` *(optional)* – request behavior and transport options
+
+### Error Handling
+
+By default, RPC calls throw `Nano.RPC.PostError` for:
+
+- Invalid request payloads
+- HTTP or transport errors
+- **Nano** node error responses
+- Invalid or unexpected response data
+
+If `throwOnError` is set to false, the method instead returns a structured result object indicating success or failure.
+
+### Request config
+
+The optional config supports:
+
+- `throwOnError` – true (default) throws, false returns `{ success, data / error }`
+- `timeoutInMs` – HTTP timeout
+- `abortSignal` – cancellation via AbortController
+- `httpClient` – custom HTTP transport
+
+By default, errors throw `Nano.RPC.PostError`.
+
+### Custom HTTP client
+
+RPC methods accept a custom `httpClient` via the request config. See the `axios` example in
+
+- [`axios-http-client.example.ts`](https://github.com/infinitybay/nano-sdk/blob/master/examples/rpc/axios-http-client.example.ts)
+
+### Examples
+
+- [`account-info.example.ts`](https://github.com/infinitybay/nano-sdk/blob/master/examples/rpc/account-info.example.ts)
+- [`version.example.ts`](https://github.com/infinitybay/nano-sdk/blob/master/examples/rpc/version.example.ts)
+
+<a name="websocket"></a>
+## WebSocket Usage
+
+`Nano.WebSocket` provides a complete, strongly typed implementation of all **Nano** node WebSocket request and response schemas and ships with a built-in `WebSocketClient`. By default, the client uses the globally available `WebSocket` implementation provided by the current runtime environment (browser or Node.js).
+
+The `WebSocketClient` exposes **fully typed WebSocket interactions** through two complementary listener APIs:
+
+- **Ack listeners** for handling typed acknowledgement messages returned by the node when a WebSocket action explicitly requests an acknowledgement (`subscribe`, `unsubscribe`, `update`, or `pong`)
+- **Topic listeners** for typed streaming subscriptions, including `bootstrap`, `confirmation`, `new_unconfirmed_block`, `started_election`, `stopped_election`, `telemetry`, `work`, and `vote`
+
+All incoming messages are validated and typed based on the corresponding WebSocket schemas, enabling safe, ergonomic access to response data without manual parsing or casting.
+
+![Typed WebSocket Response IntelliSense](./images/web-socket-response-intellisense.gif)
+
+### Available options
+
+```ts
+const ws = new Nano.WebSocketClient(webSocketUrl, undefined, {
+  webSocketClass: undefined, // WebSocket constructor, if none provided, defaults to global WebSocket
+  connectionTimeout: 4000, // retry connect if not connected after this time, in ms
+  minUptime: 5000, // min time in ms to consider connection as stable
+  maxEnqueuedMessages: Infinity, // maximum number of messages to buffer until reconnection
+  maxReconnectionAttempts: Infinity, // maximum number of reconnection attempts
+  maxReconnectionDelay: 10000, // max delay in ms between reconnections
+  minReconnectionDelay: 1000 + Math.random() * 4000, // min delay in ms between reconnections
+  reconnectionDelayGrowFactor: 1.3, // how fast the reconnection delay grows
+  startClosed: false, // start websocket in CLOSED state, call `.reconnect()` to connect
+});
+```
+
+### Examples
+
+- [`typed-ack-and-topic-listeners.example.ts`](https://github.com/infinitybay/nano-sdk/blob/master/examples/web-socket/typed-ack-and-topic-listeners.example.ts)
+- [`custom-web-socket-client.example.ts`](https://github.com/infinitybay/nano-sdk/blob/master/examples/web-socket/custom-web-socket-client.example.ts)
+
+<a name="validation"></a>
+## Validation & Typing
+
+`Nano.Types` provides a collection of **reusable Zod schemas** for common **Nano-specific primitives**. These schemas form the foundation for higher-level features such as cryptography and RPC validation. Use them to validate external input and to type values throughout your codebase:
+
+- Prefer `.parse(...)` when invalid input should throw immediately
+- Prefer `.safeParse(...)` when you want a typed success/failure result without throwing
+
+The available schemas cover a wide range of Nano primitives, including but not limited to:
+
+- `AccountString`, `RawAmountString`, `NanoAmountString`, `PrivateKeyString`, `PublicKeyString`, `SignatureString`, `HashString`, `HexString`, ...
+
+### Examples
+
+- [`alias-and-safe-parse.example.ts`](https://github.com/infinitybay/nano-sdk/blob/master/examples/types/alias-and-safe-parse.example.ts)
+
+<a name="math"></a>
+## Math
+
+`Nano.Math` provides safe arithmetic, comparison, and formatting utilities for **nano** and **raw** amounts.
+
+**Raw** amounts can be represented as **strings** (`RawAmountString`, to remain JSON-serializable) and native `BigInt` values (`RawAmount`).
+
+**Nano** amounts are represented as **strings** (`NanoAmountString`) to avoid precision issues and eliminate the need for a `BigNumber.js` dependency.
+
+All raw functions support **mixed inputs** (`RawAmount` and `RawAmountString`).
+The **type of the first parameter** of arithmetic functions determines the return type:
+- If the first `raw` parameter is a `RawAmount` (`BigInt`), the result is returned as `BigInt`
+- If the first `raw` parameter is a `RawAmountString` (`String`), the result is returned as `String`
+
+Available utilities:
+
+- Conversion: `nanoToRaw`, `rawToNano`
+- Formatting: `formatRaw`
+- Arithmetic (with bounds checking):  
+  `rawPlus`, `rawMinus`, `rawMultiply`, `rawDivide`, `rawModulo`
+- Comparisons:  
+  `rawIsZero`, `rawIsGreaterThan`, `rawIsGreaterThanOrEqualTo`, `rawIsLessThan`, `rawIsLessThanOrEqualTo`, `rawIsEqualTo`
+
+### Examples
+
+- [`format-raw.example.ts`](https://github.com/infinitybay/nano-sdk/blob/master/examples/math/format-raw.example.ts)
+- [`raw-arithmetic.example.ts`](https://github.com/infinitybay/nano-sdk/blob/master/examples/math/raw-arithmetic.example.ts)
+- [`raw-comparison.example.ts`](https://github.com/infinitybay/nano-sdk/blob/master/examples/math/raw-comparison.example.ts)
+
+<a name="crypto"></a>
+## Crypto
+
+`Nano.Crypto` provides cryptographic utilities commonly needed when building **Nano**-related services:
+
+- Key pair generation and deterministic key derivation
+- Block hashing and hash verification
+- Block signing and signature verification
+- Proof-of-work hash verification
+
+### Examples
+
+- [`derive-account-from-seed.example.ts`](https://github.com/infinitybay/nano-sdk/blob/master/examples/crypto/derive-account-from-seed.example.ts)
+- [`hash-and-verify-hash.example.ts`](https://github.com/infinitybay/nano-sdk/blob/master/examples/crypto/hash-and-verify-hash.example.ts)
+- [`sign-and-verify-signature.example.ts`](https://github.com/infinitybay/nano-sdk/blob/master/examples/crypto/sign-and-verify-signature.example.ts)
+
+## Blocks
+
+`Nano.Blocks` provides predefined Zod schemas for composing and validating **Nano** block variants. All schemas are provided as composable building blocks and can be used as a base to define extended schemas with additional custom fields.
+
+Available block schemas:
+
+- `StateBlock`
+- `LegacySendBlock`, `LegacyReceiveBlock`, `LegacyOpenBlock`, `LegacyChangeBlock`
+- `Block` as a union of all supported block variants
+
+### Examples
+
+- [`state-block-with-hash.example.ts`](https://github.com/infinitybay/nano-sdk/blob/master/examples/blocks/state-block-with-hash.example.ts)
+
+<a name="testing"></a>
+## Testing
+
+- Unit tests (`test/unit`) cover schemas, math edge cases, crypto utilities, and parsing/validation flows (throwing and non-throwing).
+- Integration tests (`test/integration`) verify both **RPC** and **WebSocket** functionality against a real **Nano** node, ensuring request and response schemas match live node behavior.
+
+Unit tests are executed using:
+
+```bash
+npm run test:unit
+```
+
+Integration test requirements:
+
+- A running **Nano** node is required.
+- All public **Nano** RPC and WebSocket endpoints must be reachable. `enable_control=true` is **not** required for any currently enabled integration tests.
+- The RPC endpoint URL can be configured via the `config.nanoRpcUrl` field in `package.json` or via the `NANO_RPC_URL` environment variable. The environment variable takes precedence if both are set.
+- The WebSocket endpoint URL can be configured via the `config.nanoWebSocketUrl` field in `package.json` or via the `NANO_WEB_SOCKET_URL` environment variable. The environment variable takes precedence if both are set.
+
+Integration tests for RPC and WebSocket are executed together using:
+
+```bash
+npm run test:integration
+```
+
+<a name="links"></a>
+## Links
+
+- npm: https://www.npmjs.com/package/nano-sdk
+- GitHub: https://github.com/infinitybay/nano-sdk
+- Nano Node RPC Protocol: https://docs.nano.org/commands/rpc-protocol/
+- Nano Node WebSockets Integration Guide: https://docs.nano.org/integration-guides/websockets/

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import * as Nano from "./nano";
+export { Nano };

package/dist/index.js

@@ -0,0 +1,38 @@
+"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.Nano = void 0;
+const Nano = __importStar(require("./nano"));
+exports.Nano = Nano;

package/dist/nano/blocks/block.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export type Block = z.infer<ReturnType<typeof Block>>;
+export declare const Block: () => z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"change">;
+    previous: z.ZodString;
+    representative: z.ZodString;
+    work: z.ZodString;
+    signature: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"open">;
+    source: z.ZodString;
+    representative: z.ZodString;
+    account: z.ZodString;
+    work: z.ZodString;
+    signature: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"receive">;
+    previous: z.ZodString;
+    source: z.ZodString;
+    work: z.ZodString;
+    signature: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"send">;
+    previous: z.ZodString;
+    destination: z.ZodString;
+    balance: z.ZodString;
+    work: z.ZodString;
+    signature: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"state">;
+    account: z.ZodString;
+    previous: z.ZodString;
+    representative: z.ZodString;
+    balance: z.ZodString;
+    link: z.ZodUnion<[z.ZodString, z.ZodString]>;
+    link_as_account: z.ZodString;
+    signature: z.ZodString;
+    work: z.ZodString;
+}, z.core.$strip>]>;

package/dist/nano/blocks/block.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Block = void 0;
+const zod_1 = require("zod");
+const legacy_change_block_1 = require("./legacy-change-block");
+const legacy_open_block_1 = require("./legacy-open-block");
+const legacy_receive_block_1 = require("./legacy-receive-block");
+const legacy_send_block_1 = require("./legacy-send-block");
+const state_block_1 = require("./state-block");
+const Block = () => zod_1.z.union([(0, legacy_change_block_1.LegacyChangeBlock)(), (0, legacy_open_block_1.LegacyOpenBlock)(), (0, legacy_receive_block_1.LegacyReceiveBlock)(), (0, legacy_send_block_1.LegacySendBlock)(), (0, state_block_1.StateBlock)()]);
+exports.Block = Block;

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

@@ -0,0 +1,6 @@
+export { Block } from "./block";
+export { LegacyChangeBlock } from "./legacy-change-block";
+export { LegacyOpenBlock } from "./legacy-open-block";
+export { LegacyReceiveBlock } from "./legacy-receive-block";
+export { LegacySendBlock } from "./legacy-send-block";
+export { StateBlock } from "./state-block";

package/dist/nano/blocks/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateBlock = exports.LegacySendBlock = exports.LegacyReceiveBlock = exports.LegacyOpenBlock = exports.LegacyChangeBlock = exports.Block = void 0;
+var block_1 = require("./block");
+Object.defineProperty(exports, "Block", { enumerable: true, get: function () { return block_1.Block; } });
+var legacy_change_block_1 = require("./legacy-change-block");
+Object.defineProperty(exports, "LegacyChangeBlock", { enumerable: true, get: function () { return legacy_change_block_1.LegacyChangeBlock; } });
+var legacy_open_block_1 = require("./legacy-open-block");
+Object.defineProperty(exports, "LegacyOpenBlock", { enumerable: true, get: function () { return legacy_open_block_1.LegacyOpenBlock; } });
+var legacy_receive_block_1 = require("./legacy-receive-block");
+Object.defineProperty(exports, "LegacyReceiveBlock", { enumerable: true, get: function () { return legacy_receive_block_1.LegacyReceiveBlock; } });
+var legacy_send_block_1 = require("./legacy-send-block");
+Object.defineProperty(exports, "LegacySendBlock", { enumerable: true, get: function () { return legacy_send_block_1.LegacySendBlock; } });
+var state_block_1 = require("./state-block");
+Object.defineProperty(exports, "StateBlock", { enumerable: true, get: function () { return state_block_1.StateBlock; } });

package/dist/nano/blocks/legacy-change-block.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export type LegacyChangeBlock = z.infer<ReturnType<typeof LegacyChangeBlock>>;
+export declare const LegacyChangeBlock: () => z.ZodObject<{
+    type: z.ZodLiteral<"change">;
+    previous: z.ZodString;
+    representative: z.ZodString;
+    work: z.ZodString;
+    signature: z.ZodString;
+}, z.core.$strip>;

package/dist/nano/blocks/legacy-change-block.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyChangeBlock = void 0;
+const zod_1 = require("zod");
+const account_1 = require("../types/account");
+const hash_1 = require("../types/hash");
+const signature_1 = require("../types/signature");
+const type_1 = require("../types/type");
+const work_1 = require("../types/work");
+const LegacyChangeBlock = () => zod_1.z.object({
+    type: (0, type_1.LegacyChangeTypeString)(),
+    previous: (0, hash_1.HashString)(),
+    representative: (0, account_1.AccountString)(),
+    work: (0, work_1.WorkString)(),
+    signature: (0, signature_1.SignatureString)(),
+});
+exports.LegacyChangeBlock = LegacyChangeBlock;

package/dist/nano/blocks/legacy-open-block.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export type LegacyOpenBlock = z.infer<ReturnType<typeof LegacyOpenBlock>>;
+export declare const LegacyOpenBlock: () => z.ZodObject<{
+    type: z.ZodLiteral<"open">;
+    source: z.ZodString;
+    representative: z.ZodString;
+    account: z.ZodString;
+    work: z.ZodString;
+    signature: z.ZodString;
+}, z.core.$strip>;

package/dist/nano/blocks/legacy-open-block.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyOpenBlock = void 0;
+const zod_1 = require("zod");
+const account_1 = require("../types/account");
+const hash_1 = require("../types/hash");
+const signature_1 = require("../types/signature");
+const type_1 = require("../types/type");
+const work_1 = require("../types/work");
+const LegacyOpenBlock = () => zod_1.z.object({
+    type: (0, type_1.LegacyOpenTypeString)(),
+    source: (0, hash_1.HashString)(),
+    representative: (0, account_1.AccountString)(),
+    account: (0, account_1.AccountString)(),
+    work: (0, work_1.WorkString)(),
+    signature: (0, signature_1.SignatureString)(),
+});
+exports.LegacyOpenBlock = LegacyOpenBlock;

package/dist/nano/blocks/legacy-receive-block.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export type LegacyReceiveBlock = z.infer<ReturnType<typeof LegacyReceiveBlock>>;
+export declare const LegacyReceiveBlock: () => z.ZodObject<{
+    type: z.ZodLiteral<"receive">;
+    previous: z.ZodString;
+    source: z.ZodString;
+    work: z.ZodString;
+    signature: z.ZodString;
+}, z.core.$strip>;

package/dist/nano/blocks/legacy-receive-block.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyReceiveBlock = void 0;
+const zod_1 = require("zod");
+const hash_1 = require("../types/hash");
+const signature_1 = require("../types/signature");
+const type_1 = require("../types/type");
+const work_1 = require("../types/work");
+const LegacyReceiveBlock = () => zod_1.z.object({
+    type: (0, type_1.LegacyReceiveTypeString)(),
+    previous: (0, hash_1.HashString)(),
+    source: (0, hash_1.HashString)(),
+    work: (0, work_1.WorkString)(),
+    signature: (0, signature_1.SignatureString)(),
+});
+exports.LegacyReceiveBlock = LegacyReceiveBlock;

package/dist/nano/blocks/legacy-send-block.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export type LegacySendBlock = z.infer<ReturnType<typeof LegacySendBlock>>;
+export declare const LegacySendBlock: () => z.ZodObject<{
+    type: z.ZodLiteral<"send">;
+    previous: z.ZodString;
+    destination: z.ZodString;
+    balance: z.ZodString;
+    work: z.ZodString;
+    signature: z.ZodString;
+}, z.core.$strip>;

package/dist/nano/blocks/legacy-send-block.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacySendBlock = void 0;
+const zod_1 = require("zod");
+const account_1 = require("../types/account");
+const amount_1 = require("../types/amount");
+const hash_1 = require("../types/hash");
+const signature_1 = require("../types/signature");
+const type_1 = require("../types/type");
+const work_1 = require("../types/work");
+const LegacySendBlock = () => zod_1.z.object({
+    type: (0, type_1.LegacySendTypeString)(),
+    previous: (0, hash_1.HashString)(),
+    destination: (0, account_1.AccountString)(),
+    balance: (0, amount_1.RawAmountString)(),
+    work: (0, work_1.WorkString)(),
+    signature: (0, signature_1.SignatureString)(),
+});
+exports.LegacySendBlock = LegacySendBlock;

package/dist/nano/blocks/state-block.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export type StateBlock = z.infer<ReturnType<typeof StateBlock>>;
+export declare const StateBlock: () => z.ZodObject<{
+    type: z.ZodLiteral<"state">;
+    account: z.ZodString;
+    previous: z.ZodString;
+    representative: z.ZodString;
+    balance: z.ZodString;
+    link: z.ZodUnion<[z.ZodString, z.ZodString]>;
+    link_as_account: z.ZodString;
+    signature: z.ZodString;
+    work: z.ZodString;
+}, z.core.$strip>;

package/dist/nano/blocks/state-block.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateBlock = void 0;
+const zod_1 = require("zod");
+const account_1 = require("../types/account");
+const amount_1 = require("../types/amount");
+const hash_1 = require("../types/hash");
+const link_1 = require("../types/link");
+const signature_1 = require("../types/signature");
+const type_1 = require("../types/type");
+const work_1 = require("../types/work");
+const StateBlock = () => zod_1.z.object({
+    type: (0, type_1.StateTypeString)(),
+    account: (0, account_1.AccountString)(),
+    previous: (0, hash_1.HashString)(),
+    representative: (0, account_1.AccountString)(),
+    balance: (0, amount_1.RawAmountString)(),
+    link: (0, link_1.LinkString)(),
+    link_as_account: (0, account_1.AccountString)(),
+    signature: (0, signature_1.SignatureString)(),
+    work: (0, work_1.WorkString)(),
+});
+exports.StateBlock = StateBlock;

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

@@ -0,0 +1,17 @@
+import { AccountString } from "../../types/account";
+import { NonThrowing } from "../../types/non-throwing";
+import { Result } from "../../types/result";
+import { Throwing } from "../../types/throwing";
+type AccountToBytesParams = {
+    account: AccountString;
+} & (Throwing | NonThrowing);
+export declare function accountToBytes(params: AccountToBytesParams & NonThrowing): Result<Uint8Array>;
+export declare function accountToBytes(params: AccountToBytesParams & Throwing): Uint8Array;
+export declare function accountToBytes(params: AccountToBytesParams): Uint8Array | Result<Uint8Array>;
+type BytesToAccountParams = {
+    publicKeyBytes: Uint8Array;
+} & (Throwing | NonThrowing);
+export declare function bytesToAccount(params: BytesToAccountParams & NonThrowing): Result<AccountString>;
+export declare function bytesToAccount(params: BytesToAccountParams & Throwing): AccountString;
+export declare function bytesToAccount(params: BytesToAccountParams): AccountString | Result<AccountString>;
+export {};

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountToBytes = accountToBytes;
+exports.bytesToAccount = bytesToAccount;
+const account_1 = require("../../types/account");
+const derive_account_from_public_key_1 = require("../derive-account-from-public-key");
+const base32_converter_1 = require("./base32-converter");
+const public_key_converter_1 = require("./public-key-converter");
+const encodedPublicKeyLength = 52;
+const encodedChecksumLength = 8;
+function accountToBytesThrowing(params) {
+    const validatedAccount = (0, account_1.AccountString)().safeParse(params.account);
+    if (!validatedAccount.success) {
+        throw new Error("Invalid account.");
+    }
+    const publicKeyStartIndex = validatedAccount.data.length - encodedPublicKeyLength - encodedChecksumLength;
+    const publicKeyEndIndex = validatedAccount.data.length - encodedChecksumLength;
+    const encodedPublicKey = validatedAccount.data.substring(publicKeyStartIndex, publicKeyEndIndex);
+    return (0, base32_converter_1.decodeBase32)({ encoded: encodedPublicKey, throwOnError: true });
+}
+function accountToBytesNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: accountToBytesThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function accountToBytes(params) {
+    if (params.throwOnError === false) {
+        return accountToBytesNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return accountToBytesThrowing({ ...params, throwOnError: true });
+    }
+}
+function bytesToAccountThrowing(params) {
+    const publicKey = (0, public_key_converter_1.bytesToPublicKey)({ publicKeyBytes: params.publicKeyBytes, throwOnError: true });
+    return (0, derive_account_from_public_key_1.deriveAccountFromPublicKey)({ publicKey, throwOnError: true });
+}
+function bytesToAccountNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: bytesToAccountThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function bytesToAccount(params) {
+    if (params.throwOnError === false) {
+        return bytesToAccountNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return bytesToAccountThrowing({ ...params, throwOnError: true });
+    }
+}