@psalomo/jsonrpc-client 0.5.0 → 1.0.1

package/dist/browser-standalone-mini.js

@@ -1,1245 +0,0 @@
-// 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 };