nano-sdk 1.0.0

package/dist/nano/types/node-id.d.ts

@@ -0,0 +1,3 @@
+import z from "zod";
+export type NodeIdString = z.infer<ReturnType<typeof NodeIdString>>;
+export declare const NodeIdString: () => z.ZodString;

package/dist/nano/types/node-id.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeIdString = void 0;
+const account_1 = require("./account");
+const NodeIdString = () => (0, account_1.AccountString)({ prefix: "node_" });
+exports.NodeIdString = NodeIdString;

package/dist/nano/types/non-throwing.d.ts

@@ -0,0 +1,3 @@
+export type NonThrowing = {
+    throwOnError: false;
+};

package/dist/nano/types/non-throwing.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nano/types/number.d.ts

@@ -0,0 +1,3 @@
+import z from "zod";
+export type NumberString = z.infer<ReturnType<typeof NumberString>>;
+export declare const NumberString: () => z.ZodString;

package/dist/nano/types/number.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberString = void 0;
+const zod_1 = __importDefault(require("zod"));
+const NumberString = () => zod_1.default.string().refine((val) => {
+    if (val === "")
+        return false;
+    if (val.trim() !== val)
+        return false;
+    const n = Number(val);
+    return Number.isFinite(n);
+}, {
+    message: "Invalid number",
+});
+exports.NumberString = NumberString;

package/dist/nano/types/port.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const PortBounds: {
+    min: () => number;
+    max: () => number;
+};
+export type Port = z.infer<ReturnType<typeof Port>>;
+export declare const Port: () => z.ZodInt;
+export type PortString = z.infer<ReturnType<typeof PortString>>;
+export declare const PortString: () => z.ZodString;

package/dist/nano/types/port.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortString = exports.Port = exports.PortBounds = void 0;
+const zod_1 = require("zod");
+exports.PortBounds = {
+    min: () => 0,
+    max: () => 65535,
+};
+const Port = () => zod_1.z.int().min(exports.PortBounds.min()).max(exports.PortBounds.max());
+exports.Port = Port;
+const PortString = () => zod_1.z
+    .string()
+    .regex(/^(0|[1-9]\d*)$/, "Invalid port")
+    .refine((val) => (0, exports.Port)().safeParse(Number(val)).success, {
+    message: "Invalid port",
+});
+exports.PortString = PortString;

package/dist/nano/types/private-key.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export type PrivateKeyString = z.infer<ReturnType<typeof PrivateKeyString>>;
+export declare const PrivateKeyString: () => z.ZodString;
+export declare const PrivateKeyStrings: {
+    zero: () => PrivateKeyString;
+};

package/dist/nano/types/private-key.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateKeyStrings = exports.PrivateKeyString = void 0;
+const hex_1 = require("./hex");
+const PrivateKeyString = () => (0, hex_1.HexString)().length(64);
+exports.PrivateKeyString = PrivateKeyString;
+exports.PrivateKeyStrings = {
+    zero: () => (0, exports.PrivateKeyString)().parse("0000000000000000000000000000000000000000000000000000000000000000"),
+};

package/dist/nano/types/public-key.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export type PublicKeyString = z.infer<ReturnType<typeof PublicKeyString>>;
+export declare const PublicKeyString: () => z.ZodString;
+export declare const PublicKeyStrings: {
+    zero: () => PublicKeyString;
+};

package/dist/nano/types/public-key.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicKeyStrings = exports.PublicKeyString = void 0;
+const hex_1 = require("./hex");
+const PublicKeyString = () => (0, hex_1.HexString)().length(64);
+exports.PublicKeyString = PublicKeyString;
+exports.PublicKeyStrings = {
+    zero: () => (0, exports.PublicKeyString)().parse("0000000000000000000000000000000000000000000000000000000000000000"),
+};

package/dist/nano/types/result.d.ts

@@ -0,0 +1,16 @@
+export type Result<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: Error;
+};
+export type PredicateResult<StatusKey extends string, ValueKey extends string> = ({
+    [K in StatusKey]: true;
+} & {
+    [K in ValueKey]: boolean;
+}) | ({
+    [K in StatusKey]: false;
+} & {
+    error: Error;
+});

package/dist/nano/types/result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nano/types/root.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export type RootString = z.infer<ReturnType<typeof RootString>>;
+export declare const RootString: () => z.ZodString;
+export declare const RootStrings: {
+    zero: () => RootString;
+};

package/dist/nano/types/root.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RootStrings = exports.RootString = void 0;
+const hex_1 = require("./hex");
+const RootString = () => (0, hex_1.HexString)().length(128);
+exports.RootString = RootString;
+exports.RootStrings = {
+    zero: () => (0, exports.RootString)().parse("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+};

package/dist/nano/types/seed.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const SeedIndexBounds: {
+    min: () => number;
+    max: () => number;
+};
+export type SeedIndex = z.infer<ReturnType<typeof SeedIndex>>;
+export declare const SeedIndex: () => z.ZodNumber;
+export type SeedString = z.infer<ReturnType<typeof SeedString>>;
+export declare const SeedString: () => z.ZodString;

package/dist/nano/types/seed.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeedString = exports.SeedIndex = exports.SeedIndexBounds = void 0;
+const zod_1 = require("zod");
+const hex_1 = require("./hex");
+exports.SeedIndexBounds = {
+    min: () => 0,
+    max: () => 4294967295,
+};
+const SeedIndex = () => zod_1.z.number().int().min(exports.SeedIndexBounds.min()).max(exports.SeedIndexBounds.max());
+exports.SeedIndex = SeedIndex;
+const SeedString = () => (0, hex_1.HexString)().length(64);
+exports.SeedString = SeedString;

package/dist/nano/types/signature.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export type SignatureString = z.infer<ReturnType<typeof SignatureString>>;
+export declare const SignatureString: () => z.ZodString;
+export declare const SignatureStrings: {
+    zero: () => SignatureString;
+};

package/dist/nano/types/signature.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureStrings = exports.SignatureString = void 0;
+const hex_1 = require("./hex");
+const SignatureString = () => (0, hex_1.HexString)().length(128);
+exports.SignatureString = SignatureString;
+exports.SignatureStrings = {
+    zero: () => (0, exports.SignatureString)().parse("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+};

package/dist/nano/types/subtype.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export type SubtypeOpenString = z.infer<ReturnType<typeof SubtypeOpenString>>;
+export declare const SubtypeOpenString: () => z.ZodLiteral<"open">;
+export type SubtypeString = z.infer<ReturnType<typeof SubtypeString>>;
+export declare const SubtypeString: () => z.ZodUnion<readonly [z.ZodLiteral<"change">, z.ZodLiteral<"epoch">, z.ZodLiteral<"receive">, z.ZodLiteral<"send">, z.ZodLiteral<"unknown">]>;

package/dist/nano/types/subtype.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubtypeString = exports.SubtypeOpenString = void 0;
+const zod_1 = require("zod");
+const SubtypeOpenString = () => zod_1.z.literal("open");
+exports.SubtypeOpenString = SubtypeOpenString;
+const SubtypeString = () => zod_1.z.union([zod_1.z.literal("change"), zod_1.z.literal("epoch"), zod_1.z.literal("receive"), zod_1.z.literal("send"), zod_1.z.literal("unknown")]);
+exports.SubtypeString = SubtypeString;

package/dist/nano/types/throwing.d.ts

@@ -0,0 +1,3 @@
+export type Throwing = {
+    throwOnError?: true | undefined;
+};

package/dist/nano/types/throwing.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nano/types/timestamp.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const TimestampBounds: {
+    min: () => number;
+    max: () => number;
+};
+export type Timestamp = z.infer<ReturnType<typeof Timestamp>>;
+export declare const Timestamp: () => z.ZodInt;
+export type TimestampString = z.infer<ReturnType<typeof TimestampString>>;
+export declare const TimestampString: () => z.ZodString;
+export type FinalVoteTimestampString = z.infer<ReturnType<typeof FinalVoteTimestampString>>;
+export declare const FinalVoteTimestampString: () => z.ZodLiteral<"18446744073709551615">;

package/dist/nano/types/timestamp.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinalVoteTimestampString = exports.TimestampString = exports.Timestamp = exports.TimestampBounds = void 0;
+const zod_1 = require("zod");
+exports.TimestampBounds = {
+    min: () => 0,
+    max: () => Number.MAX_SAFE_INTEGER,
+};
+const Timestamp = () => zod_1.z.int().min(exports.TimestampBounds.min()).max(exports.TimestampBounds.max());
+exports.Timestamp = Timestamp;
+const TimestampString = () => zod_1.z
+    .string()
+    .regex(/^(0|[1-9]\d*)$/, "Invalid timestamp")
+    .refine((val) => (0, exports.Timestamp)().safeParse(Number(val)).success, {
+    message: "Invalid timestamp",
+});
+exports.TimestampString = TimestampString;
+const FinalVoteTimestampString = () => zod_1.z.literal("18446744073709551615");
+exports.FinalVoteTimestampString = FinalVoteTimestampString;

package/dist/nano/types/type.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export type LegacyChangeTypeString = z.infer<ReturnType<typeof LegacyChangeTypeString>>;
+export declare const LegacyChangeTypeString: () => z.ZodLiteral<"change">;
+export type LegacyOpenTypeString = z.infer<ReturnType<typeof LegacyOpenTypeString>>;
+export declare const LegacyOpenTypeString: () => z.ZodLiteral<"open">;
+export type LegacyReceiveTypeString = z.infer<ReturnType<typeof LegacyReceiveTypeString>>;
+export declare const LegacyReceiveTypeString: () => z.ZodLiteral<"receive">;
+export type LegacySendTypeString = z.infer<ReturnType<typeof LegacySendTypeString>>;
+export declare const LegacySendTypeString: () => z.ZodLiteral<"send">;
+export type StateTypeString = z.infer<ReturnType<typeof StateTypeString>>;
+export declare const StateTypeString: () => z.ZodLiteral<"state">;
+export type TypeString = z.infer<ReturnType<typeof TypeString>>;
+export declare const TypeString: () => z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"change">, z.ZodLiteral<"open">]>, z.ZodLiteral<"receive">]>, z.ZodLiteral<"send">]>, z.ZodLiteral<"state">]>;

package/dist/nano/types/type.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeString = exports.StateTypeString = exports.LegacySendTypeString = exports.LegacyReceiveTypeString = exports.LegacyOpenTypeString = exports.LegacyChangeTypeString = void 0;
+const zod_1 = require("zod");
+const LegacyChangeTypeString = () => zod_1.z.literal("change");
+exports.LegacyChangeTypeString = LegacyChangeTypeString;
+const LegacyOpenTypeString = () => zod_1.z.literal("open");
+exports.LegacyOpenTypeString = LegacyOpenTypeString;
+const LegacyReceiveTypeString = () => zod_1.z.literal("receive");
+exports.LegacyReceiveTypeString = LegacyReceiveTypeString;
+const LegacySendTypeString = () => zod_1.z.literal("send");
+exports.LegacySendTypeString = LegacySendTypeString;
+const StateTypeString = () => zod_1.z.literal("state");
+exports.StateTypeString = StateTypeString;
+const TypeString = () => (0, exports.LegacyChangeTypeString)()
+    .or((0, exports.LegacyOpenTypeString)())
+    .or((0, exports.LegacyReceiveTypeString)())
+    .or((0, exports.LegacySendTypeString)())
+    .or((0, exports.StateTypeString)());
+exports.TypeString = TypeString;

package/dist/nano/types/uint.d.ts

@@ -0,0 +1,9 @@
+import z from "zod";
+export declare const UIntBounds: {
+    min: () => number;
+    max: () => number;
+};
+export type UInt = z.infer<ReturnType<typeof UInt>>;
+export declare const UInt: () => z.ZodInt;
+export type UIntString = z.infer<ReturnType<typeof UIntString>>;
+export declare const UIntString: () => z.ZodString;

package/dist/nano/types/uint.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UIntString = exports.UInt = exports.UIntBounds = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.UIntBounds = {
+    min: () => 0,
+    max: () => Number.MAX_SAFE_INTEGER,
+};
+const UInt = () => zod_1.default.int().min(exports.UIntBounds.min()).max(exports.UIntBounds.max());
+exports.UInt = UInt;
+const UIntString = () => zod_1.default
+    .string()
+    .regex(/^(0|[1-9]\d*)$/, "Invalid unsigned integer")
+    .refine((val) => (0, exports.UInt)().safeParse(Number(val)).success, {
+    message: "Invalid unsigned integer",
+});
+exports.UIntString = UIntString;

package/dist/nano/types/uppercase-keys.d.ts

@@ -0,0 +1,3 @@
+export type UppercaseKeys<T extends Record<string, unknown>> = {
+    [K in keyof T as K extends string ? Uppercase<K> : K]: T[K];
+};

package/dist/nano/types/uppercase-keys.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nano/types/work-difficulty.d.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export type WorkDifficultyString = z.infer<ReturnType<typeof WorkDifficultyString>>;
+export declare const WorkDifficultyString: () => z.ZodString;

package/dist/nano/types/work-difficulty.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkDifficultyString = void 0;
+const hex_1 = require("./hex");
+const WorkDifficultyString = () => (0, hex_1.HexString)().length(16);
+exports.WorkDifficultyString = WorkDifficultyString;

package/dist/nano/types/work.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export type WorkString = z.infer<ReturnType<typeof WorkString>>;
+export declare const WorkString: () => z.ZodString;
+export declare const WorkStrings: {
+    zero: () => WorkString;
+};

package/dist/nano/types/work.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkStrings = exports.WorkString = void 0;
+const hex_1 = require("./hex");
+const WorkString = () => (0, hex_1.HexString)().length(16);
+exports.WorkString = WorkString;
+exports.WorkStrings = {
+    zero: () => (0, exports.WorkString)().parse("0000000000000000"),
+};

package/dist/nano/web-socket/client/index.d.ts

@@ -0,0 +1 @@
+export * from "./web-socket-client";

package/dist/nano/web-socket/client/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./web-socket-client"), exports);