@psalomo/jsonrpc-client 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -1,137 +1,7 @@
-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, RPC_METHODS } from '@near-js/jsonrpc-types';
-export { JsonRpcRequestSchema, JsonRpcResponseSchema, RPC_METHODS } from '@near-js/jsonrpc-types';
-
-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>;
-}
-
-type RpcMethod = (typeof RPC_METHODS)[number];
-interface ClientConfig {
-    endpoint: string;
-    headers?: Record<string, string>;
-    timeout?: number;
-    retries?: number;
-    validateResponses?: boolean;
-}
-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 {
-    originalError: Error;
-    constructor(message: string, originalError: Error);
-}
-
-declare class NearRpcClient {
-    private endpoint;
-    private headers;
-    private timeout;
-    private retries;
-    private validateResponses;
-    private requestIdCounter;
-    constructor(config: string | ClientConfig);
-    /**
-     * Generate a unique request ID
-     */
-    private generateRequestId;
-    /**
-     * Make a raw JSON-RPC call
-     * This method is public to allow dynamic calls to any RPC method
-     */
-    call<TParams = unknown, TResult = unknown>(method: RpcMethod, params?: TParams): Promise<TResult>;
-}
-interface NearRpcClient extends DynamicRpcMethods, ConvenienceMethods {
-}
-
-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);
-}
-
-export { type ClientConfig, type CompleteClientInterface, type ConvenienceMethods, type DynamicRpcMethods, JsonRpcClientError, type JsonRpcError, JsonRpcNetworkError, type JsonRpcRequest, type JsonRpcResponse, NearRpcClient, NearRpcError, type RpcError, type RpcRequest, type RpcResponse, NearRpcClient as default };
+export * from './client';
+export * from './types';
+export * from './generated-types';
+export { JsonRpcRequestSchema, JsonRpcResponseSchema, } from '@near-js/jsonrpc-types';
+export { RPC_METHODS } from '@near-js/jsonrpc-types';
+export { NearRpcClient as default } from './client';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,mBAAmB,CAAC;AAGlC,OAAO,EACL,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAGrD,OAAO,EAAE,aAAa,IAAI,OAAO,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -88,7 +88,6 @@ var NearRpcClient = class {
   timeout;
   retries;
   validateResponses;
-  requestIdCounter = 0;
   constructor(config) {
     if (typeof config === "string") {
       this.endpoint = config;
@@ -110,17 +109,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/index.mini.cjs

@@ -0,0 +1,421 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.mini.ts
+var index_mini_exports = {};
+__export(index_mini_exports, {
+  JsonRpcClientError: () => JsonRpcClientError,
+  JsonRpcNetworkError: () => JsonRpcNetworkError,
+  JsonRpcRequestSchema: () => import_mini2.JsonRpcRequestSchema,
+  JsonRpcResponseSchema: () => import_mini2.JsonRpcResponseSchema,
+  NearRpcClient: () => NearRpcClient,
+  NearRpcError: () => NearRpcError,
+  RPC_METHODS: () => import_mini3.RPC_METHODS,
+  block: () => block,
+  broadcastTxAsync: () => broadcastTxAsync,
+  broadcastTxCommit: () => broadcastTxCommit,
+  changes: () => changes,
+  chunk: () => chunk,
+  clientConfig: () => clientConfig,
+  default: () => NearRpcClient,
+  defaultClient: () => defaultClient,
+  enableValidation: () => enableValidation,
+  experimentalChanges: () => experimentalChanges,
+  experimentalChangesInBlock: () => experimentalChangesInBlock,
+  experimentalCongestionLevel: () => experimentalCongestionLevel,
+  experimentalGenesisConfig: () => experimentalGenesisConfig,
+  experimentalLightClientBlockProof: () => experimentalLightClientBlockProof,
+  experimentalLightClientProof: () => experimentalLightClientProof,
+  experimentalMaintenanceWindows: () => experimentalMaintenanceWindows,
+  experimentalProtocolConfig: () => experimentalProtocolConfig,
+  experimentalReceipt: () => experimentalReceipt,
+  experimentalSplitStorageInfo: () => experimentalSplitStorageInfo,
+  experimentalTxStatus: () => experimentalTxStatus,
+  experimentalValidatorsOrdered: () => experimentalValidatorsOrdered,
+  gasPrice: () => gasPrice,
+  health: () => health,
+  lightClientProof: () => lightClientProof,
+  networkInfo: () => networkInfo,
+  nextLightClientBlock: () => nextLightClientBlock,
+  query: () => query,
+  sendTx: () => sendTx,
+  status: () => status,
+  tx: () => tx,
+  validators: () => validators,
+  viewAccessKey: () => viewAccessKey,
+  viewAccount: () => viewAccount,
+  viewFunction: () => viewFunction
+});
+module.exports = __toCommonJS(index_mini_exports);
+
+// 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
+var import_mini2 = require("@near-js/jsonrpc-types/mini");
+var import_mini3 = require("@near-js/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
+var import_mini = require("@near-js/jsonrpc-types/mini");
+function enableValidation() {
+  const requestSchema = (0, import_mini.JsonRpcRequestSchema)();
+  const responseSchema = (0, import_mini.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"}`
+        );
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonRpcClientError,
+  JsonRpcNetworkError,
+  JsonRpcRequestSchema,
+  JsonRpcResponseSchema,
+  NearRpcClient,
+  NearRpcError,
+  RPC_METHODS,
+  block,
+  broadcastTxAsync,
+  broadcastTxCommit,
+  changes,
+  chunk,
+  clientConfig,
+  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
+});