@psalomo/jsonrpc-client 0.4.0 → 0.5.0

package/dist/index.mini.d.mts

@@ -0,0 +1,198 @@
+import { RpcStateChangesInBlockByTypeRequest, RpcStateChangesInBlockResponse, RpcStateChangesInBlockRequest, RpcStateChangesInBlockByTypeResponse, RpcCongestionLevelRequest, RpcCongestionLevelResponse, GenesisConfigRequest, GenesisConfig, RpcLightClientBlockProofRequest, RpcLightClientBlockProofResponse, RpcLightClientExecutionProofRequest, RpcLightClientExecutionProofResponse, RpcMaintenanceWindowsRequest, EXPERIMENTALMaintenanceWindowsResponse, RpcProtocolConfigRequest, RpcProtocolConfigResponse, RpcReceiptRequest, RpcReceiptResponse, RpcSplitStorageInfoRequest, RpcSplitStorageInfoResponse, RpcTransactionStatusRequest, RpcTransactionResponse, RpcValidatorsOrderedRequest, EXPERIMENTALValidatorsOrderedResponse, RpcBlockRequest, RpcBlockResponse, RpcSendTransactionRequest, CryptoHash, RpcChunkRequest, RpcChunkResponse, RpcClientConfigRequest, RpcClientConfigResponse, RpcGasPriceRequest, RpcGasPriceResponse, RpcHealthRequest, RpcHealthResponse, RpcNetworkInfoRequest, RpcNetworkInfoResponse, RpcLightClientNextBlockRequest, RpcLightClientNextBlockResponse, RpcQueryRequest, RpcQueryResponse, RpcStatusRequest, RpcStatusResponse, RpcValidatorRequest, RpcValidatorResponse, AccountView, CallResult, AccessKeyView } from '@near-js/jsonrpc-types';
+import { RpcStateChangesInBlockByTypeRequest as RpcStateChangesInBlockByTypeRequest$1, RpcStateChangesInBlockResponse as RpcStateChangesInBlockResponse$1, RpcStateChangesInBlockRequest as RpcStateChangesInBlockRequest$1, RpcStateChangesInBlockByTypeResponse as RpcStateChangesInBlockByTypeResponse$1, RpcCongestionLevelRequest as RpcCongestionLevelRequest$1, RpcCongestionLevelResponse as RpcCongestionLevelResponse$1, GenesisConfigRequest as GenesisConfigRequest$1, GenesisConfig as GenesisConfig$1, RpcLightClientBlockProofRequest as RpcLightClientBlockProofRequest$1, RpcLightClientBlockProofResponse as RpcLightClientBlockProofResponse$1, RpcLightClientExecutionProofRequest as RpcLightClientExecutionProofRequest$1, RpcLightClientExecutionProofResponse as RpcLightClientExecutionProofResponse$1, RpcMaintenanceWindowsRequest as RpcMaintenanceWindowsRequest$1, EXPERIMENTALMaintenanceWindowsResponse as EXPERIMENTALMaintenanceWindowsResponse$1, RpcProtocolConfigRequest as RpcProtocolConfigRequest$1, RpcProtocolConfigResponse as RpcProtocolConfigResponse$1, RpcReceiptRequest as RpcReceiptRequest$1, RpcReceiptResponse as RpcReceiptResponse$1, RpcSplitStorageInfoRequest as RpcSplitStorageInfoRequest$1, RpcSplitStorageInfoResponse as RpcSplitStorageInfoResponse$1, RpcTransactionStatusRequest as RpcTransactionStatusRequest$1, RpcTransactionResponse as RpcTransactionResponse$1, RpcValidatorsOrderedRequest as RpcValidatorsOrderedRequest$1, EXPERIMENTALValidatorsOrderedResponse as EXPERIMENTALValidatorsOrderedResponse$1, RpcBlockRequest as RpcBlockRequest$1, RpcBlockResponse as RpcBlockResponse$1, RpcSendTransactionRequest as RpcSendTransactionRequest$1, CryptoHash as CryptoHash$1, RpcChunkRequest as RpcChunkRequest$1, RpcChunkResponse as RpcChunkResponse$1, RpcClientConfigRequest as RpcClientConfigRequest$1, RpcClientConfigResponse as RpcClientConfigResponse$1, RpcGasPriceRequest as RpcGasPriceRequest$1, RpcGasPriceResponse as RpcGasPriceResponse$1, RpcHealthRequest as RpcHealthRequest$1, RpcHealthResponse as RpcHealthResponse$1, RpcNetworkInfoRequest as RpcNetworkInfoRequest$1, RpcNetworkInfoResponse as RpcNetworkInfoResponse$1, RpcLightClientNextBlockRequest as RpcLightClientNextBlockRequest$1, RpcLightClientNextBlockResponse as RpcLightClientNextBlockResponse$1, RpcQueryRequest as RpcQueryRequest$1, RpcQueryResponse as RpcQueryResponse$1, RpcStatusRequest as RpcStatusRequest$1, RpcStatusResponse as RpcStatusResponse$1, RpcValidatorRequest as RpcValidatorRequest$1, RpcValidatorResponse as RpcValidatorResponse$1, AccountView as AccountView$1, CallResult as CallResult$1, AccessKeyView as AccessKeyView$1 } from '@near-js/jsonrpc-types/mini';
+export { JsonRpcRequestSchema, JsonRpcResponseSchema, RPC_METHODS } from '@near-js/jsonrpc-types/mini';
+
+interface ValidationResult {
+    validateRequest: (request: JsonRpcRequest) => void;
+    validateResponse: (response: JsonRpcResponse) => void;
+}
+/**
+ * Enable validation for the mini client
+ * This function should only be called if you want to include schema validation
+ * Calling this function will include Zod schemas in your bundle
+ */
+declare function enableValidation(): ValidationResult;
+
+interface MiniClientConfig {
+    endpoint: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    retries?: number;
+    validation?: ValidationResult;
+}
+interface JsonRpcRequest<T = unknown> {
+    jsonrpc: '2.0';
+    id: string;
+    method: string;
+    params?: T;
+}
+interface JsonRpcResponse<T = unknown> {
+    jsonrpc: '2.0';
+    id: string;
+    result?: T;
+    error?: JsonRpcError;
+}
+interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+declare class JsonRpcClientError extends Error {
+    code?: number | undefined;
+    data?: unknown | undefined;
+    constructor(message: string, code?: number | undefined, data?: unknown | undefined);
+}
+declare class JsonRpcNetworkError extends Error {
+    cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+/**
+ * Simplified NEAR RPC Client for mini version
+ * This client only holds configuration and provides a makeRequest method
+ * Individual RPC methods are provided as standalone functions that take this client as a parameter
+ */
+declare class NearRpcClient {
+    readonly endpoint: string;
+    readonly headers: Record<string, string>;
+    readonly timeout: number;
+    readonly retries: number;
+    private readonly validation?;
+    constructor(config: MiniClientConfig);
+    /**
+     * Make a raw JSON-RPC request
+     * This is used internally by the standalone RPC functions
+     */
+    makeRequest<TParams = unknown, TResult = unknown>(method: string, params?: TParams): Promise<TResult>;
+    /**
+     * Create a new client with modified configuration
+     */
+    withConfig(config: Partial<MiniClientConfig>): NearRpcClient;
+}
+declare const defaultClient: NearRpcClient;
+
+interface RpcRequest {
+    jsonrpc: '2.0';
+    id: string | number;
+    method: string;
+    params: unknown;
+}
+interface RpcResponse<T = unknown> {
+    jsonrpc: '2.0';
+    id: string | number;
+    result?: T;
+    error?: RpcError;
+}
+interface RpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+declare class NearRpcError extends Error {
+    code: number;
+    data?: unknown | undefined;
+    constructor(code: number, message: string, data?: unknown | undefined);
+}
+
+interface DynamicRpcMethods {
+    experimentalChanges(params?: RpcStateChangesInBlockByTypeRequest): Promise<RpcStateChangesInBlockResponse>;
+    experimentalChangesInBlock(params?: RpcStateChangesInBlockRequest): Promise<RpcStateChangesInBlockByTypeResponse>;
+    experimentalCongestionLevel(params?: RpcCongestionLevelRequest): Promise<RpcCongestionLevelResponse>;
+    experimentalGenesisConfig(params?: GenesisConfigRequest): Promise<GenesisConfig>;
+    experimentalLightClientBlockProof(params?: RpcLightClientBlockProofRequest): Promise<RpcLightClientBlockProofResponse>;
+    experimentalLightClientProof(params?: RpcLightClientExecutionProofRequest): Promise<RpcLightClientExecutionProofResponse>;
+    experimentalMaintenanceWindows(params?: RpcMaintenanceWindowsRequest): Promise<EXPERIMENTALMaintenanceWindowsResponse>;
+    experimentalProtocolConfig(params?: RpcProtocolConfigRequest): Promise<RpcProtocolConfigResponse>;
+    experimentalReceipt(params?: RpcReceiptRequest): Promise<RpcReceiptResponse>;
+    experimentalSplitStorageInfo(params?: RpcSplitStorageInfoRequest): Promise<RpcSplitStorageInfoResponse>;
+    experimentalTxStatus(params?: RpcTransactionStatusRequest): Promise<RpcTransactionResponse>;
+    experimentalValidatorsOrdered(params?: RpcValidatorsOrderedRequest): Promise<EXPERIMENTALValidatorsOrderedResponse>;
+    block(params?: RpcBlockRequest): Promise<RpcBlockResponse>;
+    broadcastTxAsync(params?: RpcSendTransactionRequest): Promise<CryptoHash>;
+    broadcastTxCommit(params?: RpcSendTransactionRequest): Promise<RpcTransactionResponse>;
+    changes(params?: RpcStateChangesInBlockByTypeRequest): Promise<RpcStateChangesInBlockResponse>;
+    chunk(params?: RpcChunkRequest): Promise<RpcChunkResponse>;
+    clientConfig(params?: RpcClientConfigRequest): Promise<RpcClientConfigResponse>;
+    gasPrice(params?: RpcGasPriceRequest): Promise<RpcGasPriceResponse>;
+    health(params?: RpcHealthRequest): Promise<RpcHealthResponse>;
+    lightClientProof(params?: RpcLightClientExecutionProofRequest): Promise<RpcLightClientExecutionProofResponse>;
+    networkInfo(params?: RpcNetworkInfoRequest): Promise<RpcNetworkInfoResponse>;
+    nextLightClientBlock(params?: RpcLightClientNextBlockRequest): Promise<RpcLightClientNextBlockResponse>;
+    query(params?: RpcQueryRequest): Promise<RpcQueryResponse>;
+    sendTx(params?: RpcSendTransactionRequest): Promise<RpcTransactionResponse>;
+    status(params?: RpcStatusRequest): Promise<RpcStatusResponse>;
+    tx(params?: RpcTransactionStatusRequest): Promise<RpcTransactionResponse>;
+    validators(params?: RpcValidatorRequest): Promise<RpcValidatorResponse>;
+}
+interface ConvenienceMethods {
+    viewAccount(params: {
+        accountId: string;
+        finality?: 'final' | 'near-final' | 'optimistic';
+        blockId?: string | number;
+    }): Promise<AccountView>;
+    viewFunction(params: {
+        accountId: string;
+        methodName: string;
+        argsBase64?: string;
+        finality?: 'final' | 'near-final' | 'optimistic';
+        blockId?: string | number;
+    }): Promise<CallResult>;
+    viewAccessKey(params: {
+        accountId: string;
+        publicKey: string;
+        finality?: 'final' | 'near-final' | 'optimistic';
+        blockId?: string | number;
+    }): Promise<AccessKeyView>;
+}
+interface CompleteClientInterface extends DynamicRpcMethods, ConvenienceMethods {
+    call<TParams = unknown, TResult = unknown>(method: string, params?: TParams): Promise<TResult>;
+}
+
+declare function experimentalChanges(client: NearRpcClient, params?: RpcStateChangesInBlockByTypeRequest$1): Promise<RpcStateChangesInBlockResponse$1>;
+declare function experimentalChangesInBlock(client: NearRpcClient, params?: RpcStateChangesInBlockRequest$1): Promise<RpcStateChangesInBlockByTypeResponse$1>;
+declare function experimentalCongestionLevel(client: NearRpcClient, params?: RpcCongestionLevelRequest$1): Promise<RpcCongestionLevelResponse$1>;
+declare function experimentalGenesisConfig(client: NearRpcClient, params?: GenesisConfigRequest$1): Promise<GenesisConfig$1>;
+declare function experimentalLightClientBlockProof(client: NearRpcClient, params?: RpcLightClientBlockProofRequest$1): Promise<RpcLightClientBlockProofResponse$1>;
+declare function experimentalLightClientProof(client: NearRpcClient, params?: RpcLightClientExecutionProofRequest$1): Promise<RpcLightClientExecutionProofResponse$1>;
+declare function experimentalMaintenanceWindows(client: NearRpcClient, params?: RpcMaintenanceWindowsRequest$1): Promise<EXPERIMENTALMaintenanceWindowsResponse$1>;
+declare function experimentalProtocolConfig(client: NearRpcClient, params?: RpcProtocolConfigRequest$1): Promise<RpcProtocolConfigResponse$1>;
+declare function experimentalReceipt(client: NearRpcClient, params?: RpcReceiptRequest$1): Promise<RpcReceiptResponse$1>;
+declare function experimentalSplitStorageInfo(client: NearRpcClient, params?: RpcSplitStorageInfoRequest$1): Promise<RpcSplitStorageInfoResponse$1>;
+declare function experimentalTxStatus(client: NearRpcClient, params?: RpcTransactionStatusRequest$1): Promise<RpcTransactionResponse$1>;
+declare function experimentalValidatorsOrdered(client: NearRpcClient, params?: RpcValidatorsOrderedRequest$1): Promise<EXPERIMENTALValidatorsOrderedResponse$1>;
+declare function block(client: NearRpcClient, params?: RpcBlockRequest$1): Promise<RpcBlockResponse$1>;
+declare function broadcastTxAsync(client: NearRpcClient, params?: RpcSendTransactionRequest$1): Promise<CryptoHash$1>;
+declare function broadcastTxCommit(client: NearRpcClient, params?: RpcSendTransactionRequest$1): Promise<RpcTransactionResponse$1>;
+declare function changes(client: NearRpcClient, params?: RpcStateChangesInBlockByTypeRequest$1): Promise<RpcStateChangesInBlockResponse$1>;
+declare function chunk(client: NearRpcClient, params?: RpcChunkRequest$1): Promise<RpcChunkResponse$1>;
+declare function clientConfig(client: NearRpcClient, params?: RpcClientConfigRequest$1): Promise<RpcClientConfigResponse$1>;
+declare function gasPrice(client: NearRpcClient, params?: RpcGasPriceRequest$1): Promise<RpcGasPriceResponse$1>;
+declare function health(client: NearRpcClient, params?: RpcHealthRequest$1): Promise<RpcHealthResponse$1>;
+declare function lightClientProof(client: NearRpcClient, params?: RpcLightClientExecutionProofRequest$1): Promise<RpcLightClientExecutionProofResponse$1>;
+declare function networkInfo(client: NearRpcClient, params?: RpcNetworkInfoRequest$1): Promise<RpcNetworkInfoResponse$1>;
+declare function nextLightClientBlock(client: NearRpcClient, params?: RpcLightClientNextBlockRequest$1): Promise<RpcLightClientNextBlockResponse$1>;
+declare function query(client: NearRpcClient, params?: RpcQueryRequest$1): Promise<RpcQueryResponse$1>;
+declare function sendTx(client: NearRpcClient, params?: RpcSendTransactionRequest$1): Promise<RpcTransactionResponse$1>;
+declare function status(client: NearRpcClient, params?: RpcStatusRequest$1): Promise<RpcStatusResponse$1>;
+declare function tx(client: NearRpcClient, params?: RpcTransactionStatusRequest$1): Promise<RpcTransactionResponse$1>;
+declare function validators(client: NearRpcClient, params?: RpcValidatorRequest$1): Promise<RpcValidatorResponse$1>;
+
+declare function viewAccount(client: NearRpcClient, params: {
+    accountId: string;
+    finality?: 'final' | 'near-final' | 'optimistic';
+    blockId?: string | number;
+}): Promise<AccountView$1>;
+declare function viewFunction(client: NearRpcClient, params: {
+    accountId: string;
+    methodName: string;
+    argsBase64?: string;
+    finality?: 'final' | 'near-final' | 'optimistic';
+    blockId?: string | number;
+}): Promise<CallResult$1>;
+declare function viewAccessKey(client: NearRpcClient, params: {
+    accountId: string;
+    publicKey: string;
+    finality?: 'final' | 'near-final' | 'optimistic';
+    blockId?: string | number;
+}): Promise<AccessKeyView$1>;
+
+export { type CompleteClientInterface, type ConvenienceMethods, type DynamicRpcMethods, JsonRpcClientError, type JsonRpcError, JsonRpcNetworkError, type JsonRpcRequest, type JsonRpcResponse, type MiniClientConfig, NearRpcClient, NearRpcError, type RpcError, type RpcRequest, type RpcResponse, block, broadcastTxAsync, broadcastTxCommit, changes, chunk, clientConfig, NearRpcClient as default, defaultClient, enableValidation, experimentalChanges, experimentalChangesInBlock, experimentalCongestionLevel, experimentalGenesisConfig, experimentalLightClientBlockProof, experimentalLightClientProof, experimentalMaintenanceWindows, experimentalProtocolConfig, experimentalReceipt, experimentalSplitStorageInfo, experimentalTxStatus, experimentalValidatorsOrdered, gasPrice, health, lightClientProof, networkInfo, nextLightClientBlock, query, sendTx, status, tx, validators, viewAccessKey, viewAccount, viewFunction };

package/dist/index.mini.d.ts

@@ -0,0 +1,10 @@
+export * from './client.mini';
+export * from './types';
+export { NearRpcClient, defaultClient } from './client.mini';
+export type { DynamicRpcMethods, ConvenienceMethods, CompleteClientInterface, } from './generated-types';
+export { JsonRpcRequestSchema, JsonRpcResponseSchema, } from '@near-js/jsonrpc-types/mini';
+export { RPC_METHODS } from '@near-js/jsonrpc-types/mini';
+export * from './generated-functions.mini';
+export { enableValidation } from './validation.mini.js';
+export { NearRpcClient as default } from './client.mini';
+//# sourceMappingURL=index.mini.d.ts.map

package/dist/index.mini.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mini.d.ts","sourceRoot":"","sources":["../src/index.mini.ts"],"names":[],"mappings":"AAGA,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AAGxB,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAG7D,YAAY,EACV,iBAAiB,EACjB,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAG1D,cAAc,4BAA4B,CAAC;AAG3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAGxD,OAAO,EAAE,aAAa,IAAI,OAAO,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.mini.mjs

@@ -0,0 +1,361 @@
+// src/client.mini.ts
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function convertKeysToSnakeCase(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(convertKeysToSnakeCase);
+  }
+  const converted = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const snakeKey = camelToSnake(key);
+    converted[snakeKey] = convertKeysToSnakeCase(value);
+  }
+  return converted;
+}
+function convertKeysToCamelCase(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(convertKeysToCamelCase);
+  }
+  const converted = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const camelKey = snakeToCamel(key);
+    converted[camelKey] = convertKeysToCamelCase(value);
+  }
+  return converted;
+}
+var REQUEST_ID = "dontcare";
+var JsonRpcClientError = class extends Error {
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "JsonRpcClientError";
+  }
+};
+var JsonRpcNetworkError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "JsonRpcNetworkError";
+  }
+};
+var NearRpcClient = class _NearRpcClient {
+  endpoint;
+  headers;
+  timeout;
+  retries;
+  validation;
+  constructor(config) {
+    this.endpoint = config.endpoint;
+    this.headers = config.headers || {};
+    this.timeout = config.timeout || 3e4;
+    this.retries = config.retries || 3;
+    if (config.validation) {
+      this.validation = config.validation;
+    }
+  }
+  /**
+   * Make a raw JSON-RPC request
+   * This is used internally by the standalone RPC functions
+   */
+  async makeRequest(method, params) {
+    const snakeCaseParams = params ? convertKeysToSnakeCase(params) : params;
+    const request = {
+      jsonrpc: "2.0",
+      id: REQUEST_ID,
+      method,
+      params: snakeCaseParams
+    };
+    if (this.validation) {
+      this.validation.validateRequest(request);
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(this.endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...this.headers
+          },
+          body: JSON.stringify(request),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          throw new JsonRpcNetworkError(
+            `HTTP error! status: ${response.status}`
+          );
+        }
+        const jsonResponse = await response.json();
+        if (this.validation) {
+          this.validation.validateResponse(jsonResponse);
+        }
+        if (jsonResponse.error) {
+          throw new JsonRpcClientError(
+            jsonResponse.error.message,
+            jsonResponse.error.code,
+            jsonResponse.error.data
+          );
+        }
+        const camelCaseResult = jsonResponse.result ? convertKeysToCamelCase(jsonResponse.result) : jsonResponse.result;
+        return camelCaseResult;
+      } catch (error) {
+        lastError = error;
+        if (error instanceof JsonRpcClientError) {
+          throw error;
+        }
+        if (attempt === this.retries) {
+          break;
+        }
+        await new Promise(
+          (resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1e3)
+        );
+      }
+    }
+    throw lastError || new JsonRpcNetworkError("Request failed after all retries");
+  }
+  /**
+   * Create a new client with modified configuration
+   */
+  withConfig(config) {
+    return new _NearRpcClient({
+      endpoint: config.endpoint ?? this.endpoint,
+      headers: config.headers ?? this.headers,
+      timeout: config.timeout ?? this.timeout,
+      retries: config.retries ?? this.retries,
+      ...config.validation !== void 0 ? { validation: config.validation } : this.validation !== void 0 ? { validation: this.validation } : {}
+    });
+  }
+};
+var defaultClient = new NearRpcClient({
+  endpoint: "https://rpc.mainnet.near.org"
+});
+
+// src/types.ts
+var NearRpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "NearRpcError";
+  }
+};
+
+// src/index.mini.ts
+import {
+  JsonRpcRequestSchema as JsonRpcRequestSchema2,
+  JsonRpcResponseSchema as JsonRpcResponseSchema2
+} from "@psalomo/jsonrpc-types/mini";
+import { RPC_METHODS } from "@psalomo/jsonrpc-types/mini";
+
+// src/generated-types.mini.ts
+async function experimentalChanges(client, params) {
+  return client.makeRequest("EXPERIMENTAL_changes", params);
+}
+async function experimentalChangesInBlock(client, params) {
+  return client.makeRequest("EXPERIMENTAL_changes_in_block", params);
+}
+async function experimentalCongestionLevel(client, params) {
+  return client.makeRequest("EXPERIMENTAL_congestion_level", params);
+}
+async function experimentalGenesisConfig(client, params) {
+  return client.makeRequest("EXPERIMENTAL_genesis_config", params);
+}
+async function experimentalLightClientBlockProof(client, params) {
+  return client.makeRequest("EXPERIMENTAL_light_client_block_proof", params);
+}
+async function experimentalLightClientProof(client, params) {
+  return client.makeRequest("EXPERIMENTAL_light_client_proof", params);
+}
+async function experimentalMaintenanceWindows(client, params) {
+  return client.makeRequest("EXPERIMENTAL_maintenance_windows", params);
+}
+async function experimentalProtocolConfig(client, params) {
+  return client.makeRequest("EXPERIMENTAL_protocol_config", params);
+}
+async function experimentalReceipt(client, params) {
+  return client.makeRequest("EXPERIMENTAL_receipt", params);
+}
+async function experimentalSplitStorageInfo(client, params) {
+  return client.makeRequest("EXPERIMENTAL_split_storage_info", params);
+}
+async function experimentalTxStatus(client, params) {
+  return client.makeRequest("EXPERIMENTAL_tx_status", params);
+}
+async function experimentalValidatorsOrdered(client, params) {
+  return client.makeRequest("EXPERIMENTAL_validators_ordered", params);
+}
+async function block(client, params) {
+  return client.makeRequest("block", params);
+}
+async function broadcastTxAsync(client, params) {
+  return client.makeRequest("broadcast_tx_async", params);
+}
+async function broadcastTxCommit(client, params) {
+  return client.makeRequest("broadcast_tx_commit", params);
+}
+async function changes(client, params) {
+  return client.makeRequest("changes", params);
+}
+async function chunk(client, params) {
+  return client.makeRequest("chunk", params);
+}
+async function clientConfig(client, params) {
+  return client.makeRequest("client_config", params);
+}
+async function gasPrice(client, params) {
+  return client.makeRequest("gas_price", params);
+}
+async function health(client, params) {
+  return client.makeRequest("health", params);
+}
+async function lightClientProof(client, params) {
+  return client.makeRequest("light_client_proof", params);
+}
+async function networkInfo(client, params) {
+  return client.makeRequest("network_info", params);
+}
+async function nextLightClientBlock(client, params) {
+  return client.makeRequest("next_light_client_block", params);
+}
+async function query(client, params) {
+  return client.makeRequest("query", params);
+}
+async function sendTx(client, params) {
+  return client.makeRequest("send_tx", params);
+}
+async function status(client, params) {
+  return client.makeRequest("status", params);
+}
+async function tx(client, params) {
+  return client.makeRequest("tx", params);
+}
+async function validators(client, params) {
+  return client.makeRequest("validators", params);
+}
+
+// src/convenience.mini.ts
+async function viewAccount(client, params) {
+  const queryParams = params.blockId ? {
+    requestType: "view_account",
+    accountId: params.accountId,
+    blockId: params.blockId
+  } : {
+    requestType: "view_account",
+    accountId: params.accountId,
+    finality: params.finality || "final"
+  };
+  return query(client, queryParams);
+}
+async function viewFunction(client, params) {
+  const baseParams = {
+    requestType: "call_function",
+    accountId: params.accountId,
+    methodName: params.methodName,
+    argsBase64: params.argsBase64 ?? ""
+    // Default to empty string if no arguments
+  };
+  const queryParams = params.blockId ? { ...baseParams, blockId: params.blockId } : { ...baseParams, finality: params.finality || "final" };
+  return query(client, queryParams);
+}
+async function viewAccessKey(client, params) {
+  const queryParams = params.blockId ? {
+    requestType: "view_access_key",
+    accountId: params.accountId,
+    publicKey: params.publicKey,
+    blockId: params.blockId
+  } : {
+    requestType: "view_access_key",
+    accountId: params.accountId,
+    publicKey: params.publicKey,
+    finality: params.finality || "final"
+  };
+  return query(client, queryParams);
+}
+
+// src/validation.mini.ts
+import {
+  JsonRpcRequestSchema,
+  JsonRpcResponseSchema
+} from "@psalomo/jsonrpc-types/mini";
+function enableValidation() {
+  const requestSchema = JsonRpcRequestSchema();
+  const responseSchema = JsonRpcResponseSchema();
+  return {
+    validateRequest: (request) => {
+      try {
+        requestSchema.parse(request);
+      } catch (error) {
+        throw new JsonRpcNetworkError(
+          `Invalid request format: ${error instanceof Error ? error.message : "Unknown error"}`,
+          error
+        );
+      }
+    },
+    validateResponse: (response) => {
+      try {
+        responseSchema.parse(response);
+      } catch (error) {
+        throw new JsonRpcClientError(
+          `Invalid response format: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+  };
+}
+export {
+  JsonRpcClientError,
+  JsonRpcNetworkError,
+  JsonRpcRequestSchema2 as JsonRpcRequestSchema,
+  JsonRpcResponseSchema2 as JsonRpcResponseSchema,
+  NearRpcClient,
+  NearRpcError,
+  RPC_METHODS,
+  block,
+  broadcastTxAsync,
+  broadcastTxCommit,
+  changes,
+  chunk,
+  clientConfig,
+  NearRpcClient as default,
+  defaultClient,
+  enableValidation,
+  experimentalChanges,
+  experimentalChangesInBlock,
+  experimentalCongestionLevel,
+  experimentalGenesisConfig,
+  experimentalLightClientBlockProof,
+  experimentalLightClientProof,
+  experimentalMaintenanceWindows,
+  experimentalProtocolConfig,
+  experimentalReceipt,
+  experimentalSplitStorageInfo,
+  experimentalTxStatus,
+  experimentalValidatorsOrdered,
+  gasPrice,
+  health,
+  lightClientProof,
+  networkInfo,
+  nextLightClientBlock,
+  query,
+  sendTx,
+  status,
+  tx,
+  validators,
+  viewAccessKey,
+  viewAccount,
+  viewFunction
+};

package/dist/index.mjs

@@ -59,7 +59,6 @@ var NearRpcClient = class {
   timeout;
   retries;
   validateResponses;
-  requestIdCounter = 0;
   constructor(config) {
     if (typeof config === "string") {
       this.endpoint = config;
@@ -81,17 +80,17 @@ var NearRpcClient = class {
     }
   }
   /**
-   * Generate a unique request ID
+   * Get request ID matching NEAR RPC documentation examples
    */
-  generateRequestId() {
-    return `near-rpc-${Date.now()}-${++this.requestIdCounter}`;
+  getRequestId() {
+    return "dontcare";
   }
   /**
    * Make a raw JSON-RPC call
    * This method is public to allow dynamic calls to any RPC method
    */
   async call(method, params) {
-    const requestId = this.generateRequestId();
+    const requestId = this.getRequestId();
     const snakeCaseParams = params ? convertKeysToSnakeCase(params) : void 0;
     const request = {
       jsonrpc: "2.0",

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+export interface RpcRequest {
+    jsonrpc: '2.0';
+    id: string | number;
+    method: string;
+    params: unknown;
+}
+export interface RpcResponse<T = unknown> {
+    jsonrpc: '2.0';
+    id: string | number;
+    result?: T;
+    error?: RpcError;
+}
+export interface RpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export declare class NearRpcError extends Error {
+    code: number;
+    data?: unknown | undefined;
+    constructor(code: number, message: string, data?: unknown | undefined);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,OAAO;IACtC,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,CAAC,CAAC;IACX,KAAK,CAAC,EAAE,QAAQ,CAAC;CAClB;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,qBAAa,YAAa,SAAQ,KAAK;IAE5B,IAAI,EAAE,MAAM;IAEZ,IAAI,CAAC,EAAE,OAAO;gBAFd,IAAI,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACR,IAAI,CAAC,EAAE,OAAO,YAAA;CAKxB"}

package/dist/validation.mini.d.ts

@@ -0,0 +1,12 @@
+import { JsonRpcRequest, JsonRpcResponse } from './client.mini.js';
+export interface ValidationResult {
+    validateRequest: (request: JsonRpcRequest) => void;
+    validateResponse: (response: JsonRpcResponse) => void;
+}
+/**
+ * Enable validation for the mini client
+ * This function should only be called if you want to include schema validation
+ * Calling this function will include Zod schemas in your bundle
+ */
+export declare function enableValidation(): ValidationResult;
+//# sourceMappingURL=validation.mini.d.ts.map

package/dist/validation.mini.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.mini.d.ts","sourceRoot":"","sources":["../src/validation.mini.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,cAAc,EACd,eAAe,EAGhB,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,gBAAgB;IAC/B,eAAe,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IACnD,gBAAgB,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,CAAC;CACvD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,gBAAgB,CA0BnD"}