@capxul/cli 4.20.0-beta.3 → 4.20.0-beta.31

package/dist/where-view-DuGbrSLp.mjs

@@ -0,0 +1,1420 @@
+import { A as isHex, C as numberToHex, N as BaseError, O as trim, S as bytesToHex, T as toHex, _ as hexToBigInt, a as isAddress, b as toBytes, d as formatGwei$1, f as toRlp, h as concatHex, k as size, l as InvalidAddressError, p as createCursor, r as slice, t as isRecord, v as hexToNumber, y as hexToBytes } from "./record-U7Yu4KQP.mjs";
+import { t as sha256$2 } from "./sha2-CR2DnMEk.mjs";
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/chain/defineChain.js
+function defineChain(chain) {
+	const chainInstance = {
+		formatters: void 0,
+		fees: void 0,
+		serializers: void 0,
+		...chain
+	};
+	function extend(base) {
+		return (fnOrExtended) => {
+			const properties = typeof fnOrExtended === "function" ? fnOrExtended(base) : fnOrExtended;
+			const combined = {
+				...base,
+				...properties
+			};
+			return Object.assign(combined, { extend: extend(combined) });
+		};
+	}
+	return Object.assign(chainInstance, { extend: extend(chainInstance) });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/formatters/formatter.js
+function defineFormatter(type, format) {
+	return ({ exclude, format: overrides }) => {
+		return {
+			exclude,
+			format: (args, action) => {
+				const formatted = format(args, action);
+				if (exclude) for (const key of exclude) delete formatted[key];
+				return {
+					...formatted,
+					...overrides(args, action)
+				};
+			},
+			type
+		};
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/formatters/transaction.js
+const transactionType = {
+	"0x0": "legacy",
+	"0x1": "eip2930",
+	"0x2": "eip1559",
+	"0x3": "eip4844",
+	"0x4": "eip7702"
+};
+function formatTransaction(transaction, _) {
+	const transaction_ = {
+		...transaction,
+		blockHash: transaction.blockHash ? transaction.blockHash : null,
+		blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
+		...transaction.blockTimestamp != null && { blockTimestamp: BigInt(transaction.blockTimestamp) },
+		chainId: transaction.chainId ? hexToNumber(transaction.chainId) : void 0,
+		gas: transaction.gas ? BigInt(transaction.gas) : void 0,
+		gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
+		maxFeePerBlobGas: transaction.maxFeePerBlobGas ? BigInt(transaction.maxFeePerBlobGas) : void 0,
+		maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
+		maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
+		nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
+		to: transaction.to ? transaction.to : null,
+		transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
+		type: transaction.type ? transactionType[transaction.type] : void 0,
+		typeHex: transaction.type ? transaction.type : void 0,
+		value: transaction.value ? BigInt(transaction.value) : void 0,
+		v: transaction.v ? BigInt(transaction.v) : void 0
+	};
+	if (transaction.authorizationList) transaction_.authorizationList = formatAuthorizationList(transaction.authorizationList);
+	transaction_.yParity = (() => {
+		if (transaction.yParity) return Number(transaction.yParity);
+		if (typeof transaction_.v === "bigint") {
+			if (transaction_.v === 0n || transaction_.v === 27n) return 0;
+			if (transaction_.v === 1n || transaction_.v === 28n) return 1;
+			if (transaction_.v >= 35n) return transaction_.v % 2n === 0n ? 1 : 0;
+		}
+	})();
+	if (transaction_.type === "legacy") {
+		delete transaction_.accessList;
+		delete transaction_.maxFeePerBlobGas;
+		delete transaction_.maxFeePerGas;
+		delete transaction_.maxPriorityFeePerGas;
+		delete transaction_.yParity;
+	}
+	if (transaction_.type === "eip2930") {
+		delete transaction_.maxFeePerBlobGas;
+		delete transaction_.maxFeePerGas;
+		delete transaction_.maxPriorityFeePerGas;
+	}
+	if (transaction_.type === "eip1559") delete transaction_.maxFeePerBlobGas;
+	return transaction_;
+}
+const defineTransaction = /*#__PURE__*/ defineFormatter("transaction", formatTransaction);
+function formatAuthorizationList(authorizationList) {
+	return authorizationList.map((authorization) => ({
+		address: authorization.address,
+		chainId: Number(authorization.chainId),
+		nonce: Number(authorization.nonce),
+		r: authorization.r,
+		s: authorization.s,
+		yParity: Number(authorization.yParity)
+	}));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/formatters/block.js
+function formatBlock(block, _) {
+	const transactions = (block.transactions ?? []).map((transaction) => {
+		if (typeof transaction === "string") return transaction;
+		return formatTransaction(transaction);
+	});
+	return {
+		...block,
+		baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
+		blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : void 0,
+		difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
+		excessBlobGas: block.excessBlobGas ? BigInt(block.excessBlobGas) : void 0,
+		gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
+		gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
+		hash: block.hash ? block.hash : null,
+		logsBloom: block.logsBloom ? block.logsBloom : null,
+		nonce: block.nonce ? block.nonce : null,
+		number: block.number ? BigInt(block.number) : null,
+		size: block.size ? BigInt(block.size) : void 0,
+		timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
+		transactions,
+		totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
+	};
+}
+const defineBlock = /*#__PURE__*/ defineFormatter("block", formatBlock);
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/formatters/log.js
+function formatLog(log, { args, eventName } = {}) {
+	return {
+		...log,
+		blockHash: log.blockHash ? log.blockHash : null,
+		blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
+		blockTimestamp: log.blockTimestamp ? BigInt(log.blockTimestamp) : log.blockTimestamp === null ? null : void 0,
+		logIndex: log.logIndex ? Number(log.logIndex) : null,
+		transactionHash: log.transactionHash ? log.transactionHash : null,
+		transactionIndex: log.transactionIndex ? Number(log.transactionIndex) : null,
+		...eventName ? {
+			args,
+			eventName
+		} : {}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/formatters/transactionReceipt.js
+const receiptStatuses = {
+	"0x0": "reverted",
+	"0x1": "success"
+};
+function formatTransactionReceipt(transactionReceipt, _) {
+	const receipt = {
+		...transactionReceipt,
+		blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
+		contractAddress: transactionReceipt.contractAddress ? transactionReceipt.contractAddress : null,
+		cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
+		effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
+		gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
+		logs: transactionReceipt.logs ? transactionReceipt.logs.map((log) => formatLog(log)) : null,
+		to: transactionReceipt.to ? transactionReceipt.to : null,
+		transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
+		status: transactionReceipt.status ? receiptStatuses[transactionReceipt.status] : null,
+		type: transactionReceipt.type ? transactionType[transactionReceipt.type] || transactionReceipt.type : null
+	};
+	if (transactionReceipt.blobGasPrice) receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
+	if (transactionReceipt.blobGasUsed) receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
+	return receipt;
+}
+const defineTransactionReceipt = /*#__PURE__*/ defineFormatter("transactionReceipt", formatTransactionReceipt);
+2n ** (8n - 1n) - 1n;
+2n ** (16n - 1n) - 1n;
+2n ** (24n - 1n) - 1n;
+2n ** (32n - 1n) - 1n;
+2n ** (40n - 1n) - 1n;
+2n ** (48n - 1n) - 1n;
+2n ** (56n - 1n) - 1n;
+2n ** (64n - 1n) - 1n;
+2n ** (72n - 1n) - 1n;
+2n ** (80n - 1n) - 1n;
+2n ** (88n - 1n) - 1n;
+2n ** (96n - 1n) - 1n;
+2n ** (104n - 1n) - 1n;
+2n ** (112n - 1n) - 1n;
+2n ** (120n - 1n) - 1n;
+2n ** (128n - 1n) - 1n;
+2n ** (136n - 1n) - 1n;
+2n ** (144n - 1n) - 1n;
+2n ** (152n - 1n) - 1n;
+2n ** (160n - 1n) - 1n;
+2n ** (168n - 1n) - 1n;
+2n ** (176n - 1n) - 1n;
+2n ** (184n - 1n) - 1n;
+2n ** (192n - 1n) - 1n;
+2n ** (200n - 1n) - 1n;
+2n ** (208n - 1n) - 1n;
+2n ** (216n - 1n) - 1n;
+2n ** (224n - 1n) - 1n;
+2n ** (232n - 1n) - 1n;
+2n ** (240n - 1n) - 1n;
+2n ** (248n - 1n) - 1n;
+2n ** (256n - 1n) - 1n;
+-(2n ** (8n - 1n));
+-(2n ** (16n - 1n));
+-(2n ** (24n - 1n));
+-(2n ** (32n - 1n));
+-(2n ** (40n - 1n));
+-(2n ** (48n - 1n));
+-(2n ** (56n - 1n));
+-(2n ** (64n - 1n));
+-(2n ** (72n - 1n));
+-(2n ** (80n - 1n));
+-(2n ** (88n - 1n));
+-(2n ** (96n - 1n));
+-(2n ** (104n - 1n));
+-(2n ** (112n - 1n));
+-(2n ** (120n - 1n));
+-(2n ** (128n - 1n));
+-(2n ** (136n - 1n));
+-(2n ** (144n - 1n));
+-(2n ** (152n - 1n));
+-(2n ** (160n - 1n));
+-(2n ** (168n - 1n));
+-(2n ** (176n - 1n));
+-(2n ** (184n - 1n));
+-(2n ** (192n - 1n));
+-(2n ** (200n - 1n));
+-(2n ** (208n - 1n));
+-(2n ** (216n - 1n));
+-(2n ** (224n - 1n));
+-(2n ** (232n - 1n));
+-(2n ** (240n - 1n));
+-(2n ** (248n - 1n));
+-(2n ** (256n - 1n));
+const maxUint256 = 2n ** 256n - 1n;
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/unit/formatGwei.js
+/**
+* Converts numerical wei to a string representation of gwei.
+*
+* - Docs: https://viem.sh/docs/utilities/formatGwei
+*
+* @example
+* import { formatGwei } from 'viem'
+*
+* formatGwei(1000000000n)
+* // '1'
+*/
+function formatGwei(wei, unit = "wei") {
+	return formatGwei$1(wei, unit);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/errors/transaction.js
+function prettyPrint(args) {
+	const entries = Object.entries(args).map(([key, value]) => {
+		if (value === void 0 || value === false) return null;
+		return [key, value];
+	}).filter(Boolean);
+	const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
+	return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
+}
+var InvalidLegacyVError = class extends BaseError {
+	constructor({ v }) {
+		super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, { name: "InvalidLegacyVError" });
+	}
+};
+var InvalidSerializableTransactionError = class extends BaseError {
+	constructor({ transaction }) {
+		super("Cannot infer a transaction type from provided transaction.", {
+			metaMessages: [
+				"Provided Transaction:",
+				"{",
+				prettyPrint(transaction),
+				"}",
+				"",
+				"To infer the type, either provide:",
+				"- a `type` to the Transaction, or",
+				"- an EIP-1559 Transaction with `maxFeePerGas`, or",
+				"- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
+				"- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
+				"- an EIP-7702 Transaction with `authorizationList`, or",
+				"- a Legacy Transaction with `gasPrice`"
+			],
+			name: "InvalidSerializableTransactionError"
+		});
+	}
+};
+var InvalidStorageKeySizeError = class extends BaseError {
+	constructor({ storageKey }) {
+		super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/authorization/serializeAuthorizationList.js
+function serializeAuthorizationList(authorizationList) {
+	if (!authorizationList || authorizationList.length === 0) return [];
+	const serializedAuthorizationList = [];
+	for (const authorization of authorizationList) {
+		const { chainId, nonce, ...signature } = authorization;
+		const contractAddress = authorization.address;
+		serializedAuthorizationList.push([
+			chainId ? toHex(chainId) : "0x",
+			contractAddress,
+			nonce ? toHex(nonce) : "0x",
+			...toYParitySignatureArray({}, signature)
+		]);
+	}
+	return serializedAuthorizationList;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/blob/blobsToCommitments.js
+/**
+* Compute commitments from a list of blobs.
+*
+* @example
+* ```ts
+* import { blobsToCommitments, toBlobs } from 'viem'
+* import { kzg } from './kzg'
+*
+* const blobs = toBlobs({ data: '0x1234' })
+* const commitments = blobsToCommitments({ blobs, kzg })
+* ```
+*/
+function blobsToCommitments(parameters) {
+	const { kzg } = parameters;
+	const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
+	const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
+	const commitments = [];
+	for (const blob of blobs) commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
+	return to === "bytes" ? commitments : commitments.map((x) => bytesToHex(x));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/blob/blobsToProofs.js
+/**
+* Compute the proofs for a list of blobs and their commitments.
+*
+* @example
+* ```ts
+* import {
+*   blobsToCommitments,
+*   toBlobs
+* } from 'viem'
+* import { kzg } from './kzg'
+*
+* const blobs = toBlobs({ data: '0x1234' })
+* const commitments = blobsToCommitments({ blobs, kzg })
+* const proofs = blobsToProofs({ blobs, commitments, kzg })
+* ```
+*/
+function blobsToProofs(parameters) {
+	const { kzg } = parameters;
+	const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
+	const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
+	const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes(x)) : parameters.commitments;
+	const proofs = [];
+	for (let i = 0; i < blobs.length; i++) {
+		const blob = blobs[i];
+		const commitment = commitments[i];
+		proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
+	}
+	return to === "bytes" ? proofs : proofs.map((x) => bytesToHex(x));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha256.js
+/**
+* SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.
+*
+* To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+* BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+*
+* Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+* @module
+* @deprecated
+*/
+/** @deprecated Use import from `noble/hashes/sha2` module */
+const sha256$1 = sha256$2;
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/hash/sha256.js
+function sha256(value, to_) {
+	const to = to_ || "hex";
+	const bytes = sha256$1(isHex(value, { strict: false }) ? toBytes(value) : value);
+	if (to === "bytes") return bytes;
+	return toHex(bytes);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
+/**
+* Transform a commitment to it's versioned hash.
+*
+* @example
+* ```ts
+* import {
+*   blobsToCommitments,
+*   commitmentToVersionedHash,
+*   toBlobs
+* } from 'viem'
+* import { kzg } from './kzg'
+*
+* const blobs = toBlobs({ data: '0x1234' })
+* const [commitment] = blobsToCommitments({ blobs, kzg })
+* const versionedHash = commitmentToVersionedHash({ commitment })
+* ```
+*/
+function commitmentToVersionedHash(parameters) {
+	const { commitment, version = 1 } = parameters;
+	const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
+	const versionedHash = sha256(commitment, "bytes");
+	versionedHash.set([version], 0);
+	return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
+/**
+* Transform a list of commitments to their versioned hashes.
+*
+* @example
+* ```ts
+* import {
+*   blobsToCommitments,
+*   commitmentsToVersionedHashes,
+*   toBlobs
+* } from 'viem'
+* import { kzg } from './kzg'
+*
+* const blobs = toBlobs({ data: '0x1234' })
+* const commitments = blobsToCommitments({ blobs, kzg })
+* const versionedHashes = commitmentsToVersionedHashes({ commitments })
+* ```
+*/
+function commitmentsToVersionedHashes(parameters) {
+	const { commitments, version } = parameters;
+	const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
+	const hashes = [];
+	for (const commitment of commitments) hashes.push(commitmentToVersionedHash({
+		commitment,
+		to,
+		version
+	}));
+	return hashes;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/constants/blob.js
+/** Blob limit per transaction. */
+const blobsPerTransaction = 6;
+/** The number of field elements in a blob. */
+const fieldElementsPerBlob = 4096;
+/** The number of bytes in a blob. */
+const bytesPerBlob = 32 * fieldElementsPerBlob;
+/** Blob bytes limit per transaction. */
+const maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - 1 - 1 * fieldElementsPerBlob * blobsPerTransaction;
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/errors/blob.js
+var BlobSizeTooLargeError = class extends BaseError {
+	constructor({ maxSize, size }) {
+		super("Blob size is too large.", {
+			metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size} bytes`],
+			name: "BlobSizeTooLargeError"
+		});
+	}
+};
+var EmptyBlobError = class extends BaseError {
+	constructor() {
+		super("Blob data must not be empty.", { name: "EmptyBlobError" });
+	}
+};
+var InvalidVersionedHashSizeError = class extends BaseError {
+	constructor({ hash, size }) {
+		super(`Versioned hash "${hash}" size is invalid.`, {
+			metaMessages: ["Expected: 32", `Received: ${size}`],
+			name: "InvalidVersionedHashSizeError"
+		});
+	}
+};
+var InvalidVersionedHashVersionError = class extends BaseError {
+	constructor({ hash, version }) {
+		super(`Versioned hash "${hash}" version is invalid.`, {
+			metaMessages: [`Expected: 1`, `Received: ${version}`],
+			name: "InvalidVersionedHashVersionError"
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/blob/toBlobs.js
+/**
+* Transforms arbitrary data to blobs.
+*
+* @example
+* ```ts
+* import { toBlobs, stringToHex } from 'viem'
+*
+* const blobs = toBlobs({ data: stringToHex('hello world') })
+* ```
+*/
+function toBlobs(parameters) {
+	const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
+	const data = typeof parameters.data === "string" ? hexToBytes(parameters.data) : parameters.data;
+	const size_ = size(data);
+	if (!size_) throw new EmptyBlobError();
+	if (size_ > 761855) throw new BlobSizeTooLargeError({
+		maxSize: maxBytesPerTransaction,
+		size: size_
+	});
+	const blobs = [];
+	let active = true;
+	let position = 0;
+	while (active) {
+		const blob = createCursor(new Uint8Array(bytesPerBlob));
+		let size = 0;
+		while (size < fieldElementsPerBlob) {
+			const bytes = data.slice(position, position + 31);
+			blob.pushByte(0);
+			blob.pushBytes(bytes);
+			if (bytes.length < 31) {
+				blob.pushByte(128);
+				active = false;
+				break;
+			}
+			size++;
+			position += 31;
+		}
+		blobs.push(blob);
+	}
+	return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex(x.bytes));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/blob/toBlobSidecars.js
+/**
+* Transforms arbitrary data (or blobs, commitments, & proofs) into a sidecar array.
+*
+* @example
+* ```ts
+* import { toBlobSidecars, stringToHex } from 'viem'
+*
+* const sidecars = toBlobSidecars({ data: stringToHex('hello world') })
+* ```
+*
+* @example
+* ```ts
+* import {
+*   blobsToCommitments,
+*   toBlobs,
+*   blobsToProofs,
+*   toBlobSidecars,
+*   stringToHex
+* } from 'viem'
+*
+* const blobs = toBlobs({ data: stringToHex('hello world') })
+* const commitments = blobsToCommitments({ blobs, kzg })
+* const proofs = blobsToProofs({ blobs, commitments, kzg })
+*
+* const sidecars = toBlobSidecars({ blobs, commitments, proofs })
+* ```
+*/
+function toBlobSidecars(parameters) {
+	const { data, kzg, to } = parameters;
+	const blobs = parameters.blobs ?? toBlobs({
+		data,
+		to
+	});
+	const commitments = parameters.commitments ?? blobsToCommitments({
+		blobs,
+		kzg,
+		to
+	});
+	const proofs = parameters.proofs ?? blobsToProofs({
+		blobs,
+		commitments,
+		kzg,
+		to
+	});
+	const sidecars = [];
+	for (let i = 0; i < blobs.length; i++) sidecars.push({
+		blob: blobs[i],
+		commitment: commitments[i],
+		proof: proofs[i]
+	});
+	return sidecars;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/errors/chain.js
+var InvalidChainIdError = class extends BaseError {
+	constructor({ chainId }) {
+		super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/errors/node.js
+var ExecutionRevertedError = class extends BaseError {
+	constructor({ cause, message } = {}) {
+		const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
+		super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
+			cause,
+			name: "ExecutionRevertedError"
+		});
+	}
+};
+Object.defineProperty(ExecutionRevertedError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 3
+});
+Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /execution reverted|gas required exceeds allowance/
+});
+var FeeCapTooHighError = class extends BaseError {
+	constructor({ cause, maxFeePerGas } = {}) {
+		super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
+			cause,
+			name: "FeeCapTooHighError"
+		});
+	}
+};
+Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
+});
+var FeeCapTooLowError = class extends BaseError {
+	constructor({ cause, maxFeePerGas } = {}) {
+		super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
+			cause,
+			name: "FeeCapTooLowError"
+		});
+	}
+};
+Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
+});
+var NonceTooHighError = class extends BaseError {
+	constructor({ cause, nonce } = {}) {
+		super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, {
+			cause,
+			name: "NonceTooHighError"
+		});
+	}
+};
+Object.defineProperty(NonceTooHighError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /nonce too high/
+});
+var NonceTooLowError = class extends BaseError {
+	constructor({ cause, nonce } = {}) {
+		super([`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`, "Try increasing the nonce or find the latest nonce with `getTransactionCount`."].join("\n"), {
+			cause,
+			name: "NonceTooLowError"
+		});
+	}
+};
+Object.defineProperty(NonceTooLowError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /nonce too low|transaction already imported|already known/
+});
+var NonceMaxValueError = class extends BaseError {
+	constructor({ cause, nonce } = {}) {
+		super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, {
+			cause,
+			name: "NonceMaxValueError"
+		});
+	}
+};
+Object.defineProperty(NonceMaxValueError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /nonce has max value/
+});
+var InsufficientFundsError = class extends BaseError {
+	constructor({ cause } = {}) {
+		super(["The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."].join("\n"), {
+			cause,
+			metaMessages: [
+				"This error could arise when the account does not have enough funds to:",
+				" - pay for the total gas fee,",
+				" - pay for the value to send.",
+				" ",
+				"The cost of the transaction is calculated as `gas * gas fee + value`, where:",
+				" - `gas` is the amount of gas needed for transaction to execute,",
+				" - `gas fee` is the gas fee,",
+				" - `value` is the amount of ether to send to the recipient."
+			],
+			name: "InsufficientFundsError"
+		});
+	}
+};
+Object.defineProperty(InsufficientFundsError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /insufficient funds|exceeds transaction sender account balance/
+});
+var IntrinsicGasTooHighError = class extends BaseError {
+	constructor({ cause, gas } = {}) {
+		super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
+			cause,
+			name: "IntrinsicGasTooHighError"
+		});
+	}
+};
+Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /intrinsic gas too high|gas limit reached/
+});
+var IntrinsicGasTooLowError = class extends BaseError {
+	constructor({ cause, gas } = {}) {
+		super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
+			cause,
+			name: "IntrinsicGasTooLowError"
+		});
+	}
+};
+Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /intrinsic gas too low/
+});
+var TransactionTypeNotSupportedError = class extends BaseError {
+	constructor({ cause }) {
+		super("The transaction type is not supported for this chain.", {
+			cause,
+			name: "TransactionTypeNotSupportedError"
+		});
+	}
+};
+Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /transaction type not valid/
+});
+var TipAboveFeeCapError = class extends BaseError {
+	constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
+		super([`The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`].join("\n"), {
+			cause,
+			name: "TipAboveFeeCapError"
+		});
+	}
+};
+Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
+});
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/transaction/assertTransaction.js
+function assertTransactionEIP7702(transaction) {
+	const { authorizationList } = transaction;
+	if (authorizationList) for (const authorization of authorizationList) {
+		const { chainId } = authorization;
+		const address = authorization.address;
+		if (!isAddress(address)) throw new InvalidAddressError({ address });
+		if (chainId < 0) throw new InvalidChainIdError({ chainId });
+	}
+	assertTransactionEIP1559(transaction);
+}
+function assertTransactionEIP4844(transaction) {
+	const { blobVersionedHashes } = transaction;
+	if (blobVersionedHashes) {
+		if (blobVersionedHashes.length === 0) throw new EmptyBlobError();
+		for (const hash of blobVersionedHashes) {
+			const size_ = size(hash);
+			const version = hexToNumber(slice(hash, 0, 1));
+			if (size_ !== 32) throw new InvalidVersionedHashSizeError({
+				hash,
+				size: size_
+			});
+			if (version !== 1) throw new InvalidVersionedHashVersionError({
+				hash,
+				version
+			});
+		}
+	}
+	assertTransactionEIP1559(transaction);
+}
+function assertTransactionEIP1559(transaction) {
+	const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
+	if (chainId <= 0) throw new InvalidChainIdError({ chainId });
+	if (to && !isAddress(to)) throw new InvalidAddressError({ address: to });
+	if (maxFeePerGas && maxFeePerGas > maxUint256) throw new FeeCapTooHighError({ maxFeePerGas });
+	if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas) throw new TipAboveFeeCapError({
+		maxFeePerGas,
+		maxPriorityFeePerGas
+	});
+}
+function assertTransactionEIP2930(transaction) {
+	const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
+	if (chainId <= 0) throw new InvalidChainIdError({ chainId });
+	if (to && !isAddress(to)) throw new InvalidAddressError({ address: to });
+	if (maxPriorityFeePerGas || maxFeePerGas) throw new BaseError("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
+	if (gasPrice && gasPrice > maxUint256) throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
+}
+function assertTransactionLegacy(transaction) {
+	const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
+	if (to && !isAddress(to)) throw new InvalidAddressError({ address: to });
+	if (typeof chainId !== "undefined" && chainId <= 0) throw new InvalidChainIdError({ chainId });
+	if (maxPriorityFeePerGas || maxFeePerGas) throw new BaseError("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
+	if (gasPrice && gasPrice > maxUint256) throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/transaction/getTransactionType.js
+function getTransactionType(transaction) {
+	if (transaction.type) return transaction.type;
+	if (typeof transaction.authorizationList !== "undefined") return "eip7702";
+	if (typeof transaction.blobs !== "undefined" || typeof transaction.blobVersionedHashes !== "undefined" || typeof transaction.maxFeePerBlobGas !== "undefined" || typeof transaction.sidecars !== "undefined") return "eip4844";
+	if (typeof transaction.maxFeePerGas !== "undefined" || typeof transaction.maxPriorityFeePerGas !== "undefined") return "eip1559";
+	if (typeof transaction.gasPrice !== "undefined") {
+		if (typeof transaction.accessList !== "undefined") return "eip2930";
+		return "legacy";
+	}
+	throw new InvalidSerializableTransactionError({ transaction });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/transaction/serializeAccessList.js
+function serializeAccessList(accessList) {
+	if (!accessList || accessList.length === 0) return [];
+	const serializedAccessList = [];
+	for (let i = 0; i < accessList.length; i++) {
+		const { address, storageKeys } = accessList[i];
+		for (let j = 0; j < storageKeys.length; j++) if (storageKeys[j].length - 2 !== 64) throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
+		if (!isAddress(address, { strict: false })) throw new InvalidAddressError({ address });
+		serializedAccessList.push([address, storageKeys]);
+	}
+	return serializedAccessList;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
+function serializeTransaction$1(transaction, signature) {
+	const type = getTransactionType(transaction);
+	if (type === "eip1559") return serializeTransactionEIP1559(transaction, signature);
+	if (type === "eip2930") return serializeTransactionEIP2930(transaction, signature);
+	if (type === "eip4844") return serializeTransactionEIP4844(transaction, signature);
+	if (type === "eip7702") return serializeTransactionEIP7702(transaction, signature);
+	return serializeTransactionLegacy(transaction, signature);
+}
+function serializeTransactionEIP7702(transaction, signature) {
+	const { authorizationList, chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
+	assertTransactionEIP7702(transaction);
+	const serializedAccessList = serializeAccessList(accessList);
+	const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
+	return concatHex(["0x04", toRlp([
+		numberToHex(chainId),
+		nonce ? numberToHex(nonce) : "0x",
+		maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
+		maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
+		gas ? numberToHex(gas) : "0x",
+		to ?? "0x",
+		value ? numberToHex(value) : "0x",
+		data ?? "0x",
+		serializedAccessList,
+		serializedAuthorizationList,
+		...toYParitySignatureArray(transaction, signature)
+	])]);
+}
+function serializeTransactionEIP4844(transaction, signature) {
+	const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
+	assertTransactionEIP4844(transaction);
+	let blobVersionedHashes = transaction.blobVersionedHashes;
+	let sidecars = transaction.sidecars;
+	if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
+		const blobs = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex(x));
+		const kzg = transaction.kzg;
+		const commitments = blobsToCommitments({
+			blobs,
+			kzg
+		});
+		if (typeof blobVersionedHashes === "undefined") blobVersionedHashes = commitmentsToVersionedHashes({ commitments });
+		if (typeof sidecars === "undefined") sidecars = toBlobSidecars({
+			blobs,
+			commitments,
+			proofs: blobsToProofs({
+				blobs,
+				commitments,
+				kzg
+			})
+		});
+	}
+	const serializedAccessList = serializeAccessList(accessList);
+	const serializedTransaction = [
+		numberToHex(chainId),
+		nonce ? numberToHex(nonce) : "0x",
+		maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
+		maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
+		gas ? numberToHex(gas) : "0x",
+		to ?? "0x",
+		value ? numberToHex(value) : "0x",
+		data ?? "0x",
+		serializedAccessList,
+		maxFeePerBlobGas ? numberToHex(maxFeePerBlobGas) : "0x",
+		blobVersionedHashes ?? [],
+		...toYParitySignatureArray(transaction, signature)
+	];
+	const blobs = [];
+	const commitments = [];
+	const proofs = [];
+	if (sidecars) for (let i = 0; i < sidecars.length; i++) {
+		const { blob, commitment, proof } = sidecars[i];
+		blobs.push(blob);
+		commitments.push(commitment);
+		proofs.push(proof);
+	}
+	return concatHex(["0x03", sidecars ? toRlp([
+		serializedTransaction,
+		blobs,
+		commitments,
+		proofs
+	]) : toRlp(serializedTransaction)]);
+}
+function serializeTransactionEIP1559(transaction, signature) {
+	const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
+	assertTransactionEIP1559(transaction);
+	const serializedAccessList = serializeAccessList(accessList);
+	const serializedTransaction = [
+		numberToHex(chainId),
+		nonce ? numberToHex(nonce) : "0x",
+		maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
+		maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
+		gas ? numberToHex(gas) : "0x",
+		to ?? "0x",
+		value ? numberToHex(value) : "0x",
+		data ?? "0x",
+		serializedAccessList,
+		...toYParitySignatureArray(transaction, signature)
+	];
+	return concatHex(["0x02", toRlp(serializedTransaction)]);
+}
+function serializeTransactionEIP2930(transaction, signature) {
+	const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
+	assertTransactionEIP2930(transaction);
+	const serializedAccessList = serializeAccessList(accessList);
+	const serializedTransaction = [
+		numberToHex(chainId),
+		nonce ? numberToHex(nonce) : "0x",
+		gasPrice ? numberToHex(gasPrice) : "0x",
+		gas ? numberToHex(gas) : "0x",
+		to ?? "0x",
+		value ? numberToHex(value) : "0x",
+		data ?? "0x",
+		serializedAccessList,
+		...toYParitySignatureArray(transaction, signature)
+	];
+	return concatHex(["0x01", toRlp(serializedTransaction)]);
+}
+function serializeTransactionLegacy(transaction, signature) {
+	const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
+	assertTransactionLegacy(transaction);
+	let serializedTransaction = [
+		nonce ? numberToHex(nonce) : "0x",
+		gasPrice ? numberToHex(gasPrice) : "0x",
+		gas ? numberToHex(gas) : "0x",
+		to ?? "0x",
+		value ? numberToHex(value) : "0x",
+		data ?? "0x"
+	];
+	if (signature) {
+		const v = (() => {
+			if (signature.v >= 35n) {
+				if ((signature.v - 35n) / 2n > 0) return signature.v;
+				return 27n + (signature.v === 35n ? 0n : 1n);
+			}
+			if (chainId > 0) return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
+			const v = 27n + (signature.v === 27n ? 0n : 1n);
+			if (signature.v !== v) throw new InvalidLegacyVError({ v: signature.v });
+			return v;
+		})();
+		const r = trim(signature.r);
+		const s = trim(signature.s);
+		serializedTransaction = [
+			...serializedTransaction,
+			numberToHex(v),
+			r === "0x00" ? "0x" : r,
+			s === "0x00" ? "0x" : s
+		];
+	} else if (chainId > 0) serializedTransaction = [
+		...serializedTransaction,
+		numberToHex(chainId),
+		"0x",
+		"0x"
+	];
+	return toRlp(serializedTransaction);
+}
+function toYParitySignatureArray(transaction, signature_) {
+	const signature = signature_ ?? transaction;
+	const { v, yParity } = signature;
+	if (typeof signature.r === "undefined") return [];
+	if (typeof signature.s === "undefined") return [];
+	if (typeof v === "undefined" && typeof yParity === "undefined") return [];
+	const r = trim(signature.r);
+	const s = trim(signature.s);
+	return [
+		(() => {
+			if (typeof yParity === "number") return yParity ? numberToHex(1) : "0x";
+			if (v === 0n) return "0x";
+			if (v === 1n) return numberToHex(1);
+			return v === 27n ? "0x" : numberToHex(1);
+		})(),
+		r === "0x00" ? "0x" : r,
+		s === "0x00" ? "0x" : s
+	];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/op-stack/contracts.js
+/**
+* Predeploy contracts for OP Stack.
+* @see https://github.com/ethereum-optimism/optimism/blob/develop/specs/predeploys.md
+*/
+const contracts = {
+	gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
+	l1Block: { address: "0x4200000000000000000000000000000000000015" },
+	l2CrossDomainMessenger: { address: "0x4200000000000000000000000000000000000007" },
+	l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
+	l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
+	l2ToL1MessagePasser: { address: "0x4200000000000000000000000000000000000016" }
+};
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/op-stack/formatters.js
+const formatters = {
+	block: /*#__PURE__*/ defineBlock({ format(args) {
+		return {
+			transactions: args.transactions?.map((transaction) => {
+				if (typeof transaction === "string") return transaction;
+				const formatted = formatTransaction(transaction);
+				if (formatted.typeHex === "0x7e") {
+					formatted.isSystemTx = transaction.isSystemTx;
+					formatted.mint = transaction.mint ? hexToBigInt(transaction.mint) : void 0;
+					formatted.sourceHash = transaction.sourceHash;
+					formatted.type = "deposit";
+				}
+				return formatted;
+			}),
+			stateRoot: args.stateRoot
+		};
+	} }),
+	transaction: /*#__PURE__*/ defineTransaction({ format(args) {
+		const transaction = {};
+		if (args.type === "0x7e") {
+			transaction.isSystemTx = args.isSystemTx;
+			transaction.mint = args.mint ? hexToBigInt(args.mint) : void 0;
+			transaction.sourceHash = args.sourceHash;
+			transaction.type = "deposit";
+		}
+		return transaction;
+	} }),
+	transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({ format(args) {
+		return {
+			...args.depositNonce ? { depositNonce: hexToBigInt(args.depositNonce) } : {},
+			...args.depositReceiptVersion ? { depositReceiptVersion: hexToNumber(args.depositReceiptVersion) } : {},
+			l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
+			l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
+			l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
+			l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null
+		};
+	} })
+};
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/op-stack/serializers.js
+function serializeTransaction(transaction, signature) {
+	if (isDeposit(transaction)) return serializeTransactionDeposit(transaction);
+	return serializeTransaction$1(transaction, signature);
+}
+const serializers = { transaction: serializeTransaction };
+function serializeTransactionDeposit(transaction) {
+	assertTransactionDeposit(transaction);
+	const { sourceHash, data, from, gas, isSystemTx, mint, to, value } = transaction;
+	const serializedTransaction = [
+		sourceHash,
+		from,
+		to ?? "0x",
+		mint ? toHex(mint) : "0x",
+		value ? toHex(value) : "0x",
+		gas ? toHex(gas) : "0x",
+		isSystemTx ? "0x1" : "0x",
+		data ?? "0x"
+	];
+	return concatHex(["0x7e", toRlp(serializedTransaction)]);
+}
+function isDeposit(transaction) {
+	if (transaction.type === "deposit") return true;
+	if (typeof transaction.sourceHash !== "undefined") return true;
+	return false;
+}
+function assertTransactionDeposit(transaction) {
+	const { from, to } = transaction;
+	if (from && !isAddress(from)) throw new InvalidAddressError({ address: from });
+	if (to && !isAddress(to)) throw new InvalidAddressError({ address: to });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/op-stack/chainConfig.js
+const chainConfig = {
+	blockTime: 2e3,
+	contracts,
+	formatters,
+	serializers
+};
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/chains/definitions/base.js
+const sourceId$1 = 1;
+const base = /*#__PURE__*/ defineChain({
+	...chainConfig,
+	id: 8453,
+	name: "Base",
+	nativeCurrency: {
+		name: "Ether",
+		symbol: "ETH",
+		decimals: 18
+	},
+	rpcUrls: { default: { http: ["https://mainnet.base.org"] } },
+	blockExplorers: { default: {
+		name: "Basescan",
+		url: "https://basescan.org",
+		apiUrl: "https://api.basescan.org/api"
+	} },
+	contracts: {
+		...chainConfig.contracts,
+		disputeGameFactory: { [sourceId$1]: { address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e" } },
+		l2OutputOracle: { [sourceId$1]: { address: "0x56315b90c40730925ec5485cf004d835058518A0" } },
+		multicall3: {
+			address: "0xca11bde05977b3631167028862be2a173976ca11",
+			blockCreated: 5022
+		},
+		portal: { [sourceId$1]: {
+			address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
+			blockCreated: 17482143
+		} },
+		l1StandardBridge: { [sourceId$1]: {
+			address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
+			blockCreated: 17482143
+		} }
+	},
+	sourceId: sourceId$1
+});
+({ ...base });
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/chains/definitions/baseSepolia.js
+const sourceId = 11155111;
+const baseSepolia = /*#__PURE__*/ defineChain({
+	...chainConfig,
+	id: 84532,
+	network: "base-sepolia",
+	name: "Base Sepolia",
+	nativeCurrency: {
+		name: "Sepolia Ether",
+		symbol: "ETH",
+		decimals: 18
+	},
+	rpcUrls: { default: { http: ["https://sepolia.base.org"] } },
+	blockExplorers: { default: {
+		name: "Basescan",
+		url: "https://sepolia.basescan.org",
+		apiUrl: "https://api-sepolia.basescan.org/api"
+	} },
+	contracts: {
+		...chainConfig.contracts,
+		disputeGameFactory: { [sourceId]: { address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1" } },
+		l2OutputOracle: { [sourceId]: { address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254" } },
+		portal: { [sourceId]: {
+			address: "0x49f53e41452c74589e85ca1677426ba426459e85",
+			blockCreated: 4446677
+		} },
+		l1StandardBridge: { [sourceId]: {
+			address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
+			blockCreated: 4446677
+		} },
+		multicall3: {
+			address: "0xca11bde05977b3631167028862be2a173976ca11",
+			blockCreated: 1059647
+		}
+	},
+	testnet: true,
+	sourceId
+});
+({ ...baseSepolia });
+//#endregion
+//#region ../../packages/protocol/src/evm/networks.ts
+const CHAINS = [base, baseSepolia];
+/** The network for a chain Capxul runs on, or null for any other chain. */
+function networkForChain(chainId) {
+	const chain = CHAINS.find((candidate) => candidate.id === chainId);
+	return chain === void 0 ? null : {
+		chainId,
+		name: chain.name,
+		explorerUrl: chain.blockExplorers.default.url
+	};
+}
+//#endregion
+//#region src/runtime/where.ts
+/** The bundled staging deployment's bootstrap origin. */
+const STAGING_ORIGIN = "https://api.staging.capxul.com";
+/** The standing local DevNet's bootstrap (Convex site) origin. */
+const DEVNET_ORIGIN = "http://127.0.0.1:3211";
+/** Environments `use env` and `--env` accept. Production is not wired yet. */
+const ENVIRONMENT_NAMES = [
+	"staging",
+	"devnet",
+	"production"
+];
+const EMPTY_WHERE = { version: 1 };
+const nonEmpty = (value) => typeof value === "string" && value !== "" ? value : void 0;
+const parseOrganization = (value) => {
+	if (value === null) return null;
+	if (!isRecord(value)) return void 0;
+	const [id, handle, name] = [
+		nonEmpty(value.id),
+		nonEmpty(value.handle),
+		nonEmpty(value.name)
+	];
+	return id === void 0 || handle === void 0 || name === void 0 ? void 0 : {
+		id,
+		handle,
+		name,
+		safe: nonEmpty(value.safe) ?? null
+	};
+};
+const parseOrigin = (value) => {
+	if (!isRecord(value)) return {};
+	const fields = {
+		email: nonEmpty(value.email),
+		authUserId: nonEmpty(value.authUserId),
+		pending: nonEmpty(value.pending),
+		safe: nonEmpty(value.safe),
+		chainId: Number.isSafeInteger(value.chainId) ? Number(value.chainId) : void 0,
+		org: parseOrganization(value.org)
+	};
+	return Object.fromEntries(Object.entries(fields).filter(([, field]) => field !== void 0));
+};
+/** Read `context.json` content. Damaged or foreign content reads as empty: it is a cache. */
+const parseWhere = (content) => {
+	if (content === null) return EMPTY_WHERE;
+	try {
+		const value = JSON.parse(content);
+		if (!isRecord(value) || value.version !== 1) return EMPTY_WHERE;
+		const origins = isRecord(value.origins) ? value.origins : {};
+		const env = nonEmpty(value.env);
+		return {
+			version: 1,
+			...env === void 0 ? {} : { env },
+			origins: Object.fromEntries(Object.entries(origins).map(([origin, saved]) => [origin, parseOrigin(saved)]))
+		};
+	} catch {
+		return EMPTY_WHERE;
+	}
+};
+/** The CLI home folder, from the same variables the runtime configuration reads. */
+const cliHome = (env, join) => env.CAPXUL_CLI_HOME ?? (env.XDG_CONFIG_HOME === void 0 ? env.HOME === void 0 ? void 0 : join(env.HOME, ".config", "capxul", "cli") : join(env.XDG_CONFIG_HOME, "capxul", "cli"));
+/** Every value of a `--name value` or `--name=value` flag, before any `--`. */
+const flagValues = (args, name) => {
+	const end = args.indexOf("--");
+	const flags = end < 0 ? args : args.slice(0, end);
+	return flags.flatMap((arg, index) => arg.startsWith(`--${name}=`) ? [arg.slice(name.length + 3)] : arg === `--${name}` && flags[index + 1] !== void 0 ? [flags[index + 1]] : []);
+};
+/** The last value of one flag, as the parser reads it. */
+const flagValue = (args, name) => flagValues(args, name).at(-1);
+/**
+* The `--org` and `--env` a person typed, for a suggested command line: every
+* command takes them, and without them the suggestion acts somewhere else or
+* refuses (`org payroll run`). A value that is not plain is not echoed.
+*/
+const scopeArgs = (args) => ["org", "env"].flatMap((name) => {
+	const value = flagValue(args, name);
+	return value !== void 0 && /^[\w.@:+-]{1,64}$/u.test(value) ? [`--${name}`, value] : [];
+});
+const isLoopback = (hostname) => hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+/** What an origin points at: bundled staging, the local DevNet, another loopback backend, or custom. */
+const environmentOf = (origin) => {
+	if (origin === "https://api.staging.capxul.com") return "staging";
+	if (origin === "http://127.0.0.1:3211") return "devnet";
+	return URL.canParse(origin) && isLoopback(new URL(origin).hostname) ? "local" : "custom";
+};
+/**
+* Select the deployment: `--env`, then `CAPXUL_ENV`, then `CAPXUL_BOOTSTRAP_URL`,
+* then the environment `use env` saved, then staging.
+*/
+const chooseEnvironment = (input) => {
+	const named = (name, source) => {
+		if (name === "staging") return {
+			origin: STAGING_ORIGIN,
+			source
+		};
+		if (name === "devnet") return {
+			origin: DEVNET_ORIGIN,
+			source
+		};
+		if (name === "production") return { refusal: "Production is not available in this CLI yet. Use staging or devnet." };
+		return { refusal: `Unknown environment "${name}". Use one of: staging, devnet.` };
+	};
+	if (input.flag !== void 0) return named(input.flag, "flag");
+	if (input.variable !== void 0 && input.variable !== "") return named(input.variable, "env");
+	if (input.bootstrapUrl !== void 0 && input.bootstrapUrl !== "") return {
+		origin: input.bootstrapUrl,
+		source: "env"
+	};
+	if (input.saved !== void 0) return named(input.saved, "saved");
+	return {
+		origin: STAGING_ORIGIN,
+		source: "default"
+	};
+};
+/** The network's name, from the chain Capxul data names. */
+const networkName = (chainId) => chainId === null || chainId === void 0 ? null : networkForChain(chainId)?.name ?? `Chain ${chainId}`;
+/** The Organization `--org`, else `CAPXUL_ORG`, names for one command. */
+const explicitOrganization = (flag, variable) => flag !== void 0 ? {
+	value: flag,
+	source: "flag"
+} : variable === void 0 || variable === "" ? void 0 : {
+	value: variable,
+	source: "env"
+};
+/** Who you act as: `--org` or `CAPXUL_ORG`, else the saved Organization, else yourself. */
+const actorOf = (saved, explicit) => {
+	if (explicit === void 0) {
+		const org = saved.org;
+		if (org === null || org === void 0) return { actingAs: {
+			kind: "personal",
+			source: org === null ? "saved" : "default"
+		} };
+		return {
+			known: org,
+			actingAs: {
+				kind: "organization",
+				...org,
+				source: "saved"
+			}
+		};
+	}
+	const wanted = explicit.value.replace(/^@/u, "").toLowerCase();
+	const known = saved.org?.handle.toLowerCase() === wanted || saved.org?.id === explicit.value ? saved.org : void 0;
+	return {
+		known,
+		actingAs: {
+			kind: "organization",
+			handle: known?.handle ?? explicit.value,
+			name: known?.name ?? null,
+			id: known?.id ?? null,
+			source: explicit.source
+		}
+	};
+};
+/** Combine the selected deployment, an explicit Organization, and what this machine saved. */
+const describeWhere = (input) => {
+	const saved = input.saved.origins?.[input.origin] ?? {};
+	const user = saved.email === void 0 ? null : { email: saved.email };
+	const { known, actingAs: actor } = actorOf(saved, input.explicitOrg);
+	const actingAs = actor.kind === "personal" ? actor : {
+		kind: actor.kind,
+		handle: actor.handle,
+		name: actor.name,
+		id: actor.id,
+		source: actor.source
+	};
+	const chainId = saved.chainId ?? null;
+	return {
+		user,
+		actingAs,
+		safe: actingAs.kind === "personal" ? saved.safe ?? null : known?.safe ?? null,
+		env: {
+			name: environmentOf(input.origin),
+			origin: input.origin,
+			source: input.envSource,
+			network: networkName(chainId),
+			chainId
+		}
+	};
+};
+//#endregion
+//#region src/runtime/where-view.ts
+const shortAddress = (address) => /^0x[0-9a-fA-F]{40}$/u.test(address) ? `${address.slice(0, 6)}…${address.slice(-4)}` : address;
+/** Saved names come from other clients: keep terminal control characters out of them. */
+const printable = (value) => value.replace(/[\p{Cc}\p{Cf}]/gu, "?");
+const actorLabel = (where) => where.actingAs.kind === "personal" ? "Personal" : printable(where.actingAs.name ?? where.actingAs.handle);
+const PLAIN = {
+	highlight: (text) => text,
+	dim: (text) => text,
+	bad: (text) => text,
+	good: (text) => text
+};
+const COLOR = {
+	highlight: (text) => `\u001b[33m${text}\u001b[39m`,
+	dim: (text) => `\u001b[2m${text}\u001b[22m`,
+	bad: (text) => `\u001b[31m${text}\u001b[39m`,
+	good: (text) => `\u001b[32m${text}\u001b[39m`
+};
+const styleFor = (tty, env) => tty && (env.NO_COLOR === void 0 || env.NO_COLOR === "") ? COLOR : PLAIN;
+/** `▸ Acme Ltd · staging · Base Sepolia`. Production is the normal case: no label. */
+const headerLine = (where, style) => [
+	`▸ ${actorLabel(where)}`,
+	...where.env.name === "production" ? [] : [style.highlight(where.env.name)],
+	...where.env.network === null ? [] : [where.env.network]
+].join(" · ");
+/** The `whoami` table. Values are padded before styling so columns stay aligned. */
+const whoamiLines = (where, style) => {
+	const row = (label, value, note, styled = value) => `${label.padEnd(11)}${note === void 0 || note === "default" ? styled : `${styled}${" ".repeat(Math.max(2, 23 - value.length))}${style.dim(note)}`}`;
+	const acting = where.actingAs.kind === "personal" ? "yourself" : `${printable(where.actingAs.name ?? where.actingAs.handle)} (org)`;
+	const network = where.env.network === null ? "" : ` · ${where.env.network}`;
+	return [
+		row("user", where.user === null ? "not signed in · capxul auth login" : printable(where.user.email)),
+		row("acting as", acting, where.actingAs.source),
+		...where.safe === null ? [] : [row("safe", shortAddress(where.safe))],
+		row("env", `${where.env.name}${network}`, where.env.source, `${style.highlight(where.env.name)}${network}`)
+	];
+};
+//#endregion
+export { scopeArgs as _, DEVNET_ORIGIN as a, chooseEnvironment as c, environmentOf as d, explicitOrganization as f, parseWhere as g, networkName as h, whoamiLines as i, cliHome as l, flagValues as m, headerLine as n, ENVIRONMENT_NAMES as o, flagValue as p, styleFor as r, STAGING_ORIGIN as s, PLAIN as t, describeWhere as u };
+
+//# sourceMappingURL=where-view-DuGbrSLp.mjs.map