@psalomo/jsonrpc-client 0.3.0 → 0.5.0

package/dist/browser-standalone-mini.js

@@ -0,0 +1,1245 @@
+// Case conversion utilities (identical to regular client)
+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;
+}
+// Use static ID matching NEAR RPC documentation examples
+const REQUEST_ID = 'dontcare';
+// Custom error classes
+class JsonRpcClientError extends Error {
+    code;
+    data;
+    constructor(message, code, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = 'JsonRpcClientError';
+    }
+}
+class JsonRpcNetworkError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'JsonRpcNetworkError';
+    }
+}
+/**
+ * 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
+ */
+class NearRpcClient {
+    endpoint;
+    headers;
+    timeout;
+    retries;
+    validation;
+    constructor(config) {
+        this.endpoint = config.endpoint;
+        this.headers = config.headers || {};
+        this.timeout = config.timeout || 30000;
+        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) {
+        // Convert camelCase params to snake_case for the RPC call
+        const snakeCaseParams = params ? convertKeysToSnakeCase(params) : params;
+        const request = {
+            jsonrpc: '2.0',
+            id: REQUEST_ID,
+            method,
+            params: snakeCaseParams,
+        };
+        // Validate request if validation is enabled
+        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();
+                // Validate response if validation is enabled
+                if (this.validation) {
+                    this.validation.validateResponse(jsonResponse);
+                }
+                if (jsonResponse.error) {
+                    throw new JsonRpcClientError(jsonResponse.error.message, jsonResponse.error.code, jsonResponse.error.data);
+                }
+                // Convert snake_case response back to camelCase
+                const camelCaseResult = jsonResponse.result
+                    ? convertKeysToCamelCase(jsonResponse.result)
+                    : jsonResponse.result;
+                return camelCaseResult;
+            }
+            catch (error) {
+                lastError = error;
+                // Don't retry on client errors or validation errors
+                if (error instanceof JsonRpcClientError) {
+                    throw error;
+                }
+                // Don't retry if this is the last attempt
+                if (attempt === this.retries) {
+                    break;
+                }
+                // Wait before retrying (exponential backoff)
+                await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
+            }
+        }
+        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 !== undefined
+                ? { validation: config.validation }
+                : this.validation !== undefined
+                    ? { validation: this.validation }
+                    : {}),
+        });
+    }
+}
+// Default client instance for convenience
+const defaultClient = new NearRpcClient({
+    endpoint: 'https://rpc.mainnet.near.org',
+});
+
+// Client-specific types
+class NearRpcError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = 'NearRpcError';
+    }
+}
+
+/** A special constant with type `never` */
+function $constructor(name, initializer, params) {
+    function init(inst, def) {
+        var _a;
+        Object.defineProperty(inst, "_zod", {
+            value: inst._zod ?? {},
+            enumerable: false,
+        });
+        (_a = inst._zod).traits ?? (_a.traits = new Set());
+        inst._zod.traits.add(name);
+        initializer(inst, def);
+        // support prototype modifications
+        for (const k in _.prototype) {
+            if (!(k in inst))
+                Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+        }
+        inst._zod.constr = _;
+        inst._zod.def = def;
+    }
+    // doesn't work if Parent has a constructor with arguments
+    const Parent = params?.Parent ?? Object;
+    class Definition extends Parent {
+    }
+    Object.defineProperty(Definition, "name", { value: name });
+    function _(def) {
+        var _a;
+        const inst = params?.Parent ? new Definition() : this;
+        init(inst, def);
+        (_a = inst._zod).deferred ?? (_a.deferred = []);
+        for (const fn of inst._zod.deferred) {
+            fn();
+        }
+        return inst;
+    }
+    Object.defineProperty(_, "init", { value: init });
+    Object.defineProperty(_, Symbol.hasInstance, {
+        value: (inst) => {
+            if (params?.Parent && inst instanceof params.Parent)
+                return true;
+            return inst?._zod?.traits?.has(name);
+        },
+    });
+    Object.defineProperty(_, "name", { value: name });
+    return _;
+}
+class $ZodAsyncError extends Error {
+    constructor() {
+        super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+    }
+}
+const globalConfig = {};
+function config(newConfig) {
+    return globalConfig;
+}
+
+// functions
+function jsonStringifyReplacer(_, value) {
+    if (typeof value === "bigint")
+        return value.toString();
+    return value;
+}
+function cached(getter) {
+    return {
+        get value() {
+            {
+                const value = getter();
+                Object.defineProperty(this, "value", { value });
+                return value;
+            }
+        },
+    };
+}
+function cleanRegex(source) {
+    const start = source.startsWith("^") ? 1 : 0;
+    const end = source.endsWith("$") ? source.length - 1 : source.length;
+    return source.slice(start, end);
+}
+function defineLazy(object, key, getter) {
+    Object.defineProperty(object, key, {
+        get() {
+            {
+                const value = getter();
+                object[key] = value;
+                return value;
+            }
+        },
+        set(v) {
+            Object.defineProperty(object, key, {
+                value: v,
+                // configurable: true,
+            });
+            // object[key] = v;
+        },
+        configurable: true,
+    });
+}
+function assignProp(target, prop, value) {
+    Object.defineProperty(target, prop, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+}
+function esc(str) {
+    return JSON.stringify(str);
+}
+const captureStackTrace = Error.captureStackTrace
+    ? Error.captureStackTrace
+    : (..._args) => { };
+function isObject(data) {
+    return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+const allowsEval = cached(() => {
+    if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
+        return false;
+    }
+    try {
+        const F = Function;
+        new F("");
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+});
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// zod-specific utils
+function clone(inst, def, params) {
+    const cl = new inst._zod.constr(def ?? inst._zod.def);
+    if (!def || params?.parent)
+        cl._zod.parent = inst;
+    return cl;
+}
+function normalizeParams(_params) {
+    return {};
+}
+function optionalKeys(shape) {
+    return Object.keys(shape).filter((k) => {
+        return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
+    });
+}
+function aborted(x, startIndex = 0) {
+    for (let i = startIndex; i < x.issues.length; i++) {
+        if (x.issues[i]?.continue !== true)
+            return true;
+    }
+    return false;
+}
+function prefixIssues(path, issues) {
+    return issues.map((iss) => {
+        var _a;
+        (_a = iss).path ?? (_a.path = []);
+        iss.path.unshift(path);
+        return iss;
+    });
+}
+function unwrapMessage(message) {
+    return typeof message === "string" ? message : message?.message;
+}
+function finalizeIssue(iss, ctx, config) {
+    const full = { ...iss, path: iss.path ?? [] };
+    // for backwards compatibility
+    if (!iss.message) {
+        const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ??
+            unwrapMessage(ctx?.error?.(iss)) ??
+            unwrapMessage(config.customError?.(iss)) ??
+            unwrapMessage(config.localeError?.(iss)) ??
+            "Invalid input";
+        full.message = message;
+    }
+    // delete (full as any).def;
+    delete full.inst;
+    delete full.continue;
+    if (!ctx?.reportInput) {
+        delete full.input;
+    }
+    return full;
+}
+
+const initializer = (inst, def) => {
+    inst.name = "$ZodError";
+    Object.defineProperty(inst, "_zod", {
+        value: inst._zod,
+        enumerable: false,
+    });
+    Object.defineProperty(inst, "issues", {
+        value: def,
+        enumerable: false,
+    });
+    Object.defineProperty(inst, "message", {
+        get() {
+            return JSON.stringify(def, jsonStringifyReplacer, 2);
+        },
+        enumerable: true,
+        // configurable: false,
+    });
+    Object.defineProperty(inst, "toString", {
+        value: () => inst.message,
+        enumerable: false,
+    });
+};
+const $ZodError = $constructor("$ZodError", initializer);
+const $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
+
+const _parse = (_Err) => (schema, value, _ctx, _params) => {
+    const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
+    const result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise) {
+        throw new $ZodAsyncError();
+    }
+    if (result.issues.length) {
+        const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+        captureStackTrace(e, _params?.callee);
+        throw e;
+    }
+    return result.value;
+};
+const parse = /* @__PURE__*/ _parse($ZodRealError);
+const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+    const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+    let result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise)
+        result = await result;
+    if (result.issues.length) {
+        const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+        captureStackTrace(e, params?.callee);
+        throw e;
+    }
+    return result.value;
+};
+const parseAsync = /* @__PURE__*/ _parseAsync($ZodRealError);
+const _safeParse = (_Err) => (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+    const result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise) {
+        throw new $ZodAsyncError();
+    }
+    return result.issues.length
+        ? {
+            success: false,
+            error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))),
+        }
+        : { success: true, data: result.value };
+};
+const safeParse = /* @__PURE__*/ _safeParse($ZodRealError);
+const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+    const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+    let result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise)
+        result = await result;
+    return result.issues.length
+        ? {
+            success: false,
+            error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))),
+        }
+        : { success: true, data: result.value };
+};
+const safeParseAsync = /* @__PURE__*/ _safeParseAsync($ZodRealError);
+
+const string$1 = (params) => {
+    const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+    return new RegExp(`^${regex}$`);
+};
+const number$1 = /^-?\d+(?:\.\d+)?/i;
+
+class Doc {
+    constructor(args = []) {
+        this.content = [];
+        this.indent = 0;
+        if (this)
+            this.args = args;
+    }
+    indented(fn) {
+        this.indent += 1;
+        fn(this);
+        this.indent -= 1;
+    }
+    write(arg) {
+        if (typeof arg === "function") {
+            arg(this, { execution: "sync" });
+            arg(this, { execution: "async" });
+            return;
+        }
+        const content = arg;
+        const lines = content.split("\n").filter((x) => x);
+        const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
+        const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
+        for (const line of dedented) {
+            this.content.push(line);
+        }
+    }
+    compile() {
+        const F = Function;
+        const args = this?.args;
+        const content = this?.content ?? [``];
+        const lines = [...content.map((x) => `  ${x}`)];
+        // console.log(lines.join("\n"));
+        return new F(...args, lines.join("\n"));
+    }
+}
+
+const version = {
+    major: 4,
+    minor: 0,
+    patch: 5,
+};
+
+const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
+    var _a;
+    inst ?? (inst = {});
+    inst._zod.def = def; // set _def property
+    inst._zod.bag = inst._zod.bag || {}; // initialize _bag object
+    inst._zod.version = version;
+    const checks = [...(inst._zod.def.checks ?? [])];
+    // if inst is itself a checks.$ZodCheck, run it as a check
+    if (inst._zod.traits.has("$ZodCheck")) {
+        checks.unshift(inst);
+    }
+    //
+    for (const ch of checks) {
+        for (const fn of ch._zod.onattach) {
+            fn(inst);
+        }
+    }
+    if (checks.length === 0) {
+        // deferred initializer
+        // inst._zod.parse is not yet defined
+        (_a = inst._zod).deferred ?? (_a.deferred = []);
+        inst._zod.deferred?.push(() => {
+            inst._zod.run = inst._zod.parse;
+        });
+    }
+    else {
+        const runChecks = (payload, checks, ctx) => {
+            let isAborted = aborted(payload);
+            let asyncResult;
+            for (const ch of checks) {
+                if (ch._zod.def.when) {
+                    const shouldRun = ch._zod.def.when(payload);
+                    if (!shouldRun)
+                        continue;
+                }
+                else if (isAborted) {
+                    continue;
+                }
+                const currLen = payload.issues.length;
+                const _ = ch._zod.check(payload);
+                if (_ instanceof Promise && ctx?.async === false) {
+                    throw new $ZodAsyncError();
+                }
+                if (asyncResult || _ instanceof Promise) {
+                    asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
+                        await _;
+                        const nextLen = payload.issues.length;
+                        if (nextLen === currLen)
+                            return;
+                        if (!isAborted)
+                            isAborted = aborted(payload, currLen);
+                    });
+                }
+                else {
+                    const nextLen = payload.issues.length;
+                    if (nextLen === currLen)
+                        continue;
+                    if (!isAborted)
+                        isAborted = aborted(payload, currLen);
+                }
+            }
+            if (asyncResult) {
+                return asyncResult.then(() => {
+                    return payload;
+                });
+            }
+            return payload;
+        };
+        inst._zod.run = (payload, ctx) => {
+            const result = inst._zod.parse(payload, ctx);
+            if (result instanceof Promise) {
+                if (ctx.async === false)
+                    throw new $ZodAsyncError();
+                return result.then((result) => runChecks(result, checks, ctx));
+            }
+            return runChecks(result, checks, ctx);
+        };
+    }
+    inst["~standard"] = {
+        validate: (value) => {
+            try {
+                const r = safeParse(inst, value);
+                return r.success ? { value: r.data } : { issues: r.error?.issues };
+            }
+            catch (_) {
+                return safeParseAsync(inst, value).then((r) => (r.success ? { value: r.data } : { issues: r.error?.issues }));
+            }
+        },
+        vendor: "zod",
+        version: 1,
+    };
+});
+const $ZodString = /*@__PURE__*/ $constructor("$ZodString", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = [...(inst?._zod.bag?.patterns ?? [])].pop() ?? string$1(inst._zod.bag);
+    inst._zod.parse = (payload, _) => {
+        if (def.coerce)
+            try {
+                payload.value = String(payload.value);
+            }
+            catch (_) { }
+        if (typeof payload.value === "string")
+            return payload;
+        payload.issues.push({
+            expected: "string",
+            code: "invalid_type",
+            input: payload.value,
+            inst,
+        });
+        return payload;
+    };
+});
+const $ZodNumber = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = inst._zod.bag.pattern ?? number$1;
+    inst._zod.parse = (payload, _ctx) => {
+        if (def.coerce)
+            try {
+                payload.value = Number(payload.value);
+            }
+            catch (_) { }
+        const input = payload.value;
+        if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
+            return payload;
+        }
+        const received = typeof input === "number"
+            ? Number.isNaN(input)
+                ? "NaN"
+                : !Number.isFinite(input)
+                    ? "Infinity"
+                    : undefined
+            : undefined;
+        payload.issues.push({
+            expected: "number",
+            code: "invalid_type",
+            input,
+            inst,
+            ...(received ? { received } : {}),
+        });
+        return payload;
+    };
+});
+const $ZodUnknown = /*@__PURE__*/ $constructor("$ZodUnknown", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload) => payload;
+});
+function handleObjectResult(result, final, key) {
+    // if(isOptional)
+    if (result.issues.length) {
+        final.issues.push(...prefixIssues(key, result.issues));
+    }
+    final.value[key] = result.value;
+}
+function handleOptionalObjectResult(result, final, key, input) {
+    if (result.issues.length) {
+        // validation failed against value schema
+        if (input[key] === undefined) {
+            // if input was undefined, ignore the error
+            if (key in input) {
+                final.value[key] = undefined;
+            }
+            else {
+                final.value[key] = result.value;
+            }
+        }
+        else {
+            final.issues.push(...prefixIssues(key, result.issues));
+        }
+    }
+    else if (result.value === undefined) {
+        // validation returned `undefined`
+        if (key in input)
+            final.value[key] = undefined;
+    }
+    else {
+        // non-undefined value
+        final.value[key] = result.value;
+    }
+}
+const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
+    // requires cast because technically $ZodObject doesn't extend
+    $ZodType.init(inst, def);
+    const _normalized = cached(() => {
+        const keys = Object.keys(def.shape);
+        for (const k of keys) {
+            if (!(def.shape[k] instanceof $ZodType)) {
+                throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+            }
+        }
+        const okeys = optionalKeys(def.shape);
+        return {
+            shape: def.shape,
+            keys,
+            keySet: new Set(keys),
+            numKeys: keys.length,
+            optionalKeys: new Set(okeys),
+        };
+    });
+    defineLazy(inst._zod, "propValues", () => {
+        const shape = def.shape;
+        const propValues = {};
+        for (const key in shape) {
+            const field = shape[key]._zod;
+            if (field.values) {
+                propValues[key] ?? (propValues[key] = new Set());
+                for (const v of field.values)
+                    propValues[key].add(v);
+            }
+        }
+        return propValues;
+    });
+    const generateFastpass = (shape) => {
+        const doc = new Doc(["shape", "payload", "ctx"]);
+        const normalized = _normalized.value;
+        const parseStr = (key) => {
+            const k = esc(key);
+            return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
+        };
+        doc.write(`const input = payload.value;`);
+        const ids = Object.create(null);
+        let counter = 0;
+        for (const key of normalized.keys) {
+            ids[key] = `key_${counter++}`;
+        }
+        // A: preserve key order {
+        doc.write(`const newResult = {}`);
+        for (const key of normalized.keys) {
+            if (normalized.optionalKeys.has(key)) {
+                const id = ids[key];
+                doc.write(`const ${id} = ${parseStr(key)};`);
+                const k = esc(key);
+                doc.write(`
+        if (${id}.issues.length) {
+          if (input[${k}] === undefined) {
+            if (${k} in input) {
+              newResult[${k}] = undefined;
+            }
+          } else {
+            payload.issues = payload.issues.concat(
+              ${id}.issues.map((iss) => ({
+                ...iss,
+                path: iss.path ? [${k}, ...iss.path] : [${k}],
+              }))
+            );
+          }
+        } else if (${id}.value === undefined) {
+          if (${k} in input) newResult[${k}] = undefined;
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+        `);
+            }
+            else {
+                const id = ids[key];
+                //  const id = ids[key];
+                doc.write(`const ${id} = ${parseStr(key)};`);
+                doc.write(`
+          if (${id}.issues.length) payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${esc(key)}, ...iss.path] : [${esc(key)}]
+          })));`);
+                doc.write(`newResult[${esc(key)}] = ${id}.value`);
+            }
+        }
+        doc.write(`payload.value = newResult;`);
+        doc.write(`return payload;`);
+        const fn = doc.compile();
+        return (payload, ctx) => fn(shape, payload, ctx);
+    };
+    let fastpass;
+    const isObject$1 = isObject;
+    const jit = !globalConfig.jitless;
+    const allowsEval$1 = allowsEval;
+    const fastEnabled = jit && allowsEval$1.value; // && !def.catchall;
+    const catchall = def.catchall;
+    let value;
+    inst._zod.parse = (payload, ctx) => {
+        value ?? (value = _normalized.value);
+        const input = payload.value;
+        if (!isObject$1(input)) {
+            payload.issues.push({
+                expected: "object",
+                code: "invalid_type",
+                input,
+                inst,
+            });
+            return payload;
+        }
+        const proms = [];
+        if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
+            // always synchronous
+            if (!fastpass)
+                fastpass = generateFastpass(def.shape);
+            payload = fastpass(payload, ctx);
+        }
+        else {
+            payload.value = {};
+            const shape = value.shape;
+            for (const key of value.keys) {
+                const el = shape[key];
+                // do not add omitted optional keys
+                // if (!(key in input)) {
+                //   if (optionalKeys.has(key)) continue;
+                //   payload.issues.push({
+                //     code: "invalid_type",
+                //     path: [key],
+                //     expected: "nonoptional",
+                //     note: `Missing required key: "${key}"`,
+                //     input,
+                //     inst,
+                //   });
+                // }
+                const r = el._zod.run({ value: input[key], issues: [] }, ctx);
+                const isOptional = el._zod.optin === "optional" && el._zod.optout === "optional";
+                if (r instanceof Promise) {
+                    proms.push(r.then((r) => isOptional ? handleOptionalObjectResult(r, payload, key, input) : handleObjectResult(r, payload, key)));
+                }
+                else if (isOptional) {
+                    handleOptionalObjectResult(r, payload, key, input);
+                }
+                else {
+                    handleObjectResult(r, payload, key);
+                }
+            }
+        }
+        if (!catchall) {
+            // return payload;
+            return proms.length ? Promise.all(proms).then(() => payload) : payload;
+        }
+        const unrecognized = [];
+        // iterate over input keys
+        const keySet = value.keySet;
+        const _catchall = catchall._zod;
+        const t = _catchall.def.type;
+        for (const key of Object.keys(input)) {
+            if (keySet.has(key))
+                continue;
+            if (t === "never") {
+                unrecognized.push(key);
+                continue;
+            }
+            const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+            if (r instanceof Promise) {
+                proms.push(r.then((r) => handleObjectResult(r, payload, key)));
+            }
+            else {
+                handleObjectResult(r, payload, key);
+            }
+        }
+        if (unrecognized.length) {
+            payload.issues.push({
+                code: "unrecognized_keys",
+                keys: unrecognized,
+                input,
+                inst,
+            });
+        }
+        if (!proms.length)
+            return payload;
+        return Promise.all(proms).then(() => {
+            return payload;
+        });
+    };
+});
+const $ZodLiteral = /*@__PURE__*/ $constructor("$ZodLiteral", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.values = new Set(def.values);
+    inst._zod.pattern = new RegExp(`^(${def.values
+        .map((o) => (typeof o === "string" ? escapeRegex(o) : o ? o.toString() : String(o)))
+        .join("|")})$`);
+    inst._zod.parse = (payload, _ctx) => {
+        const input = payload.value;
+        if (inst._zod.values.has(input)) {
+            return payload;
+        }
+        payload.issues.push({
+            code: "invalid_value",
+            values: def.values,
+            input,
+            inst,
+        });
+        return payload;
+    };
+});
+const $ZodOptional = /*@__PURE__*/ $constructor("$ZodOptional", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.optin = "optional";
+    inst._zod.optout = "optional";
+    defineLazy(inst._zod, "values", () => {
+        return def.innerType._zod.values ? new Set([...def.innerType._zod.values, undefined]) : undefined;
+    });
+    defineLazy(inst._zod, "pattern", () => {
+        const pattern = def.innerType._zod.pattern;
+        return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : undefined;
+    });
+    inst._zod.parse = (payload, ctx) => {
+        if (def.innerType._zod.optin === "optional") {
+            return def.innerType._zod.run(payload, ctx);
+        }
+        if (payload.value === undefined) {
+            return payload;
+        }
+        return def.innerType._zod.run(payload, ctx);
+    };
+});
+
+function _string(Class, params) {
+    return new Class({
+        type: "string",
+        ...normalizeParams(),
+    });
+}
+function _number(Class, params) {
+    return new Class({
+        type: "number",
+        checks: [],
+        ...normalizeParams(),
+    });
+}
+function _unknown(Class) {
+    return new Class({
+        type: "unknown",
+    });
+}
+
+const ZodMiniType = /*@__PURE__*/ $constructor("ZodMiniType", (inst, def) => {
+    if (!inst._zod)
+        throw new Error("Uninitialized schema in ZodMiniType.");
+    $ZodType.init(inst, def);
+    inst.def = def;
+    inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
+    inst.safeParse = (data, params) => safeParse(inst, data, params);
+    inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
+    inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
+    inst.check = (...checks) => {
+        return inst.clone({
+            ...def,
+            checks: [
+                ...(def.checks ?? []),
+                ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch),
+            ],
+        }
+        // { parent: true }
+        );
+    };
+    inst.clone = (_def, params) => clone(inst, _def, params);
+    inst.brand = () => inst;
+    inst.register = ((reg, meta) => {
+        reg.add(inst, meta);
+        return inst;
+    });
+});
+const ZodMiniString = /*@__PURE__*/ $constructor("ZodMiniString", (inst, def) => {
+    $ZodString.init(inst, def);
+    ZodMiniType.init(inst, def);
+});
+function string(params) {
+    return _string(ZodMiniString);
+}
+const ZodMiniNumber = /*@__PURE__*/ $constructor("ZodMiniNumber", (inst, def) => {
+    $ZodNumber.init(inst, def);
+    ZodMiniType.init(inst, def);
+});
+function number(params) {
+    return _number(ZodMiniNumber);
+}
+const ZodMiniUnknown = /*@__PURE__*/ $constructor("ZodMiniUnknown", (inst, def) => {
+    $ZodUnknown.init(inst, def);
+    ZodMiniType.init(inst, def);
+});
+function unknown() {
+    return _unknown(ZodMiniUnknown);
+}
+const ZodMiniObject = /*@__PURE__*/ $constructor("ZodMiniObject", (inst, def) => {
+    $ZodObject.init(inst, def);
+    ZodMiniType.init(inst, def);
+    defineLazy(inst, "shape", () => def.shape);
+});
+function object(shape, params) {
+    const def = {
+        type: "object",
+        get shape() {
+            assignProp(this, "shape", { ...shape });
+            return this.shape;
+        },
+        ...normalizeParams(),
+    };
+    return new ZodMiniObject(def);
+}
+const ZodMiniLiteral = /*@__PURE__*/ $constructor("ZodMiniLiteral", (inst, def) => {
+    $ZodLiteral.init(inst, def);
+    ZodMiniType.init(inst, def);
+});
+function literal(value, params) {
+    return new ZodMiniLiteral({
+        type: "literal",
+        values: Array.isArray(value) ? value : [value],
+        ...normalizeParams(),
+    });
+}
+const ZodMiniOptional = /*@__PURE__*/ $constructor("ZodMiniOptional", (inst, def) => {
+    $ZodOptional.init(inst, def);
+    ZodMiniType.init(inst, def);
+});
+function optional(innerType) {
+    return new ZodMiniOptional({
+        type: "optional",
+        innerType: innerType,
+    });
+}
+
+// src/schemas.mini.ts
+var JsonRpcRequestSchema = () => object({
+  jsonrpc: literal("2.0"),
+  id: string(),
+  method: string(),
+  params: optional(unknown())
+});
+var JsonRpcErrorSchema = () => object({
+  code: number(),
+  message: string(),
+  data: optional(unknown())
+});
+var JsonRpcResponseSchema = () => object({
+  jsonrpc: literal("2.0"),
+  id: string(),
+  result: optional(unknown()),
+  error: optional(JsonRpcErrorSchema())
+});
+
+// src/methods.ts
+var PATH_TO_METHOD_MAP = {
+  "/EXPERIMENTAL_changes": "EXPERIMENTAL_changes",
+  "/EXPERIMENTAL_changes_in_block": "EXPERIMENTAL_changes_in_block",
+  "/EXPERIMENTAL_congestion_level": "EXPERIMENTAL_congestion_level",
+  "/EXPERIMENTAL_genesis_config": "EXPERIMENTAL_genesis_config",
+  "/EXPERIMENTAL_light_client_block_proof": "EXPERIMENTAL_light_client_block_proof",
+  "/EXPERIMENTAL_light_client_proof": "EXPERIMENTAL_light_client_proof",
+  "/EXPERIMENTAL_maintenance_windows": "EXPERIMENTAL_maintenance_windows",
+  "/EXPERIMENTAL_protocol_config": "EXPERIMENTAL_protocol_config",
+  "/EXPERIMENTAL_receipt": "EXPERIMENTAL_receipt",
+  "/EXPERIMENTAL_split_storage_info": "EXPERIMENTAL_split_storage_info",
+  "/EXPERIMENTAL_tx_status": "EXPERIMENTAL_tx_status",
+  "/EXPERIMENTAL_validators_ordered": "EXPERIMENTAL_validators_ordered",
+  "/block": "block",
+  "/broadcast_tx_async": "broadcast_tx_async",
+  "/broadcast_tx_commit": "broadcast_tx_commit",
+  "/changes": "changes",
+  "/chunk": "chunk",
+  "/client_config": "client_config",
+  "/gas_price": "gas_price",
+  "/health": "health",
+  "/light_client_proof": "light_client_proof",
+  "/network_info": "network_info",
+  "/next_light_client_block": "next_light_client_block",
+  "/query": "query",
+  "/send_tx": "send_tx",
+  "/status": "status",
+  "/tx": "tx",
+  "/validators": "validators"
+};
+Object.entries(PATH_TO_METHOD_MAP).forEach(([path, method]) => {
+});
+var RPC_METHODS = Object.values(PATH_TO_METHOD_MAP);
+
+// Auto-generated static RPC functions for tree-shaking
+// Generated at: 2025-07-25T05:44:53.307Z
+// Total functions: 28
+//
+// This file is automatically generated by tools/codegen/generate-client-interface.ts
+// Do not edit manually - changes will be overwritten
+// EXPERIMENTAL_changes static function
+async function experimentalChanges(client, params) {
+    return client.makeRequest('EXPERIMENTAL_changes', params);
+}
+// EXPERIMENTAL_changes_in_block static function
+async function experimentalChangesInBlock(client, params) {
+    return client.makeRequest('EXPERIMENTAL_changes_in_block', params);
+}
+// EXPERIMENTAL_congestion_level static function
+async function experimentalCongestionLevel(client, params) {
+    return client.makeRequest('EXPERIMENTAL_congestion_level', params);
+}
+// EXPERIMENTAL_genesis_config static function
+async function experimentalGenesisConfig(client, params) {
+    return client.makeRequest('EXPERIMENTAL_genesis_config', params);
+}
+// EXPERIMENTAL_light_client_block_proof static function
+async function experimentalLightClientBlockProof(client, params) {
+    return client.makeRequest('EXPERIMENTAL_light_client_block_proof', params);
+}
+// EXPERIMENTAL_light_client_proof static function
+async function experimentalLightClientProof(client, params) {
+    return client.makeRequest('EXPERIMENTAL_light_client_proof', params);
+}
+// EXPERIMENTAL_maintenance_windows static function
+async function experimentalMaintenanceWindows(client, params) {
+    return client.makeRequest('EXPERIMENTAL_maintenance_windows', params);
+}
+// EXPERIMENTAL_protocol_config static function
+async function experimentalProtocolConfig(client, params) {
+    return client.makeRequest('EXPERIMENTAL_protocol_config', params);
+}
+// EXPERIMENTAL_receipt static function
+async function experimentalReceipt(client, params) {
+    return client.makeRequest('EXPERIMENTAL_receipt', params);
+}
+// EXPERIMENTAL_split_storage_info static function
+async function experimentalSplitStorageInfo(client, params) {
+    return client.makeRequest('EXPERIMENTAL_split_storage_info', params);
+}
+// EXPERIMENTAL_tx_status static function
+async function experimentalTxStatus(client, params) {
+    return client.makeRequest('EXPERIMENTAL_tx_status', params);
+}
+// EXPERIMENTAL_validators_ordered static function
+async function experimentalValidatorsOrdered(client, params) {
+    return client.makeRequest('EXPERIMENTAL_validators_ordered', params);
+}
+// block static function
+async function block(client, params) {
+    return client.makeRequest('block', params);
+}
+// broadcast_tx_async static function
+async function broadcastTxAsync(client, params) {
+    return client.makeRequest('broadcast_tx_async', params);
+}
+// broadcast_tx_commit static function
+async function broadcastTxCommit(client, params) {
+    return client.makeRequest('broadcast_tx_commit', params);
+}
+// changes static function
+async function changes(client, params) {
+    return client.makeRequest('changes', params);
+}
+// chunk static function
+async function chunk(client, params) {
+    return client.makeRequest('chunk', params);
+}
+// client_config static function
+async function clientConfig(client, params) {
+    return client.makeRequest('client_config', params);
+}
+// gas_price static function
+async function gasPrice(client, params) {
+    return client.makeRequest('gas_price', params);
+}
+// health static function
+async function health(client, params) {
+    return client.makeRequest('health', params);
+}
+// light_client_proof static function
+async function lightClientProof(client, params) {
+    return client.makeRequest('light_client_proof', params);
+}
+// network_info static function
+async function networkInfo(client, params) {
+    return client.makeRequest('network_info', params);
+}
+// next_light_client_block static function
+async function nextLightClientBlock(client, params) {
+    return client.makeRequest('next_light_client_block', params);
+}
+// query static function
+async function query(client, params) {
+    return client.makeRequest('query', params);
+}
+// send_tx static function
+async function sendTx(client, params) {
+    return client.makeRequest('send_tx', params);
+}
+// status static function
+async function status(client, params) {
+    return client.makeRequest('status', params);
+}
+// tx static function
+async function tx(client, params) {
+    return client.makeRequest('tx', params);
+}
+// validators static function
+async function validators(client, params) {
+    return client.makeRequest('validators', params);
+}
+
+async function viewAccount(client, params) {
+    // Construct query parameters: use blockId if provided, otherwise use finality (default 'final')
+    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) {
+    // Construct query parameters: use blockId if provided, otherwise use finality (default 'final')
+    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) {
+    // Construct query parameters: use blockId if provided, otherwise use finality (default 'final')
+    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);
+}
+
+// Optional validation for mini client - only imported when explicitly enabled
+/**
+ * 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
+ */
+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, JsonRpcRequestSchema, 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 };