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

package/dist/bridge-cQoOjppA.d.mts

@@ -0,0 +1,606 @@
+import { Ca as Message, Mo as Signer, T as SignModeType, a as ChainInfoProvider, ls as Numeric, r as ChainInfo, ts as Coin, ys as TransportFactory } from "./types-DGrP9Ro_.mjs";
+
+//#region src/bridge/types.d.ts
+/**
+ * Deposit options for L1 → L2 token transfer.
+ *
+ * Use `toChain` for automatic bridgeId resolution from provider,
+ * or `bridgeId` for direct specification.
+ */
+type DepositOptions = {
+  sender: string; /** L2 recipient address. Defaults to sender if omitted. */
+  to?: string; /** Amount to deposit. String format parsed via parseCoin (e.g., '1000000uinit'). */
+  amount: Coin | string; /** Hook data for L2 execution. Defaults to empty bytes. */
+  data?: Uint8Array;
+} & ({
+  toChain: string;
+  bridgeId?: never;
+} | {
+  toChain?: never;
+  bridgeId: Numeric;
+});
+/**
+ * Withdrawal options for L2 → L1 token transfer.
+ */
+interface WithdrawOptions {
+  sender: string;
+  /** L1 recipient address. Defaults to sender if omitted. */
+  to?: string;
+  /** Amount to withdraw. String format parsed via parseCoin. */
+  amount: Coin | string;
+}
+/**
+ * Claim options for finalizing a withdrawal on L1.
+ */
+interface ClaimOptions {
+  /** Claim executor address (usually the withdrawal recipient). */
+  sender: string;
+  /** Withdrawal data obtained from getWithdrawals(). Must have status 'claimable'. */
+  withdrawal: WithdrawalInfo;
+}
+/**
+ * Withdrawal information including Executor-provided proof data.
+ *
+ * Populated by Executor API (basic fields + proof data) and
+ * L1 ophost queries (status determination).
+ */
+interface WithdrawalInfo {
+  sequence: bigint;
+  /** L2 sender address. */
+  from: string;
+  /** L1 recipient address. */
+  to: string;
+  amount: Coin;
+  outputIndex: bigint;
+  bridgeId: bigint;
+  txHash: string;
+  /** Withdrawal lifecycle status, determined by L1 queries. */
+  status: WithdrawalStatus;
+  /** Merkle proofs from Executor (hex-encoded). */
+  withdrawalProofs: string[];
+  /** Output version from Executor (hex-encoded). */
+  version: string;
+  /** Storage root from Executor (hex-encoded). */
+  storageRoot: string;
+  /** Last block hash from Executor (hex-encoded). */
+  lastBlockHash: string;
+}
+/**
+ * Withdrawal lifecycle status.
+ *
+ * - pending: Not yet included in any proposed output.
+ * - waiting: Included in output, awaiting finalization period.
+ * - claimable: Finalization period passed, ready to claim on L1.
+ * - claimed: Already finalized on L1.
+ */
+type WithdrawalStatus = {
+  status: 'pending';
+} | {
+  status: 'waiting';
+  claimableAt: Date;
+} | {
+  status: 'claimable';
+} | {
+  status: 'claimed';
+};
+/**
+ * Options for finding a transfer route.
+ */
+interface RouteOptions {
+  /** Transfer amount in minimal denomination (e.g., '1000000'). */
+  amount: string;
+  /** Source chain and asset. */
+  source: {
+    chainId: string;
+    denom: string;
+  };
+  /** Destination chain and asset. */
+  dest: {
+    chainId: string;
+    denom: string;
+  };
+  /** Allow routes that may involve risk (default: true). */
+  allowUnsafe?: boolean;
+  /** Prefer faster routes (default: false). */
+  goFast?: boolean;
+  /** Force an Optimistic withdrawal route. */
+  isOpWithdraw?: boolean;
+}
+/**
+ * A resolved transfer route from the Router API.
+ *
+ * Contains amounts, operations, and the raw server response needed
+ * for buildTransferMsgs().
+ */
+interface Route {
+  amountIn: string;
+  amountOut: string;
+  source: {
+    chainId: string;
+    denom: string;
+    symbol?: string;
+  };
+  dest: {
+    chainId: string;
+    denom: string;
+    symbol?: string;
+  };
+  /** Normalized operations (for display purposes). */
+  operations: RouteOperation[];
+  estimatedDurationSeconds?: number;
+  usdAmountIn?: string;
+  usdAmountOut?: string;
+  warnings?: string[];
+  extraInfos?: string[];
+  extraWarnings?: string[];
+  /** True if getOpHook() + signOpHook() must be called before buildTransferMsgs(). */
+  requiresOpHook?: boolean;
+  /** @internal Server's original response. Used by buildTransferMsgs(); not intended for user access. */
+  _raw: unknown;
+}
+/**
+ * A single operation within a route.
+ */
+type RouteOperation = {
+  type: 'transfer';
+  chainId: string;
+  channel: string;
+  denomIn: string;
+  denomOut: string;
+} | {
+  type: 'swap';
+  poolId: string;
+  denomIn: string;
+  denomOut: string;
+} | {
+  type: 'op_init_transfer';
+  denomIn: string;
+  denomOut: string;
+} | {
+  type: 'axelar_transfer';
+  denomIn: string;
+  denomOut: string;
+} | {
+  type: 'cctp_transfer';
+  denomIn: string;
+  denomOut: string;
+} | {
+  type: 'layer_zero_transfer';
+  denomIn: string;
+  denomOut: string;
+};
+/**
+ * Options for building transfer messages from a route.
+ */
+interface BuildTransferMsgsOptions {
+  route: Route;
+  /** Addresses for each chain in the path: [source, ...hops, dest]. */
+  addresses: string[];
+  /** Slippage tolerance as percentage string (default: '1' = 1%). */
+  slippageTolerance?: string;
+  /** Signed OP Hook data. Required when route.requiresOpHook is true. */
+  signedOpHook?: SignedOpHook;
+  /** Include blacklisted networks (default: false). */
+  ignoreBlacklist?: boolean;
+}
+/**
+ * A transaction to execute as part of a multi-hop transfer.
+ */
+interface TransferTx {
+  /** Chain where this transaction should be signed and broadcast. */
+  chainId: string;
+  /** Cosmos messages for signAndBroadcast. */
+  cosmosMsgs?: Message[];
+  /** EVM transaction data (for native EVM chains). */
+  evmTx?: {
+    to: string;
+    data: string;
+    value?: string;
+  };
+  /** Address that must sign this transaction. */
+  signerAddress: string;
+}
+/**
+ * Options for requesting OP Hook data.
+ */
+interface OpHookOptions {
+  sourceAddress: string;
+  sourceChainId: string;
+  sourceDenom: string;
+  destAddress: string;
+  destChainId: string;
+  destDenom: string;
+}
+/**
+ * Cosmos message in Router API format.
+ */
+interface CosmosMsgJson {
+  /** JSON-stringified message body */
+  msg: string;
+  /** Protobuf typeUrl (e.g., "/minievm.evm.v1.MsgCall") */
+  msg_type_url: string;
+}
+/**
+ * OP Hook data returned by the Router API.
+ */
+interface OpHookResult {
+  chainId: string;
+  hook: CosmosMsgJson[];
+}
+/**
+ * Signed OP Hook data to pass to buildTransferMsgs().
+ */
+interface SignedOpHook {
+  hook: string;
+  signer: string;
+}
+/**
+ * Overall transaction state from the Router API.
+ */
+type TransferState = 'STATE_SUBMITTED' | 'STATE_PENDING' | 'STATE_COMPLETED_SUCCESS' | 'STATE_COMPLETED_ERROR' | 'STATE_ABANDONED' | 'STATE_PENDING_ERROR';
+/**
+ * A single hop in the transfer sequence.
+ */
+interface TransferHop {
+  srcChainId: string;
+  dstChainId: string;
+  state: string;
+}
+/**
+ * Asset release info for completed transfers.
+ */
+interface TransferAssetRelease {
+  chainId: string;
+  denom: string;
+  amount?: string;
+  released: boolean;
+}
+/**
+ * Transfer tracking status from the Router API.
+ */
+interface TransferStatus {
+  /** Overall end-to-end state. */
+  state: TransferState;
+  /** Detailed transfer status for each hop. */
+  transfers: unknown[];
+  /** Flat list of transfer events in sequence order. */
+  transferSequence: TransferHop[];
+  /** Next transfer blocking progress, if any. */
+  nextBlockingTransfer?: {
+    transferSequenceIndex: number;
+  };
+  /** Info about released assets at destination. */
+  transferAssetRelease?: TransferAssetRelease;
+  /** Error details if the transaction failed. */
+  error?: unknown;
+}
+/**
+ * A routable asset from the Router API.
+ * Based on @skip-go/client AssetJson + router-api RouterAsset extensions.
+ */
+interface RoutableAsset {
+  denom: string;
+  chainId: string;
+  originDenom: string;
+  originChainId: string;
+  symbol?: string;
+  name?: string;
+  decimals?: number;
+  logoUri?: string;
+  recommendedSymbol?: string;
+  description?: string;
+  coingeckoId?: string;
+  trace: string;
+  isCw20: boolean;
+  isEvm: boolean;
+  isSvm: boolean;
+  tokenContract?: string;
+  hidden?: boolean;
+  forwardContract?: string;
+  oftOwner?: string;
+}
+/**
+ * Query input for cross-chain balance lookup.
+ */
+interface BalanceQuery {
+  address: string;
+  denoms: string[];
+}
+/**
+ * Balance result for a single denom.
+ */
+interface BalanceResult {
+  amount: string;
+  priceUsd?: string;
+  valueUsd?: string;
+}
+/**
+ * Cross-chain balance response from the Router API.
+ * Map of chainId → denom → balance info.
+ */
+type RouterBalances = Record<string, Record<string, BalanceResult>>;
+/**
+ * A chain supported by the Router API.
+ */
+interface RouterChain {
+  chainId: string;
+  chainName: string;
+  chainType: string;
+  pfmEnabled: boolean;
+  supportsMemo: boolean;
+  logoUri?: string;
+  bech32Prefix?: string;
+  rest?: string;
+  rpc?: string;
+  evmFeeAsset?: {
+    decimals: number;
+    name: string;
+    symbol: string;
+  };
+}
+/**
+ * Options for cross-chain NFT transfer.
+ */
+interface NftTransferOptions {
+  fromAddress: string;
+  fromChainId: string;
+  toAddress: string;
+  toChainId: string;
+  /** Token IDs to transfer (maximum 30). */
+  tokenIds: string[];
+  /** NFT collection contract address. Pass empty string for Move chains. */
+  collectionAddress: string;
+  /** IBC class ID. Required for cross-chain transfers. */
+  classId?: string;
+  /** IBC class trace for multi-hop transfers. */
+  classTrace?: {
+    path: string;
+    baseClassId: string;
+  };
+  /** Move object addresses (maximum 30). Required for same-chain Move transfers. */
+  objectAddresses?: string[];
+  /** L1 recovery address for L2→L1→L2 transfers. Defaults to fromAddress. */
+  l1RecoverAddress?: string;
+  /** Outgoing proxy contract address (Wasm chains). */
+  outgoingProxy?: string;
+  /** IBC timeout in seconds (default: 1800). */
+  timeout?: number;
+  /** Include blacklisted networks (default: false). */
+  ignoreBlacklist?: boolean;
+}
+/**
+ * Result of an NFT transfer message generation.
+ */
+interface NftTransferResult {
+  msgs: Array<{
+    typeUrl: string;
+    value: Record<string, unknown>;
+  }>;
+}
+/**
+ * Options for depositAndWait — deposit L1 → L2 and wait for finalization.
+ */
+interface DepositAndWaitOptions {
+  sender: string;
+  /** L2 recipient address. Defaults to sender. */
+  to?: string;
+  /** Target L2 chain (required for watching finalization). */
+  toChain: string;
+  /** Amount to deposit. */
+  amount: Coin | string;
+  /** Hook data for L2 execution. */
+  data?: Uint8Array;
+  /** Sign and broadcast on L1. */
+  signAndBroadcast: (msgs: Message[]) => Promise<unknown>;
+  /** Timeout in milliseconds (default: 5 minutes). */
+  timeout?: number;
+}
+/**
+ * Options for withdrawAndClaim — withdraw L2 → L1, wait for finalization, and auto-claim.
+ */
+interface WithdrawAndClaimOptions {
+  sender: string;
+  /** L1 recipient address. Defaults to sender. */
+  to?: string;
+  /** Amount to withdraw. */
+  amount: Coin | string;
+  /** L2 chain ID. */
+  l2ChainId: string;
+  /** Sign and broadcast withdrawal on L2. */
+  signAndBroadcastL2: (msgs: Message[]) => Promise<unknown>;
+  /** Sign and broadcast claim on L1. */
+  signAndBroadcastL1: (msgs: Message[]) => Promise<unknown>;
+  /** Timeout in milliseconds (default: 2 hours). */
+  timeout?: number;
+}
+type DepositEvent = {
+  status: 'initiated';
+  l1Sequence: bigint;
+  from: string;
+  to: string;
+  amount: string;
+  bridgeId: bigint;
+} | {
+  status: 'finalized';
+  l1Sequence: bigint;
+  recipient: string;
+  amount: string;
+  success: boolean;
+  reason?: string;
+};
+type WithdrawalEvent = {
+  status: 'initiated';
+  l2Sequence: bigint;
+  from: string;
+  to: string;
+  amount: string;
+} | {
+  status: 'proposed';
+  outputIndex: bigint;
+  l2BlockNumber: bigint;
+} | {
+  status: 'waiting';
+  claimableAt: Date;
+} | {
+  status: 'claimable';
+} | {
+  status: 'claimed';
+  l2Sequence: bigint;
+  from: string;
+  to: string;
+  amount: string;
+};
+interface WatchDepositOptions {
+  l2ChainId: string;
+  l1Sequence?: Numeric;
+  sender?: string;
+  recipient?: string;
+  /** Called on error. If not provided, the watcher logs to console.error and terminates. */
+  onError?: (error: unknown) => void;
+}
+interface WatchWithdrawalOptions {
+  l2ChainId: string;
+  l2Sequence?: Numeric;
+  sender?: string;
+  timeout?: number;
+  /** Called on error. If not provided, the watcher logs to console.error and terminates. */
+  onError?: (error: unknown) => void;
+}
+interface BridgeWatchHandle {
+  unsubscribe(): void;
+}
+//#endregion
+//#region src/bridge/executor.d.ts
+/**
+ * Pagination options for withdrawal list queries.
+ */
+interface FetchWithdrawalsOptions {
+  limit?: number;
+  offset?: number;
+}
+/**
+ * Fetch paginated withdrawal list from Executor API.
+ *
+ * @param executorUri - Executor API base URL (e.g., 'https://executor.minimove-2.initia.xyz')
+ * @param address - L2 sender address to query withdrawals for
+ * @param options - Pagination options
+ * @returns Array of WithdrawalInfo without status (status determined separately by L1 queries)
+ */
+declare function fetchWithdrawals(executorUri: string, address: string, options?: FetchWithdrawalsOptions): Promise<Omit<WithdrawalInfo, 'status'>[]>;
+/**
+ * Fetch a single withdrawal by sequence from Executor API.
+ *
+ * @param executorUri - Executor API base URL
+ * @param sequence - Withdrawal sequence number
+ * @returns WithdrawalInfo without status (status determined separately by L1 queries)
+ */
+declare function fetchWithdrawal(executorUri: string, sequence: Numeric): Promise<Omit<WithdrawalInfo, 'status'>>;
+//#endregion
+//#region src/bridge/bridge.d.ts
+declare class Bridge {
+  private provider;
+  private createTransport;
+  private opBridge;
+  private router?;
+  constructor(provider: ChainInfoProvider, createTransport: TransportFactory, routerUrl?: string);
+  deposit(options: DepositOptions): Message;
+  withdraw(options: WithdrawOptions): Message;
+  claim(options: ClaimOptions): Message;
+  getWithdrawals(l2ChainId: string, address: string, options?: FetchWithdrawalsOptions): Promise<WithdrawalInfo[]>;
+  getWithdrawalStatus(l2ChainId: string, sequence: Numeric): Promise<WithdrawalInfo>;
+  listBridgeableChains(): ChainInfo[];
+  getBridgeId(l2ChainId: string): bigint;
+  private requireRouter;
+  route(options: RouteOptions): Promise<Route>;
+  getRoutableAssets(chainIds?: string[]): Promise<Record<string, RoutableAsset[]>>;
+  /**
+   * Resolve an asset by symbol on a specific chain.
+   *
+   * @returns The matching asset with denom, decimals, symbol, etc.
+   * @throws If the symbol is not found or ambiguous (multiple matches).
+   *
+   * @example
+   * ```typescript
+   * const asset = await provider.bridge.resolveAsset('evm-1', 'INIT')
+   * // → { denom: 'evm/2eE7...', decimals: 18, symbol: 'INIT', ... }
+   * ```
+   */
+  resolveAsset(chainId: string, symbol: string): Promise<RoutableAsset>;
+  getRoutableChains(chainIds?: string[]): Promise<RouterChain[]>;
+  getBalances(queries: Record<string, BalanceQuery>): Promise<RouterBalances>;
+  nftTransfer(options: NftTransferOptions): Promise<NftTransferResult>;
+  buildTransferMsgs(options: BuildTransferMsgsOptions): Promise<TransferTx[]>;
+  getOpHook(options: OpHookOptions): Promise<OpHookResult>;
+  /**
+   * Build and sign a Cosmos transaction from OP Hook messages.
+   *
+   * The hook messages (from getOpHook) are assembled into a Cosmos TxRaw,
+   * signed with the appropriate sign mode, and returned as base64.
+   * The L2's handleBridgeHook decodes and executes this transaction.
+   *
+   * opHook is minievm-only (ERC-20 6d↔18d wrapping). Default sign mode
+   * is eip191 if the signer supports it, otherwise direct, then amino.
+   *
+   * @param hookResult - OP Hook data from getOpHook()
+   * @param signer - Any Signer (Key, Keplr, WalletConnect, etc.)
+   * @param options - Optional sign mode override and source chain ID
+   */
+  signOpHook(hookResult: OpHookResult, signer: Signer, options?: {
+    /** Override auto-detected sign mode */signMode?: SignModeType; /** Source chain ID — if same as hook chain, sequence is incremented by 2 (minievm MsgCall accounting) */
+    sourceChainId?: string;
+  }): Promise<SignedOpHook>;
+  trackTransfer(txHash: string, chainId: string): Promise<void>;
+  getTransferStatus(txHash: string, chainId: string): Promise<TransferStatus>;
+  watchDeposit(options: WatchDepositOptions, callback: (event: DepositEvent) => void): BridgeWatchHandle;
+  watchWithdrawal(options: WatchWithdrawalOptions, callback: (event: WithdrawalEvent) => void): BridgeWatchHandle;
+  waitForDeposit(options: WatchDepositOptions & {
+    timeout?: number;
+  }): Promise<DepositEvent & {
+    status: 'finalized';
+  }>;
+  waitForClaimable(options: WatchWithdrawalOptions & {
+    timeout?: number;
+  }): Promise<WithdrawalEvent & {
+    status: 'claimable';
+  }>;
+  /**
+   * Deposit L1 → L2 and wait for finalization on L2.
+   *
+   * Combines `deposit()` + `signAndBroadcast()` + `waitForDeposit()` into one call.
+   *
+   * @example
+   * ```typescript
+   * const event = await bridge.depositAndWait({
+   *   sender: key.address,
+   *   toChain: 'rollup-1',
+   *   amount: coin('uinit', 1_000_000),
+   *   signAndBroadcast: (msgs) => l1.signAndBroadcast(msgs),
+   * })
+   * console.log(event.status) // 'finalized'
+   * ```
+   */
+  depositAndWait(options: DepositAndWaitOptions): Promise<DepositEvent & {
+    status: 'finalized';
+  }>;
+  /**
+   * Withdraw L2 → L1, wait for finalization, and auto-claim on L1.
+   *
+   * Combines `withdraw()` + `signAndBroadcastL2()` + `waitForClaimable()` +
+   * `getWithdrawals()` + `claim()` + `signAndBroadcastL1()`.
+   *
+   * @example
+   * ```typescript
+   * const withdrawal = await bridge.withdrawAndClaim({
+   *   sender: key.address,
+   *   amount: coin('uinit', 1_000_000),
+   *   l2ChainId: 'rollup-1',
+   *   signAndBroadcastL2: (msgs) => l2.signAndBroadcast(msgs),
+   *   signAndBroadcastL1: (msgs) => l1.signAndBroadcast(msgs),
+   * })
+   * ```
+   */
+  withdrawAndClaim(options: WithdrawAndClaimOptions): Promise<WithdrawalInfo>;
+}
+//#endregion
+export { WithdrawOptions as C, WithdrawalStatus as E, WithdrawAndClaimOptions as S, WithdrawalInfo as T, SignedOpHook as _, BridgeWatchHandle as a, WatchDepositOptions as b, DepositAndWaitOptions as c, OpHookOptions as d, OpHookResult as f, RouteOptions as g, RouteOperation as h, fetchWithdrawals as i, DepositEvent as l, Route as m, FetchWithdrawalsOptions as n, BuildTransferMsgsOptions as o, RoutableAsset as p, fetchWithdrawal as r, ClaimOptions as s, Bridge as t, DepositOptions as u, TransferStatus as v, WithdrawalEvent as w, WatchWithdrawalOptions as x, TransferTx as y };
+//# sourceMappingURL=bridge-cQoOjppA.d.mts.map