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

package/dist/bridge-DL-q-7P7.mjs

@@ -0,0 +1,1222 @@
+import { t as CoinSchema } from "./coin_pb--WuIu4sX.mjs";
+import { c as InitiaError, g as isNotFoundError, h as WebSocketNotAvailableError, p as TimeoutError } from "./errors-CN1MFOLv.mjs";
+import { s as parseCoin, t as Coin } from "./coin-DPWbtAFA.mjs";
+import { o as UnsignedTx } from "./broadcast-De8MdmYa.mjs";
+import { t as Message$1 } from "./types-CSS5rfW1.mjs";
+import { t as base64ToUint8Array } from "./amino-CMQN7Frn.mjs";
+import { n as isDirectSigner, r as isEIP191Signer, t as isAminoSigner } from "./types-CLfdsa48.mjs";
+import { n as fetchWithTimeout, t as fetchJson } from "./fetch-Bq_aay6V.mjs";
+import { t as createGrpcClient } from "./grpc-client-DGyZjGcT.mjs";
+import { a as file_cosmos_bank_v1beta1_tx, r as file_ibc_applications_transfer_v1_tx, v as buildChainContextFactory, y as wrapClientWithCache } from "./types_pb-K7pKBvcg.mjs";
+import { o as createSession } from "./waiting-BigHYRNN.mjs";
+import { r as file_minievm_evm_v1_tx } from "./tx_pb-BVCXH992.mjs";
+import { s as file_initia_move_v1_tx } from "./tx_pb-DYspoJTt.mjs";
+import { i as file_opinit_ophost_v1_tx, n as MsgFinalizeTokenWithdrawalSchema, r as MsgInitiateTokenDepositSchema, t as initiaChain } from "./initia-B8l_x6sT.mjs";
+import { a as file_opinit_opchild_v1_tx, i as MsgInitiateTokenWithdrawalSchema } from "./tx_pb-CnFNMLIq.mjs";
+import { n as resolveRegistry, r as resolveServices, t as resolveMsgs } from "./resolve-DdtY7KDz.mjs";
+import { create, createRegistry, fromJson, toBinary } from "@bufbuild/protobuf";
+import { AnySchema } from "@bufbuild/protobuf/wkt";
+import { base64 } from "@scure/base";
+import { sha3_256 } from "@noble/hashes/sha3.js";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
+//#region src/bridge/executor.ts
+/**
+* Decode base64 string to hex string.
+*/
+function base64ToHex(b64) {
+	return bytesToHex(base64.decode(b64));
+}
+/**
+* Convert Executor API response to WithdrawalInfo.
+* Status is set to { status: 'pending' } as a placeholder — actual status
+* is determined by L1 queries in the status determination logic.
+*/
+function toWithdrawalInfo(raw) {
+	return {
+		sequence: BigInt(raw.sequence),
+		from: raw.from,
+		to: raw.to,
+		amount: new Coin(raw.amount.denom, raw.amount.amount),
+		outputIndex: BigInt(raw.output_index),
+		bridgeId: BigInt(raw.bridge_id),
+		txHash: raw.tx_hash,
+		withdrawalProofs: raw.withdrawal_proofs.map(base64ToHex),
+		version: base64ToHex(raw.version),
+		storageRoot: base64ToHex(raw.storage_root),
+		lastBlockHash: base64ToHex(raw.last_block_hash)
+	};
+}
+/**
+* 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)
+*/
+async function fetchWithdrawals(executorUri, address, options) {
+	const params = new URLSearchParams();
+	if (options?.limit != null) params.set("limit", String(options.limit));
+	if (options?.offset != null) params.set("offset", String(options.offset));
+	const query = params.toString();
+	return (await fetchJson(`${executorUri}/withdrawals/${address}${query ? `?${query}` : ""}`)).withdrawals.map(toWithdrawalInfo);
+}
+/**
+* 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)
+*/
+async function fetchWithdrawal(executorUri, sequence) {
+	return toWithdrawalInfo(await fetchJson(`${executorUri}/withdrawal/${sequence.toString()}`));
+}
+//#endregion
+//#region src/bridge/hash.ts
+/**
+* Withdrawal hash calculation for OPInit bridge.
+*
+* Computes the SHA3-256 double hash used as Merkle leaf for withdrawal verification.
+*/
+const textEncoder = new TextEncoder();
+/**
+* Encode a bigint as big-endian 8 bytes.
+*/
+function bigintToBeBytes(value) {
+	const buf = new Uint8Array(8);
+	for (let i = 7; i >= 0; i--) {
+		buf[i] = Number(value & 255n);
+		value >>= 8n;
+	}
+	return buf;
+}
+/**
+* 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
+*/
+function calculateWithdrawalHash(bridgeId, l2Sequence, sender, receiver, denom, amount) {
+	const parts = [
+		bigintToBeBytes(bridgeId),
+		bigintToBeBytes(l2Sequence),
+		sha3_256(textEncoder.encode(sender)),
+		sha3_256(textEncoder.encode(receiver)),
+		sha3_256(textEncoder.encode(denom)),
+		bigintToBeBytes(amount)
+	];
+	const totalLength = parts.reduce((sum, p) => sum + p.length, 0);
+	const concat = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const part of parts) {
+		concat.set(part, offset);
+		offset += part.length;
+	}
+	return sha3_256(sha3_256(concat));
+}
+//#endregion
+//#region src/bridge/utils.ts
+/**
+* Convert protobuf Duration to milliseconds.
+*/
+function durationToMs(d) {
+	return Number(d.seconds) * 1e3 + Math.floor(d.nanos / 1e6);
+}
+/**
+* Convert protobuf Timestamp to milliseconds since epoch.
+*/
+function timestampToMs(t) {
+	return Number(t.seconds) * 1e3 + Math.floor(t.nanos / 1e6);
+}
+//#endregion
+//#region src/bridge/op-bridge.ts
+/**
+* Internal OP bridge implementation.
+* Use `provider.bridge` instead of instantiating directly.
+*/
+var OpBridgeInternal = class {
+	_l1Client;
+	constructor(provider, createTransport) {
+		this.provider = provider;
+		this.createTransport = createTransport;
+	}
+	/**
+	* Lazily create and cache the L1 ophost gRPC client.
+	* Finds L1 chain from provider automatically.
+	*/
+	getL1Client() {
+		if (this._l1Client) return this._l1Client;
+		const l1Chain = this.provider.listChains().find((c) => c.chainType === "initia");
+		if (!l1Chain) throw new Error("L1 (initia) chain not found in provider. Ensure the provider includes L1 chain info for withdrawal status queries.");
+		const config = initiaChain.build();
+		this._l1Client = wrapClientWithCache(createGrpcClient(this.createTransport(l1Chain), config.services, void 0, void 0, config.registry), l1Chain.chainId);
+		return this._l1Client;
+	}
+	/**
+	* Resolve bridgeId for a given L2 chain.
+	*
+	* @param l2ChainId - The L2 chain ID (e.g., 'minimove-1')
+	* @returns The bridge ID for the L2 chain
+	* @throws Error if chain is not found or has no opBridgeId
+	*/
+	getBridgeId(l2ChainId) {
+		const chainInfo = this.provider.getChainInfo(l2ChainId);
+		if (!chainInfo) throw new Error(`Chain not found: ${l2ChainId}`);
+		if (chainInfo.opBridgeId == null) throw new Error(`Chain ${l2ChainId} does not have an opBridgeId. Only L2 (minitia) chains support bridging.`);
+		return chainInfo.opBridgeId;
+	}
+	/**
+	* Create a MsgInitiateTokenDeposit for L1 → L2 transfer.
+	*
+	* @param options - Deposit options (use toChain for auto bridgeId resolve, or bridgeId directly)
+	* @returns Packed Message ready for signAndBroadcast
+	*/
+	deposit(options) {
+		const { sender, to, amount, data } = options;
+		const bridgeId = "toChain" in options && options.toChain ? this.getBridgeId(options.toChain) : options.bridgeId;
+		const resolvedCoin = typeof amount === "string" ? parseCoin(amount) : amount;
+		return new Message$1(MsgInitiateTokenDepositSchema, {
+			sender,
+			bridgeId: BigInt(bridgeId),
+			to: to ?? sender,
+			amount: create(CoinSchema, {
+				denom: resolvedCoin.denom,
+				amount: resolvedCoin.amount
+			}),
+			data: data ?? new Uint8Array()
+		});
+	}
+	/**
+	* Create a MsgInitiateTokenWithdrawal for L2 → L1 transfer.
+	*
+	* @param options - Withdrawal options
+	* @returns Packed Message ready for signAndBroadcast
+	*/
+	withdraw(options) {
+		const { sender, to, amount } = options;
+		const resolvedCoin = typeof amount === "string" ? parseCoin(amount) : amount;
+		return new Message$1(MsgInitiateTokenWithdrawalSchema, {
+			sender,
+			to: to ?? sender,
+			amount: create(CoinSchema, {
+				denom: resolvedCoin.denom,
+				amount: resolvedCoin.amount
+			})
+		});
+	}
+	/**
+	* Create a MsgFinalizeTokenWithdrawal to claim a withdrawal on L1.
+	*
+	* @param options - Claim options with sender and withdrawal info (must be 'claimable')
+	* @returns Packed Message ready for signAndBroadcast
+	* @throws Error if withdrawal status is not 'claimable'
+	*/
+	claim(options) {
+		const { sender, withdrawal } = options;
+		if (withdrawal.status.status !== "claimable") throw new Error(`Withdrawal is not claimable (current status: ${withdrawal.status.status})`);
+		return new Message$1(MsgFinalizeTokenWithdrawalSchema, {
+			sender,
+			bridgeId: withdrawal.bridgeId,
+			outputIndex: withdrawal.outputIndex,
+			withdrawalProofs: withdrawal.withdrawalProofs.map((p) => hexToBytes(p)),
+			from: withdrawal.from,
+			to: withdrawal.to,
+			sequence: withdrawal.sequence,
+			amount: create(CoinSchema, {
+				denom: withdrawal.amount.denom,
+				amount: withdrawal.amount.amount
+			}),
+			version: hexToBytes(withdrawal.version),
+			storageRoot: hexToBytes(withdrawal.storageRoot),
+			lastBlockHash: hexToBytes(withdrawal.lastBlockHash)
+		});
+	}
+	/**
+	* List all chains that support OPInit bridging.
+	*
+	* @returns Array of ChainInfo with opBridgeId defined
+	*/
+	listBridgeableChains() {
+		return this.provider.listChains().filter((c) => c.opBridgeId != null);
+	}
+	/**
+	* Fetch withdrawals for an address and determine their statuses via L1 queries.
+	*
+	* @param l2ChainId - The L2 chain ID (e.g., 'minimove-1')
+	* @param address - L2 sender address
+	* @param options - Pagination options for Executor API
+	* @returns Array of WithdrawalInfo with status determined
+	*/
+	async getWithdrawals(l2ChainId, address, options) {
+		const l2Info = this.provider.getChainInfo(l2ChainId);
+		if (!l2Info) throw new Error(`Chain not found: ${l2ChainId}`);
+		if (!l2Info.executorUri) throw new Error(`Chain ${l2ChainId} does not have an executorUri. Cannot fetch withdrawals.`);
+		if (l2Info.opBridgeId == null) throw new Error(`Chain ${l2ChainId} does not have an opBridgeId`);
+		const rawWithdrawals = await fetchWithdrawals(l2Info.executorUri, address, options);
+		if (rawWithdrawals.length === 0) return [];
+		const ophost = this.getL1Client().ophost;
+		const finalizationPeriod = (await ophost.bridge({ bridgeId: l2Info.opBridgeId })).bridgeConfig?.finalizationPeriod;
+		if (!finalizationPeriod) throw new Error("Bridge config missing finalizationPeriod");
+		const finalizationMs = durationToMs(finalizationPeriod);
+		let latestProposedIndex = 0n;
+		try {
+			const proposalsResponse = await ophost.outputProposals({
+				bridgeId: l2Info.opBridgeId,
+				pagination: {
+					reverse: true,
+					limit: 1n
+				}
+			});
+			if (proposalsResponse.outputProposals.length > 0) latestProposedIndex = proposalsResponse.outputProposals[0].outputIndex;
+		} catch (err) {
+			if (!isNotFoundError(err)) throw err;
+		}
+		const nonPendingIndices = [...new Set(rawWithdrawals.map((w) => w.outputIndex).filter((i) => i > 0n && i <= latestProposedIndex))];
+		const outputTimestamps = /* @__PURE__ */ new Map();
+		await Promise.all(nonPendingIndices.map(async (outputIndex) => {
+			try {
+				const response = await ophost.outputProposal({
+					bridgeId: l2Info.opBridgeId,
+					outputIndex
+				});
+				if (response.outputProposal?.l1BlockTime) outputTimestamps.set(outputIndex, timestampToMs(response.outputProposal.l1BlockTime));
+			} catch (err) {
+				if (!isNotFoundError(err)) throw err;
+			}
+		}));
+		const now = Date.now();
+		return Promise.all(rawWithdrawals.map(async (raw) => {
+			const status = await this.determineWithdrawalStatus(raw, outputTimestamps, latestProposedIndex, finalizationMs, now, ophost);
+			return {
+				...raw,
+				status
+			};
+		}));
+	}
+	/**
+	* Fetch a single withdrawal and determine its status.
+	*
+	* @param l2ChainId - The L2 chain ID
+	* @param sequence - Withdrawal sequence number
+	* @returns WithdrawalInfo with status determined
+	*/
+	async getWithdrawalStatus(l2ChainId, sequence) {
+		const l2Info = this.provider.getChainInfo(l2ChainId);
+		if (!l2Info) throw new Error(`Chain not found: ${l2ChainId}`);
+		if (!l2Info.executorUri) throw new Error(`Chain ${l2ChainId} does not have an executorUri. Cannot fetch withdrawal.`);
+		if (l2Info.opBridgeId == null) throw new Error(`Chain ${l2ChainId} does not have an opBridgeId`);
+		const raw = await fetchWithdrawal(l2Info.executorUri, sequence);
+		const ophost = this.getL1Client().ophost;
+		const finalizationPeriod = (await ophost.bridge({ bridgeId: l2Info.opBridgeId })).bridgeConfig?.finalizationPeriod;
+		if (!finalizationPeriod) throw new Error("Bridge config missing finalizationPeriod");
+		const finalizationMs = durationToMs(finalizationPeriod);
+		const outputTimestamps = /* @__PURE__ */ new Map();
+		let latestProposedIndex = 0n;
+		if (raw.outputIndex > 0n) try {
+			const response = await ophost.outputProposal({
+				bridgeId: l2Info.opBridgeId,
+				outputIndex: raw.outputIndex
+			});
+			if (response.outputProposal?.l1BlockTime) {
+				outputTimestamps.set(raw.outputIndex, timestampToMs(response.outputProposal.l1BlockTime));
+				latestProposedIndex = raw.outputIndex;
+			}
+		} catch (err) {
+			if (!isNotFoundError(err)) throw err;
+		}
+		const status = await this.determineWithdrawalStatus(raw, outputTimestamps, latestProposedIndex, finalizationMs, Date.now(), ophost);
+		return {
+			...raw,
+			status
+		};
+	}
+	/**
+	* Determine withdrawal status based on output proposals and finalization period.
+	*/
+	async determineWithdrawalStatus(raw, outputTimestamps, latestProposedIndex, finalizationMs, now, ophost) {
+		if (raw.outputIndex === 0n || raw.outputIndex > latestProposedIndex) return { status: "pending" };
+		const l1BlockTimeMs = outputTimestamps.get(raw.outputIndex);
+		if (l1BlockTimeMs == null) return { status: "pending" };
+		const claimableAt = new Date(l1BlockTimeMs + finalizationMs);
+		if (claimableAt.getTime() > now) return {
+			status: "waiting",
+			claimableAt
+		};
+		const hash = calculateWithdrawalHash(raw.bridgeId, raw.sequence, raw.from, raw.to, raw.amount.denom, BigInt(raw.amount.amount));
+		try {
+			if ((await ophost.claimed({
+				bridgeId: raw.bridgeId,
+				withdrawalHash: hash
+			})).claimed) return { status: "claimed" };
+		} catch (err) {
+			if (!isNotFoundError(err)) throw err;
+		}
+		return { status: "claimable" };
+	}
+};
+//#endregion
+//#region src/bridge/router-client.ts
+const INTERWOVENKIT_VERSION = "2.4.6";
+const routerRegistry = createRegistry(file_cosmos_bank_v1beta1_tx, file_ibc_applications_transfer_v1_tx, file_opinit_ophost_v1_tx, file_opinit_opchild_v1_tx, file_minievm_evm_v1_tx, file_initia_move_v1_tx);
+var RouterClient = class {
+	constructor(baseUrl) {
+		this.baseUrl = baseUrl;
+	}
+	async route(opts) {
+		const body = {
+			amount_in: opts.amount,
+			source_asset_chain_id: opts.source.chainId,
+			source_asset_denom: opts.source.denom,
+			dest_asset_chain_id: opts.dest.chainId,
+			dest_asset_denom: opts.dest.denom,
+			allow_unsafe: opts.allowUnsafe,
+			go_fast: opts.goFast,
+			is_op_withdraw: opts.isOpWithdraw
+		};
+		return normalizeRouteResponse(await (await this.post("/v2/fungible/route", body)).json());
+	}
+	async msgs(opts) {
+		const raw = opts.route._raw;
+		const body = {
+			amount_in: raw.amount_in,
+			amount_out: raw.amount_out,
+			source_asset_chain_id: raw.source_asset_chain_id,
+			source_asset_denom: raw.source_asset_denom,
+			dest_asset_chain_id: raw.dest_asset_chain_id,
+			dest_asset_denom: raw.dest_asset_denom,
+			address_list: opts.addresses,
+			operations: raw.operations,
+			slippage_tolerance_percent: opts.slippageTolerance ?? "1",
+			signed_op_hook: opts.signedOpHook,
+			ignore_blacklist: opts.ignoreBlacklist
+		};
+		return normalizeTransferTxs(await (await this.post("/v2/fungible/msgs", body)).json());
+	}
+	async opHook(opts) {
+		const body = {
+			source_address: opts.sourceAddress,
+			source_asset_chain_id: opts.sourceChainId,
+			source_asset_denom: opts.sourceDenom,
+			dest_address: opts.destAddress,
+			dest_asset_chain_id: opts.destChainId,
+			dest_asset_denom: opts.destDenom
+		};
+		return normalizeOpHookResponse(await (await this.post("/op-hook", body)).json());
+	}
+	async track(txHash, chainId) {
+		await this.post("/v2/tx/track", {
+			tx_hash: txHash,
+			chain_id: chainId
+		});
+	}
+	async assets(chainIds) {
+		const query = chainIds?.length ? `?chain_ids=${chainIds.join(",")}` : "";
+		return normalizeAssetsResponse(await (await this.get(`/v2/fungible/assets${query}`)).json());
+	}
+	async chains(chainIds) {
+		const query = chainIds?.length ? `?chain_ids=${chainIds.join(",")}` : "";
+		return normalizeChainsResponse(await (await this.get(`/v2/info/chains${query}`)).json());
+	}
+	async balances(queries) {
+		return normalizeBalancesResponse(await (await this.post("/v2/info/balances", { chains: queries })).json());
+	}
+	async nftTransfer(opts) {
+		const body = {
+			from_address: opts.fromAddress,
+			from_chain_id: opts.fromChainId,
+			to_address: opts.toAddress,
+			to_chain_id: opts.toChainId,
+			token_ids: opts.tokenIds,
+			collection_address: opts.collectionAddress
+		};
+		if (opts.classId) body.class_id = opts.classId;
+		if (opts.classTrace) body.class_trace = {
+			path: opts.classTrace.path,
+			base_class_id: opts.classTrace.baseClassId
+		};
+		if (opts.objectAddresses) body.object_addresses = opts.objectAddresses;
+		if (opts.l1RecoverAddress) body.l1_recover_address = opts.l1RecoverAddress;
+		if (opts.outgoingProxy) body.outgoing_proxy = opts.outgoingProxy;
+		if (opts.timeout !== void 0) body.timeout = opts.timeout;
+		if (opts.ignoreBlacklist) body.ignore_blacklist = opts.ignoreBlacklist;
+		return await (await this.post("/nft", body)).json();
+	}
+	async status(txHash, chainId) {
+		const params = new URLSearchParams({
+			tx_hash: txHash,
+			chain_id: chainId
+		});
+		return normalizeStatus(await (await this.get(`/v2/tx/status?${params.toString()}`)).json());
+	}
+	headers() {
+		return { "InterwovenKit-Version": INTERWOVENKIT_VERSION };
+	}
+	async throwIfNotOk(res, path) {
+		if (res.ok) return;
+		let detail = "";
+		try {
+			const body = await res.json();
+			if (body.message) detail = `: ${body.message}`;
+		} catch {}
+		throw new InitiaError(`Router API ${path} failed (${res.status})${detail}`);
+	}
+	async get(path) {
+		const res = await fetchWithTimeout(`${this.baseUrl}${path}`, { headers: this.headers() });
+		await this.throwIfNotOk(res, path);
+		return res;
+	}
+	async post(path, body) {
+		const res = await fetchWithTimeout(`${this.baseUrl}${path}`, {
+			method: "POST",
+			headers: {
+				...this.headers(),
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify(body)
+		});
+		await this.throwIfNotOk(res, path);
+		return res;
+	}
+};
+/**
+* Normalize route response. Preserves the entire raw response in `_raw`
+* so that buildTransferMsgs() can pass server-original data without loss.
+*/
+function normalizeRouteResponse(raw) {
+	return {
+		amountIn: raw.amount_in,
+		amountOut: raw.amount_out,
+		source: {
+			chainId: raw.source_asset_chain_id,
+			denom: raw.source_asset_denom,
+			symbol: raw.source_asset_symbol
+		},
+		dest: {
+			chainId: raw.dest_asset_chain_id,
+			denom: raw.dest_asset_denom,
+			symbol: raw.dest_asset_symbol
+		},
+		operations: normalizeOperations(raw.operations),
+		estimatedDurationSeconds: raw.estimated_duration_seconds,
+		usdAmountIn: raw.usd_amount_in,
+		usdAmountOut: raw.usd_amount_out,
+		warnings: raw.warnings,
+		extraInfos: raw.extra_infos,
+		extraWarnings: raw.extra_warnings,
+		requiresOpHook: raw.required_op_hook,
+		_raw: raw
+	};
+}
+/**
+* Normalize operations array (display-only; originals preserved in _raw).
+*/
+function normalizeOperations(raw) {
+	return raw.map((op) => {
+		const type = op.type ?? op.op_type;
+		switch (type) {
+			case "transfer": return {
+				type: "transfer",
+				chainId: op.chain_id ?? "",
+				channel: op.channel ?? "",
+				denomIn: op.denom_in ?? "",
+				denomOut: op.denom_out ?? ""
+			};
+			case "swap": return {
+				type: "swap",
+				poolId: op.pool_id ?? "",
+				denomIn: op.denom_in ?? "",
+				denomOut: op.denom_out ?? ""
+			};
+			default: return {
+				type,
+				denomIn: op.denom_in ?? "",
+				denomOut: op.denom_out ?? ""
+			};
+		}
+	});
+}
+/**
+* Normalize transfer transactions response.
+* Converts base64-encoded proto messages to SDK Message format.
+*/
+function normalizeTransferTxs(raw) {
+	return raw.txs.map((tx) => ({
+		chainId: tx.chain_id ?? tx.cosmos_tx?.chain_id ?? tx.evm_tx?.chain_id ?? "",
+		cosmosMsgs: normalizeCosmosMsgs(tx.cosmos_tx?.msgs),
+		evmTx: tx.evm_tx ? {
+			to: tx.evm_tx.to,
+			data: tx.evm_tx.data,
+			value: tx.evm_tx.value
+		} : void 0,
+		signerAddress: tx.signer_address ?? tx.cosmos_tx?.signer_address ?? tx.evm_tx?.signer_address ?? ""
+	}));
+}
+/**
+* Convert router API message format to SDK Message format.
+*
+* The Router API returns `msg` as a JSON string (snake_case),
+* not base64-encoded proto bytes. We use the routerRegistry to
+* resolve the schema, then `fromJson` → `toBinary` → `Any`.
+*/
+function normalizeCosmosMsgs(msgs) {
+	if (!msgs?.length) return void 0;
+	return msgs.map((m) => {
+		let value;
+		if (m.msg.startsWith("{")) {
+			const typeName = m.msg_type_url.replace(/^\//, "");
+			const desc = routerRegistry.getMessage(typeName);
+			if (!desc) throw new InitiaError(`Unknown router msg type: ${m.msg_type_url}`);
+			value = toBinary(desc, fromJson(desc, JSON.parse(m.msg)));
+		} else value = base64ToUint8Array(m.msg);
+		return Message$1.fromAny(create(AnySchema, {
+			typeUrl: m.msg_type_url,
+			value
+		}));
+	});
+}
+function normalizeOpHookResponse(raw) {
+	return {
+		chainId: raw.chain_id,
+		hook: raw.hook
+	};
+}
+function normalizeAssetsResponse(raw) {
+	const result = {};
+	for (const [chainId, { assets }] of Object.entries(raw.chain_to_assets_map)) result[chainId] = assets.map((a) => ({
+		denom: a.denom,
+		chainId: a.chain_id,
+		originDenom: a.origin_denom,
+		originChainId: a.origin_chain_id,
+		symbol: a.symbol,
+		name: a.name,
+		decimals: a.decimals,
+		logoUri: a.logo_uri,
+		recommendedSymbol: a.recommended_symbol,
+		description: a.description,
+		coingeckoId: a.coingecko_id,
+		trace: a.trace,
+		isCw20: a.is_cw20,
+		isEvm: a.is_evm,
+		isSvm: a.is_svm,
+		tokenContract: a.token_contract,
+		hidden: a.hidden,
+		forwardContract: a.forwardContract,
+		oftOwner: a.oftOwner
+	}));
+	return result;
+}
+function normalizeStatus(raw) {
+	return {
+		state: raw.state,
+		transfers: raw.transfers ?? [],
+		transferSequence: (raw.transfer_sequence ?? []).map((h) => ({
+			srcChainId: h.src_chain_id,
+			dstChainId: h.dst_chain_id,
+			state: h.state
+		})),
+		nextBlockingTransfer: raw.next_blocking_transfer ? { transferSequenceIndex: raw.next_blocking_transfer.transfer_sequence_index } : void 0,
+		transferAssetRelease: raw.transfer_asset_release ? {
+			chainId: raw.transfer_asset_release.chain_id,
+			denom: raw.transfer_asset_release.denom,
+			amount: raw.transfer_asset_release.amount ?? void 0,
+			released: raw.transfer_asset_release.released
+		} : void 0,
+		error: raw.error ?? void 0
+	};
+}
+function normalizeBalancesResponse(raw) {
+	const result = {};
+	for (const [chainId, chainData] of Object.entries(raw.chains ?? {})) {
+		result[chainId] = {};
+		for (const [denom, info] of Object.entries(chainData.denoms ?? {})) result[chainId][denom] = {
+			amount: info.amount,
+			priceUsd: info.price_usd,
+			valueUsd: info.value_usd
+		};
+	}
+	return result;
+}
+function normalizeChainsResponse(raw) {
+	return (raw.chains ?? []).map((c) => ({
+		chainId: c.chain_id,
+		chainName: c.chain_name,
+		chainType: c.chain_type,
+		pfmEnabled: c.pfm_enabled,
+		supportsMemo: c.supports_memo,
+		logoUri: c.logo_uri,
+		bech32Prefix: c.bech32_prefix,
+		rest: c.rest,
+		rpc: c.rpc,
+		evmFeeAsset: c.evm_fee_asset
+	}));
+}
+//#endregion
+//#region src/bridge/watch.ts
+/**
+* Extract events of a specific type from a WebSocket TxResult.
+* Returns an array of attribute maps for each matching event.
+*/
+function parseTxEvents(tx, eventType) {
+	const results = [];
+	const events = tx.result?.events ?? [];
+	for (const event of events) {
+		if (event.type !== eventType) continue;
+		const attrs = {};
+		for (const attr of event.attributes ?? []) if (attr.key && attr.value !== void 0) attrs[attr.key] = attr.value;
+		results.push(attrs);
+	}
+	return results;
+}
+function buildDepositFilter(eventType, opts, bridgeId) {
+	const conditions = [];
+	if (eventType === "initiate_token_deposit") {
+		if (bridgeId !== void 0) conditions.push(`initiate_token_deposit.bridge_id='${bridgeId}'`);
+		if (opts.l1Sequence !== void 0) conditions.push(`initiate_token_deposit.l1_sequence='${opts.l1Sequence}'`);
+		if (opts.sender) conditions.push(`initiate_token_deposit.from='${opts.sender}'`);
+		if (opts.recipient) conditions.push(`initiate_token_deposit.to='${opts.recipient}'`);
+	} else if (eventType === "finalize_token_deposit") {
+		if (opts.l1Sequence !== void 0) conditions.push(`finalize_token_deposit.l1_sequence='${opts.l1Sequence}'`);
+		if (opts.sender) conditions.push(`finalize_token_deposit.sender='${opts.sender}'`);
+		if (opts.recipient) conditions.push(`finalize_token_deposit.recipient='${opts.recipient}'`);
+	}
+	return conditions.length > 0 ? conditions.join(" AND ") : void 0;
+}
+function buildWithdrawalFilter(eventType, opts, bridgeId) {
+	const conditions = [];
+	if (eventType === "initiate_token_withdrawal") {
+		if (opts.l2Sequence !== void 0) conditions.push(`initiate_token_withdrawal.l2_sequence='${opts.l2Sequence}'`);
+		if (opts.sender) conditions.push(`initiate_token_withdrawal.from='${opts.sender}'`);
+	} else if (eventType === "propose_output") {
+		if (bridgeId !== void 0) conditions.push(`propose_output.bridge_id='${bridgeId}'`);
+	} else if (eventType === "finalize_token_withdrawal") {
+		if (bridgeId !== void 0) conditions.push(`finalize_token_withdrawal.bridge_id='${bridgeId}'`);
+		if (opts.l2Sequence !== void 0) conditions.push(`finalize_token_withdrawal.l2_sequence='${opts.l2Sequence}'`);
+	}
+	return conditions.length > 0 ? conditions.join(" AND ") : void 0;
+}
+/**
+* Watch deposit events in real-time via WebSocket.
+*
+* Subscribes to L1 initiate_token_deposit and L2 finalize_token_deposit events.
+* Call `handle.unsubscribe()` to stop watching and close connections.
+*/
+function watchDeposit(provider, options, callback) {
+	const l2Info = provider.getChainInfo(options.l2ChainId);
+	if (!l2Info) throw new Error(`Chain not found: ${options.l2ChainId}`);
+	const l1Info = provider.listChains().find((c) => c.chainType === "initia");
+	if (!l1Info) throw new Error("L1 (initia) chain not found in provider");
+	if (!l1Info.wss) throw new WebSocketNotAvailableError(l1Info.chainId);
+	if (!l2Info.wss) throw new WebSocketNotAvailableError(l2Info.chainId);
+	const bridgeId = l2Info.opBridgeId;
+	const sessions = [];
+	const subs = [];
+	let cleaned = false;
+	const cleanup = () => {
+		if (cleaned) return;
+		cleaned = true;
+		for (const sub of subs) sub.unsubscribe();
+		for (const session of sessions) session.close();
+		subs.length = 0;
+		sessions.length = 0;
+	};
+	const handleError = options.onError ?? ((err) => {
+		console.error("[initia.js] watchDeposit failed — watcher terminated. Provide onError to handle:", err);
+		cleanup();
+	});
+	const l1Session = createSession(l1Info);
+	sessions.push(l1Session);
+	const l1Filter = buildDepositFilter("initiate_token_deposit", options, bridgeId);
+	l1Session.subscribe({
+		event: "tx",
+		filter: l1Filter
+	}, (tx) => {
+		const events = parseTxEvents(tx, "initiate_token_deposit");
+		for (const attrs of events) {
+			if (options.l1Sequence !== void 0 && attrs.l1_sequence !== String(options.l1Sequence)) continue;
+			callback({
+				status: "initiated",
+				l1Sequence: BigInt(attrs.l1_sequence ?? "0"),
+				from: attrs.from ?? "",
+				to: attrs.to ?? "",
+				amount: attrs.amount ?? "0",
+				bridgeId: BigInt(attrs.bridge_id ?? "0")
+			});
+		}
+	}).then((sub) => {
+		if (!cleaned) subs.push(sub);
+		else sub.unsubscribe();
+	}).catch(handleError);
+	const l2Session = createSession(l2Info);
+	sessions.push(l2Session);
+	const l2Filter = buildDepositFilter("finalize_token_deposit", options);
+	l2Session.subscribe({
+		event: "tx",
+		filter: l2Filter
+	}, (tx) => {
+		const events = parseTxEvents(tx, "finalize_token_deposit");
+		for (const attrs of events) {
+			if (options.l1Sequence !== void 0 && attrs.l1_sequence !== String(options.l1Sequence)) continue;
+			callback({
+				status: "finalized",
+				l1Sequence: BigInt(attrs.l1_sequence ?? "0"),
+				recipient: attrs.recipient ?? "",
+				amount: attrs.amount ?? "0",
+				success: attrs.success === "true",
+				reason: attrs.reason || void 0
+			});
+		}
+	}).then((sub) => {
+		if (!cleaned) subs.push(sub);
+		else sub.unsubscribe();
+	}).catch(handleError);
+	return { unsubscribe: cleanup };
+}
+/**
+* Watch withdrawal events in real-time via WebSocket.
+*
+* Subscribes to L2 initiate_token_withdrawal, L1 propose_output, and
+* L1 finalize_token_withdrawal events. Emits 'waiting' and 'claimable'
+* events based on the finalization period.
+*
+* Call `handle.unsubscribe()` to stop watching and close connections.
+*/
+function watchWithdrawal(provider, options, callback, createTransport) {
+	const l2Info = provider.getChainInfo(options.l2ChainId);
+	if (!l2Info) throw new Error(`Chain not found: ${options.l2ChainId}`);
+	if (l2Info.opBridgeId == null) throw new Error(`Chain ${options.l2ChainId} has no opBridgeId`);
+	const l1Info = provider.listChains().find((c) => c.chainType === "initia");
+	if (!l1Info) throw new Error("L1 (initia) chain not found in provider");
+	if (!l1Info.wss) throw new WebSocketNotAvailableError(l1Info.chainId);
+	if (!l2Info.wss) throw new WebSocketNotAvailableError(l2Info.chainId);
+	const bridgeId = l2Info.opBridgeId;
+	const sessions = [];
+	const subs = [];
+	const timers = [];
+	let timeoutTimer = null;
+	let cleaned = false;
+	const cleanup = () => {
+		if (cleaned) return;
+		cleaned = true;
+		for (const sub of subs) sub.unsubscribe();
+		for (const session of sessions) session.close();
+		for (const timer of timers) clearTimeout(timer);
+		if (timeoutTimer) clearTimeout(timeoutTimer);
+		subs.length = 0;
+		sessions.length = 0;
+		timers.length = 0;
+	};
+	const handleError = options.onError ?? ((err) => {
+		console.error("[initia.js] watchWithdrawal failed — watcher terminated. Provide onError to handle:", err);
+		cleanup();
+	});
+	if (options.timeout) timeoutTimer = setTimeout(() => {
+		cleanup();
+		handleError(new TimeoutError("watchWithdrawal", options.timeout));
+	}, options.timeout);
+	const finalizationMsPromise = (async () => {
+		const config = initiaChain.build();
+		const fp = (await wrapClientWithCache(createGrpcClient(createTransport(l1Info), config.services, void 0, void 0, config.registry), l1Info.chainId).ophost.bridge({ bridgeId })).bridgeConfig?.finalizationPeriod;
+		if (!fp) throw new Error("Bridge config missing finalizationPeriod — cannot determine claimable timing");
+		return durationToMs(fp);
+	})();
+	finalizationMsPromise.catch((err) => {
+		cleanup();
+		handleError(err);
+	});
+	const l2Session = createSession(l2Info);
+	sessions.push(l2Session);
+	const l2Filter = buildWithdrawalFilter("initiate_token_withdrawal", options);
+	l2Session.subscribe({
+		event: "tx",
+		filter: l2Filter
+	}, (tx) => {
+		const events = parseTxEvents(tx, "initiate_token_withdrawal");
+		for (const attrs of events) {
+			if (options.l2Sequence !== void 0 && attrs.l2_sequence !== String(options.l2Sequence)) continue;
+			callback({
+				status: "initiated",
+				l2Sequence: BigInt(attrs.l2_sequence ?? "0"),
+				from: attrs.from ?? "",
+				to: attrs.to ?? "",
+				amount: attrs.amount ?? "0"
+			});
+		}
+	}).then((sub) => {
+		if (!cleaned) subs.push(sub);
+		else sub.unsubscribe();
+	}).catch(handleError);
+	const l1Session = createSession(l1Info);
+	sessions.push(l1Session);
+	const proposeFilter = buildWithdrawalFilter("propose_output", options, bridgeId);
+	l1Session.subscribe({
+		event: "tx",
+		filter: proposeFilter
+	}, (tx) => {
+		const events = parseTxEvents(tx, "propose_output");
+		for (const attrs of events) {
+			if (attrs.bridge_id !== String(bridgeId)) continue;
+			callback({
+				status: "proposed",
+				outputIndex: BigInt(attrs.output_index ?? "0"),
+				l2BlockNumber: BigInt(attrs.l2_block_number ?? "0")
+			});
+			finalizationMsPromise.then((ms) => {
+				if (cleaned) return;
+				callback({
+					status: "waiting",
+					claimableAt: new Date(Date.now() + ms)
+				});
+				const timer = setTimeout(() => {
+					if (!cleaned) callback({ status: "claimable" });
+				}, ms);
+				timers.push(timer);
+			}).catch((err) => {
+				if (!cleaned) handleError(err);
+			});
+		}
+	}).then((sub) => {
+		if (!cleaned) subs.push(sub);
+		else sub.unsubscribe();
+	}).catch(handleError);
+	const claimFilter = buildWithdrawalFilter("finalize_token_withdrawal", options, bridgeId);
+	l1Session.subscribe({
+		event: "tx",
+		filter: claimFilter
+	}, (tx) => {
+		const events = parseTxEvents(tx, "finalize_token_withdrawal");
+		for (const attrs of events) {
+			if (options.l2Sequence !== void 0 && attrs.l2_sequence !== String(options.l2Sequence)) continue;
+			callback({
+				status: "claimed",
+				l2Sequence: BigInt(attrs.l2_sequence ?? "0"),
+				from: attrs.from ?? "",
+				to: attrs.to ?? "",
+				amount: attrs.amount ?? "0"
+			});
+		}
+	}).then((sub) => {
+		if (!cleaned) subs.push(sub);
+		else sub.unsubscribe();
+	}).catch(handleError);
+	return { unsubscribe: cleanup };
+}
+/**
+* Generic helper: watch for a specific event status and wrap in a Promise.
+* Resolves on matching event, rejects on error or timeout.
+*/
+function waitForEvent(watchFn, provider, options, targetStatus, defaultTimeout, label) {
+	return new Promise((resolve, reject) => {
+		const timeout = options.timeout ?? defaultTimeout;
+		let settled = false;
+		const settle = () => {
+			if (settled) return false;
+			settled = true;
+			handle.unsubscribe();
+			if (timer) clearTimeout(timer);
+			return true;
+		};
+		const handle = watchFn(provider, {
+			...options,
+			timeout: void 0,
+			onError: (err) => {
+				options.onError?.(err);
+				if (settle()) reject(err instanceof Error ? err : new Error(String(err)));
+			}
+		}, (event) => {
+			if (event.status === targetStatus && settle()) resolve(event);
+		});
+		const timer = setTimeout(() => {
+			if (settle()) reject(new TimeoutError(label, timeout));
+		}, timeout);
+	});
+}
+/**
+* Wait for a deposit to be finalized on L2.
+*
+* Returns a Promise that resolves when the finalize_token_deposit event
+* is observed on L2. Rejects on timeout (default: 5 minutes).
+*/
+function waitForDeposit(provider, options) {
+	return waitForEvent(watchDeposit, provider, options, "finalized", 3e5, "waitForDeposit");
+}
+/**
+* Wait for a withdrawal to become claimable on L1.
+*
+* Returns a Promise that resolves when the finalization period passes
+* after an output proposal. Rejects on timeout (default: 2 hours).
+*/
+function waitForClaimable(provider, options, createTransport) {
+	const watchFn = (p, opts, cb) => watchWithdrawal(p, opts, cb, createTransport);
+	return waitForEvent(watchFn, provider, options, "claimable", 72e5, "waitForClaimable");
+}
+//#endregion
+//#region src/bridge/bridge.ts
+var Bridge = class {
+	opBridge;
+	router;
+	constructor(provider, createTransport, routerUrl) {
+		this.provider = provider;
+		this.createTransport = createTransport;
+		this.opBridge = new OpBridgeInternal(provider, createTransport);
+		if (routerUrl) this.router = new RouterClient(routerUrl);
+	}
+	deposit(options) {
+		return this.opBridge.deposit(options);
+	}
+	withdraw(options) {
+		return this.opBridge.withdraw(options);
+	}
+	claim(options) {
+		return this.opBridge.claim(options);
+	}
+	getWithdrawals(l2ChainId, address, options) {
+		return this.opBridge.getWithdrawals(l2ChainId, address, options);
+	}
+	getWithdrawalStatus(l2ChainId, sequence) {
+		return this.opBridge.getWithdrawalStatus(l2ChainId, sequence);
+	}
+	listBridgeableChains() {
+		return this.opBridge.listBridgeableChains();
+	}
+	getBridgeId(l2ChainId) {
+		return this.opBridge.getBridgeId(l2ChainId);
+	}
+	requireRouter() {
+		if (!this.router) throw new InitiaError("Router API not available for this network");
+		return this.router;
+	}
+	route(options) {
+		return this.requireRouter().route(options);
+	}
+	getRoutableAssets(chainIds) {
+		return this.requireRouter().assets(chainIds);
+	}
+	/**
+	* 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', ... }
+	* ```
+	*/
+	async resolveAsset(chainId, symbol) {
+		const matches = (await this.getRoutableAssets([chainId]))[chainId]?.filter((a) => a.symbol === symbol) ?? [];
+		if (matches.length === 0) throw new InitiaError(`No asset with symbol '${symbol}' found on chain '${chainId}'`);
+		if (matches.length > 1) {
+			const denoms = matches.map((a) => a.denom).join(", ");
+			throw new InitiaError(`Ambiguous symbol '${symbol}' on chain '${chainId}': ${matches.length} matches (${denoms}). Use getRoutableAssets() and specify denom directly.`);
+		}
+		return matches[0];
+	}
+	getRoutableChains(chainIds) {
+		return this.requireRouter().chains(chainIds);
+	}
+	getBalances(queries) {
+		return this.requireRouter().balances(queries);
+	}
+	nftTransfer(options) {
+		return this.requireRouter().nftTransfer(options);
+	}
+	buildTransferMsgs(options) {
+		return this.requireRouter().msgs(options);
+	}
+	getOpHook(options) {
+		return this.requireRouter().opHook(options);
+	}
+	/**
+	* 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
+	*/
+	async signOpHook(hookResult, signer, options) {
+		const chainInfo = this.provider.getChainInfo(hookResult.chainId);
+		if (!chainInfo) throw new InitiaError(`Chain not found: ${hookResult.chainId}`);
+		const registry = resolveRegistry(chainInfo);
+		const messages = hookResult.hook.map((hookMsg) => {
+			const typeUrl = hookMsg.msg_type_url;
+			const typeName = typeUrl.startsWith("/") ? typeUrl.slice(1) : typeUrl;
+			const schema = registry.getMessage(typeName);
+			if (!schema) throw new InitiaError(`Unknown message type in opHook: ${typeUrl}. Ensure the chain config includes this message schema.`);
+			let parsed;
+			try {
+				parsed = JSON.parse(hookMsg.msg);
+			} catch (err) {
+				throw new InitiaError(`Failed to parse opHook message JSON (type: ${typeUrl}): ` + (err instanceof Error ? err.message : String(err)));
+			}
+			let msg;
+			try {
+				msg = fromJson(schema, parsed, { registry });
+			} catch (err) {
+				throw new InitiaError(`Failed to deserialize opHook message (type: ${typeUrl}): ` + (err instanceof Error ? err.message : String(err)));
+			}
+			return new Message$1(schema, msg);
+		});
+		let signMode;
+		if (options?.signMode) signMode = options.signMode;
+		else switch (true) {
+			case isEIP191Signer(signer):
+				signMode = "eip191";
+				break;
+			case isDirectSigner(signer):
+				signMode = "direct";
+				break;
+			case isAminoSigner(signer):
+				signMode = "amino";
+				break;
+			default: throw new InitiaError("Signer must support signDirect, signAmino, or signPersonal");
+		}
+		if (signMode === "direct" && !isDirectSigner(signer)) throw new InitiaError("signMode \"direct\" requires a signer that implements signDirect");
+		if (signMode === "amino" && !isAminoSigner(signer)) throw new InitiaError("signMode \"amino\" requires a signer that implements signAmino");
+		if (signMode === "eip191" && !isEIP191Signer(signer)) throw new InitiaError("signMode \"eip191\" requires a signer that implements signPersonal");
+		const ctx = buildChainContextFactory(this.createTransport, resolveServices, resolveMsgs)(chainInfo, { signer });
+		const prefix = chainInfo.bech32Prefix ?? "init";
+		const address = await signer.getAddress(prefix);
+		let accountNumber = 0n;
+		let sequence = 0n;
+		try {
+			const account = await ctx.getAccount({ address });
+			accountNumber = account.number;
+			sequence = account.sequence;
+		} catch (err) {
+			if (!isNotFoundError(err)) throw err;
+		}
+		if (options?.sourceChainId === hookResult.chainId) sequence += 2n;
+		const unsignedTx = new UnsignedTx({
+			msgs: messages,
+			signMode,
+			chainId: hookResult.chainId,
+			accountNumber,
+			sequence,
+			fee: [],
+			gasLimit: 0n,
+			memo: "",
+			timeoutHeight: 0n
+		});
+		const signed = await ctx.sign(unsignedTx);
+		return {
+			hook: base64.encode(signed.txBytes),
+			signer: address
+		};
+	}
+	trackTransfer(txHash, chainId) {
+		return this.requireRouter().track(txHash, chainId);
+	}
+	getTransferStatus(txHash, chainId) {
+		return this.requireRouter().status(txHash, chainId);
+	}
+	watchDeposit(options, callback) {
+		return watchDeposit(this.provider, options, callback);
+	}
+	watchWithdrawal(options, callback) {
+		return watchWithdrawal(this.provider, options, callback, this.createTransport);
+	}
+	waitForDeposit(options) {
+		return waitForDeposit(this.provider, options);
+	}
+	waitForClaimable(options) {
+		return waitForClaimable(this.provider, options, this.createTransport);
+	}
+	/**
+	* 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'
+	* ```
+	*/
+	async depositAndWait(options) {
+		const msg = this.deposit({
+			sender: options.sender,
+			to: options.to,
+			toChain: options.toChain,
+			amount: options.amount,
+			data: options.data
+		});
+		await options.signAndBroadcast([msg]);
+		return this.waitForDeposit({
+			l2ChainId: options.toChain,
+			sender: options.sender,
+			recipient: options.to ?? options.sender,
+			timeout: options.timeout
+		});
+	}
+	/**
+	* 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),
+	* })
+	* ```
+	*/
+	async withdrawAndClaim(options) {
+		const withdrawMsg = this.withdraw({
+			sender: options.sender,
+			to: options.to,
+			amount: options.amount
+		});
+		await options.signAndBroadcastL2([withdrawMsg]);
+		await this.waitForClaimable({
+			l2ChainId: options.l2ChainId,
+			sender: options.sender,
+			timeout: options.timeout
+		});
+		const recipient = options.to ?? options.sender;
+		const claimable = (await this.getWithdrawals(options.l2ChainId, recipient)).find((w) => w.status.status === "claimable");
+		if (!claimable) throw new InitiaError("No claimable withdrawal found after finalization");
+		const claimMsg = this.claim({
+			sender: recipient,
+			withdrawal: claimable
+		});
+		await options.signAndBroadcastL1([claimMsg]);
+		return claimable;
+	}
+};
+//#endregion
+export { watchWithdrawal as a, fetchWithdrawals as c, watchDeposit as i, waitForClaimable as n, calculateWithdrawalHash as o, waitForDeposit as r, fetchWithdrawal as s, Bridge as t };
+
+//# sourceMappingURL=bridge-DL-q-7P7.mjs.map