nano-sdk 1.0.0

package/dist/nano/rpc/responses/account-info.d.ts

@@ -0,0 +1,124 @@
+import { z } from "zod";
+import { BooleanDistribution } from "../../types/boolean-distribution";
+import { BooleanOption } from "../../types/boolean-option";
+import { UppercaseKeys } from "../../types/uppercase-keys";
+declare const AccountInfoBase: () => z.ZodObject<{
+    frontier: z.ZodString;
+    open_block: z.ZodString;
+    representative_block: z.ZodString;
+    balance: z.ZodString;
+    modified_timestamp: z.ZodString;
+    block_count: z.ZodString;
+    account_version: z.ZodString;
+}, z.core.$strip>;
+declare const AccountInfoRepresentative: () => {
+    representative: z.ZodString;
+};
+declare const AccountInfoWeight: () => {
+    weight: z.ZodString;
+};
+declare const AccountInfoReceivable: () => {
+    receivable: z.ZodString;
+};
+declare const AccountInfoConfirmedBase: () => {
+    confirmed_balance: z.ZodString;
+    confirmed_height: z.ZodString;
+    confirmed_frontier: z.ZodString;
+};
+declare const AccountInfoConfirmedRepresentative: () => {
+    confirmed_representative: z.ZodString;
+};
+declare const AccountInfoConfirmedReceivable: () => {
+    confirmed_receivable: z.ZodString;
+};
+type AccountInfoResponseOptions = {
+    representative: boolean;
+    weight: boolean;
+    receivable: boolean;
+    include_confirmed: boolean;
+};
+type AccountInfoResponseBaseZodType<T extends UppercaseKeys<AccountInfoResponseOptions>> = z.ZodObject<ReturnType<typeof AccountInfoBase>["shape"] & BooleanOption<T["REPRESENTATIVE"], ReturnType<typeof AccountInfoRepresentative>, {}> & BooleanOption<T["WEIGHT"], ReturnType<typeof AccountInfoWeight>, {}> & BooleanOption<T["RECEIVABLE"], ReturnType<typeof AccountInfoReceivable>, {}> & BooleanOption<T["INCLUDE_CONFIRMED"], ReturnType<typeof AccountInfoConfirmedBase> & BooleanOption<T["REPRESENTATIVE"], ReturnType<typeof AccountInfoConfirmedRepresentative>, {}> & BooleanOption<T["RECEIVABLE"], ReturnType<typeof AccountInfoConfirmedReceivable>, {}>, {}>>;
+type AccountInfoResponseZodType<T extends UppercaseKeys<AccountInfoResponseOptions>> = BooleanDistribution<T["INCLUDE_CONFIRMED"], BooleanDistribution<T["REPRESENTATIVE"], BooleanDistribution<T["WEIGHT"], BooleanDistribution<T["RECEIVABLE"], AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: true;
+    WEIGHT: true;
+    RECEIVABLE: true;
+    INCLUDE_CONFIRMED: true;
+}>, AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: true;
+    WEIGHT: true;
+    RECEIVABLE: false;
+    INCLUDE_CONFIRMED: true;
+}>>, BooleanDistribution<T["RECEIVABLE"], AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: true;
+    WEIGHT: false;
+    RECEIVABLE: true;
+    INCLUDE_CONFIRMED: true;
+}>, AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: true;
+    WEIGHT: false;
+    RECEIVABLE: false;
+    INCLUDE_CONFIRMED: true;
+}>>>, BooleanDistribution<T["WEIGHT"], BooleanDistribution<T["RECEIVABLE"], AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: false;
+    WEIGHT: true;
+    RECEIVABLE: true;
+    INCLUDE_CONFIRMED: true;
+}>, AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: false;
+    WEIGHT: true;
+    RECEIVABLE: false;
+    INCLUDE_CONFIRMED: true;
+}>>, BooleanDistribution<T["RECEIVABLE"], AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: false;
+    WEIGHT: false;
+    RECEIVABLE: true;
+    INCLUDE_CONFIRMED: true;
+}>, AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: false;
+    WEIGHT: false;
+    RECEIVABLE: false;
+    INCLUDE_CONFIRMED: true;
+}>>>>, BooleanDistribution<T["REPRESENTATIVE"], BooleanDistribution<T["WEIGHT"], BooleanDistribution<T["RECEIVABLE"], AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: true;
+    WEIGHT: true;
+    RECEIVABLE: true;
+    INCLUDE_CONFIRMED: false;
+}>, AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: true;
+    WEIGHT: true;
+    RECEIVABLE: false;
+    INCLUDE_CONFIRMED: false;
+}>>, BooleanDistribution<T["RECEIVABLE"], AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: true;
+    WEIGHT: false;
+    RECEIVABLE: true;
+    INCLUDE_CONFIRMED: false;
+}>, AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: true;
+    WEIGHT: false;
+    RECEIVABLE: false;
+    INCLUDE_CONFIRMED: false;
+}>>>, BooleanDistribution<T["WEIGHT"], BooleanDistribution<T["RECEIVABLE"], AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: false;
+    WEIGHT: true;
+    RECEIVABLE: true;
+    INCLUDE_CONFIRMED: false;
+}>, AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: false;
+    WEIGHT: true;
+    RECEIVABLE: false;
+    INCLUDE_CONFIRMED: false;
+}>>, BooleanDistribution<T["RECEIVABLE"], AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: false;
+    WEIGHT: false;
+    RECEIVABLE: true;
+    INCLUDE_CONFIRMED: false;
+}>, AccountInfoResponseBaseZodType<{
+    REPRESENTATIVE: false;
+    WEIGHT: false;
+    RECEIVABLE: false;
+    INCLUDE_CONFIRMED: false;
+}>>>>>;
+export type AccountInfoResponse<T extends UppercaseKeys<AccountInfoResponseOptions>> = z.infer<AccountInfoResponseZodType<T>>;
+export declare function AccountInfoResponse<T extends AccountInfoResponseOptions>(options: T): AccountInfoResponseZodType<UppercaseKeys<T>>;
+export {};

package/dist/nano/rpc/responses/account-info.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountInfoResponse = AccountInfoResponse;
+const zod_1 = require("zod");
+const account_1 = require("../../types/account");
+const amount_1 = require("../../types/amount");
+const hash_1 = require("../../types/hash");
+const height_1 = require("../../types/height");
+const timestamp_1 = require("../../types/timestamp");
+const uint_1 = require("../../types/uint");
+const AccountInfoBase = () => zod_1.z.object({
+    frontier: (0, hash_1.HashString)(),
+    open_block: (0, hash_1.HashString)(),
+    representative_block: (0, hash_1.HashString)(),
+    balance: (0, amount_1.RawAmountString)(),
+    modified_timestamp: (0, timestamp_1.TimestampString)(),
+    block_count: (0, uint_1.UIntString)(),
+    account_version: (0, uint_1.UIntString)(),
+});
+const AccountInfoRepresentative = () => ({
+    representative: (0, account_1.AccountString)(),
+});
+const AccountInfoWeight = () => ({
+    weight: (0, amount_1.RawAmountString)(),
+});
+const AccountInfoReceivable = () => ({
+    receivable: (0, amount_1.RawAmountString)(),
+});
+const AccountInfoConfirmedBase = () => ({
+    confirmed_balance: (0, amount_1.RawAmountString)(),
+    confirmed_height: (0, height_1.HeightString)(),
+    confirmed_frontier: (0, hash_1.HashString)(),
+});
+const AccountInfoConfirmedRepresentative = () => ({
+    confirmed_representative: (0, account_1.AccountString)(),
+});
+const AccountInfoConfirmedReceivable = () => ({
+    confirmed_receivable: (0, amount_1.RawAmountString)(),
+});
+function AccountInfoResponse(options) {
+    return options.include_confirmed
+        ? AccountInfoBase()
+            .extend(options.representative ? AccountInfoRepresentative() : {})
+            .extend(options.weight ? AccountInfoWeight() : {})
+            .extend(options.receivable ? AccountInfoReceivable() : {})
+            .extend(AccountInfoConfirmedBase())
+            .extend(options.representative ? AccountInfoConfirmedRepresentative() : {})
+            .extend(options.receivable ? AccountInfoConfirmedReceivable() : {})
+        : AccountInfoBase()
+            .extend(options.representative ? AccountInfoRepresentative() : {})
+            .extend(options.weight ? AccountInfoWeight() : {})
+            .extend(options.receivable ? AccountInfoReceivable() : {});
+}

package/dist/nano/rpc/responses/account-key.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function AccountKeyResponse(): z.ZodObject<{
+    key: z.ZodString;
+}, z.core.$strip>;
+export type AccountKeyResponse = z.infer<ReturnType<typeof AccountKeyResponse>>;

package/dist/nano/rpc/responses/account-key.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountKeyResponse = AccountKeyResponse;
+const zod_1 = require("zod");
+const public_key_1 = require("../../types/public-key");
+function AccountKeyResponse() {
+    return zod_1.z.object({
+        key: (0, public_key_1.PublicKeyString)(),
+    });
+}

package/dist/nano/rpc/responses/account-representative.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function AccountRepresentativeResponse(): z.ZodObject<{
+    representative: z.ZodString;
+}, z.core.$strip>;
+export type AccountRepresentativeResponse = z.infer<ReturnType<typeof AccountRepresentativeResponse>>;

package/dist/nano/rpc/responses/account-representative.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountRepresentativeResponse = AccountRepresentativeResponse;
+const zod_1 = require("zod");
+const account_1 = require("../../types/account");
+function AccountRepresentativeResponse() {
+    return zod_1.z.object({
+        representative: (0, account_1.AccountString)(),
+    });
+}

package/dist/nano/rpc/responses/account-weight.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function AccountWeightResponse(): z.ZodObject<{
+    weight: z.ZodString;
+}, z.core.$strip>;
+export type AccountWeightResponse = z.infer<ReturnType<typeof AccountWeightResponse>>;

package/dist/nano/rpc/responses/account-weight.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountWeightResponse = AccountWeightResponse;
+const zod_1 = require("zod");
+const amount_1 = require("../../types/amount");
+function AccountWeightResponse() {
+    return zod_1.z.object({
+        weight: (0, amount_1.RawAmountString)(),
+    });
+}

package/dist/nano/rpc/responses/accounts-balances.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare function AccountsBalancesResponse(): z.ZodObject<{
+    balances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        balance: z.ZodString;
+        pending: z.ZodString;
+        receivable: z.ZodString;
+    }, z.core.$strip>>>;
+    errors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type AccountsBalancesResponse = z.infer<ReturnType<typeof AccountsBalancesResponse>>;

package/dist/nano/rpc/responses/accounts-balances.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountsBalancesResponse = AccountsBalancesResponse;
+const zod_1 = require("zod");
+const account_1 = require("../../types/account");
+const amount_1 = require("../../types/amount");
+const AccountBalanceTotals = () => zod_1.z.object({
+    balance: (0, amount_1.RawAmountString)(),
+    pending: (0, amount_1.RawAmountString)(),
+    receivable: (0, amount_1.RawAmountString)(),
+});
+function AccountsBalancesResponse() {
+    return zod_1.z.object({
+        balances: zod_1.z.record((0, account_1.AccountString)(), AccountBalanceTotals()).optional(),
+        errors: zod_1.z.record((0, account_1.AccountString)(), zod_1.z.string()).optional(),
+    });
+}

package/dist/nano/rpc/responses/accounts-frontiers.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare function AccountsFrontiersResponse(): z.ZodObject<{
+    frontiers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    errors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type AccountsFrontiersResponse = z.infer<ReturnType<typeof AccountsFrontiersResponse>>;

package/dist/nano/rpc/responses/accounts-frontiers.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountsFrontiersResponse = AccountsFrontiersResponse;
+const zod_1 = require("zod");
+const account_1 = require("../../types/account");
+const hash_1 = require("../../types/hash");
+function AccountsFrontiersResponse() {
+    return zod_1.z.object({
+        frontiers: zod_1.z.record((0, account_1.AccountString)(), (0, hash_1.HashString)()).optional(),
+        errors: zod_1.z.record((0, account_1.AccountString)(), zod_1.z.string()).optional(),
+    });
+}

package/dist/nano/rpc/responses/accounts-receivable.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { AccountString } from "../../types/account";
+import { BooleanDistribution } from "../../types/boolean-distribution";
+import { HashString } from "../../types/hash";
+import { UppercaseKeys } from "../../types/uppercase-keys";
+declare const AccountsReceivableAmounts: () => z.ZodRecord<z.ZodString, z.ZodString>;
+declare const AccountsReceivableSources: () => z.ZodRecord<z.ZodString, z.ZodObject<{
+    amount: z.ZodString;
+    source: z.ZodString;
+}, z.core.$strip>>;
+type AccountsReceivableBlocksOptions = {
+    source: boolean;
+    threshold: boolean;
+};
+type AccountsReceivableBlocksZodType<T extends UppercaseKeys<AccountsReceivableBlocksOptions>> = BooleanDistribution<T["SOURCE"], z.ZodRecord<ReturnType<typeof AccountString>, ReturnType<typeof AccountsReceivableSources>>, BooleanDistribution<T["THRESHOLD"], z.ZodRecord<ReturnType<typeof AccountString>, ReturnType<typeof AccountsReceivableAmounts>>, z.ZodRecord<ReturnType<typeof AccountString>, z.ZodArray<ReturnType<typeof HashString>>>>>;
+type AccountsReceivableResponseOptions = {
+    source: boolean;
+    threshold: boolean;
+};
+type AccountsReceivableResponseZodType<T extends UppercaseKeys<AccountsReceivableResponseOptions>> = z.ZodObject<{
+    blocks: z.ZodUnion<[AccountsReceivableBlocksZodType<T>, z.ZodLiteral<"">]>;
+}>;
+export type AccountsReceivableResponse<T extends UppercaseKeys<AccountsReceivableResponseOptions>> = z.infer<AccountsReceivableResponseZodType<T>>;
+export declare function AccountsReceivableResponse<T extends AccountsReceivableResponseOptions>(options: T): AccountsReceivableResponseZodType<UppercaseKeys<T>>;
+export {};

package/dist/nano/rpc/responses/accounts-receivable.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountsReceivableResponse = AccountsReceivableResponse;
+const zod_1 = require("zod");
+const account_1 = require("../../types/account");
+const amount_1 = require("../../types/amount");
+const hash_1 = require("../../types/hash");
+const AccountsReceivableAmounts = () => zod_1.z.record((0, hash_1.HashString)(), (0, amount_1.RawAmountString)());
+const AccountsReceivableSources = () => zod_1.z.record((0, hash_1.HashString)(), zod_1.z.object({
+    amount: (0, amount_1.RawAmountString)(),
+    source: (0, account_1.AccountString)(),
+}));
+function AccountsReceivableBlocks(options) {
+    if (options.source) {
+        return zod_1.z.record((0, account_1.AccountString)(), AccountsReceivableSources());
+    }
+    else if (options.threshold) {
+        return zod_1.z.record((0, account_1.AccountString)(), AccountsReceivableAmounts());
+    }
+    else {
+        return zod_1.z.record((0, account_1.AccountString)(), (0, hash_1.HashString)().array());
+    }
+}
+function AccountsReceivableResponse(options) {
+    return zod_1.z.object({
+        blocks: AccountsReceivableBlocks(options).or(zod_1.z.literal("")),
+    });
+}

package/dist/nano/rpc/responses/accounts-representatives.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare function AccountsRepresentativesResponse(): z.ZodObject<{
+    representatives: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    errors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type AccountsRepresentativesResponse = z.infer<ReturnType<typeof AccountsRepresentativesResponse>>;

package/dist/nano/rpc/responses/accounts-representatives.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountsRepresentativesResponse = AccountsRepresentativesResponse;
+const zod_1 = require("zod");
+const account_1 = require("../../types/account");
+function AccountsRepresentativesResponse() {
+    return zod_1.z.object({
+        representatives: zod_1.z.record((0, account_1.AccountString)(), (0, account_1.AccountString)()).optional(),
+        errors: zod_1.z.record((0, account_1.AccountString)(), zod_1.z.string()).optional(),
+    });
+}

package/dist/nano/rpc/responses/available-supply.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function AvailableSupplyResponse(): z.ZodObject<{
+    available: z.ZodString;
+}, z.core.$strip>;
+export type AvailableSupplyResponse = z.infer<ReturnType<typeof AvailableSupplyResponse>>;

package/dist/nano/rpc/responses/available-supply.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvailableSupplyResponse = AvailableSupplyResponse;
+const zod_1 = require("zod");
+const amount_1 = require("../../types/amount");
+function AvailableSupplyResponse() {
+    return zod_1.z.object({
+        available: (0, amount_1.RawAmountString)(),
+    });
+}

package/dist/nano/rpc/responses/block-account.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function BlockAccountResponse(): z.ZodObject<{
+    account: z.ZodString;
+}, z.core.$strip>;
+export type BlockAccountResponse = z.infer<ReturnType<typeof BlockAccountResponse>>;

package/dist/nano/rpc/responses/block-account.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockAccountResponse = BlockAccountResponse;
+const zod_1 = require("zod");
+const account_1 = require("../../types/account");
+function BlockAccountResponse() {
+    return zod_1.z.object({
+        account: (0, account_1.AccountString)(),
+    });
+}

package/dist/nano/rpc/responses/block-confirm.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function BlockConfirmResponse(): z.ZodObject<{
+    started: z.ZodLiteral<"1">;
+}, z.core.$strip>;
+export type BlockConfirmResponse = z.infer<ReturnType<typeof BlockConfirmResponse>>;

package/dist/nano/rpc/responses/block-confirm.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockConfirmResponse = BlockConfirmResponse;
+const zod_1 = require("zod");
+function BlockConfirmResponse() {
+    return zod_1.z.object({
+        started: zod_1.z.literal("1"),
+    });
+}

package/dist/nano/rpc/responses/block-count.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare function BlockCountResponse(): z.ZodObject<{
+    count: z.ZodString;
+    unchecked: z.ZodString;
+    cemented: z.ZodString;
+}, z.core.$strip>;
+export type BlockCountResponse = z.infer<ReturnType<typeof BlockCountResponse>>;

package/dist/nano/rpc/responses/block-count.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockCountResponse = BlockCountResponse;
+const zod_1 = require("zod");
+const uint_1 = require("../../types/uint");
+function BlockCountResponse() {
+    return zod_1.z.object({
+        count: (0, uint_1.UIntString)(),
+        unchecked: (0, uint_1.UIntString)(),
+        cemented: (0, uint_1.UIntString)(),
+    });
+}

package/dist/nano/rpc/responses/block-create.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { StateBlock } from "../../blocks/state-block";
+import { BooleanDistribution } from "../../types/boolean-distribution";
+import { HashString } from "../../types/hash";
+import { UppercaseKeys } from "../../types/uppercase-keys";
+import { WorkDifficultyString } from "../../types/work-difficulty";
+type BlockCreateResponseOptions = {
+    json_block: boolean;
+};
+type BlockCreateResponseZodType<T extends UppercaseKeys<BlockCreateResponseOptions>> = BooleanDistribution<T["JSON_BLOCK"], z.ZodObject<{
+    hash: ReturnType<typeof HashString>;
+    difficulty: ReturnType<typeof WorkDifficultyString>;
+    block: ReturnType<typeof StateBlock>;
+}>, z.ZodObject<{
+    hash: ReturnType<typeof HashString>;
+    difficulty: ReturnType<typeof WorkDifficultyString>;
+    block: z.ZodString;
+}>>;
+export type BlockCreateResponse<T extends UppercaseKeys<BlockCreateResponseOptions>> = z.infer<BlockCreateResponseZodType<T>>;
+export declare function BlockCreateResponse<T extends BlockCreateResponseOptions>(options: T): BlockCreateResponseZodType<UppercaseKeys<T>>;
+export {};

package/dist/nano/rpc/responses/block-create.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockCreateResponse = BlockCreateResponse;
+const zod_1 = require("zod");
+const state_block_1 = require("../../blocks/state-block");
+const hash_1 = require("../../types/hash");
+const work_difficulty_1 = require("../../types/work-difficulty");
+function BlockCreateResponse(options) {
+    return options.json_block
+        ? zod_1.z.object({
+            hash: (0, hash_1.HashString)(),
+            difficulty: (0, work_difficulty_1.WorkDifficultyString)(),
+            block: (0, state_block_1.StateBlock)(),
+        })
+        : zod_1.z.object({
+            hash: (0, hash_1.HashString)(),
+            difficulty: (0, work_difficulty_1.WorkDifficultyString)(),
+            block: zod_1.z.string(),
+        });
+}

package/dist/nano/rpc/responses/block-hash.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function BlockHashResponse(): z.ZodObject<{
+    hash: z.ZodString;
+}, z.core.$strip>;
+export type BlockHashResponse = z.infer<ReturnType<typeof BlockHashResponse>>;

package/dist/nano/rpc/responses/block-hash.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockHashResponse = BlockHashResponse;
+const zod_1 = require("zod");
+const hash_1 = require("../../types/hash");
+function BlockHashResponse() {
+    return zod_1.z.object({
+        hash: (0, hash_1.HashString)(),
+    });
+}