@initia/initia.js 1.0.20 → 2.0.0-rc.0

package/dist/grpc-client-DGyZjGcT.mjs

@@ -0,0 +1,254 @@
+import { c as InitiaError, r as AuthenticationError } from "./errors-CN1MFOLv.mjs";
+import { t as toCallOptions } from "./headers-CMO7ia_D.mjs";
+import { toJson } from "@bufbuild/protobuf";
+import { Code, ConnectError, createClient } from "@connectrpc/connect";
+//#region src/client/response.ts
+const WRAPPED_MARKER = Symbol.for("initia.wrappedResponse");
+const SYNTHETIC_KEYS = [
+	"schema",
+	"typeUrl",
+	"toJson",
+	"toJSON"
+];
+const fieldMapCache = /* @__PURE__ */ new WeakMap();
+function getFieldMap(schema) {
+	let map = fieldMapCache.get(schema);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		for (const field of schema.fields) if (field.fieldKind === "message" || field.fieldKind === "list" && field.listKind === "message" || field.fieldKind === "map" && field.mapKind === "message") map.set(field.localName, field);
+		fieldMapCache.set(schema, map);
+	}
+	return map;
+}
+/**
+* Wrap a gRPC response with a Proxy that adds schema, typeUrl, and toJson()
+* while preserving depth — property access stays identical.
+*
+* - `schema`: The DescMessage schema descriptor
+* - `typeUrl`: '/' + schema.typeName (same pattern as Message class)
+* - `toJson(options?)`: Canonical protobuf JSON serialization with optional JsonWriteOptions
+* - `toJSON()`: Called by JSON.stringify(), delegates to toJson() with no options
+*
+* **Shadowing rules**:
+* - `schema` and `typeUrl` are non-shadowing: if the underlying object already
+*   has these properties, the original values pass through unchanged.
+* - `toJson` and `toJSON` always shadow the underlying object's methods to
+*   ensure consistent protobuf JSON serialization.
+*
+* Nested message-type fields are recursively wrapped using the field's
+* DescMessage from the schema descriptor. Supported field kinds:
+* - `fieldKind: 'message'` — single nested message
+* - `fieldKind: 'list', listKind: 'message'` — repeated message
+* - `fieldKind: 'map', mapKind: 'message'` — map with message values
+*
+* Field maps are cached per schema via WeakMap for O(1) lookup after first access.
+* Assumes protobuf-es message immutability — nestedCache may return stale data
+* if underlying fields are mutated after wrapping.
+*
+* Protobuf's own `$typeName` passes through from the underlying message.
+*
+* @param schema - The DescMessage schema descriptor for the response type
+* @param value - The raw gRPC response object to wrap
+* @param registry - Optional protobuf Registry for google.protobuf.Any serialization.
+*   When provided, injected as default registry into toJson() calls.
+*   Callers can override it by passing their own `registry` in JsonWriteOptions.
+*   Propagated to all recursively wrapped nested message fields.
+*/
+function wrapResponse(schema, value, registry) {
+	if (value == null || typeof value !== "object") return value;
+	if (WRAPPED_MARKER in value) return value;
+	const fieldMap = getFieldMap(schema);
+	const nestedCache = /* @__PURE__ */ new Map();
+	const msg = value;
+	const toJsonFn = (options) => {
+		try {
+			let mergedOptions = options;
+			if (registry && !options?.registry) mergedOptions = {
+				...options,
+				registry
+			};
+			return toJson(schema, msg, mergedOptions);
+		} catch (e) {
+			const cause = e instanceof Error ? e.message : String(e);
+			throw new Error(`Failed to serialize ${schema.typeName} to JSON: ${cause}`, { cause: e });
+		}
+	};
+	const toJSONFn = () => toJsonFn();
+	return new Proxy(value, {
+		get(target, prop, receiver) {
+			if (prop === WRAPPED_MARKER) return true;
+			if (prop === "schema" && !Reflect.has(target, prop)) return schema;
+			if (prop === "typeUrl" && !Reflect.has(target, prop)) return "/" + schema.typeName;
+			if (prop === "toJson") return toJsonFn;
+			if (prop === "toJSON") return toJSONFn;
+			const raw = Reflect.get(target, prop, receiver);
+			if (typeof prop === "string" && fieldMap.has(prop) && raw != null) {
+				if (nestedCache.has(prop)) return nestedCache.get(prop);
+				const field = fieldMap.get(prop);
+				let wrapped;
+				if (field.fieldKind === "message") wrapped = wrapResponse(field.message, raw, registry);
+				else if (field.fieldKind === "list" && field.listKind === "message") wrapped = raw.map((item) => wrapResponse(field.message, item, registry));
+				else if (field.fieldKind === "map" && field.mapKind === "message") {
+					const entries = Object.entries(raw);
+					wrapped = Object.fromEntries(entries.map(([k, v]) => [k, wrapResponse(field.message, v, registry)]));
+				} else throw new Error(`[initia.js] Internal error: unexpected field kind for ${prop}: ${field.fieldKind}. getFieldMap and wrapping logic are out of sync.`);
+				if (wrapped !== void 0) {
+					nestedCache.set(prop, wrapped);
+					return wrapped;
+				}
+			}
+			return raw;
+		},
+		has(target, prop) {
+			if (prop === WRAPPED_MARKER || prop === "schema" || prop === "toJson" || prop === "toJSON") return true;
+			if (prop === "typeUrl") return true;
+			return Reflect.has(target, prop);
+		},
+		ownKeys(target) {
+			const keys = Reflect.ownKeys(target);
+			for (const k of SYNTHETIC_KEYS) if (!keys.includes(k)) keys.push(k);
+			return keys;
+		},
+		getOwnPropertyDescriptor(target, prop) {
+			if (prop === "schema" && !Reflect.has(target, "schema")) return {
+				configurable: true,
+				enumerable: true,
+				writable: false,
+				value: schema
+			};
+			if (prop === "typeUrl" && !Reflect.has(target, "typeUrl")) return {
+				configurable: true,
+				enumerable: true,
+				writable: false,
+				value: "/" + schema.typeName
+			};
+			if (prop === "typeUrl") return Reflect.getOwnPropertyDescriptor(target, prop);
+			if (prop === "toJson") return {
+				configurable: true,
+				enumerable: true,
+				writable: false,
+				value: toJsonFn
+			};
+			if (prop === "toJSON") return {
+				configurable: true,
+				enumerable: true,
+				writable: false,
+				value: toJSONFn
+			};
+			return Reflect.getOwnPropertyDescriptor(target, prop);
+		}
+	});
+}
+/**
+* Type guard: check if a value is a wrapped gRPC response.
+* Generic preserves the input type through narrowing:
+*   isWrappedResponse(coin) → coin is WrappedResponse<Coin>
+*/
+function isWrappedResponse(value) {
+	return value != null && typeof value === "object" && WRAPPED_MARKER in value;
+}
+//#endregion
+//#region src/client/grpc-client.ts
+/**
+* Proxy-based lazy gRPC client factory.
+*
+* Creates clients on-demand when first accessed, caching them for reuse.
+* Optionally wraps methods to inject auth/headers and convert auth errors.
+*/
+/**
+* Wrap a service client to:
+* - Inject auth/headers via toCallOptions()
+* - Convert ConnectError (Unauthenticated/PermissionDenied) to AuthenticationError
+* - Wrap **unary** responses with WrappedResponse (schema, typeUrl, toJson);
+*   streaming responses pass through unchanged
+*/
+function createServiceProxy(service, serviceClient, contextAuth, contextHeaders, typeRegistry) {
+	return new Proxy(serviceClient, { get(target, methodName, receiver) {
+		if (typeof methodName !== "string") return Reflect.get(target, methodName, receiver);
+		const original = serviceClient[methodName];
+		if (typeof original !== "function") return original;
+		const method = service.method[methodName];
+		const outputSchema = method?.methodKind === "unary" ? method.output : void 0;
+		return async (request, queryOptions) => {
+			const callOptions = toCallOptions(contextAuth, contextHeaders, queryOptions);
+			try {
+				const result = await original.call(serviceClient, request, callOptions);
+				if (outputSchema && result != null && typeof result === "object") return wrapResponse(outputSchema, result, typeRegistry);
+				return result;
+			} catch (error) {
+				if (error instanceof ConnectError) {
+					if (error.code === Code.Unauthenticated || error.code === Code.PermissionDenied) throw new AuthenticationError(error.code === Code.Unauthenticated ? 401 : 403, error.message);
+					if (error.code === Code.Unimplemented) throw new InitiaError(`Module not available on this chain: ${service.typeName}.${String(methodName)} is not implemented`);
+				}
+				throw error;
+			}
+		};
+	} });
+}
+/**
+* Creates a proxy-based lazy gRPC client.
+*
+* Clients are created on first access and cached for subsequent calls.
+* When `contextAuth` or `contextHeaders` are provided, each service client
+* is wrapped with a proxy that injects auth/headers via `toCallOptions()`.
+*
+* @param transport - The connect transport (gRPC-web, gRPC, etc.)
+* @param services - Map of service names to service descriptors
+* @param contextAuth - Context-level auth config (injected into every request)
+* @param contextHeaders - Context-level headers (injected into every request)
+* @param typeRegistry - Protobuf type registry for google.protobuf.Any serialization (passed to wrapResponse)
+* @returns Proxy object with lazy-initialized clients
+*
+* @example
+* ```typescript
+* const services = InitiaServices.getServices('mainnet')
+* const client = createGrpcClient(transport, services, auth.apiKey('key'))
+*
+* // Clients are created lazily on first access
+* const balance = await client.bank.balance({ address, denom: 'uinit' })
+* ```
+*/
+function createGrpcClient(transport, services, contextAuth, contextHeaders, typeRegistry) {
+	const cache = {};
+	return new Proxy({}, {
+		get(_, prop) {
+			if (typeof prop !== "string" || !(prop in services)) return;
+			const key = prop;
+			if (!(key in cache)) {
+				const desc = services[key];
+				if (Array.isArray(desc)) {
+					const perServiceClients = desc.map((d) => {
+						return createServiceProxy(d, createClient(d, transport), contextAuth, contextHeaders, typeRegistry);
+					});
+					const merged = {};
+					for (let i = 0; i < desc.length; i++) {
+						const svc = desc[i];
+						const proxied = perServiceClients[i];
+						for (const methodName of Object.keys(svc.method)) {
+							if (methodName in merged) throw new Error(`Multi-query method collision: '${methodName}' exists in multiple services merged under '${String(key)}'`);
+							merged[methodName] = proxied[methodName];
+						}
+					}
+					cache[key] = merged;
+				} else cache[key] = createServiceProxy(desc, createClient(desc, transport), contextAuth, contextHeaders, typeRegistry);
+			}
+			return cache[key];
+		},
+		has(_, prop) {
+			return typeof prop === "string" && prop in services;
+		},
+		ownKeys() {
+			return Object.keys(services);
+		},
+		getOwnPropertyDescriptor(_, prop) {
+			if (typeof prop === "string" && prop in services) return {
+				enumerable: true,
+				configurable: true
+			};
+		}
+	});
+}
+//#endregion
+export { isWrappedResponse as n, wrapResponse as r, createGrpcClient as t };
+
+//# sourceMappingURL=grpc-client-DGyZjGcT.mjs.map

package/dist/grpc-client-DGyZjGcT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpc-client-DGyZjGcT.mjs","names":[],"sources":["../src/client/response.ts","../src/client/grpc-client.ts"],"sourcesContent":["import type {\n  DescMessage,\n  DescField,\n  Message,\n  MessageShape,\n  JsonValue,\n  JsonWriteOptions,\n  Registry,\n} from '@bufbuild/protobuf'\nimport { toJson } from '@bufbuild/protobuf'\n\nconst WRAPPED_MARKER = Symbol.for('initia.wrappedResponse')\n\n// Synthetic property names added by the Proxy wrapper.\n// Included in ownKeys so they survive spread/destructuring and appear in Object.keys().\n// WRAPPED_MARKER (Symbol) is intentionally excluded — internal detection sentinel,\n// should not leak through enumeration.\nconst SYNTHETIC_KEYS = ['schema', 'typeUrl', 'toJson', 'toJSON'] as const\n\n// =============================================================================\n// Field Map Cache (WeakMap per DescMessage — build once per schema type)\n// =============================================================================\n\ntype FieldMap = Map<string, DescField>\nconst fieldMapCache = new WeakMap<DescMessage, FieldMap>()\n\nfunction getFieldMap(schema: DescMessage): FieldMap {\n  let map = fieldMapCache.get(schema)\n  if (!map) {\n    map = new Map()\n    for (const field of schema.fields) {\n      const isMessageField =\n        field.fieldKind === 'message' ||\n        (field.fieldKind === 'list' && field.listKind === 'message') ||\n        (field.fieldKind === 'map' && field.mapKind === 'message')\n      if (isMessageField) {\n        map.set(field.localName, field)\n      }\n    }\n    fieldMapCache.set(schema, map)\n  }\n  return map\n}\n\n// =============================================================================\n// Response Wrapper\n// =============================================================================\n\n/**\n * Wrap a gRPC response with a Proxy that adds schema, typeUrl, and toJson()\n * while preserving depth — property access stays identical.\n *\n * - `schema`: The DescMessage schema descriptor\n * - `typeUrl`: '/' + schema.typeName (same pattern as Message class)\n * - `toJson(options?)`: Canonical protobuf JSON serialization with optional JsonWriteOptions\n * - `toJSON()`: Called by JSON.stringify(), delegates to toJson() with no options\n *\n * **Shadowing rules**:\n * - `schema` and `typeUrl` are non-shadowing: if the underlying object already\n *   has these properties, the original values pass through unchanged.\n * - `toJson` and `toJSON` always shadow the underlying object's methods to\n *   ensure consistent protobuf JSON serialization.\n *\n * Nested message-type fields are recursively wrapped using the field's\n * DescMessage from the schema descriptor. Supported field kinds:\n * - `fieldKind: 'message'` — single nested message\n * - `fieldKind: 'list', listKind: 'message'` — repeated message\n * - `fieldKind: 'map', mapKind: 'message'` — map with message values\n *\n * Field maps are cached per schema via WeakMap for O(1) lookup after first access.\n * Assumes protobuf-es message immutability — nestedCache may return stale data\n * if underlying fields are mutated after wrapping.\n *\n * Protobuf's own `$typeName` passes through from the underlying message.\n *\n * @param schema - The DescMessage schema descriptor for the response type\n * @param value - The raw gRPC response object to wrap\n * @param registry - Optional protobuf Registry for google.protobuf.Any serialization.\n *   When provided, injected as default registry into toJson() calls.\n *   Callers can override it by passing their own `registry` in JsonWriteOptions.\n *   Propagated to all recursively wrapped nested message fields.\n */\nexport function wrapResponse<T extends object>(\n  schema: DescMessage,\n  value: T,\n  registry?: Registry\n): WrappedResponse<T> {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-explicit-any\n  if (value == null || typeof value !== 'object') return value as any\n\n  // Don't double-wrap\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-explicit-any\n  if (WRAPPED_MARKER in value) return value as any\n\n  const fieldMap = getFieldMap(schema)\n  const nestedCache = new Map<string, unknown>()\n  const msg = value as MessageShape<typeof schema>\n  const toJsonFn = (options?: Partial<JsonWriteOptions>) => {\n    try {\n      // Inject built-in registry as default; user-provided registry takes precedence.\n      let mergedOptions = options\n      if (registry && !options?.registry) {\n        mergedOptions = { ...options, registry }\n      }\n      return toJson(schema, msg, mergedOptions)\n    } catch (e) {\n      const cause = e instanceof Error ? e.message : String(e)\n      throw new Error(`Failed to serialize ${schema.typeName} to JSON: ${cause}`, { cause: e })\n    }\n  }\n  const toJSONFn = () => toJsonFn()\n\n  const proxy = new Proxy(value, {\n    get(target, prop, receiver) {\n      if (prop === WRAPPED_MARKER) return true\n      if (prop === 'schema' && !Reflect.has(target, prop)) return schema\n      if (prop === 'typeUrl' && !Reflect.has(target, prop)) return '/' + schema.typeName\n      if (prop === 'toJson') return toJsonFn\n      if (prop === 'toJSON') return toJSONFn\n\n      const raw = Reflect.get(target, prop, receiver)\n\n      // Recursively wrap message-type fields\n      if (typeof prop === 'string' && fieldMap.has(prop) && raw != null) {\n        if (nestedCache.has(prop)) return nestedCache.get(prop)\n\n        const field = fieldMap.get(prop)!\n        let wrapped: unknown\n\n        if (field.fieldKind === 'message') {\n          wrapped = wrapResponse(field.message, raw as object, registry)\n        } else if (field.fieldKind === 'list' && field.listKind === 'message') {\n          const arr = raw as object[]\n          wrapped = arr.map(item => wrapResponse(field.message, item, registry))\n        } else if (field.fieldKind === 'map' && field.mapKind === 'message') {\n          const entries = Object.entries(raw as Record<string, object>)\n          wrapped = Object.fromEntries(\n            entries.map(([k, v]) => [k, wrapResponse(field.message, v, registry)])\n          )\n        } else {\n          // Unreachable — getFieldMap only includes message-type fields.\n          // If this fires, getFieldMap and wrapping logic are out of sync.\n          throw new Error(\n            `[initia.js] Internal error: unexpected field kind for ${prop}: ${field.fieldKind}. ` +\n              'getFieldMap and wrapping logic are out of sync.'\n          )\n        }\n\n        if (wrapped !== undefined) {\n          nestedCache.set(prop, wrapped)\n          return wrapped\n        }\n      }\n\n      return raw\n    },\n\n    has(target, prop) {\n      if (prop === WRAPPED_MARKER || prop === 'schema' || prop === 'toJson' || prop === 'toJSON')\n        return true\n      if (prop === 'typeUrl') return true // either from target or computed\n      return Reflect.has(target, prop)\n    },\n\n    ownKeys(target) {\n      const keys = Reflect.ownKeys(target)\n      for (const k of SYNTHETIC_KEYS) {\n        if (!keys.includes(k)) keys.push(k)\n      }\n      return keys\n    },\n\n    getOwnPropertyDescriptor(target, prop) {\n      if (prop === 'schema' && !Reflect.has(target, 'schema'))\n        return { configurable: true, enumerable: true, writable: false, value: schema }\n      if (prop === 'typeUrl' && !Reflect.has(target, 'typeUrl'))\n        return {\n          configurable: true,\n          enumerable: true,\n          writable: false,\n          value: '/' + schema.typeName,\n        }\n      if (prop === 'typeUrl') return Reflect.getOwnPropertyDescriptor(target, prop)\n      if (prop === 'toJson')\n        return { configurable: true, enumerable: true, writable: false, value: toJsonFn }\n      if (prop === 'toJSON')\n        return { configurable: true, enumerable: true, writable: false, value: toJSONFn }\n      return Reflect.getOwnPropertyDescriptor(target, prop)\n    },\n  })\n  return proxy as WrappedResponse<T>\n}\n\n// =============================================================================\n// Type Guard & Types\n// =============================================================================\n\n/**\n * Type guard: check if a value is a wrapped gRPC response.\n * Generic preserves the input type through narrowing:\n *   isWrappedResponse(coin) → coin is WrappedResponse<Coin>\n */\nexport function isWrappedResponse<T>(value: T): value is WrappedResponse<T> {\n  return value != null && typeof value === 'object' && WRAPPED_MARKER in (value as object)\n}\n\n/** Synthetic properties added by the response wrapper Proxy. */\ntype WrappedProps = {\n  /** The protobuf schema descriptor. */\n  readonly schema: DescMessage\n  /** Type URL with '/' prefix (e.g., '/cosmos.bank.v1beta1.QueryBalanceResponse') */\n  readonly typeUrl: string\n  /** Serialize to canonical protobuf JSON. */\n  toJson(options?: Partial<JsonWriteOptions>): JsonValue\n  /** Called by JSON.stringify(). Returns canonical protobuf JSON (no options). */\n  toJSON(): JsonValue\n}\n\n/**\n * Recursively wraps nested protobuf message fields with WrappedProps.\n * - Single message fields (`balance?: Coin`) → `WrappedResponse<Coin> | undefined`\n * - Repeated message fields (`validators: Validator[]`) → `WrappedResponse<Validator>[]`\n * - Map fields with message values (`{ [key: string]: Msg }`) → `Record<string, WrappedResponse<Msg>>`\n * - Scalar / Uint8Array / non-message fields pass through unchanged.\n *\n * Map detection uses `string extends keyof T[K]` to distinguish index signatures\n * from named properties, preventing false positives on `{ a: Msg; b: Msg }`.\n */\ntype DeepWrapFields<T> = {\n  [K in keyof T]: T[K] extends Message | undefined\n    ? WrappedResponse<NonNullable<T[K]>> | Extract<T[K], undefined>\n    : T[K] extends (infer U)[]\n      ? U extends Message\n        ? WrappedResponse<U>[]\n        : T[K]\n      : string extends keyof T[K]\n        ? T[K] extends Record<string, infer V>\n          ? V extends Message\n            ? Record<string, WrappedResponse<V>>\n            : T[K]\n          : T[K]\n        : T[K]\n}\n\n/**\n * A gRPC response enhanced with schema access and JSON serialization.\n * Nested message fields are also recursively wrapped with the same properties.\n *\n * **Spread/destructuring**: `{ ...wrapped }` copies all properties including\n * synthetic ones (`schema`, `typeUrl`, `toJson`, `toJSON`) and nested Proxy-wrapped\n * fields. The spread result itself is a plain object (not a Proxy), so\n * `isWrappedResponse({ ...wrapped })` returns false.\n */\nexport type WrappedResponse<T = unknown> = T & WrappedProps & DeepWrapFields<T>\n\n/**\n * Transforms Promise return types to include WrappedResponse.\n * Non-Promise types (e.g., AsyncIterable for streaming) pass through unchanged.\n */\nexport type WrapReturnType<T> = T extends Promise<infer O> ? Promise<WrappedResponse<O>> : T\n","/**\n * Proxy-based lazy gRPC client factory.\n *\n * Creates clients on-demand when first accessed, caching them for reuse.\n * Optionally wraps methods to inject auth/headers and convert auth errors.\n */\n\nimport {\n  createClient,\n  ConnectError,\n  Code,\n  type Client,\n  type CallOptions,\n} from '@connectrpc/connect'\nimport type { Transport } from '@connectrpc/connect'\nimport type { DescMessage, DescService, Registry } from '@bufbuild/protobuf'\nimport { AuthenticationError, InitiaError } from '../errors'\nimport { toCallOptions } from './headers'\nimport { wrapResponse } from './response'\nimport type { WrapReturnType } from './response'\nimport type { AuthConfig, QueryOptions } from './types'\nimport type { UnionToIntersection } from '../util/types'\n\n/**\n * Maps a Connect RPC Client's methods to accept QueryOptions instead of CallOptions.\n * Unary methods return WrappedResponse (with schema, typeUrl, toJson()).\n */\nexport type QueryClient<S extends DescService> = {\n  [M in keyof Client<S>]: Client<S>[M] extends (\n    request: infer R,\n    options?: CallOptions\n  ) => infer Ret\n    ? (request: R, options?: QueryOptions) => WrapReturnType<Ret>\n    : Client<S>[M]\n}\n\n/**\n * Maps service descriptors to their query-wrapped client types.\n * Supports both single DescService and arrays of DescService (merged via intersection).\n */\nexport type ServiceClients<T extends Record<string, DescService | readonly DescService[]>> = {\n  [K in keyof T]: T[K] extends readonly DescService[]\n    ? UnionToIntersection<QueryClient<T[K][number]>>\n    : T[K] extends DescService\n      ? QueryClient<T[K]>\n      : never\n}\n\n/**\n * Wrap a service client to:\n * - Inject auth/headers via toCallOptions()\n * - Convert ConnectError (Unauthenticated/PermissionDenied) to AuthenticationError\n * - Wrap **unary** responses with WrappedResponse (schema, typeUrl, toJson);\n *   streaming responses pass through unchanged\n */\nfunction createServiceProxy<S extends DescService>(\n  service: S,\n  serviceClient: Client<S>,\n  contextAuth: AuthConfig | undefined,\n  contextHeaders: Record<string, string> | undefined,\n  typeRegistry: Registry | undefined\n): QueryClient<S> {\n  return new Proxy(serviceClient as unknown as QueryClient<S>, {\n    get(target, methodName: string | symbol, receiver) {\n      if (typeof methodName !== 'string') return Reflect.get(target, methodName, receiver)\n\n      const original = (serviceClient as Record<string, unknown>)[methodName]\n      if (typeof original !== 'function') return original\n\n      // Hoist method lookup: resolve output schema once per method access\n      const method = (service.method as Record<string, { methodKind: string; output: unknown }>)[\n        methodName\n      ]\n      const outputSchema =\n        method?.methodKind === 'unary' ? (method.output as DescMessage) : undefined\n\n      return async (request: unknown, queryOptions?: QueryOptions) => {\n        const callOptions = toCallOptions(contextAuth, contextHeaders, queryOptions)\n        try {\n          const result = await (original.call(\n            serviceClient,\n            request,\n            callOptions\n          ) as Promise<unknown>)\n\n          // Wrap unary response with pre-resolved output schema\n          if (outputSchema && result != null && typeof result === 'object') {\n            return wrapResponse(outputSchema, result, typeRegistry)\n          }\n          return result\n        } catch (error) {\n          if (error instanceof ConnectError) {\n            if (error.code === Code.Unauthenticated || error.code === Code.PermissionDenied) {\n              throw new AuthenticationError(\n                error.code === Code.Unauthenticated ? 401 : 403,\n                error.message\n              )\n            }\n            if (error.code === Code.Unimplemented) {\n              throw new InitiaError(\n                `Module not available on this chain: ${service.typeName}.${String(methodName)} is not implemented`\n              )\n            }\n          }\n          throw error\n        }\n      }\n    },\n  })\n}\n\n/**\n * Creates a proxy-based lazy gRPC client.\n *\n * Clients are created on first access and cached for subsequent calls.\n * When `contextAuth` or `contextHeaders` are provided, each service client\n * is wrapped with a proxy that injects auth/headers via `toCallOptions()`.\n *\n * @param transport - The connect transport (gRPC-web, gRPC, etc.)\n * @param services - Map of service names to service descriptors\n * @param contextAuth - Context-level auth config (injected into every request)\n * @param contextHeaders - Context-level headers (injected into every request)\n * @param typeRegistry - Protobuf type registry for google.protobuf.Any serialization (passed to wrapResponse)\n * @returns Proxy object with lazy-initialized clients\n *\n * @example\n * ```typescript\n * const services = InitiaServices.getServices('mainnet')\n * const client = createGrpcClient(transport, services, auth.apiKey('key'))\n *\n * // Clients are created lazily on first access\n * const balance = await client.bank.balance({ address, denom: 'uinit' })\n * ```\n */\nexport function createGrpcClient<T extends Record<string, DescService | readonly DescService[]>>(\n  transport: Transport,\n  services: T,\n  contextAuth?: AuthConfig,\n  contextHeaders?: Record<string, string>,\n  typeRegistry?: Registry\n): ServiceClients<T> {\n  const cache: Partial<Record<keyof T, QueryClient<DescService> | Record<string, unknown>>> = {}\n\n  return new Proxy({} as ServiceClients<T>, {\n    get(_, prop: string | symbol) {\n      // Only handle string keys that exist in services\n      if (typeof prop !== 'string' || !(prop in services)) {\n        return undefined\n      }\n\n      const key = prop as keyof T\n\n      // Create client on first access, wrap with service proxy\n      if (!(key in cache)) {\n        const desc = services[key]\n        if (Array.isArray(desc)) {\n          // Multi-query: create per-service proxied clients, then merge methods by descriptor keys\n          const perServiceClients = (desc as DescService[]).map(d => {\n            const raw = createClient(d, transport)\n            return createServiceProxy(d, raw, contextAuth, contextHeaders, typeRegistry)\n          })\n          const merged: Record<string, unknown> = {}\n          for (let i = 0; i < (desc as DescService[]).length; i++) {\n            const svc = (desc as DescService[])[i]\n            const proxied = perServiceClients[i]\n            for (const methodName of Object.keys(svc.method as Record<string, unknown>)) {\n              if (methodName in merged) {\n                throw new Error(\n                  `Multi-query method collision: '${methodName}' exists in multiple services merged under '${String(key)}'`\n                )\n              }\n              merged[methodName] = (proxied as Record<string, unknown>)[methodName]\n            }\n          }\n          cache[key] = merged\n        } else {\n          const rawClient = createClient(desc as DescService, transport)\n          cache[key] = createServiceProxy(\n            desc as DescService,\n            rawClient,\n            contextAuth,\n            contextHeaders,\n            typeRegistry\n          )\n        }\n      }\n\n      return cache[key]\n    },\n\n    has(_, prop: string | symbol) {\n      return typeof prop === 'string' && prop in services\n    },\n\n    ownKeys() {\n      return Object.keys(services)\n    },\n\n    getOwnPropertyDescriptor(_, prop: string | symbol) {\n      if (typeof prop === 'string' && prop in services) {\n        return {\n          enumerable: true,\n          configurable: true,\n        }\n      }\n      return undefined\n    },\n  })\n}\n"],"mappings":"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"}

package/dist/hash-D40mxOlF.mjs

@@ -0,0 +1,14 @@
+import { t as __exportAll } from "./rolldown-runtime-wcPFST8Q.mjs";
+import { sha256 as sha256$1 } from "@noble/hashes/sha2.js";
+import { ripemd160 } from "@noble/hashes/legacy.js";
+import { keccak_256 as keccak256 } from "@noble/hashes/sha3.js";
+//#region src/util/hash.ts
+var hash_exports = /* @__PURE__ */ __exportAll({
+	keccak256: () => keccak256,
+	ripemd160: () => ripemd160,
+	sha256: () => sha256$1
+});
+//#endregion
+export { sha256$1 as i, keccak256 as n, ripemd160 as r, hash_exports as t };
+
+//# sourceMappingURL=hash-D40mxOlF.mjs.map

package/dist/hash-D40mxOlF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-D40mxOlF.mjs","names":[],"sources":["../src/util/hash.ts"],"sourcesContent":["/**\n * Hash utilities for Cosmos/EVM address derivation and transaction signing.\n *\n * Re-exports from @noble/hashes for consistency and documentation.\n * - sha256: Used for Cosmos address derivation and transaction hashing\n * - ripemd160: Used in Bitcoin-style address derivation (sha256 + ripemd160)\n * - keccak256: Used for EVM address derivation and EIP-191 signing\n */\n\nexport { sha256 } from '@noble/hashes/sha2.js'\nexport { ripemd160 } from '@noble/hashes/legacy.js'\nexport { keccak_256 as keccak256 } from '@noble/hashes/sha3.js'\n"],"mappings":""}

package/dist/hash-Doo89wm3.d.mts

@@ -0,0 +1,31 @@
+//#region src/bridge/hash.d.ts
+/**
+ * Withdrawal hash calculation for OPInit bridge.
+ *
+ * Computes the SHA3-256 double hash used as Merkle leaf for withdrawal verification.
+ */
+/**
+ * Calculate the withdrawal hash for OPInit bridge verification.
+ *
+ * This is a SHA3-256 double hash (Merkle leaf node format) computed from:
+ * - bridgeId (8 bytes big-endian)
+ * - l2Sequence (8 bytes big-endian)
+ * - sha3_256(sender UTF-8) (32 bytes)
+ * - sha3_256(receiver UTF-8) (32 bytes)
+ * - sha3_256(denom UTF-8) (32 bytes)
+ * - amount (8 bytes big-endian)
+ *
+ * Result = sha3_256(sha3_256(concatenation))
+ *
+ * @param bridgeId - Bridge ID
+ * @param l2Sequence - L2 withdrawal sequence number
+ * @param sender - L2 sender address
+ * @param receiver - L1 receiver address
+ * @param denom - Token denomination
+ * @param amount - Token amount
+ * @returns 32-byte withdrawal hash
+ */
+declare function calculateWithdrawalHash(bridgeId: bigint, l2Sequence: bigint, sender: string, receiver: string, denom: string, amount: bigint): Uint8Array;
+//#endregion
+export { calculateWithdrawalHash as t };
+//# sourceMappingURL=hash-Doo89wm3.d.mts.map

package/dist/headers-CMO7ia_D.mjs

@@ -0,0 +1,83 @@
+import { s as HeaderConflictError } from "./errors-CN1MFOLv.mjs";
+import { base64 } from "@scure/base";
+//#region src/client/headers.ts
+/**
+* Convert AuthConfig to HTTP headers.
+*
+* All header keys are returned in lowercase.
+*/
+function authConfigToHeaders(config) {
+	switch (config.type) {
+		case "bearer": return { authorization: `Bearer ${config.token}` };
+		case "api-key": return { [(config.header ?? "x-api-key").toLowerCase()]: config.key };
+		case "basic": {
+			const credentials = new TextEncoder().encode(`${config.username}:${config.password}`);
+			return { authorization: `Basic ${base64.encode(credentials)}` };
+		}
+	}
+}
+/**
+* Convert block height to gRPC metadata header.
+*/
+function heightToHeaders(height) {
+	return { "x-cosmos-block-height": height.toString() };
+}
+/**
+* Merge multiple header sources with lowercase key normalization.
+*
+* Later sources override earlier ones for the same key.
+* Order: contextHeaders (base) → authHeaders → queryHeaders (highest priority)
+*/
+function mergeHeaders(...sources) {
+	const result = {};
+	for (const source of sources) if (source) for (const [key, value] of Object.entries(source)) result[key.toLowerCase()] = value;
+	return result;
+}
+/**
+* Validate that `auth` and `headers` at the same level don't set the same header key.
+*
+* Called in:
+* - `createChainContext` (level: 'context')
+* - `toCallOptions` (level: 'query')
+*
+* @throws {HeaderConflictError} when auth and headers set the same key
+*/
+function validateHeaderConflict(auth, headers, level) {
+	if (!auth || !headers) return;
+	const authHeaders = authConfigToHeaders(auth);
+	const normalizedKeys = new Set(Object.keys(headers).map((k) => k.toLowerCase()));
+	for (const key of Object.keys(authHeaders)) if (normalizedKeys.has(key)) throw new HeaderConflictError(key, level);
+}
+/**
+* Build merged HTTP headers from context-level and request-level options.
+*
+* Handles conflict validation, auth resolution (request overrides context),
+* and multi-source header merge. Transport-agnostic — used by both gRPC and
+* EVM JSON-RPC clients.
+*/
+function toFetchHeaders(contextAuth, contextHeaders, requestOptions) {
+	validateHeaderConflict(requestOptions?.auth, requestOptions?.headers, "query");
+	const effectiveAuth = requestOptions?.auth ?? contextAuth;
+	return mergeHeaders(contextHeaders, effectiveAuth ? authConfigToHeaders(effectiveAuth) : void 0, requestOptions?.headers);
+}
+/**
+* Convert QueryOptions to Connect RPC CallOptions.
+*
+* Uses toFetchHeaders() for header merge, then adds gRPC-specific
+* height injection and callback mapping.
+*/
+function toCallOptions(contextAuth, contextHeaders, queryOptions) {
+	const headers = toFetchHeaders(contextAuth, contextHeaders, queryOptions);
+	if (queryOptions?.height !== void 0) Object.assign(headers, heightToHeaders(queryOptions.height));
+	return {
+		headers,
+		signal: queryOptions?.signal,
+		timeoutMs: queryOptions?.timeoutMs,
+		onHeader: queryOptions?.onHeaders,
+		onTrailer: queryOptions?.onTrailer
+	};
+}
+//#endregion
+export { toFetchHeaders as n, validateHeaderConflict as r, toCallOptions as t };
+
+//# sourceMappingURL=headers-CMO7ia_D.mjs.map

package/dist/headers-CMO7ia_D.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers-CMO7ia_D.mjs","names":[],"sources":["../src/client/headers.ts"],"sourcesContent":["/**\n * Header utilities for gRPC authentication and metadata.\n *\n * Converts AuthConfig to HTTP headers, merges header sources,\n * validates conflicts, and transforms QueryOptions to Connect RPC CallOptions.\n */\n\nimport type { CallOptions } from '@connectrpc/connect'\nimport { base64 } from '@scure/base'\nimport { HeaderConflictError } from '../errors'\nimport type { Numeric } from '../types'\nimport type { AuthConfig, HttpRequestOptions, QueryOptions } from './types'\n\n/**\n * Convert AuthConfig to HTTP headers.\n *\n * All header keys are returned in lowercase.\n */\nexport function authConfigToHeaders(config: AuthConfig): Record<string, string> {\n  switch (config.type) {\n    case 'bearer':\n      return { authorization: `Bearer ${config.token}` }\n    case 'api-key': {\n      const headerName = config.header ?? 'x-api-key'\n      return { [headerName.toLowerCase()]: config.key }\n    }\n    case 'basic': {\n      const credentials = new TextEncoder().encode(`${config.username}:${config.password}`)\n      const encoded = base64.encode(credentials)\n      return { authorization: `Basic ${encoded}` }\n    }\n  }\n}\n\n/**\n * Convert block height to gRPC metadata header.\n */\nexport function heightToHeaders(height: Numeric): Record<string, string> {\n  return { 'x-cosmos-block-height': height.toString() }\n}\n\n/**\n * Merge multiple header sources with lowercase key normalization.\n *\n * Later sources override earlier ones for the same key.\n * Order: contextHeaders (base) → authHeaders → queryHeaders (highest priority)\n */\nexport function mergeHeaders(\n  ...sources: (Record<string, string> | undefined)[]\n): Record<string, string> {\n  const result: Record<string, string> = {}\n  for (const source of sources) {\n    if (source) {\n      for (const [key, value] of Object.entries(source)) {\n        result[key.toLowerCase()] = value\n      }\n    }\n  }\n  return result\n}\n\n/**\n * Validate that `auth` and `headers` at the same level don't set the same header key.\n *\n * Called in:\n * - `createChainContext` (level: 'context')\n * - `toCallOptions` (level: 'query')\n *\n * @throws {HeaderConflictError} when auth and headers set the same key\n */\nexport function validateHeaderConflict(\n  auth: AuthConfig | undefined,\n  headers: Record<string, string> | undefined,\n  level: 'context' | 'query'\n): void {\n  if (!auth || !headers) return\n  const authHeaders = authConfigToHeaders(auth)\n  const normalizedKeys = new Set(Object.keys(headers).map(k => k.toLowerCase()))\n  for (const key of Object.keys(authHeaders)) {\n    if (normalizedKeys.has(key)) {\n      throw new HeaderConflictError(key, level)\n    }\n  }\n}\n\n/**\n * Build merged HTTP headers from context-level and request-level options.\n *\n * Handles conflict validation, auth resolution (request overrides context),\n * and multi-source header merge. Transport-agnostic — used by both gRPC and\n * EVM JSON-RPC clients.\n */\nexport function toFetchHeaders(\n  contextAuth: AuthConfig | undefined,\n  contextHeaders: Record<string, string> | undefined,\n  requestOptions?: HttpRequestOptions\n): Record<string, string> {\n  validateHeaderConflict(requestOptions?.auth, requestOptions?.headers, 'query')\n  const effectiveAuth = requestOptions?.auth ?? contextAuth\n  const authHeaders = effectiveAuth ? authConfigToHeaders(effectiveAuth) : undefined\n  return mergeHeaders(contextHeaders, authHeaders, requestOptions?.headers)\n}\n\n/**\n * Convert QueryOptions to Connect RPC CallOptions.\n *\n * Uses toFetchHeaders() for header merge, then adds gRPC-specific\n * height injection and callback mapping.\n */\nexport function toCallOptions(\n  contextAuth: AuthConfig | undefined,\n  contextHeaders: Record<string, string> | undefined,\n  queryOptions?: QueryOptions\n): CallOptions {\n  const headers = toFetchHeaders(contextAuth, contextHeaders, queryOptions)\n\n  if (queryOptions?.height !== undefined) {\n    Object.assign(headers, heightToHeaders(queryOptions.height))\n  }\n\n  return {\n    headers,\n    signal: queryOptions?.signal,\n    timeoutMs: queryOptions?.timeoutMs,\n    onHeader: queryOptions?.onHeaders, // onHeaders → onHeader (Connect RPC naming)\n    onTrailer: queryOptions?.onTrailer,\n  }\n}\n"],"mappings":";;;;;;;;AAkBA,SAAgB,oBAAoB,QAA4C;AAC9E,SAAQ,OAAO,MAAf;EACE,KAAK,SACH,QAAO,EAAE,eAAe,UAAU,OAAO,SAAS;EACpD,KAAK,UAEH,QAAO,IADY,OAAO,UAAU,aACf,aAAa,GAAG,OAAO,KAAK;EAEnD,KAAK,SAAS;GACZ,MAAM,cAAc,IAAI,aAAa,CAAC,OAAO,GAAG,OAAO,SAAS,GAAG,OAAO,WAAW;AAErF,UAAO,EAAE,eAAe,SADR,OAAO,OAAO,YAAY,IACE;;;;;;;AAQlD,SAAgB,gBAAgB,QAAyC;AACvE,QAAO,EAAE,yBAAyB,OAAO,UAAU,EAAE;;;;;;;;AASvD,SAAgB,aACd,GAAG,SACqB;CACxB,MAAM,SAAiC,EAAE;AACzC,MAAK,MAAM,UAAU,QACnB,KAAI,OACF,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,CAC/C,QAAO,IAAI,aAAa,IAAI;AAIlC,QAAO;;;;;;;;;;;AAYT,SAAgB,uBACd,MACA,SACA,OACM;AACN,KAAI,CAAC,QAAQ,CAAC,QAAS;CACvB,MAAM,cAAc,oBAAoB,KAAK;CAC7C,MAAM,iBAAiB,IAAI,IAAI,OAAO,KAAK,QAAQ,CAAC,KAAI,MAAK,EAAE,aAAa,CAAC,CAAC;AAC9E,MAAK,MAAM,OAAO,OAAO,KAAK,YAAY,CACxC,KAAI,eAAe,IAAI,IAAI,CACzB,OAAM,IAAI,oBAAoB,KAAK,MAAM;;;;;;;;;AAY/C,SAAgB,eACd,aACA,gBACA,gBACwB;AACxB,wBAAuB,gBAAgB,MAAM,gBAAgB,SAAS,QAAQ;CAC9E,MAAM,gBAAgB,gBAAgB,QAAQ;AAE9C,QAAO,aAAa,gBADA,gBAAgB,oBAAoB,cAAc,GAAG,KAAA,GACxB,gBAAgB,QAAQ;;;;;;;;AAS3E,SAAgB,cACd,aACA,gBACA,cACa;CACb,MAAM,UAAU,eAAe,aAAa,gBAAgB,aAAa;AAEzE,KAAI,cAAc,WAAW,KAAA,EAC3B,QAAO,OAAO,SAAS,gBAAgB,aAAa,OAAO,CAAC;AAG9D,QAAO;EACL;EACA,QAAQ,cAAc;EACtB,WAAW,cAAc;EACzB,UAAU,cAAc;EACxB,WAAW,cAAc;EAC1B"}

package/dist/http-client-BrdVurTg.mjs

@@ -0,0 +1,40 @@
+import "./constants-W6V0E-3W.mjs";
+import { n as toFetchHeaders } from "./headers-CMO7ia_D.mjs";
+import { r as mergeAbortSignals } from "./fetch-Bq_aay6V.mjs";
+//#region src/client/http-client.ts
+/**
+* Shared HTTP request utility for fetch-based clients.
+*
+* Provides unified auth/header merge, timeout, and signal handling
+* for EVM JSON-RPC, CometBFT RPC, and (future) REST clients.
+*/
+/**
+* Perform an HTTP request with auth/header merge, timeout, and signal support.
+*
+* Header priority: config.headers (base) → config.auth → requestOptions.headers (highest)
+* Timeout: requestOptions.timeoutMs → config.timeoutMs → DEFAULT_REQUEST_TIMEOUT_MS
+* Signal: merged with user signal when provided (AbortSignal.any or manual forwarding fallback)
+*/
+async function httpRequest(config, path, init, requestOptions) {
+	const headers = toFetchHeaders(config.auth, config.headers, requestOptions);
+	const timeoutMs = requestOptions?.timeoutMs ?? config.timeoutMs ?? 3e4;
+	const controller = new AbortController();
+	const signal = requestOptions?.signal ? mergeAbortSignals(requestOptions.signal, controller) : controller.signal;
+	const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		return await fetch(`${config.endpoint.replace(/\/+$/, "")}${path}`, {
+			...init,
+			headers: {
+				...headers,
+				...init.headers
+			},
+			signal
+		});
+	} finally {
+		clearTimeout(timeoutId);
+	}
+}
+//#endregion
+export { httpRequest as t };
+
+//# sourceMappingURL=http-client-BrdVurTg.mjs.map

package/dist/http-client-BrdVurTg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-client-BrdVurTg.mjs","names":[],"sources":["../src/client/http-client.ts"],"sourcesContent":["/**\n * Shared HTTP request utility for fetch-based clients.\n *\n * Provides unified auth/header merge, timeout, and signal handling\n * for EVM JSON-RPC, CometBFT RPC, and (future) REST clients.\n */\n\nimport { DEFAULT_REQUEST_TIMEOUT_MS } from '../constants'\nimport { toFetchHeaders } from './headers'\nimport { mergeAbortSignals } from '../util/fetch'\nimport type { AuthConfig, HttpRequestOptions } from './types'\n\n/**\n * Configuration for an HTTP-based client.\n */\nexport interface HttpClientConfig {\n  endpoint: string\n  auth?: AuthConfig\n  headers?: Record<string, string>\n  timeoutMs?: number\n}\n\n/**\n * Perform an HTTP request with auth/header merge, timeout, and signal support.\n *\n * Header priority: config.headers (base) → config.auth → requestOptions.headers (highest)\n * Timeout: requestOptions.timeoutMs → config.timeoutMs → DEFAULT_REQUEST_TIMEOUT_MS\n * Signal: merged with user signal when provided (AbortSignal.any or manual forwarding fallback)\n */\nexport async function httpRequest(\n  config: HttpClientConfig,\n  path: string,\n  init: RequestInit,\n  requestOptions?: HttpRequestOptions\n): Promise<Response> {\n  const headers = toFetchHeaders(config.auth, config.headers, requestOptions)\n  const timeoutMs = requestOptions?.timeoutMs ?? config.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS\n\n  const controller = new AbortController()\n  const signal = requestOptions?.signal\n    ? mergeAbortSignals(requestOptions.signal, controller)\n    : controller.signal\n  const timeoutId = setTimeout(() => controller.abort(), timeoutMs)\n\n  try {\n    return await fetch(`${config.endpoint.replace(/\\/+$/, '')}${path}`, {\n      ...init,\n      headers: { ...headers, ...(init.headers as Record<string, string>) },\n      signal,\n    })\n  } finally {\n    clearTimeout(timeoutId)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA6BA,eAAsB,YACpB,QACA,MACA,MACA,gBACmB;CACnB,MAAM,UAAU,eAAe,OAAO,MAAM,OAAO,SAAS,eAAe;CAC3E,MAAM,YAAY,gBAAgB,aAAa,OAAO,aAAA;CAEtD,MAAM,aAAa,IAAI,iBAAiB;CACxC,MAAM,SAAS,gBAAgB,SAC3B,kBAAkB,eAAe,QAAQ,WAAW,GACpD,WAAW;CACf,MAAM,YAAY,iBAAiB,WAAW,OAAO,EAAE,UAAU;AAEjE,KAAI;AACF,SAAO,MAAM,MAAM,GAAG,OAAO,SAAS,QAAQ,QAAQ,GAAG,GAAG,QAAQ;GAClE,GAAG;GACH,SAAS;IAAE,GAAG;IAAS,GAAI,KAAK;IAAoC;GACpE;GACD,CAAC;WACM;AACR,eAAa,UAAU"}