nano-sdk 1.0.0

package/dist/nano/math/raw-plus.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawPlus = rawPlus;
+const amount_1 = require("../types/amount");
+function rawPlusThrowing(params) {
+    const baseResult = (0, amount_1.RawAmount)().safeParse(params.raw);
+    if (!baseResult.success) {
+        throw new Error("Invalid raw value.");
+    }
+    const addendResult = (0, amount_1.RawAmount)().safeParse(params.addend);
+    if (!addendResult.success) {
+        throw new Error("Invalid addend value.");
+    }
+    const base = baseResult.data;
+    const addend = addendResult.data;
+    const sum = base + addend;
+    const result = (0, amount_1.RawAmount)().safeParse(sum);
+    if (!result.success) {
+        throw new Error("Resulting amount is no valid raw amount.");
+    }
+    if (typeof params.raw === "bigint") {
+        return result.data;
+    }
+    else {
+        return result.data.toString();
+    }
+}
+function rawPlusNonThrowing(params) {
+    try {
+        let result;
+        if (typeof params.raw === "bigint") {
+            result = rawPlusThrowing({ raw: params.raw, addend: params.addend, throwOnError: true });
+        }
+        else {
+            result = rawPlusThrowing({ raw: params.raw, addend: params.addend, throwOnError: true });
+        }
+        return {
+            success: true,
+            data: result,
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function rawPlus(params) {
+    if (params.throwOnError === false) {
+        if (typeof params.raw === "bigint") {
+            return rawPlusNonThrowing({ raw: params.raw, addend: params.addend, throwOnError: false });
+        }
+        else {
+            return rawPlusNonThrowing({ raw: params.raw, addend: params.addend, throwOnError: false });
+        }
+    }
+    else {
+        if (typeof params.raw === "bigint") {
+            return rawPlusThrowing({ raw: params.raw, addend: params.addend, throwOnError: true });
+        }
+        else {
+            return rawPlusThrowing({ raw: params.raw, addend: params.addend, throwOnError: true });
+        }
+    }
+}

package/dist/nano/math/raw-to-nano.d.ts

@@ -0,0 +1,15 @@
+import { NanoAmountString, RawAmount, RawAmountString } from "../types/amount";
+import { NonThrowing } from "../types/non-throwing";
+import { Result } from "../types/result";
+import { Throwing } from "../types/throwing";
+type RawToNanoParams = {
+    raw: RawAmount | RawAmountString;
+    decimalPlaces?: number;
+    decimalSeparator?: "." | ",";
+    groupingSize?: number;
+    groupingSeparator?: "," | "." | " ";
+} & (Throwing | NonThrowing);
+export declare function rawToNano(params: RawToNanoParams & NonThrowing): Result<NanoAmountString>;
+export declare function rawToNano(params: RawToNanoParams & Throwing): NanoAmountString;
+export declare function rawToNano(params: RawToNanoParams): NanoAmountString | Result<NanoAmountString>;
+export {};

package/dist/nano/math/raw-to-nano.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawToNano = rawToNano;
+const format_raw_1 = require("./format-raw");
+function rawToNanoThrowing(params) {
+    return (0, format_raw_1.formatRaw)({
+        ...params,
+        unit: "nano",
+    });
+}
+function rawToNanoNonThrowing(params) {
+    try {
+        return {
+            success: true,
+            data: rawToNanoThrowing({ ...params, throwOnError: true }),
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e : new Error("Unexpected error."),
+        };
+    }
+}
+function rawToNano(params) {
+    if (params.throwOnError === false) {
+        return rawToNanoNonThrowing({ ...params, throwOnError: false });
+    }
+    else {
+        return rawToNanoThrowing({ ...params, throwOnError: true });
+    }
+}

package/dist/nano/rpc/http/http-client.d.ts

@@ -0,0 +1,20 @@
+import { RequestConfig } from "./request-config";
+export interface HttpResponseSuccess {
+    success: true;
+    data?: unknown;
+    status?: number;
+    statusText?: string;
+}
+export interface HttpResponseError {
+    success: false;
+    error: {
+        message: string;
+    };
+    status?: number;
+    statusText?: string;
+}
+export type HttpResponse = HttpResponseSuccess | HttpResponseError;
+export interface HttpClient {
+    post(url: string, body: unknown, config?: RequestConfig): Promise<HttpResponse>;
+}
+export declare const defaultHttpClient: HttpClient;

package/dist/nano/rpc/http/http-client.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultHttpClient = void 0;
+// Credits: https://github.com/rashidshamloo/multi-signal
+const multiSignal = (...inputSignals) => {
+    const signals = Array.isArray(inputSignals[0]) ? inputSignals[0] : inputSignals;
+    // if only one signal is provided, return it
+    const len = signals.length;
+    if (len === 1)
+        return signals[0];
+    // new signal setup
+    const controller = new AbortController();
+    const signal = controller.signal;
+    // add event listener
+    for (let i = 0; i < len; i++) {
+        // if signal is already aborted, abort new signal
+        if (signals[i].aborted) {
+            controller.abort(signals[i].reason);
+            break;
+        }
+        // else add on signal abort: abort new signal
+        signals[i].addEventListener("abort", () => {
+            controller.abort(signals[i].reason);
+        }, { signal });
+    }
+    return signal;
+};
+exports.defaultHttpClient = {
+    async post(url, body, config) {
+        const timeoutAbortSignal = config?.timeoutInMs ? AbortSignal.timeout(config.timeoutInMs) : undefined;
+        const signal = config?.abortSignal && timeoutAbortSignal
+            ? multiSignal(config.abortSignal, timeoutAbortSignal)
+            : config?.abortSignal
+                ? config.abortSignal
+                : timeoutAbortSignal;
+        try {
+            const response = await fetch(url, {
+                method: "POST",
+                body: JSON.stringify(body),
+                signal: signal,
+                headers: { "Content-Type": "application/json" },
+            });
+            let parsed = null;
+            try {
+                parsed = await response.json();
+            }
+            catch {
+                parsed = null;
+            }
+            if (response.ok) {
+                return {
+                    success: true,
+                    data: parsed,
+                    status: response.status,
+                    statusText: response.statusText,
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    message: response.statusText,
+                },
+                status: response.status,
+                statusText: response.statusText,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: {
+                    message: err instanceof Error ? err.message : "Unknown fetch error",
+                },
+            };
+        }
+    },
+};

package/dist/nano/rpc/http/index.d.ts

@@ -0,0 +1,5 @@
+export { HttpClient, HttpResponse, HttpResponseError, HttpResponseSuccess } from "./http-client";
+export * from "./post";
+export * from "./post-error";
+export * from "./post-result";
+export * from "./request-config";

package/dist/nano/rpc/http/index.js

@@ -0,0 +1,20 @@
+"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("./post"), exports);
+__exportStar(require("./post-error"), exports);
+__exportStar(require("./post-result"), exports);
+__exportStar(require("./request-config"), exports);

package/dist/nano/rpc/http/post-error.d.ts

@@ -0,0 +1,8 @@
+export declare class PostError extends Error {
+    readonly status?: number;
+    readonly statusText?: string;
+    constructor(message: string, meta?: {
+        status?: number;
+        statusText?: string;
+    });
+}

package/dist/nano/rpc/http/post-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostError = void 0;
+class PostError extends Error {
+    constructor(message, meta) {
+        super(message);
+        this.name = "PostError";
+        this.status = meta?.status;
+        this.statusText = meta?.statusText;
+    }
+}
+exports.PostError = PostError;

package/dist/nano/rpc/http/post-result.d.ts

@@ -0,0 +1,15 @@
+export type SuccessfulPostResult<TDataType> = {
+    success: true;
+    data: TDataType;
+    status?: number;
+    statusText?: string;
+};
+export type UnsuccessfulPostResult = {
+    success: false;
+    error: {
+        message: string;
+    };
+    status?: number;
+    statusText?: string;
+};
+export type PostResult<TDataType> = SuccessfulPostResult<TDataType> | UnsuccessfulPostResult;

package/dist/nano/rpc/http/post-result.js

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

package/dist/nano/rpc/http/post.d.ts

@@ -0,0 +1,9 @@
+import z from "zod";
+import { PostResult } from "./post-result";
+import { NonThrowingRequestConfig, ThrowingRequestConfig } from "./request-config";
+export declare function post<T extends z.ZodType, U extends z.ZodType>(url: string, requestBody: z.infer<T>, requestSchema: T, responseSchema: U, config: ThrowingRequestConfig): Promise<z.infer<U>>;
+export declare function post<T extends z.ZodType, U extends z.ZodType>(url: string, requestBody: z.infer<T>, requestSchema: T, responseSchema: U, config?: NonThrowingRequestConfig): Promise<PostResult<z.infer<U>>>;
+export declare function postFunction<T extends z.ZodType, U extends z.ZodType>(requestSchema: T, responseSchema: U): {
+    (url: string, request: z.infer<T>, config: ThrowingRequestConfig): Promise<z.infer<U>>;
+    (url: string, request: z.infer<T>, config?: NonThrowingRequestConfig): Promise<PostResult<z.infer<U>>>;
+};

package/dist/nano/rpc/http/post.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.post = post;
+exports.postFunction = postFunction;
+const error_response_1 = require("../responses/error-response");
+const http_client_1 = require("./http-client");
+const post_error_1 = require("./post-error");
+async function post(url, requestBody, requestSchema, responseSchema, config) {
+    try {
+        if (!requestSchema.safeParse(requestBody).success) {
+            throw new post_error_1.PostError("Request parsing failed.");
+        }
+        const httpClient = config?.httpClient ?? http_client_1.defaultHttpClient;
+        const httpResponse = await httpClient.post(url, requestBody, config);
+        if (!httpResponse.success) {
+            throw new post_error_1.PostError(httpResponse.error.message, {
+                status: httpResponse.status,
+                statusText: httpResponse.statusText,
+            });
+        }
+        const errorResponse = (0, error_response_1.ErrorResponse)().safeParse(httpResponse.data);
+        if (errorResponse.success) {
+            throw new post_error_1.PostError(errorResponse.data.error, {
+                status: httpResponse.status,
+                statusText: httpResponse.statusText,
+            });
+        }
+        const response = responseSchema.safeParse(httpResponse.data);
+        if (!response.success) {
+            throw new post_error_1.PostError("Response parsing failed. Please contact the library developer with details about your usage and environment.", {
+                status: httpResponse.status,
+                statusText: httpResponse.statusText,
+            });
+        }
+        if (config?.throwOnError === false) {
+            return {
+                success: true,
+                data: response.data,
+                status: httpResponse.status,
+                statusText: httpResponse.statusText,
+            };
+        }
+        return response.data;
+    }
+    catch (e) {
+        if (e instanceof post_error_1.PostError) {
+            if (config?.throwOnError === false) {
+                return { success: false, error: { message: e.message }, status: e.status, statusText: e.statusText };
+            }
+            throw e;
+        }
+        if (e instanceof Error) {
+            if (config?.throwOnError === false) {
+                return { success: false, error: { message: e.message } };
+            }
+            throw e;
+        }
+        if (config?.throwOnError === false) {
+            return {
+                success: false,
+                error: {
+                    message: "An unknown error occurred. Please contact the library developer with details about your usage and environment.",
+                },
+            };
+        }
+        throw new Error("An unknown error occurred. Please contact the library developer with details about your usage and environment.");
+    }
+}
+function postFunction(requestSchema, responseSchema) {
+    async function fn(url, request, config) {
+        if (config?.throwOnError === false) {
+            return post(url, request, requestSchema, responseSchema, config);
+        }
+        return post(url, request, requestSchema, responseSchema, config);
+    }
+    return fn;
+}

package/dist/nano/rpc/http/request-config.d.ts

@@ -0,0 +1,13 @@
+import { HttpClient } from "./http-client";
+export interface RequestConfig {
+    abortSignal?: AbortSignal;
+    httpClient?: HttpClient;
+    timeoutInMs?: number;
+    throwOnError?: boolean;
+}
+export type NonThrowingRequestConfig = RequestConfig & {
+    throwOnError: false;
+};
+export type ThrowingRequestConfig = RequestConfig & {
+    throwOnError?: true | undefined;
+};

package/dist/nano/rpc/http/request-config.js

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

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

@@ -0,0 +1,4 @@
+export * from "./http";
+export * from "./methods";
+export * from "./requests";
+export * from "./responses";

package/dist/nano/rpc/index.js

@@ -0,0 +1,20 @@
+"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("./http"), exports);
+__exportStar(require("./methods"), exports);
+__exportStar(require("./requests"), exports);
+__exportStar(require("./responses"), exports);

package/dist/nano/rpc/methods/account-balance.d.ts

@@ -0,0 +1,20 @@
+export declare const account_balance: {
+    (url: string, request: {
+        action: "account_balance";
+        account: string;
+        include_only_confirmed?: boolean | "false" | "true" | undefined;
+    }, config: import("..").ThrowingRequestConfig): Promise<{
+        balance: string;
+        pending: string;
+        receivable: string;
+    }>;
+    (url: string, request: {
+        action: "account_balance";
+        account: string;
+        include_only_confirmed?: boolean | "false" | "true" | undefined;
+    }, config?: import("..").NonThrowingRequestConfig): Promise<import("..").PostResult<{
+        balance: string;
+        pending: string;
+        receivable: string;
+    }>>;
+};

package/dist/nano/rpc/methods/account-balance.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.account_balance = void 0;
+const post_1 = require("../http/post");
+const account_balance_1 = require("../requests/account-balance");
+const account_balance_2 = require("../responses/account-balance");
+exports.account_balance = (0, post_1.postFunction)((0, account_balance_1.AccountBalanceRequest)(), (0, account_balance_2.AccountBalanceResponse)());

package/dist/nano/rpc/methods/account-block-count.d.ts

@@ -0,0 +1,14 @@
+export declare const account_block_count: {
+    (url: string, request: {
+        action: "account_block_count";
+        account: string;
+    }, config: import("..").ThrowingRequestConfig): Promise<{
+        block_count: string;
+    }>;
+    (url: string, request: {
+        action: "account_block_count";
+        account: string;
+    }, config?: import("..").NonThrowingRequestConfig): Promise<import("..").PostResult<{
+        block_count: string;
+    }>>;
+};

package/dist/nano/rpc/methods/account-block-count.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.account_block_count = void 0;
+const post_1 = require("../http/post");
+const account_block_count_1 = require("../requests/account-block-count");
+const account_block_count_2 = require("../responses/account-block-count");
+exports.account_block_count = (0, post_1.postFunction)((0, account_block_count_1.AccountBlockCountRequest)(), (0, account_block_count_2.AccountBlockCountResponse)());

package/dist/nano/rpc/methods/account-get.d.ts

@@ -0,0 +1,14 @@
+export declare const account_get: {
+    (url: string, request: {
+        action: "account_get";
+        key: string;
+    }, config: import("..").ThrowingRequestConfig): Promise<{
+        account: string;
+    }>;
+    (url: string, request: {
+        action: "account_get";
+        key: string;
+    }, config?: import("..").NonThrowingRequestConfig): Promise<import("..").PostResult<{
+        account: string;
+    }>>;
+};

package/dist/nano/rpc/methods/account-get.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.account_get = void 0;
+const post_1 = require("../http/post");
+const account_get_1 = require("../requests/account-get");
+const account_get_2 = require("../responses/account-get");
+exports.account_get = (0, post_1.postFunction)((0, account_get_1.AccountGetRequest)(), (0, account_get_2.AccountGetResponse)());

package/dist/nano/rpc/methods/account-history.d.ts

@@ -0,0 +1,15 @@
+import { PostResult } from "../http/post-result";
+import { NonThrowingRequestConfig, RequestConfig, ThrowingRequestConfig } from "../http/request-config";
+import { AccountHistoryRequest } from "../requests/account-history";
+import { AccountHistoryResponse } from "../responses/account-history";
+import { BoolFlag } from "./conditional-types/bool-flag";
+import { WithDefault } from "./conditional-types/with-default";
+type ResponseType<T extends AccountHistoryRequest> = AccountHistoryResponse<{
+    INCLUDE_LINKED_ACCOUNT: BoolFlag<WithDefault<T, "include_linked_account", false>["include_linked_account"]>;
+    RAW: BoolFlag<WithDefault<T, "raw", false>["raw"]>;
+    REVERSE: BoolFlag<WithDefault<T, "reverse", false>["reverse"]>;
+}>;
+export declare function account_history<const T extends AccountHistoryRequest>(url: string, request: T, config?: NonThrowingRequestConfig): Promise<PostResult<ResponseType<T>>>;
+export declare function account_history<const T extends AccountHistoryRequest>(url: string, request: T, config: ThrowingRequestConfig): Promise<ResponseType<T>>;
+export declare function account_history<const T extends AccountHistoryRequest>(url: string, request: T, config?: RequestConfig): Promise<ResponseType<T>> | Promise<PostResult<ResponseType<T>>>;
+export {};

package/dist/nano/rpc/methods/account-history.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.account_history = account_history;
+const post_1 = require("../http/post");
+const account_history_1 = require("../requests/account-history");
+const account_history_2 = require("../responses/account-history");
+function account_history(url, request, config) {
+    if (config?.throwOnError === false) {
+        return (0, post_1.post)(url, request, (0, account_history_1.AccountHistoryRequest)(), (0, account_history_2.AccountHistoryResponse)({
+            include_linked_account: request.include_linked_account === true,
+            raw: request.raw === true,
+            reverse: request.reverse === true,
+        }), config);
+    }
+    else {
+        return (0, post_1.post)(url, request, (0, account_history_1.AccountHistoryRequest)(), (0, account_history_2.AccountHistoryResponse)({
+            include_linked_account: request.include_linked_account === true,
+            raw: request.raw === true,
+            reverse: request.reverse === true,
+        }), config);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { PostResult } from "../http/post-result";
+import { NonThrowingRequestConfig, RequestConfig, ThrowingRequestConfig } from "../http/request-config";
+import { AccountInfoRequest } from "../requests/account-info";
+import { AccountInfoResponse } from "../responses/account-info";
+import { BoolFlag } from "./conditional-types/bool-flag";
+import { WithDefault } from "./conditional-types/with-default";
+type ResponseType<T extends AccountInfoRequest> = AccountInfoResponse<{
+    REPRESENTATIVE: BoolFlag<WithDefault<T, "representative", false>["representative"]>;
+    WEIGHT: BoolFlag<WithDefault<T, "weight", false>["weight"]>;
+    RECEIVABLE: BoolFlag<WithDefault<T, "receivable", false>["receivable"]>;
+    INCLUDE_CONFIRMED: BoolFlag<WithDefault<T, "include_confirmed", false>["include_confirmed"]>;
+}>;
+export declare function account_info<const T extends AccountInfoRequest>(url: string, request: T, config?: NonThrowingRequestConfig): Promise<PostResult<ResponseType<T>>>;
+export declare function account_info<const T extends AccountInfoRequest>(url: string, request: T, config: ThrowingRequestConfig): Promise<ResponseType<T>>;
+export declare function account_info<const T extends AccountInfoRequest>(url: string, request: T, config?: RequestConfig): Promise<ResponseType<T>> | Promise<PostResult<ResponseType<T>>>;
+export {};

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.account_info = account_info;
+const post_1 = require("../http/post");
+const account_info_1 = require("../requests/account-info");
+const account_info_2 = require("../responses/account-info");
+function account_info(url, request, config) {
+    if (config?.throwOnError === false) {
+        return (0, post_1.post)(url, request, (0, account_info_1.AccountInfoRequest)(), (0, account_info_2.AccountInfoResponse)({
+            representative: request.representative === true,
+            weight: request.weight === true,
+            receivable: request.receivable === true,
+            include_confirmed: request.include_confirmed === true,
+        }), config);
+    }
+    else {
+        return (0, post_1.post)(url, request, (0, account_info_1.AccountInfoRequest)(), (0, account_info_2.AccountInfoResponse)({
+            representative: request.representative === true,
+            weight: request.weight === true,
+            receivable: request.receivable === true,
+            include_confirmed: request.include_confirmed === true,
+        }), config);
+    }
+}

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

@@ -0,0 +1,14 @@
+export declare const account_key: {
+    (url: string, request: {
+        action: "account_key";
+        account: string;
+    }, config: import("..").ThrowingRequestConfig): Promise<{
+        key: string;
+    }>;
+    (url: string, request: {
+        action: "account_key";
+        account: string;
+    }, config?: import("..").NonThrowingRequestConfig): Promise<import("..").PostResult<{
+        key: string;
+    }>>;
+};

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.account_key = void 0;
+const post_1 = require("../http/post");
+const account_key_1 = require("../requests/account-key");
+const account_key_2 = require("../responses/account-key");
+exports.account_key = (0, post_1.postFunction)((0, account_key_1.AccountKeyRequest)(), (0, account_key_2.AccountKeyResponse)());

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

@@ -0,0 +1,14 @@
+export declare const account_representative: {
+    (url: string, request: {
+        action: "account_representative";
+        account: string;
+    }, config: import("..").ThrowingRequestConfig): Promise<{
+        representative: string;
+    }>;
+    (url: string, request: {
+        action: "account_representative";
+        account: string;
+    }, config?: import("..").NonThrowingRequestConfig): Promise<import("..").PostResult<{
+        representative: string;
+    }>>;
+};

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.account_representative = void 0;
+const post_1 = require("../http/post");
+const account_representative_1 = require("../requests/account-representative");
+const account_representative_2 = require("../responses/account-representative");
+exports.account_representative = (0, post_1.postFunction)((0, account_representative_1.AccountRepresentativeRequest)(), (0, account_representative_2.AccountRepresentativeResponse)());

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

@@ -0,0 +1,14 @@
+export declare const account_weight: {
+    (url: string, request: {
+        action: "account_weight";
+        account: string;
+    }, config: import("..").ThrowingRequestConfig): Promise<{
+        weight: string;
+    }>;
+    (url: string, request: {
+        action: "account_weight";
+        account: string;
+    }, config?: import("..").NonThrowingRequestConfig): Promise<import("..").PostResult<{
+        weight: string;
+    }>>;
+};