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

package/dist/entry.provider.d.mts

@@ -0,0 +1,355 @@
+import { C as NetworkType, a as ChainInfoProvider, c as OpBridgeInfo, d as isCosmosAssetList, f as isInitiaAssetList, i as ChainInfoForType, l as RefreshResult, m as ChainType, n as ChainDataProvider, o as IbcChannelInfo, r as ChainInfo, s as ListAssetsOptions, t as AssetInfo, ts as Coin, u as TransferPath } from "./types-DGrP9Ro_.mjs";
+import { t as Bridge } from "./bridge-cQoOjppA.mjs";
+import { t as BaseChainDataProvider } from "./base-provider-CLnd7kte.mjs";
+import { n as CosmosRegistryProviderOptions } from "./cosmos-registry-provider-DCrEEhJ-.mjs";
+import * as v from "valibot";
+import { AssetList } from "@initia/initia-registry-types";
+import { AssetList as AssetList$1 } from "@chain-registry/types";
+
+//#region src/provider/registry-provider.d.ts
+/**
+ * Options for creating a RegistryProvider.
+ */
+interface RegistryProviderOptions {
+  /** Filter by network type. If not specified, fetches from all networks. */
+  network?: 'mainnet' | 'testnet';
+  /** Request timeout in milliseconds (default: 10000) */
+  timeout?: number;
+  /**
+   * Prefetch asset lists during initialization.
+   * - true: prefetch all chains
+   * - string[]: prefetch specific chain IDs
+   * - false/undefined: lazy load on demand (default)
+   */
+  prefetchAssets?: boolean | string[];
+}
+/**
+ * Registry-based chain data provider.
+ *
+ * Provides chain info, asset data, and IBC channel information
+ * from the Initia registry API. Asset lists are lazily loaded on demand.
+ *
+ * This class is synchronous for chain info queries after initialization.
+ * Asset queries may trigger lazy network requests on first call.
+ * Use createRegistryProvider() to create an instance.
+ */
+declare class RegistryProvider extends BaseChainDataProvider {
+  private chains;
+  private assetlistUrls;
+  private assetMap;
+  private assetInfoCache;
+  private chainNameToIds;
+  private chainIdToName;
+  private pendingFetches;
+  private pendingAllLoad;
+  private refreshOptions;
+  private _bridge?;
+  /**
+   * @internal Use createRegistryProvider() instead
+   */
+  constructor(init: {
+    chains: Map<string, ChainInfo>;
+    assetlistUrls: Map<string, string>;
+    chainNameToIds: Map<string, string[]>;
+    chainIdToName: Map<string, string>;
+    assetMap: Map<string, AssetList>;
+    options: RegistryProviderOptions;
+  });
+  getChainInfo<T extends ChainType = ChainType>(chainId: string): ChainInfoForType<T> | undefined;
+  listChains(): ChainInfo[];
+  hasChain(chainId: string): boolean;
+  getAssets(chainId: string): Promise<AssetInfo[]>;
+  getRawAssetList(chainId: string): Promise<AssetList | AssetList$1 | undefined>;
+  findAsset(denom: string, chainId?: string): Promise<AssetInfo | undefined>;
+  findAssetBySymbol(symbol: string, chainId?: string): Promise<AssetInfo[]>;
+  listAssets(options?: ListAssetsOptions): Promise<AssetInfo[]>;
+  getIbcChannels(chainId: string): IbcChannelInfo[];
+  getIbcChannel(fromChainId: string, toChainId: string): IbcChannelInfo | undefined;
+  getTransferPath(fromChainId: string, toChainId: string, _denom?: string): TransferPath | undefined;
+  getOpBridge(l2ChainId: string): OpBridgeInfo | undefined;
+  resolveChainId(chainName: string, network?: NetworkType): string | undefined;
+  getChainName(chainId: string): string | undefined;
+  get bridge(): Bridge;
+  refresh(): Promise<RefreshResult>;
+  private ensureAssetLoaded;
+  private ensureAllAssetsLoaded;
+}
+/**
+ * Create a RegistryProvider by fetching chain metadata from the Initia registry API.
+ *
+ * Most users don't need to call this directly — typed factories handle it:
+ * ```typescript
+ * const ctx = await createInitiaContext({ network: 'testnet' })
+ * ```
+ *
+ * Use this when you need to reuse a provider across multiple contexts or
+ * inspect chain metadata before creating a context:
+ *
+ * ```typescript
+ * const provider = await createRegistryProvider({ network: 'testnet' })
+ * const chains = provider.listChains()
+ *
+ * const ctx = createInitiaContext(provider, 'initiation-2', { signer: key })
+ * ```
+ *
+ * After creation, `getChainInfo()` and `listChains()` are synchronous.
+ * Asset queries (`getAssets`, `findAsset`) may trigger a lazy fetch on first call
+ * unless `prefetchAssets: true` is passed.
+ *
+ * @see createInitiaContext — Typed factory (recommended entry point)
+ * @see createLocalRegistryProvider — Offline alternative (Node.js only)
+ *
+ * @example
+ * ```typescript
+ * // Fetch only testnet chains
+ * const provider = await createRegistryProvider({ network: 'testnet' })
+ *
+ * // Prefetch all asset lists during init
+ * const provider = await createRegistryProvider({ prefetchAssets: true })
+ *
+ * // List all available chains
+ * const allChains = provider.listChains()
+ * ```
+ */
+declare function createRegistryProvider(options?: RegistryProviderOptions): Promise<RegistryProvider>;
+//#endregion
+//#region src/provider/custom-provider.d.ts
+/**
+ * Chain schema for validating chain-registry format (snake_case).
+ * Used by CustomProvider.from() for JSON input.
+ */
+declare const ChainInputSchema: v.ObjectSchema<{
+  readonly chain_id: v.StringSchema<undefined>;
+  readonly chain_name: v.StringSchema<undefined>;
+  readonly pretty_name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly network_type: v.PicklistSchema<["mainnet", "testnet", "devnet"], undefined>;
+  readonly bech32_prefix: v.StringSchema<undefined>;
+  readonly slip44: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+  readonly apis: v.ObjectSchema<{
+    readonly rpc: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly rest: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly grpc: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly 'grpc-web': v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly wss: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly 'json-rpc': v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly 'json-rpc-websocket': v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+  }, undefined>;
+  readonly fees: v.ObjectSchema<{
+    readonly fee_tokens: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+      readonly denom: v.StringSchema<undefined>;
+    }, undefined>, undefined>, v.MinLengthAction<{
+      denom: string;
+    }[], 1, undefined>]>;
+  }, undefined>;
+  readonly metadata: v.OptionalSchema<v.ObjectSchema<{
+    readonly is_l1: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly minitia: v.OptionalSchema<v.ObjectSchema<{
+      readonly type: v.PicklistSchema<["minimove", "miniwasm", "minievm", "custom"], undefined>;
+    }, undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly assets: v.OptionalSchema<v.ArraySchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>, undefined>;
+  readonly ibc_channels: v.OptionalSchema<v.ArraySchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>, undefined>;
+}, undefined>;
+type ChainInput = v.InferOutput<typeof ChainInputSchema>;
+/**
+ * Extended chain config with optional inline assets and IBC channels.
+ * Used with constructor and addChain() for one-step chain registration.
+ */
+interface CustomChainConfig extends ChainInfo {
+  /** Assets on this chain (normalized format) */
+  assets?: AssetInfo[];
+  /** IBC channels from this chain */
+  ibcChannels?: IbcChannelInfo[];
+}
+/**
+ * Flexible asset list input for addAssetList().
+ * Supports both snake_case and camelCase identifiers.
+ */
+interface AssetListInput {
+  /** Chain ID (camelCase) */
+  chainId?: string;
+  /** Chain ID (snake_case) */
+  chain_id?: string;
+  /** Assets in any supported format (snake_case, camelCase, or minimal) */
+  assets: Record<string, unknown>[];
+}
+/**
+ * Custom chain info provider.
+ *
+ * Provides chain information, assets, and IBC channels from user-defined configurations.
+ * Supports dynamic addition and removal of chains.
+ *
+ * @example Basic usage (programmatic)
+ * ```typescript
+ * const provider = new CustomProvider([
+ *   {
+ *     chainId: 'my-local-chain',
+ *     chainName: 'My Local Chain',
+ *     chainType: 'initia',
+ *     network: 'local',
+ *     grpc: 'localhost:9090',
+ *     nativeDenom: 'utoken',
+ *     assets: [
+ *       { chainId: 'my-local-chain', denom: 'utoken', symbol: 'TOKEN', name: 'Token',
+ *         display: 'token', denomUnits: [{ denom: 'utoken', exponent: 0 }, { denom: 'token', exponent: 6 }],
+ *         decimals: 6 },
+ *     ],
+ *   }
+ * ])
+ * ```
+ *
+ * @example From chain-registry JSON
+ * ```typescript
+ * const provider = CustomProvider.from({
+ *   chain_id: 'my-chain', chain_name: 'my-chain', network_type: 'testnet',
+ *   bech32_prefix: 'init', apis: { grpc: [{ address: 'localhost:9090' }] },
+ *   fees: { fee_tokens: [{ denom: 'utoken' }] },
+ *   assets: [{ denom: 'utoken', symbol: 'TOKEN', name: 'Token', decimals: 6, denom_units: [...] }],
+ * })
+ * ```
+ */
+declare class CustomProvider extends BaseChainDataProvider {
+  private chains;
+  private assetMap;
+  private ibcMap;
+  private _bridge?;
+  constructor(chains?: (ChainInfo | CustomChainConfig)[]);
+  /**
+   * Create a CustomProvider from chain-registry JSON (snake_case format).
+   *
+   * Validates input with Valibot schema. Supports inline assets and IBC channels.
+   *
+   * @param input - JSON string, ChainInput object, or ChainInput array
+   * @returns CustomProvider instance with validated chain(s)
+   * @throws If input is invalid JSON or fails schema validation
+   */
+  static from(input: string | ChainInput | ChainInput[]): CustomProvider;
+  /**
+   * Add a chain configuration.
+   * Overwrites if chain with same ID already exists.
+   * Optionally includes inline assets and IBC channels.
+   */
+  addChain(chain: CustomChainConfig): void;
+  /**
+   * Remove a chain and its associated assets and IBC channels.
+   * @returns true if chain was removed, false if not found
+   */
+  removeChain(chainId: string): boolean;
+  /**
+   * Add assets for a chain. Merges with existing assets (dedup by denom).
+   */
+  addAssets(chainId: string, assets: AssetInfo[]): void;
+  /**
+   * Add asset list from flexible input (supports snake_case/camelCase).
+   * @param input - JSON string or AssetListInput with dual-case fields
+   */
+  addAssetList(input: AssetListInput | string): void;
+  /**
+   * Add an IBC channel for a chain.
+   * Accepts normalized IbcChannelInfo or flexible Record input.
+   */
+  addIbcChannel(chainId: string, channel: IbcChannelInfo | Record<string, unknown>): void;
+  get bridge(): Bridge;
+  getChainInfo<T extends ChainType = ChainType>(chainId: string): ChainInfoForType<T> | undefined;
+  listChains(): ChainInfo[];
+  hasChain(chainId: string): boolean;
+  getAssets(chainId: string): Promise<AssetInfo[]>;
+  getRawAssetList(_chainId: string): Promise<AssetList | AssetList$1 | undefined>;
+  findAsset(denom: string, chainId?: string): Promise<AssetInfo | undefined>;
+  findAssetBySymbol(symbol: string, chainId?: string): Promise<AssetInfo[]>;
+  listAssets(options?: ListAssetsOptions): Promise<AssetInfo[]>;
+  getIbcChannels(chainId: string): IbcChannelInfo[];
+  getIbcChannel(fromChainId: string, toChainId: string): IbcChannelInfo | undefined;
+  getTransferPath(fromChainId: string, toChainId: string, _denom?: string): TransferPath | undefined;
+  getOpBridge(_l2ChainId: string): OpBridgeInfo | undefined;
+  resolveChainId(chainName: string, network?: NetworkType): string | undefined;
+  getChainName(chainId: string): string | undefined;
+}
+//#endregion
+//#region src/provider/composite-provider.d.ts
+/**
+ * Composite provider that combines multiple chain data providers.
+ *
+ * When multiple providers have the same chain ID, the first provider wins.
+ * This allows for overriding chain configurations by ordering providers.
+ *
+ * All ChainDataProvider methods are delegated to the child provider that owns
+ * the chain. Amount methods throw ChainNotFoundError if no provider matches.
+ *
+ * @example
+ * ```typescript
+ * const provider = new CompositeProvider([
+ *   new RegistryProvider(registryData),   // Initia chains
+ *   new CosmosRegistryProvider(),         // Cosmos ecosystem
+ *   new CustomProvider([localChain]),     // Custom chains
+ * ])
+ *
+ * // Routes to the correct child provider automatically
+ * const osmosis = provider.getChainInfo('osmosis-1')
+ * const assets = await provider.getAssets('noble-1')
+ * const display = await provider.toDisplayAmount(coin, 'interwoven-1')
+ * ```
+ */
+declare class CompositeProvider implements ChainDataProvider {
+  private providers;
+  private chainCache;
+  private chainToProvider;
+  constructor(providers: ChainDataProvider[]);
+  /**
+   * Build chain cache and provider routing from all providers.
+   * First provider wins for duplicate chain IDs.
+   */
+  private rebuildCache;
+  getChainInfo<T extends ChainType = ChainType>(chainId: string): ChainInfoForType<T> | undefined;
+  listChains(): ChainInfo[];
+  hasChain(chainId: string): boolean;
+  /**
+   * Get the number of providers in this composite.
+   */
+  get providerCount(): number;
+  getAssets(chainId: string): Promise<AssetInfo[]>;
+  getRawAssetList(chainId: string): Promise<AssetList | AssetList$1 | undefined>;
+  findAsset(denom: string, chainId?: string): Promise<AssetInfo | undefined>;
+  findAssets(denoms: string[], chainId: string): Promise<Map<string, AssetInfo | undefined>>;
+  findAssetBySymbol(symbol: string, chainId?: string): Promise<AssetInfo[]>;
+  listAssets(options?: ListAssetsOptions): Promise<AssetInfo[]>;
+  getIbcChannels(chainId: string): IbcChannelInfo[];
+  getIbcChannel(fromChainId: string, toChainId: string): IbcChannelInfo | undefined;
+  getTransferPath(fromChainId: string, toChainId: string, denom?: string): TransferPath | undefined;
+  getOpBridge(l2ChainId: string): OpBridgeInfo | undefined;
+  toDisplayAmount(coin: Coin, chainId: string): Promise<string>;
+  toBaseAmount(amount: string, denom: string, chainId: string): Promise<string>;
+  convertAmount(amount: string, fromDenom: string, toDenom: string, chainId: string): Promise<string>;
+  formatAmount(coin: Coin, chainId: string, options?: {
+    maxDecimals?: number;
+    minDecimals?: number;
+    trimTrailingZeros?: boolean;
+  }): Promise<string>;
+  resolveChainId(chainName: string, network?: NetworkType): string | undefined;
+  getChainName(chainId: string): string | undefined;
+  refresh(): Promise<RefreshResult>;
+}
+//#endregion
+//#region src/provider/compose.d.ts
+/**
+ * Compose multiple providers into a single CompositeProvider.
+ * First provider wins for duplicate chain IDs.
+ */
+declare function composeProviders(...providers: ChainDataProvider[]): CompositeProvider;
+//#endregion
+export { type AssetInfo, BaseChainDataProvider, type ChainDataProvider, type ChainInfo, type ChainInfoForType, type ChainInfoProvider, CompositeProvider, type CosmosRegistryProviderOptions, type CustomChainConfig, CustomProvider, type IbcChannelInfo, type ListAssetsOptions, type OpBridgeInfo, type RefreshResult, RegistryProvider, type RegistryProviderOptions, type TransferPath, composeProviders, createRegistryProvider, isCosmosAssetList, isInitiaAssetList };
+//# sourceMappingURL=entry.provider.d.mts.map