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

package/dist/broadcast-De8MdmYa.mjs

@@ -0,0 +1,974 @@
+import { i as file_amino_amino, o as file_cosmos_proto_cosmos, s as file_gogoproto_gogo } from "./amino_pb-Bi6YDY_U.mjs";
+import { d as ParseError, f as SimulationError, g as isNotFoundError, i as BroadcastError, t as AccountNotFoundError } from "./errors-CN1MFOLv.mjs";
+import { n as DecCoin, t as Coin } from "./coin-DPWbtAFA.mjs";
+import { c as normalizeMsg } from "./types-CSS5rfW1.mjs";
+import { _ as TxBodySchema, f as AuthInfoSchema, g as SignerInfoSchema, m as ModeInfoSchema, o as MultiSignature, p as FeeSchema, v as TxRawSchema, x as SignMode, y as TxSchema } from "./public-key-DV-uGaUC.mjs";
+import { c as makeSignBytes, n as createSignedTx } from "./sign-DqagxLcg.mjs";
+import { r as validateHeaderConflict } from "./headers-CMO7ia_D.mjs";
+import { t as httpRequest } from "./http-client-BrdVurTg.mjs";
+import { t as BroadcastMode } from "./service_pb-Be-O-2-c.mjs";
+import { create, toBinary } from "@bufbuild/protobuf";
+import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2";
+import { anyIs, anyUnpack, file_google_protobuf_any } from "@bufbuild/protobuf/wkt";
+//#region src/core/coins.ts
+/**
+* Coins module - Immutable, Map-backed multi-denom coin collection.
+*/
+/**
+* Immutable collection of coins, keyed by denom.
+*
+* Duplicate denoms are merged (summed) on construction and on every arithmetic
+* operation.  All mutating operations return new `Coins` instances.
+*
+* @example
+* ```typescript
+* const wallet = new Coins({ uinit: 1000, uusdc: 500 })
+* const fee    = new Coins([new Coin('uinit', 200)])
+* const after  = wallet.sub(fee)
+* console.log(after.toString()) // '800uinit,500uusdc'
+* ```
+*/
+var Coins = class Coins {
+	_map;
+	constructor(input) {
+		this._map = /* @__PURE__ */ new Map();
+		if (!input) return;
+		if (input instanceof Coins) for (const c of input) this._merge(c);
+		else if (Array.isArray(input)) for (const c of input) this._merge(new Coin(c.denom, c.amount));
+		else for (const [denom, amount] of Object.entries(input)) this._merge(new Coin(denom, amount));
+	}
+	_merge(c) {
+		const existing = this._map.get(c.denom);
+		this._map.set(c.denom, existing ? existing.add(c) : c);
+	}
+	/** Return the Coin for the given denom, or undefined. */
+	get(denom) {
+		return this._map.get(denom);
+	}
+	/** True if the collection contains the given denom. */
+	has(denom) {
+		return this._map.has(denom);
+	}
+	/** Sorted list of all denoms in this collection. */
+	denoms() {
+		return [...this._map.keys()].sort();
+	}
+	/** True when the collection has no coins. */
+	isEmpty() {
+		return this._map.size === 0;
+	}
+	[Symbol.iterator]() {
+		return this.toArray()[Symbol.iterator]();
+	}
+	/** Return all coins sorted by denom. */
+	toArray() {
+		return [...this._map.values()].sort((a, b) => a.denom.localeCompare(b.denom));
+	}
+	/**
+	* Add a single Coin or another Coins collection.
+	* Coins with the same denom are summed; new denoms are inserted.
+	*/
+	add(other) {
+		const items = other instanceof Coin ? [other] : other.toArray();
+		return new Coins([...this.toArray(), ...items]);
+	}
+	/**
+	* Subtract coins. Allows negative amounts for intermediate calculations.
+	*/
+	sub(other) {
+		const negated = (other instanceof Coin ? [other] : other.toArray()).map((c) => new Coin(c.denom, -c.amountBigInt));
+		return new Coins([...this.toArray(), ...negated]);
+	}
+	/**
+	* Subtract coins, throwing if any resulting amount is negative.
+	* Use this when the result must be valid for on-chain submission.
+	*/
+	safeSub(other) {
+		const result = this.sub(other);
+		for (const c of result) if (c.amountBigInt < 0n) throw new Error(`Insufficient balance for ${c.denom}: would result in ${c.amount}`);
+		return result;
+	}
+	/**
+	* Multiply all coins by a scalar value.
+	*/
+	mul(n) {
+		return new Coins(this.toArray().map((c) => c.mul(n)));
+	}
+	/** Map over sorted coins and return an array of results. */
+	map(fn) {
+		return this.toArray().map(fn);
+	}
+	/** Return a new Coins containing only coins matching the predicate. */
+	filter(fn) {
+		return new Coins(this.toArray().filter(fn));
+	}
+	/** Return the first coin satisfying the predicate, or undefined. */
+	find(fn) {
+		return this.toArray().find(fn);
+	}
+	/** Return proto messages array, sorted by denom. */
+	toProto() {
+		return this.toArray().map((c) => c.toProto());
+	}
+	/** Return plain `{ denom, amount }` array (for JSON.stringify). */
+	toJSON() {
+		return this.toArray().map((c) => c.toJSON());
+	}
+	/** Return Amino-compatible `{ denom, amount }` array. */
+	toAmino() {
+		return this.toArray().map((c) => c.toAmino());
+	}
+	/**
+	* Format as a comma-separated coin string, sorted by denom.
+	*
+	* @example
+	* ```typescript
+	* new Coins({ uinit: 1000, uusdc: 500 }).toString()
+	* // '1000uinit,500uusdc'
+	* ```
+	*/
+	toString() {
+		return this.toArray().map((c) => `${c.amount}${c.denom}`).join(",");
+	}
+	/**
+	* Convert each Coin to a DecCoin (18 fractional decimal places) and return
+	* a DecCoins collection.
+	*/
+	toDecCoins() {
+		return new DecCoins(this.toArray().map((c) => c.toDecCoin()));
+	}
+};
+/**
+* Immutable collection of decimal coins, keyed by denom.
+*
+* Duplicate denoms are merged (summed) on construction and on every arithmetic
+* operation.  All mutating operations return new `DecCoins` instances.
+*
+* @example
+* ```typescript
+* const fees = new DecCoins({ uinit: '1.5', uusdc: '0.5' })
+* const extra = new DecCoins([new DecCoin('uinit', '0.5')])
+* const total = fees.add(extra)
+* console.log(total.toString()) // '2.000000000000000000uinit,0.5uusdc'
+* ```
+*/
+var DecCoins = class DecCoins {
+	_map;
+	constructor(input) {
+		this._map = /* @__PURE__ */ new Map();
+		if (!input) return;
+		if (input instanceof DecCoins) for (const c of input) this._merge(c);
+		else if (Array.isArray(input)) for (const c of input) this._merge(new DecCoin(c.denom, c.amount));
+		else for (const [denom, amount] of Object.entries(input)) this._merge(new DecCoin(denom, amount));
+	}
+	_merge(c) {
+		const existing = this._map.get(c.denom);
+		this._map.set(c.denom, existing ? existing.add(c) : c);
+	}
+	/** Return the DecCoin for the given denom, or undefined. */
+	get(denom) {
+		return this._map.get(denom);
+	}
+	/** True if the collection contains the given denom. */
+	has(denom) {
+		return this._map.has(denom);
+	}
+	/** Sorted list of all denoms in this collection. */
+	denoms() {
+		return [...this._map.keys()].sort();
+	}
+	/** True when the collection has no coins. */
+	isEmpty() {
+		return this._map.size === 0;
+	}
+	[Symbol.iterator]() {
+		return this.toArray()[Symbol.iterator]();
+	}
+	/** Return all coins sorted by denom. */
+	toArray() {
+		return [...this._map.values()].sort((a, b) => a.denom.localeCompare(b.denom));
+	}
+	/**
+	* Add a single DecCoin or another DecCoins collection.
+	* Coins with the same denom are summed; new denoms are inserted.
+	*/
+	add(other) {
+		const items = other instanceof DecCoin ? [other] : other.toArray();
+		return new DecCoins([...this.toArray(), ...items]);
+	}
+	/**
+	* Subtract coins. Allows negative amounts for intermediate calculations.
+	*/
+	sub(other) {
+		const negated = (other instanceof DecCoin ? [other] : other.toArray()).map((c) => c.mul(-1));
+		return new DecCoins([...this.toArray(), ...negated]);
+	}
+	/**
+	* Subtract coins, throwing if any resulting amount is negative.
+	* Use this when the result must be valid for on-chain submission.
+	*/
+	safeSub(other) {
+		const result = this.sub(other);
+		for (const c of result) if (c.amount.startsWith("-")) throw new Error(`Insufficient balance for ${c.denom}: would result in ${c.amount}`);
+		return result;
+	}
+	/**
+	* Multiply all coins by a scalar value.
+	*/
+	mul(n) {
+		return new DecCoins(this.toArray().map((c) => c.mul(n)));
+	}
+	/** Map over sorted coins and return an array of results. */
+	map(fn) {
+		return this.toArray().map(fn);
+	}
+	/** Return a new DecCoins containing only coins matching the predicate. */
+	filter(fn) {
+		return new DecCoins(this.toArray().filter(fn));
+	}
+	/** Return the first coin satisfying the predicate, or undefined. */
+	find(fn) {
+		return this.toArray().find(fn);
+	}
+	/** Return proto messages array, sorted by denom. */
+	toProto() {
+		return this.toArray().map((c) => c.toProto());
+	}
+	/** Return plain `{ denom, amount }` array (for JSON.stringify). */
+	toJSON() {
+		return this.toArray().map((c) => c.toJSON());
+	}
+	/** Return Amino-compatible `{ denom, amount }` array. */
+	toAmino() {
+		return this.toArray().map((c) => c.toAmino());
+	}
+	/**
+	* Format as a comma-separated coin string, sorted by denom.
+	*
+	* @example
+	* ```typescript
+	* new DecCoins({ uinit: '1.5', uusdc: '0.5' }).toString()
+	* // '1.5uinit,0.5uusdc'
+	* ```
+	*/
+	toString() {
+		return this.toArray().map((c) => `${c.amount}${c.denom}`).join(",");
+	}
+	/**
+	* Convert each DecCoin to an integer Coin by truncating toward zero.
+	* Collects results into a new `Coins` collection.
+	*/
+	toIntCoins() {
+		return new Coins(this.toArray().map((c) => c.toIntCoin()));
+	}
+	/**
+	* Convert each DecCoin to an integer Coin by ceiling away from zero.
+	* Collects results into a new `Coins` collection.
+	*/
+	toIntCeilCoins() {
+		return new Coins(this.toArray().map((c) => c.toIntCeilCoin()));
+	}
+};
+//#endregion
+//#region node_modules/@buf/cosmos_cosmos-sdk.bufbuild_es/cosmos/auth/v1beta1/auth_pb.js
+/**
+* Describes the file cosmos/auth/v1beta1/auth.proto.
+*/
+const file_cosmos_auth_v1beta1_auth = /* @__PURE__ */ fileDesc("Ch5jb3Ntb3MvYXV0aC92MWJldGExL2F1dGgucHJvdG8SE2Nvc21vcy5hdXRoLnYxYmV0YTEi9wEKC0Jhc2VBY2NvdW50EikKB2FkZHJlc3MYASABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZxJOCgdwdWJfa2V5GAIgASgLMhQuZ29vZ2xlLnByb3RvYnVmLkFueUIn6t4fFHB1YmxpY19rZXksb21pdGVtcHR5ouewKgpwdWJsaWNfa2V5EhYKDmFjY291bnRfbnVtYmVyGAMgASgEEhAKCHNlcXVlbmNlGAQgASgEOkOIoB8A6KAfAMq0LRxjb3Ntb3MuYXV0aC52MWJldGExLkFjY291bnRJiuewKhZjb3Ntb3Mtc2RrL0Jhc2VBY2NvdW50IswBCg1Nb2R1bGVBY2NvdW50EjwKDGJhc2VfYWNjb3VudBgBIAEoCzIgLmNvc21vcy5hdXRoLnYxYmV0YTEuQmFzZUFjY291bnRCBNDeHwESDAoEbmFtZRgCIAEoCRITCgtwZXJtaXNzaW9ucxgDIAMoCTpaiKAfAMq0LSJjb3Ntb3MuYXV0aC52MWJldGExLk1vZHVsZUFjY291bnRJiuewKhhjb3Ntb3Mtc2RrL01vZHVsZUFjY291bnSS57AqDm1vZHVsZV9hY2NvdW50ImgKEE1vZHVsZUNyZWRlbnRpYWwSEwoLbW9kdWxlX25hbWUYASABKAkSFwoPZGVyaXZhdGlvbl9rZXlzGAIgAygMOiaK57AqIWNvc21vcy1zZGsvR3JvdXBBY2NvdW50Q3JlZGVudGlhbCL3AQoGUGFyYW1zEhsKE21heF9tZW1vX2NoYXJhY3RlcnMYASABKAQSFAoMdHhfc2lnX2xpbWl0GAIgASgEEh0KFXR4X3NpemVfY29zdF9wZXJfYnl0ZRgDIAEoBBI5ChdzaWdfdmVyaWZ5X2Nvc3RfZWQyNTUxORgEIAEoBEIY4t4fFFNpZ1ZlcmlmeUNvc3RFRDI1NTE5Ej0KGXNpZ192ZXJpZnlfY29zdF9zZWNwMjU2azEYBSABKARCGuLeHxZTaWdWZXJpZnlDb3N0U2VjcDI1NmsxOiHooB8BiuewKhhjb3Ntb3Mtc2RrL3gvYXV0aC9QYXJhbXNCK1opZ2l0aHViLmNvbS9jb3Ntb3MvY29zbW9zLXNkay94L2F1dGgvdHlwZXNiBnByb3RvMw", [
+	file_amino_amino,
+	file_cosmos_proto_cosmos,
+	file_gogoproto_gogo,
+	file_google_protobuf_any
+]);
+/**
+* Describes the message cosmos.auth.v1beta1.BaseAccount.
+* Use `create(BaseAccountSchema)` to create a new message.
+*/
+const BaseAccountSchema = /* @__PURE__ */ messageDesc(file_cosmos_auth_v1beta1_auth, 0);
+//#endregion
+//#region src/core/account.ts
+/**
+* Query account information from chain.
+*
+* @param client - gRPC client with auth service
+* @param address - Bech32 address to query
+* @param options - Query options (height for historical query)
+* @returns Account information (address, number, sequence)
+* @throws {AccountNotFoundError} If account doesn't exist on chain
+*
+* @example
+* ```typescript
+* const account = await getAccount(client, 'init1...')
+* console.log('Account number:', account.number)
+* console.log('Sequence:', account.sequence)
+* ```
+*/
+async function getAccount(client, address, options) {
+	const queryOptions = options?.height !== void 0 ? { height: options.height } : void 0;
+	const response = await client.auth.account({ address }, queryOptions);
+	if (!response.account) throw new AccountNotFoundError(address);
+	if (anyIs(response.account, BaseAccountSchema)) {
+		const baseAccount = anyUnpack(response.account, BaseAccountSchema);
+		if (!baseAccount) throw new AccountNotFoundError(address);
+		return {
+			address,
+			number: baseAccount.accountNumber,
+			sequence: baseAccount.sequence
+		};
+	}
+	throw new Error(`Unsupported account type: ${response.account.typeUrl}`);
+}
+//#endregion
+//#region src/client/gas.ts
+/**
+* Gas estimation module - Estimate gas for transactions.
+*/
+/**
+* Parse gas price string into denom and amount.
+* @param gasPrice - e.g., '0.015uinit'
+* @returns { amount: string, denom: string }
+*/
+function parseGasPrice(gasPrice) {
+	const match = gasPrice.match(/^([\d.]+)(.+)$/);
+	if (!match) throw new ParseError("gasPrice", `Invalid format: ${gasPrice}`);
+	return {
+		amount: match[1],
+		denom: match[2]
+	};
+}
+/**
+* Calculate fee from gas limit and gas price.
+*/
+function calculateFee(gasLimit, gasPrice) {
+	const { amount, denom } = parseGasPrice(gasPrice);
+	return [new Coin(denom, mulBigIntByFloat(gasLimit, parseFloat(amount)))];
+}
+/**
+* Multiply a bigint by a float using fixed-point arithmetic.
+* Avoids Number(bigint) precision loss for values > 2^53.
+* The multiplier is scaled to 6 decimal places and ceiled, so the result
+* may be slightly above the true mathematical ceiling. This is safe for
+* gas estimation (always rounds in the user's favor).
+*/
+function mulBigIntByFloat(value, multiplier) {
+	if (!Number.isFinite(multiplier) || multiplier < 0) throw new ParseError("multiplier", `Expected a non-negative finite number, got: ${multiplier}`);
+	const PRECISION = 1000000n;
+	return (value * BigInt(Math.ceil(multiplier * Number(PRECISION))) + PRECISION - 1n) / PRECISION;
+}
+/**
+* Estimate gas for a transaction.
+*
+* Uses the simulate endpoint to get accurate gas estimation.
+*
+* @param client - gRPC client with tx service
+* @param msgs - Messages to estimate gas for
+* @param signer - Signer address (for simulation)
+* @param options - Estimation options
+* @returns Gas estimate with fee
+*
+* @example
+* ```typescript
+* const estimate = await estimateGas(client, [sendMsg], wallet.address, {
+*   multiplier: 1.3,
+*   gasPrice: '0.015uinit'
+* })
+*
+* console.log('Gas limit:', estimate.gasLimit)
+* console.log('Fee:', estimate.fee)
+* ```
+*/
+async function estimateGas(client, msgs, signer, options) {
+	const multiplier = options?.multiplier ?? 1.3;
+	const gasPrice = options?.gasPrice ?? "0.015uinit";
+	let sequence = 0n;
+	try {
+		sequence = (await getAccount(client, signer)).sequence;
+	} catch (error) {
+		if (!(error instanceof AccountNotFoundError) && !isNotFoundError(error)) throw error;
+	}
+	const txBody = create(TxBodySchema, {
+		messages: msgs.map((m) => normalizeMsg(m).toAny()),
+		memo: "",
+		timeoutHeight: 0n,
+		extensionOptions: [],
+		nonCriticalExtensionOptions: []
+	});
+	const signerInfo = create(SignerInfoSchema, {
+		publicKey: void 0,
+		modeInfo: create(ModeInfoSchema, { sum: {
+			case: "single",
+			value: { mode: SignMode.DIRECT }
+		} }),
+		sequence
+	});
+	const fee = create(FeeSchema, {
+		amount: [],
+		gasLimit: 0n,
+		payer: "",
+		granter: ""
+	});
+	const tx = create(TxSchema, {
+		body: txBody,
+		authInfo: create(AuthInfoSchema, {
+			signerInfos: [signerInfo],
+			fee,
+			tip: void 0
+		}),
+		signatures: [new Uint8Array(64)]
+	});
+	const response = await client.tx.simulate({ tx });
+	if (!response.gasInfo) throw new SimulationError("No gas info returned");
+	const gasUsed = response.gasInfo.gasUsed;
+	const gasLimit = mulBigIntByFloat(gasUsed, multiplier);
+	return {
+		gasLimit,
+		fee: calculateFee(gasLimit, gasPrice)
+	};
+}
+/**
+* Fetch the on-chain gas prices for a chain.
+*
+* Automatically detects chain type:
+* - L1 (Initia): queries `initiaTx.gasPrices`
+* - L2 (rollup): queries `opchild.params.minGasPrices`
+*
+* @param client - gRPC client with either `initiaTx` or `opchild` service
+* @returns DecCoins collection of gas prices per denom
+* @throws Error if neither `initiaTx` nor `opchild` service is available
+*
+* @example
+* ```typescript
+* // L1
+* const prices = await getGasPrices(client)
+* console.log(prices.get('uinit')?.amount) // '0.015000000000000000'
+*
+* // L2 rollup
+* const prices = await getGasPrices(l2Client)
+* ```
+*/
+async function getGasPrices(client) {
+	if (client.initiaTx) return new DecCoins((await client.initiaTx.gasPrices({})).gasPrices);
+	if (client.opchild) {
+		const res = await client.opchild.params({});
+		if (!res.params) throw new Error("getGasPrices: opchild.params() returned no params");
+		return new DecCoins(res.params.minGasPrices);
+	}
+	throw new Error("Cannot determine gas prices: client has neither initiaTx nor opchild service");
+}
+//#endregion
+//#region src/tx/unsigned-tx.ts
+/**
+* Unsigned transaction with all structured data needed to produce a signed transaction.
+*
+* Encoding (bodyBytes, authInfoBytes) is deferred to the signing step based on signMode.
+* For multisig workflows, use getMultisigSignBytes() and assembleMultisig().
+*
+* @example
+* ```typescript
+* // Standard single-key signing
+* const signedTx = await key.sign(unsignedTx)
+*
+* // Multisig signing
+* const signBytes = unsignedTx.getMultisigSignBytes(mpk)
+* const sig = await key.sign(signBytes)
+* const signedTx = unsignedTx.assembleMultisig(mpk, [{ index: 0, signature: sig }])
+* ```
+*/
+var UnsignedTx = class {
+	/** Messages to include in the transaction */
+	msgs;
+	/** Signing mode determined for this transaction */
+	signMode;
+	/** Chain ID for signing */
+	chainId;
+	/** Account number for signing */
+	accountNumber;
+	/** Account sequence number */
+	sequence;
+	/** Fee for the transaction */
+	fee;
+	/** Gas limit */
+	gasLimit;
+	/** Memo */
+	memo;
+	/** Timeout block height (0 = no timeout) */
+	timeoutHeight;
+	constructor(data) {
+		this.msgs = data.msgs;
+		this.signMode = data.signMode;
+		this.chainId = data.chainId;
+		this.accountNumber = data.accountNumber;
+		this.sequence = data.sequence;
+		this.fee = data.fee.map((c) => c instanceof Coin ? c : new Coin(c.denom, c.amount));
+		this.gasLimit = data.gasLimit;
+		this.memo = data.memo;
+		this.timeoutHeight = data.timeoutHeight ?? 0n;
+	}
+	/**
+	* Compute the sign bytes for multisig SIGN_MODE_DIRECT signing.
+	*
+	* Builds bodyBytes and authInfoBytes with the multisig public key in a
+	* single-DIRECT SignerInfo (matches what the chain expects for the SignDoc),
+	* then serializes them into a protobuf SignDoc.
+	*
+	* Each co-signer must call this method and sign the returned bytes.
+	*
+	* @param mpk - The multisig public key
+	* @returns Protobuf-encoded SignDoc bytes to be signed by each co-signer
+	*/
+	getMultisigSignBytes(mpk) {
+		const { bodyBytes, authInfoBytes } = this._encodeForMultisigSignDoc(mpk);
+		return makeSignBytes(bodyBytes, authInfoBytes, this.chainId, this.accountNumber);
+	}
+	/**
+	* Assemble a complete signed multisig transaction from collected signatures.
+	*
+	* Builds a TxRaw with the multisig ModeInfo derived from the provided signatures
+	* and the MultiSignature proto encoding. The caller is responsible for ensuring
+	* enough signatures have been collected to meet the threshold.
+	*
+	* @param mpk - The multisig public key (defines threshold and signer order)
+	* @param signatures - Collected signatures with their signer index
+	* @returns SignedTx ready for broadcast
+	*/
+	assembleMultisig(mpk, signatures) {
+		const ms = new MultiSignature(mpk);
+		for (const { index, signature } of signatures) ms.appendSignature(index, signature);
+		if (!ms.isComplete()) throw new Error(`Multisig threshold not met: need ${mpk.threshold} signatures, got ${signatures.length}`);
+		return { txBytes: toBinary(TxRawSchema, createSignedTx(this._buildTxBody(), this._buildFeeOnlyAuthInfo(), mpk, ms, this.sequence)) };
+	}
+	/**
+	* Build the TxBody proto from this transaction's messages and memo.
+	*/
+	_buildTxBody() {
+		return create(TxBodySchema, {
+			messages: this.msgs.map((m) => m.toAny()),
+			memo: this.memo,
+			timeoutHeight: this.timeoutHeight
+		});
+	}
+	_buildFee() {
+		return create(FeeSchema, {
+			amount: this.fee.map((c) => c.toProto()),
+			gasLimit: this.gasLimit
+		});
+	}
+	/**
+	* Build a minimal AuthInfo that carries only the fee (no signerInfos).
+	* createSignedTx replaces signerInfos internally, so we only need to
+	* preserve the fee for the final TxRaw.
+	*/
+	_buildFeeOnlyAuthInfo() {
+		return create(AuthInfoSchema, { fee: this._buildFee() });
+	}
+	/**
+	* Encode bodyBytes and authInfoBytes for the multisig SignDoc.
+	*
+	* Uses a single SIGN_MODE_DIRECT SignerInfo with the multisig public key.
+	* This is the standard form expected by the chain when verifying individual
+	* co-signer signatures against the SignDoc.
+	*/
+	_encodeForMultisigSignDoc(mpk) {
+		return {
+			bodyBytes: toBinary(TxBodySchema, this._buildTxBody()),
+			authInfoBytes: toBinary(AuthInfoSchema, create(AuthInfoSchema, {
+				signerInfos: [create(SignerInfoSchema, {
+					publicKey: mpk.packAny(),
+					modeInfo: create(ModeInfoSchema, { sum: {
+						case: "single",
+						value: { mode: SignMode.DIRECT }
+					} }),
+					sequence: this.sequence
+				})],
+				fee: this._buildFee()
+			}))
+		};
+	}
+};
+//#endregion
+//#region src/client/types.ts
+/**
+* Factory helpers for creating AuthConfig.
+*
+* @example
+* ```typescript
+* auth.apiKey('sk-12345')
+* auth.apiKey('key', 'x-alchemy-token')
+* auth.bearer('eyJhbGciOiJIUzI1NiIs...')
+* auth.basic('username', 'password')
+* ```
+*/
+const auth = {
+	bearer: (token) => ({
+		type: "bearer",
+		token
+	}),
+	apiKey: (key, header) => ({
+		type: "api-key",
+		key,
+		header
+	}),
+	basic: (username, password) => ({
+		type: "basic",
+		username,
+		password
+	})
+};
+//#endregion
+//#region src/client/rpc.ts
+/**
+* CometBFT HTTP RPC Client
+*
+* Provides HTTP-based RPC methods for CometBFT endpoints not available via gRPC.
+* Primary use case: block_results (finalize_block_events, validator_updates).
+*/
+/**
+* CometBFT HTTP RPC client.
+*
+* Provides access to CometBFT v0.38 endpoints not available via Cosmos SDK gRPC:
+*
+* **Block & Header:** `block`, `blockByHash`, `blockResults`, `header`, `headerByHash`, `blockchain`, `blockSearch`
+* **Transaction:** `tx`, `txSearch`, `unconfirmedTxs`, `numUnconfirmedTxs`
+* **Consensus:** `validators`, `commit`, `consensusParams`, `consensusState`, `dumpConsensusState`
+* **Node:** `status`, `health`, `netInfo`, `genesis`, `genesisChunked`
+* **ABCI:** `abciInfo`, `abciQuery`
+*
+* @example
+* ```typescript
+* const rpc = createRpcClient('https://rpc.initia.xyz')
+*
+* const results = await rpc.blockResults(14107946)
+* const tx = await rpc.tx('6E7457...')
+* const header = await rpc.header(14107946)
+* const healthy = await rpc.health()
+* ```
+*/
+var RpcClient = class {
+	config;
+	constructor(endpoint, options = {}) {
+		validateHeaderConflict(options.auth, options.headers, "context");
+		this.config = {
+			endpoint,
+			auth: options.auth,
+			headers: options.headers,
+			timeoutMs: options.timeoutMs
+		};
+	}
+	/**
+	* Make a GET request to a CometBFT RPC endpoint.
+	*/
+	async get(path, options) {
+		const response = await httpRequest(this.config, path, { method: "GET" }, options);
+		if (!response.ok) {
+			const body = await response.text().catch(() => "");
+			throw new Error(`HTTP error: ${response.status} ${response.statusText}${body ? ` — ${body}` : ""}`);
+		}
+		const json = await response.json();
+		if (json.error) throw new Error(`RPC error (${json.error.code}): ${json.error.message}`);
+		return json.result;
+	}
+	/**
+	* Get ABCI results for a block, including finalize_block_events.
+	*
+	* This is the primary endpoint for data not available via gRPC:
+	* - `finalize_block_events`: chain-level events (staking rewards, slashing, epoch)
+	* - `txs_results`: per-tx execution results for the entire block
+	* - `validator_updates`: validator set changes
+	* - `consensus_param_updates`: consensus parameter changes
+	*
+	* @param height - Block height (omit for latest)
+	*/
+	async blockResults(height, options) {
+		const params = height !== void 0 ? `?height=${height}` : "";
+		return this.get(`/block_results${params}`, options);
+	}
+	/**
+	* Get transaction by hash with block index.
+	*
+	* Unlike gRPC GetTx, includes `index` (tx position within block).
+	*
+	* @param hash - Transaction hash (hex, with or without 0x prefix)
+	*/
+	async tx(hash, options) {
+		const normalizedHash = hash.startsWith("0x") ? hash : `0x${hash}`;
+		return this.get(`/tx?hash=${normalizedHash}`, options);
+	}
+	/**
+	* Search transactions by TMQL event query.
+	*
+	* @param query - TMQL query string (e.g., "tx.height=100", "transfer.sender='init1...'")
+	* @param searchOptions - Pagination options
+	*
+	* @example
+	* ```typescript
+	* // Find all txs at a specific height
+	* const result = await rpc.txSearch("tx.height=14107946")
+	*
+	* // Find txs by event
+	* const result = await rpc.txSearch("transfer.sender='init1abc...'", { perPage: 50 })
+	* ```
+	*/
+	async txSearch(query, searchOptions, options) {
+		const params = new URLSearchParams();
+		params.set("query", `"${query}"`);
+		if (searchOptions?.page) params.set("page", String(searchOptions.page));
+		if (searchOptions?.perPage) params.set("per_page", String(searchOptions.perPage));
+		if (searchOptions?.orderBy) params.set("order_by", `"${searchOptions.orderBy}"`);
+		return this.get(`/tx_search?${params.toString()}`, options);
+	}
+	/**
+	* Get block by height.
+	*
+	* @param height - Block height (omit for latest)
+	*/
+	async block(height, options) {
+		const params = height !== void 0 ? `?height=${height}` : "";
+		return this.get(`/block${params}`, options);
+	}
+	/**
+	* Get node status including sync info.
+	*/
+	async status(options) {
+		return this.get("/status", options);
+	}
+	/**
+	* Check if the node is healthy.
+	*
+	* Returns `true` if healthy, `false` otherwise. Never throws for health status.
+	*/
+	async health(options) {
+		try {
+			await this.get("/health", options);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Get ABCI application info.
+	*/
+	async abciInfo(options) {
+		return this.get("/abci_info", options);
+	}
+	/**
+	* Get signed header (commit) at a given height.
+	*
+	* @param height - Block height (omit for latest)
+	*/
+	async commit(height, options) {
+		const params = height !== void 0 ? `?height=${height}` : "";
+		return this.get(`/commit${params}`, options);
+	}
+	/**
+	* Get validator set at a given height.
+	*
+	* CometBFT returns max 100 validators per page (default 30).
+	*
+	* @param height - Block height (omit for latest)
+	* @param pagination - Pagination options
+	*/
+	async validators(height, pagination, options) {
+		const params = new URLSearchParams();
+		if (height !== void 0) params.set("height", String(height));
+		if (pagination?.page) params.set("page", String(pagination.page));
+		if (pagination?.perPage) params.set("per_page", String(pagination.perPage));
+		const qs = params.toString();
+		return this.get(`/validators${qs ? `?${qs}` : ""}`, options);
+	}
+	/**
+	* Get consensus parameters at a given height.
+	*
+	* @param height - Block height (omit for latest)
+	*/
+	async consensusParams(height, options) {
+		const params = height !== void 0 ? `?height=${height}` : "";
+		return this.get(`/consensus_params${params}`, options);
+	}
+	/**
+	* Get block metadata for a range of heights.
+	*
+	* CometBFT returns max 20 block metas per call.
+	*
+	* @param minHeight - Minimum block height (optional)
+	* @param maxHeight - Maximum block height (optional)
+	*/
+	async blockchain(minHeight, maxHeight, options) {
+		const params = new URLSearchParams();
+		if (minHeight !== void 0) params.set("minHeight", String(minHeight));
+		if (maxHeight !== void 0) params.set("maxHeight", String(maxHeight));
+		const qs = params.toString();
+		return this.get(`/blockchain${qs ? `?${qs}` : ""}`, options);
+	}
+	/**
+	* Get block by hash.
+	*
+	* @param hash - Block hash (hex, with or without 0x prefix)
+	*/
+	async blockByHash(hash, options) {
+		const normalizedHash = hash.startsWith("0x") ? hash : `0x${hash}`;
+		return this.get(`/block_by_hash?hash=${normalizedHash}`, options);
+	}
+	/**
+	* Search blocks by TMQL event query.
+	*
+	* @param query - TMQL query string
+	* @param searchOptions - Pagination and ordering options
+	*/
+	async blockSearch(query, searchOptions, options) {
+		const params = new URLSearchParams();
+		params.set("query", `"${query}"`);
+		if (searchOptions?.page) params.set("page", String(searchOptions.page));
+		if (searchOptions?.perPage) params.set("per_page", String(searchOptions.perPage));
+		if (searchOptions?.orderBy) params.set("order_by", `"${searchOptions.orderBy}"`);
+		return this.get(`/block_search?${params.toString()}`, options);
+	}
+	/**
+	* Get unconfirmed transactions from the mempool.
+	*
+	* @param limit - Max number of transactions to return
+	*/
+	async unconfirmedTxs(limit, options) {
+		const params = limit !== void 0 ? `?limit=${limit}` : "";
+		return this.get(`/unconfirmed_txs${params}`, options);
+	}
+	/**
+	* Get number of unconfirmed transactions in the mempool.
+	*/
+	async numUnconfirmedTxs(options) {
+		return this.get("/num_unconfirmed_txs", options);
+	}
+	/**
+	* Get block header by height (lightweight alternative to block()).
+	*
+	* @param height - Block height (omit for latest)
+	*/
+	async header(height, options) {
+		const params = height !== void 0 ? `?height=${height}` : "";
+		return this.get(`/header${params}`, options);
+	}
+	/**
+	* Get block header by hash.
+	*
+	* @param hash - Block hash (hex, with or without 0x prefix)
+	*/
+	async headerByHash(hash, options) {
+		const normalizedHash = hash.startsWith("0x") ? hash : `0x${hash}`;
+		return this.get(`/header_by_hash?hash=${normalizedHash}`, options);
+	}
+	/**
+	* Get current consensus state.
+	*/
+	async consensusState(options) {
+		return this.get("/consensus_state", options);
+	}
+	/**
+	* Dump full consensus state (verbose debugging).
+	*/
+	async dumpConsensusState(options) {
+		return this.get("/dump_consensus_state", options);
+	}
+	/**
+	* Get the full genesis document.
+	*
+	* Can be very large — consider using genesisChunked() for large genesis files.
+	*/
+	async genesis(options) {
+		return this.get("/genesis", options);
+	}
+	/**
+	* Get genesis document in chunks (16MB per chunk).
+	*
+	* @param chunk - 0-based chunk index
+	*/
+	async genesisChunked(chunk, options) {
+		return this.get(`/genesis_chunked?chunk=${chunk}`, options);
+	}
+	/**
+	* Get network info including connected peers.
+	*/
+	async netInfo(options) {
+		return this.get("/net_info", options);
+	}
+	/**
+	* Query the ABCI application directly.
+	*
+	* @param path - ABCI query path (e.g., "/store/bank/key")
+	* @param queryOptions - Optional data, height, and prove parameters
+	*/
+	async abciQuery(path, queryOptions, options) {
+		const params = new URLSearchParams();
+		params.set("path", `"${path}"`);
+		if (queryOptions?.data) params.set("data", `"${queryOptions.data}"`);
+		if (queryOptions?.height !== void 0) params.set("height", String(queryOptions.height));
+		if (queryOptions?.prove !== void 0) params.set("prove", String(queryOptions.prove));
+		return this.get(`/abci_query?${params.toString()}`, options);
+	}
+};
+/**
+* Create a CometBFT HTTP RPC client.
+*
+* @param endpoint - CometBFT RPC endpoint URL (e.g., 'https://rpc.initia.xyz')
+* @param options - Client options (auth, headers, timeout)
+*/
+function createRpcClient(endpoint, options) {
+	return new RpcClient(endpoint, options);
+}
+//#endregion
+//#region src/client/broadcast.ts
+/**
+* Broadcast module - Submit signed transactions to the network.
+*/
+/**
+* Helper to create BroadcastResultWithWait from BroadcastResult.
+* @internal
+*/
+function createBroadcastResultWithWait(result, waitFn) {
+	return {
+		...result,
+		waitForConfirmation: (options) => waitFn(result.txHash, options)
+	};
+}
+/**
+* Map our BroadcastMode to BSR enum.
+*/
+function toBsrMode(mode) {
+	switch (mode) {
+		case "sync": return BroadcastMode.SYNC;
+		case "async": return BroadcastMode.ASYNC;
+		case "block": return BroadcastMode.BLOCK;
+	}
+}
+/**
+* Broadcast a signed transaction to the network.
+*
+* @param client - gRPC client with tx service
+* @param signedTx - Signed transaction bytes
+* @param options - Broadcast options (mode defaults to 'sync')
+* @returns Broadcast result with txHash and gasUsed
+* @throws {BroadcastError} If the transaction fails
+*
+* @example
+* ```typescript
+* const result = await broadcast(client, signedTx)
+* console.log('Tx hash:', result.txHash)
+* console.log('Gas used:', result.gasUsed)
+* ```
+*/
+async function broadcast(client, signedTx, options) {
+	const mode = options?.mode ?? "sync";
+	const txResponse = (await client.tx.broadcastTx({
+		txBytes: signedTx.txBytes,
+		mode: toBsrMode(mode)
+	})).txResponse;
+	if (!txResponse) throw new BroadcastError("", 0, "No response from broadcast");
+	if (txResponse.code !== 0) throw new BroadcastError(txResponse.txhash, txResponse.code, txResponse.rawLog);
+	return {
+		txHash: txResponse.txhash,
+		gasUsed: txResponse.gasUsed,
+		rawLog: txResponse.rawLog || void 0
+	};
+}
+//#endregion
+export { auth as a, getGasPrices as c, Coins as d, DecCoins as f, createRpcClient as i, getAccount as l, createBroadcastResultWithWait as n, UnsignedTx as o, RpcClient as r, estimateGas as s, broadcast as t, file_cosmos_auth_v1beta1_auth as u };
+
+//# sourceMappingURL=broadcast-De8MdmYa.mjs.map