@hashspan/core 0.7.0 → 0.9.0

package/dist/index.cjs

@@ -6,7 +6,7 @@ const ATTR_GEN_AI_AGENT_NAME = "gen_ai.agent.name";
 /**
 * Agent identity as GenAI attributes. A field set in the static identity always wins; Baggage, which a remote caller
 * can set, only fills fields it leaves unset, and is not read at all with `fromBaggage` false
-* (https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.7.0/docs/adr/0011-agent-identity-precedence.md).
+* (https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.9.0/docs/adr/0011-agent-identity-precedence.md).
 */
 function agentAttributes(ctx, identity, fromBaggage = true) {
 	const baggage = fromBaggage ? _opentelemetry_api.propagation.getBaggage(ctx) : void 0;
@@ -22,7 +22,7 @@ function agentAttributes(ctx, identity, fromBaggage = true) {
 /**
 * Attribute keys emitted by hashspan.
 *
-* Stability: development. See https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.7.0/docs/semconv.md for
+* Stability: development. See https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.9.0/docs/semconv.md for
 * definitions and value types. These names are a public contract: changes follow the deprecation policy in AGENTS.md.
 */
 const ATTR_BLOCKCHAIN_SYSTEM = "blockchain.system";
@@ -33,6 +33,12 @@ const ATTR_BLOCKCHAIN_TX_FROM = "blockchain.tx.from";
 const ATTR_BLOCKCHAIN_TX_TO = "blockchain.tx.to";
 const ATTR_BLOCKCHAIN_TX_VALUE = "blockchain.tx.value";
 const ATTR_BLOCKCHAIN_TX_NONCE = "blockchain.tx.nonce";
+/** Number of EIP-7702 authorizations a type 4 transaction carries. */
+const ATTR_BLOCKCHAIN_TX_AUTHORIZATION_COUNT = "blockchain.tx.authorization.count";
+/** Delegated contract address of each well-formed EIP-7702 authorization, per the address mode; at most 64. */
+const ATTR_BLOCKCHAIN_TX_AUTHORIZATION_ADDRESSES = "blockchain.tx.authorization.addresses";
+/** Chain id of each well-formed EIP-7702 authorization, aligned with the addresses; 0 means every chain. */
+const ATTR_BLOCKCHAIN_TX_AUTHORIZATION_CHAIN_IDS = "blockchain.tx.authorization.chain_ids";
 const ATTR_BLOCKCHAIN_TX_STATUS = "blockchain.tx.status";
 const ATTR_BLOCKCHAIN_TX_GAS_USED = "blockchain.tx.gas.used";
 const ATTR_BLOCKCHAIN_TX_EFFECTIVE_GAS_PRICE = "blockchain.tx.effective_gas_price";
@@ -46,12 +52,12 @@ const ATTR_BLOCKCHAIN_CONTRACT_FUNCTION_NAME = "blockchain.contract.function.nam
 const ATTR_BLOCKCHAIN_CONTRACT_FUNCTION_SELECTOR = "blockchain.contract.function.selector";
 /**
 * Opt-in: decoded call arguments as a JSON array. See
-* https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.7.0/docs/adr/0004-privacy-defaults.md.
+* https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.9.0/docs/adr/0004-privacy-defaults.md.
 */
 const ATTR_BLOCKCHAIN_CONTRACT_FUNCTION_ARGUMENTS = "blockchain.contract.function.arguments";
 /**
 * Payments settled on chain by a party other than the agent, e.g. an x402 facilitator. See
-* https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.7.0/docs/adr/0013-x402-payments.md.
+* https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.9.0/docs/adr/0013-x402-payments.md.
 */
 const ATTR_BLOCKCHAIN_PAYMENT_PROTOCOL = "blockchain.payment.protocol";
 const ATTR_BLOCKCHAIN_PAYMENT_PAYER = "blockchain.payment.payer";
@@ -64,12 +70,52 @@ const ATTR_BLOCKCHAIN_PAYMENT_SETTLED_AMOUNT = "blockchain.payment.settled_amoun
 /**
 * Whether the settlement transaction's receipt carries the payment, as checked by the adapter; absent when no check
 * was possible. See
-* https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.7.0/docs/adr/0017-x402-payment-verification.md.
+* https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.9.0/docs/adr/0017-x402-payment-verification.md.
 */
 const ATTR_BLOCKCHAIN_PAYMENT_VERIFIED = "blockchain.payment.verified";
 /** x402's own payment fields. */
 const ATTR_X402_SCHEME = "x402.scheme";
 const ATTR_X402_RESOURCE = "x402.resource";
+/**
+* User operations of ERC-4337 smart accounts. See
+* https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.9.0/docs/adr/0021-user-operations.md.
+*/
+const ATTR_BLOCKCHAIN_USER_OPERATION_HASH = "blockchain.user_operation.hash";
+const ATTR_BLOCKCHAIN_USER_OPERATION_SENDER = "blockchain.user_operation.sender";
+const ATTR_BLOCKCHAIN_USER_OPERATION_ENTRY_POINT = "blockchain.user_operation.entry_point";
+const ATTR_BLOCKCHAIN_USER_OPERATION_CALL_COUNT = "blockchain.user_operation.call_count";
+const ATTR_BLOCKCHAIN_USER_OPERATION_NONCE = "blockchain.user_operation.nonce";
+const ATTR_BLOCKCHAIN_USER_OPERATION_SUCCESS = "blockchain.user_operation.success";
+const ATTR_BLOCKCHAIN_USER_OPERATION_GAS_USED = "blockchain.user_operation.gas.used";
+/** What the operation itself paid, in wei; the bundle transaction's fee covers every operation in the bundle. */
+const ATTR_BLOCKCHAIN_USER_OPERATION_GAS_COST = "blockchain.user_operation.gas.cost";
+const ATTR_BLOCKCHAIN_USER_OPERATION_PAYMASTER = "blockchain.user_operation.paymaster";
+/**
+* The batch id the wallet returned, truncated after 256 characters. See
+* https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.9.0/docs/adr/0022-call-batches.md.
+*/
+const ATTR_BLOCKCHAIN_CALL_BATCH_ID = "blockchain.call_batch.id";
+const ATTR_BLOCKCHAIN_CALL_BATCH_SENDER = "blockchain.call_batch.sender";
+const ATTR_BLOCKCHAIN_CALL_BATCH_CALL_COUNT = "blockchain.call_batch.call_count";
+/** The outcome of a batch from chain data: `success`, `reverted` or `partially_reverted`. */
+const ATTR_BLOCKCHAIN_CALL_BATCH_STATUS = "blockchain.call_batch.status";
+/** The EIP-5792 status code of the batch as the wallet reported it, e.g. 200 confirmed or 500 reverted; spans only. */
+const ATTR_BLOCKCHAIN_CALL_BATCH_STATUS_CODE = "blockchain.call_batch.status_code";
+const ATTR_BLOCKCHAIN_CALL_BATCH_ATOMIC = "blockchain.call_batch.atomic";
+/** Hashes of the transactions whose receipts the wallet reported for the batch. */
+const ATTR_BLOCKCHAIN_CALL_BATCH_TRANSACTION_HASHES = "blockchain.call_batch.transaction_hashes";
+/**
+* Metrics only: what a send, confirmation or fee sample is about. Recorded as `user_operation` on samples of user
+* operations and `call_batch` on those of call batches, and absent on those of transactions.
+*/
+const ATTR_BLOCKCHAIN_OPERATION_SUBJECT = "blockchain.operation.subject";
+/** Values for {@link ATTR_BLOCKCHAIN_OPERATION_SUBJECT}. */
+const BLOCKCHAIN_OPERATION_SUBJECT_VALUE_USER_OPERATION = "user_operation";
+const BLOCKCHAIN_OPERATION_SUBJECT_VALUE_CALL_BATCH = "call_batch";
+/** Values for {@link ATTR_BLOCKCHAIN_CALL_BATCH_STATUS}. */
+const BLOCKCHAIN_CALL_BATCH_STATUS_VALUE_SUCCESS = "success";
+const BLOCKCHAIN_CALL_BATCH_STATUS_VALUE_REVERTED = "reverted";
+const BLOCKCHAIN_CALL_BATCH_STATUS_VALUE_PARTIALLY_REVERTED = "partially_reverted";
 /** Values for {@link ATTR_BLOCKCHAIN_SYSTEM}. */
 const BLOCKCHAIN_SYSTEM_VALUE_EVM = "evm";
 /** Values for {@link ATTR_BLOCKCHAIN_OPERATION_NAME}. */
@@ -88,7 +134,7 @@ const BLOCKCHAIN_TX_STATUS_VALUE_REVERTED = "reverted";
 /**
 * @deprecated No longer recorded: a confirm span that gave up waiting records `error.type` `timeout` and no
 * `blockchain.tx.status`. The constant is removed in 1.0. See
-* https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.7.0/docs/adr/0016-timeout-is-an-observer-outcome.md.
+* https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.9.0/docs/adr/0016-timeout-is-an-observer-outcome.md.
 */
 const BLOCKCHAIN_TX_STATUS_VALUE_TIMEOUT = "timeout";
 const BLOCKCHAIN_TX_STATUS_VALUE_REPLACED = "replaced";
@@ -102,11 +148,20 @@ const ATTR_ERROR_TYPE = "error.type";
 const ERROR_TYPE_VALUE_OTHER = "_OTHER";
 //#endregion
 //#region src/metrics.ts
-/** Duration of a send: from the start of the sending call until the hash is known or the call failed. */
+/**
+* Duration of a send of a transaction or user operation: from the start of the sending call until the hash is known or
+* the call failed.
+*/
 const METRIC_BLOCKCHAIN_CLIENT_SEND_DURATION = "blockchain.client.send.duration";
-/** Duration of a confirmation: from the start of the wait until the receipt, a timeout or a failure. */
+/**
+* Duration of a confirmation of a transaction or user operation: from the start of the wait until the receipt, a
+* timeout or a failure.
+*/
 const METRIC_BLOCKCHAIN_CLIENT_CONFIRMATION_DURATION = "blockchain.client.confirmation.duration";
-/** Total fee of a mined transaction (execution fee plus L1 data fee), in the chain's smallest unit (wei). */
+/**
+* Total fee of a mined transaction (execution fee plus L1 data fee), or the cost of a user operation, in the chain's
+* smallest unit (wei).
+*/
 const METRIC_BLOCKCHAIN_CLIENT_FEE = "blockchain.client.fee";
 const DURATION_BUCKETS = [
 	.05,
@@ -124,6 +179,21 @@ const DURATION_BUCKETS = [
 	300
 ];
 const FEE_BUCKETS = Array.from({ length: 11 }, (_, i) => 10 ** (i + 8));
+const ERROR_CLASS = /^[A-Z][A-Za-z]{0,62}Error$|^Error$/;
+const ERROR_CODE = /^[a-z]{1,32}(_[a-z]{1,32}){0,7}$/;
+/**
+* `attributes` with `error.type` kept only if it is an error class name or a lower-case code, else `_OTHER`. Error
+* names are free text (any `Error.name`), and metrics do not pass through the `redact` hook; the span keeps its own
+* `error.type`.
+*/
+function withMetricErrorType(attributes) {
+	const type = attributes[ATTR_ERROR_TYPE];
+	if (type === void 0) return attributes;
+	return typeof type === "string" && (type === "_OTHER" || ERROR_CLASS.test(type) || ERROR_CODE.test(type)) ? attributes : {
+		...attributes,
+		[ATTR_ERROR_TYPE]: ERROR_TYPE_VALUE_OTHER
+	};
+}
 /** Milliseconds since the epoch of a span time, as the OpenTelemetry API accepts it. */
 function toEpochMs(time) {
 	if (time === void 0) return Date.now();
@@ -141,17 +211,17 @@ function createTxMetrics(meterProvider, name, version) {
 			return {
 				send: meter.createHistogram(METRIC_BLOCKCHAIN_CLIENT_SEND_DURATION, {
 					unit: "s",
-					description: "Duration of sending a transaction, until its hash is known",
+					description: "Duration of sending a transaction or user operation, until its hash is known",
 					advice: { explicitBucketBoundaries: DURATION_BUCKETS }
 				}),
 				confirmation: meter.createHistogram(METRIC_BLOCKCHAIN_CLIENT_CONFIRMATION_DURATION, {
 					unit: "s",
-					description: "Duration of waiting for a transaction receipt",
+					description: "Duration of waiting for a transaction or user operation receipt",
 					advice: { explicitBucketBoundaries: DURATION_BUCKETS }
 				}),
 				fee: meter.createHistogram(METRIC_BLOCKCHAIN_CLIENT_FEE, {
 					unit: "{wei}",
-					description: "Total fee of a mined transaction",
+					description: "Total fee of a mined transaction, or the cost of a user operation",
 					advice: { explicitBucketBoundaries: FEE_BUCKETS }
 				})
 			};
@@ -167,10 +237,10 @@ function createTxMetrics(meterProvider, name, version) {
 	};
 	return {
 		sendDuration: (seconds, attributes) => record("send duration", () => {
-			if (seconds >= 0) get().send.record(seconds, attributes);
+			if (seconds >= 0) get().send.record(seconds, withMetricErrorType(attributes));
 		}),
 		confirmationDuration: (seconds, attributes) => record("confirmation duration", () => {
-			if (seconds >= 0) get().confirmation.record(seconds, attributes);
+			if (seconds >= 0) get().confirmation.record(seconds, withMetricErrorType(attributes));
 		}),
 		fee: (wei, attributes) => record("fee", () => {
 			if (wei >= 0n) get().fee.record(Number(wei), attributes);
@@ -287,7 +357,7 @@ function resolveAddressFormatter(option) {
 		hash: void 0
 	};
 	switch (mode) {
-		case "raw": return formatter((address) => address, false);
+		case "raw": return formatter((address) => address.toLowerCase(), false);
 		case "off": return OFF_ADDRESS_FORMATTER;
 		case "hashed": {
 			const hashFn = hash ?? defaultHash();
@@ -311,6 +381,8 @@ const ADDRESS_LENGTH = 42;
 */
 const MAX_HEX_LENGTH = 66;
 const MAX_MESSAGE_LENGTH = 256;
+/** A URL in free text: `scheme://` up to the next whitespace, quote or bracket; the bounded scheme keeps it linear. */
+const URL_IN_TEXT = /\b[A-Za-z][A-Za-z0-9+.-]{0,31}:\/\/[^\s"'<>()[\]{}]+/g;
 /**
 * Rewrites every address in `text` with the address mode (`<address>` when it records none). In `off` and `hashed`
 * mode, hex values longer than an address become `<hex>`, because they can embed one.
@@ -322,11 +394,12 @@ function formatAddressesIn(text, formatAddress) {
 	});
 }
 /**
-* First line of an error message with addresses per address mode and longer hex data (such as calldata)
-* replaced by `<hex>`. Best effort: other free text is kept, so the redaction hook still runs on the result.
+* First line of an error message with URLs cut to their origin (an RPC URL can carry an API key in its path or
+* query), addresses per address mode and longer hex data (such as calldata) replaced by `<hex>`. Best effort: other
+* free text is kept, so the redaction hook still runs on the result.
 */
 function sanitizeErrorMessage(message, formatAddress) {
-	const sanitized = formatAddressesIn(message.split("\n", 1)[0]?.trim() ?? "", formatAddress).replace(HEX, (hex) => hex.length > MAX_HEX_LENGTH ? "<hex>" : hex);
+	const sanitized = formatAddressesIn((message.split("\n", 1)[0]?.trim() ?? "").replace(URL_IN_TEXT, (url) => hidesUserInfo(url) ? "<url>" : originOf(url) ?? "<url>"), formatAddress).replace(HEX, (hex) => hex.length > MAX_HEX_LENGTH ? "<hex>" : hex);
 	return sanitized.length > MAX_MESSAGE_LENGTH ? `${sanitized.slice(0, MAX_MESSAGE_LENGTH)}...` : sanitized;
 }
 const MAX_ARGUMENTS_LENGTH = 4096;
@@ -429,7 +502,16 @@ function paymentResourceOf(resource, mode) {
 	if (mode === "off" || hidesUserInfo(resource)) return void 0;
 	const recorded = mode === "path" ? sanitizeResource(resource) : originOf(resource);
 	if (recorded === void 0) return void 0;
-	return recorded.length > MAX_RESOURCE_LENGTH ? `${recorded.slice(0, MAX_RESOURCE_LENGTH)}...` : recorded;
+	return cutAt(recorded, MAX_RESOURCE_LENGTH);
+}
+/**
+* `text` cut to `max` characters, followed by `...`. A hex value that the cut splits is dropped whole: the part left
+* is shorter than an address, so the address mode, applied later, would no longer recognise it as one.
+*/
+function cutAt(text, max) {
+	if (text.length <= max) return text;
+	const head = text.slice(0, max);
+	return `${/^[0-9a-fA-F]/.test(text.slice(max)) ? head.replace(/0[xX][0-9a-fA-F]*$/, "") : head}...`;
 }
 /** Longest `x402.resource` recorded; the value comes from the server that asks for the payment. */
 const MAX_RESOURCE_LENGTH = 512;
@@ -463,7 +545,7 @@ function sanitizeResource(resource) {
 }
 //#endregion
 //#region src/version.ts
-const VERSION = "0.7.0";
+const VERSION = "0.9.0";
 //#endregion
 //#region src/tracker.ts
 const INSTRUMENTATION_NAME = "@hashspan/core";
@@ -486,15 +568,42 @@ const NON_SENSITIVE_KEYS = /* @__PURE__ */ new Set([
 	ATTR_BLOCKCHAIN_PAYMENT_PROTOCOL,
 	ATTR_BLOCKCHAIN_PAYMENT_STATUS,
 	ATTR_BLOCKCHAIN_PAYMENT_VERIFIED,
+	ATTR_BLOCKCHAIN_USER_OPERATION_HASH,
+	ATTR_BLOCKCHAIN_USER_OPERATION_SUCCESS,
+	ATTR_BLOCKCHAIN_CALL_BATCH_ID,
+	ATTR_BLOCKCHAIN_CALL_BATCH_STATUS,
 	ATTR_ERROR_TYPE,
 	ATTR_EXCEPTION_TYPE
 ]);
 const TX_HASH = /^0x[0-9a-fA-F]{64}$/;
 const ADDRESS = /^0x[0-9a-fA-F]{40}$/;
+const ZERO_ADDRESS = /^0x0{40}$/;
+/** The value of an own data property of `target`; undefined for an accessor, so no getter of the caller runs. */
+function ownValue(target, key) {
+	if (typeof target !== "object" || target === null) return void 0;
+	const descriptor = Object.getOwnPropertyDescriptor(target, key);
+	return descriptor !== void 0 && "value" in descriptor ? descriptor.value : void 0;
+}
 /** A non-negative integer that fits in 256 bits. */
 const AMOUNT = /^(0|[1-9][0-9]{0,77})$/;
+/** A `0x` hex quantity of at most 256 bits, as JSON-RPC encodes integers. */
+const HEX_QUANTITY = /^0x[0-9a-fA-F]{1,64}$/;
+const MAX_UINT256 = 2n ** 256n - 1n;
+const MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
 /** `error.type` of a wait that gave up: a confirmation or a payment whose outcome was never learned. */
 const OBSERVER_TIMEOUT = "timeout";
+/** `error.type` of a call batch that failed without being included (EIP-5792 status 400). */
+const CALL_BATCH_FAILED = "failed";
+/** A call batch id: `0x`-prefixed hex of at most 8194 characters, the bound EIP-5792 sets. */
+const CALL_BATCH_ID = /^0x[0-9a-fA-F]{1,8192}$/;
+/** Longest call batch id recorded as an attribute. */
+const MAX_CALL_BATCH_ID_ATTRIBUTE_LENGTH = 256;
+/** Most transaction hashes recorded for one call batch. */
+const MAX_CALL_BATCH_TRANSACTION_HASHES = 64;
+/** Most EIP-7702 authorizations listed on a send span; the count covers all of them. */
+const MAX_AUTHORIZATIONS = 64;
+/** EIP-5792 status code of a batch that is still pending. */
+const CALL_BATCH_PENDING = 100;
 const PAYMENT_STATUSES = /* @__PURE__ */ new Set([
 	BLOCKCHAIN_PAYMENT_STATUS_VALUE_SETTLED,
 	BLOCKCHAIN_PAYMENT_STATUS_VALUE_PENDING,
@@ -511,6 +620,11 @@ const noopSend = (parent) => ({
 	end: () => {},
 	fail: () => {}
 });
+const noopUserOperationSend = (parent) => ({
+	context: parent,
+	end: () => {},
+	fail: () => {}
+});
 const NOOP_PAYMENT = {
 	end: () => {},
 	fail: () => {},
@@ -522,6 +636,21 @@ const NOOP_CONFIRM = {
 	timeout: () => {},
 	fail: () => {}
 };
+const NOOP_USER_OPERATION_CONFIRM = {
+	end: () => {},
+	timeout: () => {},
+	fail: () => {}
+};
+const noopCallBatchSend = (parent) => ({
+	context: parent,
+	end: () => {},
+	fail: () => {}
+});
+const NOOP_CALL_BATCH_CONFIRM = {
+	end: () => {},
+	timeout: () => {},
+	fail: () => {}
+};
 /** Runs `fn`, logging instead of throwing: instrumentation must never break the caller. */
 function safely(what, fn, fallback) {
 	try {
@@ -544,12 +673,27 @@ const ERROR_TYPE_OVERRIDE = /^[A-Za-z0-9_.-]{1,64}$/;
 function identifier(value) {
 	return typeof value === "string" && ERROR_TYPE_OVERRIDE.test(value) ? value : void 0;
 }
+/**
+* A non-negative integer of at most 256 bits, from a bigint, a safe integer, or a decimal or `0x` hex string, as
+* bundlers return them; undefined for anything else.
+*/
+function quantity(value) {
+	let parsed;
+	if (typeof value === "bigint") parsed = value;
+	else if (typeof value === "number" && Number.isSafeInteger(value)) parsed = BigInt(value);
+	else if (typeof value === "string" && (AMOUNT.test(value) || HEX_QUANTITY.test(value))) parsed = BigInt(value);
+	return parsed !== void 0 && parsed >= 0n && parsed <= MAX_UINT256 ? parsed : void 0;
+}
+/** A quantity as a number, or undefined when it is none or too large to be one exactly. */
+function smallQuantity(value) {
+	const parsed = quantity(value);
+	return parsed !== void 0 && parsed <= MAX_SAFE_INTEGER ? Number(parsed) : void 0;
+}
 /** A decimal amount, or undefined when `value` is not a non-negative integer. */
 function amount(value) {
 	const text = typeof value === "bigint" ? value.toString() : value;
 	return typeof text === "string" && AMOUNT.test(text) ? text : void 0;
 }
-/** The `error.type` for a failure: an adapter's override when it is a short identifier, else the class name. */
 /** A finite number, an `HrTime` pair or a `Date`: what the deprecated positional `endTime` argument takes. */
 function isTimeInput(value) {
 	if (typeof value === "number") return Number.isFinite(value);
@@ -581,6 +725,7 @@ function handleOptions(second, third) {
 		return {};
 	}
 }
+/** The `error.type` for a failure: an adapter's override when it is a short identifier, else the class name. */
 function reportedErrorType(error, options) {
 	const override = options?.errorType;
 	if (override === void 0) return errorType(error);
@@ -588,9 +733,53 @@ function reportedErrorType(error, options) {
 	_opentelemetry_api.diag.debug("hashspan: ignoring an error type that is not a short identifier");
 	return errorType(error);
 }
+/** A call batch id the tracker keys and records. */
+function isCallBatchId(id) {
+	return typeof id === "string" && CALL_BATCH_ID.test(id);
+}
+/** Whether `status` says the batch is still pending: its wait resolved before an outcome. */
+function isPendingCallBatch(status) {
+	return status?.statusCode === CALL_BATCH_PENDING;
+}
+/**
+* Joins the confirm span for `hash` in `registry`, opening it with `open` for the first handle; undefined when the
+* key recently got a receipt. A receipt from any handle ends the span; a timeout or failure only ends it when it is the
+* last handle still waiting.
+*/
+function joinConfirm(registry, chainId, hash, open) {
+	const current = registry.get(chainId, hash);
+	if (current === "settled") return void 0;
+	let confirm = current;
+	if (!confirm) {
+		confirm = open();
+		registry.start(chainId, hash, confirm);
+	}
+	const shared = confirm;
+	shared.active += 1;
+	let done = false;
+	return {
+		shared,
+		receive: () => {
+			if (done || shared.ended) return false;
+			done = true;
+			shared.active -= 1;
+			shared.ended = true;
+			return true;
+		},
+		withdraw: (end) => {
+			if (done || shared.ended) return;
+			done = true;
+			shared.active -= 1;
+			if (shared.active > 0) return;
+			shared.ended = true;
+			registry.release(chainId, hash, shared);
+			end();
+		}
+	};
+}
 /**
 * Creates a tracker that records transactions as `send` and `confirm` spans, and payments as `payment` spans, with
-* `@opentelemetry/api` (https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.7.0/docs/semconv.md). It makes
+* `@opentelemetry/api` (https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.9.0/docs/semconv.md). It makes
 * no network calls; the caller passes hashes and receipts. Its methods and handles never throw: failures are logged
 * via `diag`, and a method that fails returns a handle that records nothing.
 */
@@ -606,6 +795,22 @@ function createTxTracker(options = {}) {
 	const formatAddress = safely("configure address mode", () => resolveAddressFormatter(options.address), OFF_ADDRESS_FORMATTER);
 	const errorMessages = safely("configure error message mode", () => resolveErrorMessageMode(options.errorMessages), "off");
 	const paymentResource = safely("configure payment resource mode", () => resolvePaymentResourceMode(options.paymentResource), "off");
+	const userOperationLinks = new LinkStore({
+		ttlMs: options.linkTtlMs ?? DEFAULT_LINK_TTL_MS,
+		maxEntries: options.maxTrackedTransactions ?? DEFAULT_MAX_TRACKED
+	});
+	const userOperationConfirmations = new ConfirmRegistry({
+		ttlMs: options.linkTtlMs ?? DEFAULT_LINK_TTL_MS,
+		maxEntries: options.maxTrackedTransactions ?? DEFAULT_MAX_TRACKED
+	});
+	const callBatchLinks = new LinkStore({
+		ttlMs: options.linkTtlMs ?? DEFAULT_LINK_TTL_MS,
+		maxEntries: options.maxTrackedTransactions ?? DEFAULT_MAX_TRACKED
+	});
+	const callBatchConfirmations = new ConfirmRegistry({
+		ttlMs: options.linkTtlMs ?? DEFAULT_LINK_TTL_MS,
+		maxEntries: options.maxTrackedTransactions ?? DEFAULT_MAX_TRACKED
+	});
 	const txMetrics = createTxMetrics(options.meterProvider, INSTRUMENTATION_NAME, VERSION);
 	/** Attributes of a metric: low-cardinality only, never an address, hash or agent identity. */
 	const metricAttributes = (chainId, extra = {}) => ({
@@ -613,6 +818,16 @@ function createTxTracker(options = {}) {
 		[ATTR_BLOCKCHAIN_CHAIN_ID]: chainId,
 		...extra
 	});
+	/** Metric attributes of a user operation sample: as for transactions, plus what the sample is about. */
+	const userOperationMetricAttributes = (chainId, extra = {}) => metricAttributes(chainId, {
+		[ATTR_BLOCKCHAIN_OPERATION_SUBJECT]: BLOCKCHAIN_OPERATION_SUBJECT_VALUE_USER_OPERATION,
+		...extra
+	});
+	/** Metric attributes of a call batch sample. */
+	const callBatchMetricAttributes = (chainId, extra = {}) => metricAttributes(chainId, {
+		[ATTR_BLOCKCHAIN_OPERATION_SUBJECT]: BLOCKCHAIN_OPERATION_SUBJECT_VALUE_CALL_BATCH,
+		...extra
+	});
 	const secondsSince = (startMs, endTime) => (toEpochMs(endTime) - startMs) / 1e3;
 	let tracer;
 	const getTracer = () => {
@@ -638,7 +853,7 @@ function createTxTracker(options = {}) {
 	/**
 	* Exception event attributes for `error`, per the error message mode. The error object itself is never handed to
 	* the SDK: its message and stack can carry addresses and calldata
-	* (https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.7.0/docs/adr/0006-error-privacy.md).
+	* (https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.9.0/docs/adr/0006-error-privacy.md).
 	*/
 	const exceptionAttributes = (type, error) => {
 		const attributes = { [ATTR_EXCEPTION_TYPE]: type };
@@ -693,8 +908,30 @@ function createTxTracker(options = {}) {
 		const formatted = formatAddress(address);
 		if (formatted !== void 0) attributes[key] = formatted;
 	};
-	/** Records `address` only if it is one: payment addresses come from remote parties. */
-	const setPaymentAddress = (attributes, key, address) => {
+	/**
+	* Records an EIP-7702 authorization list: its length, and for each well-formed entry (an address and a non-negative
+	* integer chain id, read from own data properties only) its address per the address mode and its chain id, at most
+	* {@link MAX_AUTHORIZATIONS}. The two lists stay aligned: an entry is listed in both or in neither.
+	*/
+	const setAuthorizations = (attributes, list) => {
+		if (!Array.isArray(list) || list.length === 0) return;
+		attributes[ATTR_BLOCKCHAIN_TX_AUTHORIZATION_COUNT] = list.length;
+		const addresses = [];
+		const chainIds = [];
+		for (const entry of list.slice(0, MAX_AUTHORIZATIONS)) {
+			const address = ownValue(entry, "address");
+			const chainId = ownValue(entry, "chainId");
+			if (typeof address !== "string" || !ADDRESS.test(address)) continue;
+			if (typeof chainId !== "number" || !Number.isSafeInteger(chainId) || chainId < 0) continue;
+			const formatted = formatAddress(address);
+			if (formatted !== void 0) addresses.push(formatted);
+			chainIds.push(chainId);
+		}
+		if (addresses.length > 0) attributes[ATTR_BLOCKCHAIN_TX_AUTHORIZATION_ADDRESSES] = addresses;
+		if (chainIds.length > 0) attributes[ATTR_BLOCKCHAIN_TX_AUTHORIZATION_CHAIN_IDS] = chainIds;
+	};
+	/** Records `address` only if it is one: payment and user operation addresses come from remote parties. */
+	const setRemoteAddress = (attributes, key, address) => {
 		if (typeof address === "string" && ADDRESS.test(address)) setAddress(attributes, key, address);
 	};
 	const baseAttributes = (chainId, operation, ctx) => ({
@@ -710,6 +947,11 @@ function createTxTracker(options = {}) {
 		setAddress(attributes, ATTR_BLOCKCHAIN_TX_TO, input.to);
 		if (input.value !== void 0) attributes[ATTR_BLOCKCHAIN_TX_VALUE] = input.value.toString();
 		if (input.nonce !== void 0) attributes[ATTR_BLOCKCHAIN_TX_NONCE] = input.nonce;
+		try {
+			setAuthorizations(attributes, input.authorizations);
+		} catch (error) {
+			_opentelemetry_api.diag.debug(`hashspan: could not record authorizations (${errorType(error)})`);
+		}
 		if (input.functionName !== void 0) attributes[ATTR_BLOCKCHAIN_CONTRACT_FUNCTION_NAME] = input.functionName;
 		if (input.functionSelector !== void 0) attributes[ATTR_BLOCKCHAIN_CONTRACT_FUNCTION_SELECTOR] = input.functionSelector;
 		if (options.recordFunctionArguments === true && input.functionArguments !== void 0) try {
@@ -830,7 +1072,7 @@ function createTxTracker(options = {}) {
 	};
 	/**
 	* Ends `shared` with `receipt`, attributing it to the transaction that was mined
-	* (https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.7.0/docs/adr/0008-replaced-transactions.md).
+	* (https://github.com/selimaytac/hashspan/blob/@hashspan/core@0.9.0/docs/adr/0008-replaced-transactions.md).
 	*/
 	const endWithReceipt = (chainId, hash, shared, receipt, endTime) => {
 		const mined = receipt.transactionHash;
@@ -860,41 +1102,22 @@ function createTxTracker(options = {}) {
 	*/
 	const startConfirm = (input, parentCtx) => {
 		const { chainId, hash } = input;
-		const current = confirmations.get(chainId, hash);
-		if (current === "settled") return NOOP_CONFIRM;
-		let confirm = current;
-		if (!confirm) {
-			confirm = openConfirm(input, parentCtx);
-			confirmations.start(chainId, hash, confirm);
-		}
-		const shared = confirm;
-		shared.active += 1;
-		let done = false;
-		const withdraw = (end) => {
-			if (done || shared.ended) return;
-			done = true;
-			shared.active -= 1;
-			if (shared.active > 0) return;
-			shared.ended = true;
-			confirmations.release(chainId, hash, shared);
-			end();
-		};
+		const claim = joinConfirm(confirmations, chainId, hash, () => openConfirm(input, parentCtx));
+		if (!claim) return NOOP_CONFIRM;
+		const { shared } = claim;
 		return {
 			end: (receipt, second) => {
 				const { endTime } = handleOptions(second);
-				if (done || shared.ended) return;
-				done = true;
-				shared.active -= 1;
-				shared.ended = true;
+				if (!claim.receive()) return;
 				safely("record receipt", () => endWithReceipt(chainId, hash, shared, receipt, endTime), void 0);
 			},
 			timeout: (second) => {
 				const { endTime } = handleOptions(second);
-				withdraw(() => shared.timeout(endTime));
+				claim.withdraw(() => shared.timeout(endTime));
 			},
 			fail: (error, second) => {
 				const { endTime } = handleOptions(second);
-				withdraw(() => shared.fail(error, endTime));
+				claim.withdraw(() => shared.fail(error, endTime));
 			}
 		};
 	};
@@ -903,10 +1126,10 @@ function createTxTracker(options = {}) {
 		const attributes = baseAttributes(input.chainId, BLOCKCHAIN_OPERATION_NAME_VALUE_PAYMENT, parent);
 		const protocol = identifier(input.protocol);
 		if (protocol !== void 0) attributes[ATTR_BLOCKCHAIN_PAYMENT_PROTOCOL] = protocol;
-		setPaymentAddress(attributes, ATTR_BLOCKCHAIN_PAYMENT_PAYER, input.payer);
+		setRemoteAddress(attributes, ATTR_BLOCKCHAIN_PAYMENT_PAYER, input.payer);
 		const knownPayer = typeof input.payer === "string" && ADDRESS.test(input.payer);
-		setPaymentAddress(attributes, ATTR_BLOCKCHAIN_PAYMENT_RECIPIENT, input.recipient);
-		setPaymentAddress(attributes, ATTR_BLOCKCHAIN_PAYMENT_ASSET, input.asset);
+		setRemoteAddress(attributes, ATTR_BLOCKCHAIN_PAYMENT_RECIPIENT, input.recipient);
+		setRemoteAddress(attributes, ATTR_BLOCKCHAIN_PAYMENT_ASSET, input.asset);
 		const paid = amount(input.amount);
 		if (paid !== void 0) attributes[ATTR_BLOCKCHAIN_PAYMENT_AMOUNT] = paid;
 		const scheme = identifier(input.x402?.scheme);
@@ -938,7 +1161,7 @@ function createTxTracker(options = {}) {
 			const settled = { [ATTR_BLOCKCHAIN_PAYMENT_STATUS]: status };
 			const hash = settlement.hash;
 			if (linkHash(hash)) settled[ATTR_BLOCKCHAIN_TX_HASH] = hash;
-			if (!knownPayer) setPaymentAddress(settled, ATTR_BLOCKCHAIN_PAYMENT_PAYER, settlement.payer);
+			if (!knownPayer) setRemoteAddress(settled, ATTR_BLOCKCHAIN_PAYMENT_PAYER, settlement.payer);
 			const settledAmount = amount(settlement.amount);
 			if (settledAmount !== void 0) {
 				settled[ATTR_BLOCKCHAIN_PAYMENT_SETTLED_AMOUNT] = settledAmount;
@@ -959,19 +1182,312 @@ function createTxTracker(options = {}) {
 			link: (hash) => safely("link the payment span", () => void linkHash(hash), void 0)
 		};
 	};
+	const startUserOperationSend = (input, parentCtx) => {
+		const parent = parentCtx ?? _opentelemetry_api.context.active();
+		const { chainId } = input;
+		const attributes = baseAttributes(chainId, BLOCKCHAIN_OPERATION_NAME_VALUE_SEND, parent);
+		setRemoteAddress(attributes, ATTR_BLOCKCHAIN_USER_OPERATION_SENDER, input.sender);
+		setRemoteAddress(attributes, ATTR_BLOCKCHAIN_USER_OPERATION_ENTRY_POINT, input.entryPoint);
+		const callCount = smallQuantity(input.callCount);
+		if (callCount !== void 0) attributes[ATTR_BLOCKCHAIN_USER_OPERATION_CALL_COUNT] = callCount;
+		const span = getTracer().startSpan(`send ${chainId}`, {
+			kind: _opentelemetry_api.SpanKind.CLIENT,
+			attributes: redact(attributes),
+			...input.startTime !== void 0 ? { startTime: input.startTime } : {}
+		}, parent);
+		const finish = finisher(span);
+		const startMs = toEpochMs(input.startTime);
+		const recordSend = (endTime, errorType) => txMetrics.sendDuration(secondsSince(startMs, endTime), userOperationMetricAttributes(chainId, errorType === void 0 ? {} : { [ATTR_ERROR_TYPE]: errorType }));
+		return {
+			context: _opentelemetry_api.trace.setSpan(parent, span),
+			end: (result, second) => {
+				const { endTime } = handleOptions(second);
+				finish("record user operation hash", () => {
+					const hash = result?.userOpHash;
+					if (typeof hash !== "string" || !TX_HASH.test(hash)) {
+						_opentelemetry_api.diag.debug("hashspan: ending a send span without a valid user operation hash");
+						return;
+					}
+					userOperationLinks.set(chainId, hash, {
+						spanContext: span.spanContext(),
+						parent
+					});
+					span.setAttributes(redact({ [ATTR_BLOCKCHAIN_USER_OPERATION_HASH]: hash }));
+					recordSend(endTime);
+				}, endTime);
+			},
+			fail: (error, second) => {
+				const read = handleOptions(second);
+				finish("record user operation send failure", () => recordSend(read.endTime, markError(span, reportedErrorType(error, read), error, errorType(error))), read.endTime);
+			}
+		};
+	};
+	/**
+	* Attributes of a user operation receipt. Its values come from a bundler: what is malformed is left out. The bundle
+	* transaction's status, gas and fee are not recorded: they cover every operation in the bundle (ADR 0021).
+	*/
+	const userOperationReceiptAttributes = (receipt) => {
+		const attributes = {};
+		const success = receipt.success;
+		if (typeof success === "boolean") attributes[ATTR_BLOCKCHAIN_USER_OPERATION_SUCCESS] = success;
+		const gasUsed = smallQuantity(receipt.actualGasUsed);
+		if (gasUsed !== void 0) attributes[ATTR_BLOCKCHAIN_USER_OPERATION_GAS_USED] = gasUsed;
+		const gasCost = quantity(receipt.actualGasCost);
+		if (gasCost !== void 0) attributes[ATTR_BLOCKCHAIN_USER_OPERATION_GAS_COST] = gasCost.toString();
+		setRemoteAddress(attributes, ATTR_BLOCKCHAIN_USER_OPERATION_SENDER, receipt.sender);
+		const nonce = quantity(receipt.nonce);
+		if (nonce !== void 0) attributes[ATTR_BLOCKCHAIN_USER_OPERATION_NONCE] = nonce.toString();
+		const paymaster = receipt.paymaster;
+		if (typeof paymaster === "string" && !ZERO_ADDRESS.test(paymaster)) setRemoteAddress(attributes, ATTR_BLOCKCHAIN_USER_OPERATION_PAYMASTER, paymaster);
+		setRemoteAddress(attributes, ATTR_BLOCKCHAIN_USER_OPERATION_ENTRY_POINT, receipt.entryPoint);
+		const reason = receipt.revertReason;
+		if (typeof reason === "string") attributes[ATTR_BLOCKCHAIN_TX_REVERT_REASON] = formatAddressesIn(reason, formatAddress);
+		const bundle = receipt.transactionHash;
+		if (typeof bundle === "string" && TX_HASH.test(bundle)) attributes[ATTR_BLOCKCHAIN_TX_HASH] = bundle;
+		const block = smallQuantity(receipt.blockNumber);
+		if (block !== void 0) attributes[ATTR_BLOCKCHAIN_BLOCK_NUMBER] = block;
+		return attributes;
+	};
+	/** Opens the confirm span of a user operation. */
+	const openUserOperationConfirm = (input, parentCtx) => {
+		const { chainId, userOpHash } = input;
+		const sent = userOperationLinks.get(chainId, userOpHash);
+		const active = _opentelemetry_api.context.active();
+		const parent = parentCtx ?? (_opentelemetry_api.trace.getSpan(active) ? active : sent?.parent ?? active);
+		const attributes = baseAttributes(chainId, BLOCKCHAIN_OPERATION_NAME_VALUE_CONFIRM, parent);
+		attributes[ATTR_BLOCKCHAIN_USER_OPERATION_HASH] = userOpHash;
+		const span = getTracer().startSpan(`confirm ${chainId}`, {
+			kind: _opentelemetry_api.SpanKind.CLIENT,
+			attributes: redact(attributes),
+			links: sent ? [{ context: sent.spanContext }] : [],
+			...input.startTime !== void 0 ? { startTime: input.startTime } : {}
+		}, parent);
+		const finish = finisher(span);
+		const startMs = toEpochMs(input.startTime);
+		const recordConfirmation = (endTime, outcome) => txMetrics.confirmationDuration(secondsSince(startMs, endTime), userOperationMetricAttributes(chainId, outcome));
+		return {
+			active: 0,
+			ended: false,
+			receipt: (receipt, endTime) => finish("record user operation receipt", () => {
+				const attributes = userOperationReceiptAttributes(receipt ?? {});
+				span.setAttributes(redact(attributes));
+				const success = attributes[ATTR_BLOCKCHAIN_USER_OPERATION_SUCCESS];
+				if (success === false) markError(span, BLOCKCHAIN_TX_STATUS_VALUE_REVERTED);
+				const outcome = typeof success === "boolean" ? { [ATTR_BLOCKCHAIN_USER_OPERATION_SUCCESS]: success } : {};
+				recordConfirmation(endTime, outcome);
+				const cost = attributes[ATTR_BLOCKCHAIN_USER_OPERATION_GAS_COST];
+				if (typeof cost === "string") txMetrics.fee(BigInt(cost), userOperationMetricAttributes(chainId, outcome));
+			}, endTime),
+			timeout: (endTime) => finish("record user operation confirmation timeout", () => recordConfirmation(endTime, { [ATTR_ERROR_TYPE]: markError(span, OBSERVER_TIMEOUT) }), endTime),
+			fail: (error, read) => finish("record user operation confirmation failure", () => recordConfirmation(read.endTime, { [ATTR_ERROR_TYPE]: markError(span, reportedErrorType(error, read), error, errorType(error)) }), read.endTime)
+		};
+	};
+	const startUserOperationConfirm = (input, parentCtx) => {
+		const { chainId, userOpHash } = input;
+		if (typeof userOpHash !== "string" || !TX_HASH.test(userOpHash)) {
+			_opentelemetry_api.diag.debug("hashspan: not confirming a user operation without a valid hash");
+			return NOOP_USER_OPERATION_CONFIRM;
+		}
+		const claim = joinConfirm(userOperationConfirmations, chainId, userOpHash, () => openUserOperationConfirm(input, parentCtx));
+		if (!claim) return NOOP_USER_OPERATION_CONFIRM;
+		const { shared } = claim;
+		return {
+			end: (receipt, second) => {
+				const { endTime } = handleOptions(second);
+				if (!claim.receive()) return;
+				userOperationConfirmations.settle(chainId, userOpHash, shared);
+				shared.receipt(receipt, endTime);
+			},
+			timeout: (second) => {
+				const { endTime } = handleOptions(second);
+				claim.withdraw(() => shared.timeout(endTime));
+			},
+			fail: (error, second) => {
+				const read = handleOptions(second);
+				claim.withdraw(() => shared.fail(error, read));
+			}
+		};
+	};
+	const startCallBatchSend = (input, parentCtx) => {
+		const parent = parentCtx ?? _opentelemetry_api.context.active();
+		const { chainId } = input;
+		const attributes = baseAttributes(chainId, BLOCKCHAIN_OPERATION_NAME_VALUE_SEND, parent);
+		setRemoteAddress(attributes, ATTR_BLOCKCHAIN_CALL_BATCH_SENDER, input.sender);
+		const callCount = smallQuantity(input.callCount);
+		if (callCount !== void 0) attributes[ATTR_BLOCKCHAIN_CALL_BATCH_CALL_COUNT] = callCount;
+		const span = getTracer().startSpan(`send ${chainId}`, {
+			kind: _opentelemetry_api.SpanKind.CLIENT,
+			attributes: redact(attributes),
+			...input.startTime !== void 0 ? { startTime: input.startTime } : {}
+		}, parent);
+		const finish = finisher(span);
+		const startMs = toEpochMs(input.startTime);
+		const recordSend = (endTime, errorType) => txMetrics.sendDuration(secondsSince(startMs, endTime), callBatchMetricAttributes(chainId, errorType === void 0 ? {} : { [ATTR_ERROR_TYPE]: errorType }));
+		return {
+			context: _opentelemetry_api.trace.setSpan(parent, span),
+			end: (result, second) => {
+				const { endTime } = handleOptions(second);
+				finish("record call batch id", () => {
+					const id = result?.id;
+					if (!isCallBatchId(id)) {
+						_opentelemetry_api.diag.debug("hashspan: ending a send span without a valid call batch id");
+						return;
+					}
+					const sent = {
+						spanContext: span.spanContext(),
+						parent
+					};
+					callBatchLinks.set(chainId, id, sent);
+					const hashes = result.transactionHashes;
+					if (Array.isArray(hashes)) {
+						for (const hash of hashes) if (typeof hash === "string" && TX_HASH.test(hash) && !/^0x0+$/.test(hash)) links.set(chainId, hash, sent);
+					}
+					span.setAttributes(redact({ [ATTR_BLOCKCHAIN_CALL_BATCH_ID]: id.slice(0, MAX_CALL_BATCH_ID_ATTRIBUTE_LENGTH) }));
+					recordSend(endTime);
+				}, endTime);
+			},
+			fail: (error, second) => {
+				const read = handleOptions(second);
+				finish("record call batch send failure", () => recordSend(read.endTime, markError(span, reportedErrorType(error, read), error, errorType(error))), read.endTime);
+			}
+		};
+	};
+	/** Attributes of a call batch status. Its values come from a wallet: what is malformed is left out. */
+	const callBatchStatusAttributes = (status) => {
+		const attributes = {};
+		const code = smallQuantity(status.statusCode);
+		if (code !== void 0) attributes[ATTR_BLOCKCHAIN_CALL_BATCH_STATUS_CODE] = code;
+		const atomic = status.atomic;
+		if (typeof atomic === "boolean") attributes[ATTR_BLOCKCHAIN_CALL_BATCH_ATOMIC] = atomic;
+		const receipts = status.receipts;
+		if (Array.isArray(receipts)) {
+			const hashes = [];
+			const seen = /* @__PURE__ */ new Set();
+			let block;
+			for (const receipt of receipts) {
+				const hash = receipt?.transactionHash;
+				if (typeof hash === "string" && TX_HASH.test(hash) && !seen.has(hash.toLowerCase()) && hashes.length < MAX_CALL_BATCH_TRANSACTION_HASHES) {
+					seen.add(hash.toLowerCase());
+					hashes.push(hash);
+				}
+				const number = smallQuantity(receipt?.blockNumber);
+				if (number !== void 0 && (block === void 0 || number > block)) block = number;
+			}
+			if (hashes.length > 0) attributes[ATTR_BLOCKCHAIN_CALL_BATCH_TRANSACTION_HASHES] = hashes;
+			if (block !== void 0) attributes[ATTR_BLOCKCHAIN_BLOCK_NUMBER] = block;
+		}
+		return attributes;
+	};
+	/**
+	* The outcome of an EIP-5792 status code (ADR 0022): `blockchain.call_batch.status` for outcomes from chain data,
+	* `error.type` for the rest; a code the spec does not define, or none, is `_OTHER`.
+	*/
+	const callBatchOutcome = (code) => {
+		switch (code) {
+			case 200: return { status: BLOCKCHAIN_CALL_BATCH_STATUS_VALUE_SUCCESS };
+			case 400: return { errorType: CALL_BATCH_FAILED };
+			case 500: return {
+				status: BLOCKCHAIN_CALL_BATCH_STATUS_VALUE_REVERTED,
+				errorType: BLOCKCHAIN_CALL_BATCH_STATUS_VALUE_REVERTED
+			};
+			case 600: return {
+				status: BLOCKCHAIN_CALL_BATCH_STATUS_VALUE_PARTIALLY_REVERTED,
+				errorType: BLOCKCHAIN_CALL_BATCH_STATUS_VALUE_PARTIALLY_REVERTED
+			};
+			default: return { errorType: ERROR_TYPE_VALUE_OTHER };
+		}
+	};
+	/** Opens the confirm span of a call batch. */
+	const openCallBatchConfirm = (input, parentCtx) => {
+		const { chainId, id } = input;
+		const sent = callBatchLinks.get(chainId, id);
+		const active = _opentelemetry_api.context.active();
+		const parent = parentCtx ?? (_opentelemetry_api.trace.getSpan(active) ? active : sent?.parent ?? active);
+		const attributes = baseAttributes(chainId, BLOCKCHAIN_OPERATION_NAME_VALUE_CONFIRM, parent);
+		attributes[ATTR_BLOCKCHAIN_CALL_BATCH_ID] = id.slice(0, MAX_CALL_BATCH_ID_ATTRIBUTE_LENGTH);
+		const span = getTracer().startSpan(`confirm ${chainId}`, {
+			kind: _opentelemetry_api.SpanKind.CLIENT,
+			attributes: redact(attributes),
+			links: sent ? [{ context: sent.spanContext }] : [],
+			...input.startTime !== void 0 ? { startTime: input.startTime } : {}
+		}, parent);
+		const finish = finisher(span);
+		const startMs = toEpochMs(input.startTime);
+		const recordConfirmation = (endTime, outcome) => txMetrics.confirmationDuration(secondsSince(startMs, endTime), callBatchMetricAttributes(chainId, outcome));
+		return {
+			active: 0,
+			ended: false,
+			status: (status, endTime) => finish("record call batch status", () => {
+				const attributes = callBatchStatusAttributes(status ?? {});
+				if (isPendingCallBatch(status)) {
+					span.setAttributes(redact(attributes));
+					return;
+				}
+				const outcome = callBatchOutcome(status?.statusCode);
+				if (outcome.status !== void 0) attributes[ATTR_BLOCKCHAIN_CALL_BATCH_STATUS] = outcome.status;
+				span.setAttributes(redact(attributes));
+				if (outcome.errorType !== void 0) markError(span, outcome.errorType);
+				recordConfirmation(endTime, outcome.status !== void 0 ? { [ATTR_BLOCKCHAIN_CALL_BATCH_STATUS]: outcome.status } : { [ATTR_ERROR_TYPE]: outcome.errorType });
+			}, endTime),
+			timeout: (endTime) => finish("record call batch confirmation timeout", () => recordConfirmation(endTime, { [ATTR_ERROR_TYPE]: markError(span, OBSERVER_TIMEOUT) }), endTime),
+			fail: (error, read) => finish("record call batch confirmation failure", () => recordConfirmation(read.endTime, { [ATTR_ERROR_TYPE]: markError(span, reportedErrorType(error, read), error, errorType(error)) }), read.endTime)
+		};
+	};
+	const startCallBatchConfirm = (input, parentCtx) => {
+		const { chainId, id } = input;
+		if (!isCallBatchId(id)) {
+			_opentelemetry_api.diag.debug("hashspan: not confirming a call batch without a valid id");
+			return NOOP_CALL_BATCH_CONFIRM;
+		}
+		const claim = joinConfirm(callBatchConfirmations, chainId, id, () => openCallBatchConfirm(input, parentCtx));
+		if (!claim) return NOOP_CALL_BATCH_CONFIRM;
+		const { shared } = claim;
+		return {
+			end: (status, second) => {
+				const { endTime } = handleOptions(second);
+				if (isPendingCallBatch(status)) {
+					claim.withdraw(() => shared.status(status, endTime));
+					return;
+				}
+				if (!claim.receive()) return;
+				callBatchConfirmations.settle(chainId, id, shared);
+				shared.status(status, endTime);
+			},
+			timeout: (second) => {
+				const { endTime } = handleOptions(second);
+				claim.withdraw(() => shared.timeout(endTime));
+			},
+			fail: (error, second) => {
+				const read = handleOptions(second);
+				claim.withdraw(() => shared.fail(error, read));
+			}
+		};
+	};
 	return {
 		startSend: (input, parent) => safely("start send span", () => startSend(input, parent), noopSend(parent ?? _opentelemetry_api.context.active())),
 		startConfirm: (input, parent) => safely("start confirm span", () => startConfirm(input, parent), NOOP_CONFIRM),
-		startPayment: (input, parent) => safely("start payment span", () => startPayment(input, parent), NOOP_PAYMENT)
+		startPayment: (input, parent) => safely("start payment span", () => startPayment(input, parent), NOOP_PAYMENT),
+		startUserOperationSend: (input, parent) => safely("start user operation send span", () => startUserOperationSend(input, parent), noopUserOperationSend(parent ?? _opentelemetry_api.context.active())),
+		startUserOperationConfirm: (input, parent) => safely("start user operation confirm span", () => startUserOperationConfirm(input, parent), NOOP_USER_OPERATION_CONFIRM),
+		startCallBatchSend: (input, parent) => safely("start call batch send span", () => startCallBatchSend(input, parent), noopCallBatchSend(parent ?? _opentelemetry_api.context.active())),
+		startCallBatchConfirm: (input, parent) => safely("start call batch confirm span", () => startCallBatchConfirm(input, parent), NOOP_CALL_BATCH_CONFIRM)
 	};
 }
 //#endregion
 exports.ATTR_BLOCKCHAIN_BLOCK_NUMBER = ATTR_BLOCKCHAIN_BLOCK_NUMBER;
+exports.ATTR_BLOCKCHAIN_CALL_BATCH_ATOMIC = ATTR_BLOCKCHAIN_CALL_BATCH_ATOMIC;
+exports.ATTR_BLOCKCHAIN_CALL_BATCH_CALL_COUNT = ATTR_BLOCKCHAIN_CALL_BATCH_CALL_COUNT;
+exports.ATTR_BLOCKCHAIN_CALL_BATCH_ID = ATTR_BLOCKCHAIN_CALL_BATCH_ID;
+exports.ATTR_BLOCKCHAIN_CALL_BATCH_SENDER = ATTR_BLOCKCHAIN_CALL_BATCH_SENDER;
+exports.ATTR_BLOCKCHAIN_CALL_BATCH_STATUS = ATTR_BLOCKCHAIN_CALL_BATCH_STATUS;
+exports.ATTR_BLOCKCHAIN_CALL_BATCH_STATUS_CODE = ATTR_BLOCKCHAIN_CALL_BATCH_STATUS_CODE;
+exports.ATTR_BLOCKCHAIN_CALL_BATCH_TRANSACTION_HASHES = ATTR_BLOCKCHAIN_CALL_BATCH_TRANSACTION_HASHES;
 exports.ATTR_BLOCKCHAIN_CHAIN_ID = ATTR_BLOCKCHAIN_CHAIN_ID;
 exports.ATTR_BLOCKCHAIN_CONTRACT_FUNCTION_ARGUMENTS = ATTR_BLOCKCHAIN_CONTRACT_FUNCTION_ARGUMENTS;
 exports.ATTR_BLOCKCHAIN_CONTRACT_FUNCTION_NAME = ATTR_BLOCKCHAIN_CONTRACT_FUNCTION_NAME;
 exports.ATTR_BLOCKCHAIN_CONTRACT_FUNCTION_SELECTOR = ATTR_BLOCKCHAIN_CONTRACT_FUNCTION_SELECTOR;
 exports.ATTR_BLOCKCHAIN_OPERATION_NAME = ATTR_BLOCKCHAIN_OPERATION_NAME;
+exports.ATTR_BLOCKCHAIN_OPERATION_SUBJECT = ATTR_BLOCKCHAIN_OPERATION_SUBJECT;
 exports.ATTR_BLOCKCHAIN_PAYMENT_AMOUNT = ATTR_BLOCKCHAIN_PAYMENT_AMOUNT;
 exports.ATTR_BLOCKCHAIN_PAYMENT_ASSET = ATTR_BLOCKCHAIN_PAYMENT_ASSET;
 exports.ATTR_BLOCKCHAIN_PAYMENT_PAYER = ATTR_BLOCKCHAIN_PAYMENT_PAYER;
@@ -981,6 +1497,9 @@ exports.ATTR_BLOCKCHAIN_PAYMENT_SETTLED_AMOUNT = ATTR_BLOCKCHAIN_PAYMENT_SETTLED
 exports.ATTR_BLOCKCHAIN_PAYMENT_STATUS = ATTR_BLOCKCHAIN_PAYMENT_STATUS;
 exports.ATTR_BLOCKCHAIN_PAYMENT_VERIFIED = ATTR_BLOCKCHAIN_PAYMENT_VERIFIED;
 exports.ATTR_BLOCKCHAIN_SYSTEM = ATTR_BLOCKCHAIN_SYSTEM;
+exports.ATTR_BLOCKCHAIN_TX_AUTHORIZATION_ADDRESSES = ATTR_BLOCKCHAIN_TX_AUTHORIZATION_ADDRESSES;
+exports.ATTR_BLOCKCHAIN_TX_AUTHORIZATION_CHAIN_IDS = ATTR_BLOCKCHAIN_TX_AUTHORIZATION_CHAIN_IDS;
+exports.ATTR_BLOCKCHAIN_TX_AUTHORIZATION_COUNT = ATTR_BLOCKCHAIN_TX_AUTHORIZATION_COUNT;
 exports.ATTR_BLOCKCHAIN_TX_EFFECTIVE_GAS_PRICE = ATTR_BLOCKCHAIN_TX_EFFECTIVE_GAS_PRICE;
 exports.ATTR_BLOCKCHAIN_TX_FEE = ATTR_BLOCKCHAIN_TX_FEE;
 exports.ATTR_BLOCKCHAIN_TX_FROM = ATTR_BLOCKCHAIN_TX_FROM;
@@ -994,14 +1513,28 @@ exports.ATTR_BLOCKCHAIN_TX_REVERT_REASON = ATTR_BLOCKCHAIN_TX_REVERT_REASON;
 exports.ATTR_BLOCKCHAIN_TX_STATUS = ATTR_BLOCKCHAIN_TX_STATUS;
 exports.ATTR_BLOCKCHAIN_TX_TO = ATTR_BLOCKCHAIN_TX_TO;
 exports.ATTR_BLOCKCHAIN_TX_VALUE = ATTR_BLOCKCHAIN_TX_VALUE;
+exports.ATTR_BLOCKCHAIN_USER_OPERATION_CALL_COUNT = ATTR_BLOCKCHAIN_USER_OPERATION_CALL_COUNT;
+exports.ATTR_BLOCKCHAIN_USER_OPERATION_ENTRY_POINT = ATTR_BLOCKCHAIN_USER_OPERATION_ENTRY_POINT;
+exports.ATTR_BLOCKCHAIN_USER_OPERATION_GAS_COST = ATTR_BLOCKCHAIN_USER_OPERATION_GAS_COST;
+exports.ATTR_BLOCKCHAIN_USER_OPERATION_GAS_USED = ATTR_BLOCKCHAIN_USER_OPERATION_GAS_USED;
+exports.ATTR_BLOCKCHAIN_USER_OPERATION_HASH = ATTR_BLOCKCHAIN_USER_OPERATION_HASH;
+exports.ATTR_BLOCKCHAIN_USER_OPERATION_NONCE = ATTR_BLOCKCHAIN_USER_OPERATION_NONCE;
+exports.ATTR_BLOCKCHAIN_USER_OPERATION_PAYMASTER = ATTR_BLOCKCHAIN_USER_OPERATION_PAYMASTER;
+exports.ATTR_BLOCKCHAIN_USER_OPERATION_SENDER = ATTR_BLOCKCHAIN_USER_OPERATION_SENDER;
+exports.ATTR_BLOCKCHAIN_USER_OPERATION_SUCCESS = ATTR_BLOCKCHAIN_USER_OPERATION_SUCCESS;
 exports.ATTR_ERROR_TYPE = ATTR_ERROR_TYPE;
 exports.ATTR_GEN_AI_AGENT_ID = ATTR_GEN_AI_AGENT_ID;
 exports.ATTR_GEN_AI_AGENT_NAME = ATTR_GEN_AI_AGENT_NAME;
 exports.ATTR_X402_RESOURCE = ATTR_X402_RESOURCE;
 exports.ATTR_X402_SCHEME = ATTR_X402_SCHEME;
+exports.BLOCKCHAIN_CALL_BATCH_STATUS_VALUE_PARTIALLY_REVERTED = BLOCKCHAIN_CALL_BATCH_STATUS_VALUE_PARTIALLY_REVERTED;
+exports.BLOCKCHAIN_CALL_BATCH_STATUS_VALUE_REVERTED = BLOCKCHAIN_CALL_BATCH_STATUS_VALUE_REVERTED;
+exports.BLOCKCHAIN_CALL_BATCH_STATUS_VALUE_SUCCESS = BLOCKCHAIN_CALL_BATCH_STATUS_VALUE_SUCCESS;
 exports.BLOCKCHAIN_OPERATION_NAME_VALUE_CONFIRM = BLOCKCHAIN_OPERATION_NAME_VALUE_CONFIRM;
 exports.BLOCKCHAIN_OPERATION_NAME_VALUE_PAYMENT = BLOCKCHAIN_OPERATION_NAME_VALUE_PAYMENT;
 exports.BLOCKCHAIN_OPERATION_NAME_VALUE_SEND = BLOCKCHAIN_OPERATION_NAME_VALUE_SEND;
+exports.BLOCKCHAIN_OPERATION_SUBJECT_VALUE_CALL_BATCH = BLOCKCHAIN_OPERATION_SUBJECT_VALUE_CALL_BATCH;
+exports.BLOCKCHAIN_OPERATION_SUBJECT_VALUE_USER_OPERATION = BLOCKCHAIN_OPERATION_SUBJECT_VALUE_USER_OPERATION;
 exports.BLOCKCHAIN_PAYMENT_PROTOCOL_VALUE_X402 = BLOCKCHAIN_PAYMENT_PROTOCOL_VALUE_X402;
 exports.BLOCKCHAIN_PAYMENT_STATUS_VALUE_FAILED = BLOCKCHAIN_PAYMENT_STATUS_VALUE_FAILED;
 exports.BLOCKCHAIN_PAYMENT_STATUS_VALUE_PENDING = BLOCKCHAIN_PAYMENT_STATUS_VALUE_PENDING;