@seams/wallet 0.9.0 → 0.9.1

package/README.md

@@ -1,18 +1,18 @@
 # Seams Wallet SDK
 
-`@seams/wallet` **0.9.0** provides browser wallet lifecycle, NEAR and EVM-family
+`@seams/wallet` **0.9.1** provides browser wallet lifecycle, NEAR and EVM-family
 threshold signing, React components, and hosted wallet runtime assets.
 
 ## Install
 
 ```sh
-pnpm add @seams/wallet@0.9.0
+pnpm add @seams/wallet@0.9.1
 ```
 
 React integrations support React 18 and 19. Import the provider and UI from
 `@seams/wallet/react` and its stylesheet from `@seams/wallet/react/styles`.
 Keep the application package, wallet-origin assets, and
-`@seams/wallet-server@0.9.0` on the matching release.
+`@seams/wallet-server@0.9.1` on the matching release.
 
 ## Next release migration (unreleased)
 

package/dist/.build-inputs.sha256

@@ -1 +1 @@
-b17394151f88cd47fcc785945c545b600a58769c4ccb3ce56aa76fc6fcd46cef
+ae160ae14f2523702c4fef83cd460099dc8ebef71ae5079e056f38d97cc5d19d

package/dist/esm/core/signingEngine/chains/evm/bytes.js

@@ -1,8 +1,22 @@
 //#region src/core/signingEngine/chains/evm/bytes.ts
+function hexToBytes(hex) {
+	const raw = String(hex || "");
+	const normalized = raw.startsWith("0x") ? raw.slice(2) : raw;
+	if (normalized.length === 0) return new Uint8Array();
+	if (normalized.length % 2 !== 0) throw new Error(`Invalid hex (odd length): ${hex}`);
+	const bytes = new Uint8Array(normalized.length / 2);
+	for (let i = 0; i < bytes.length; i++) {
+		const byte = normalized.slice(i * 2, i * 2 + 2);
+		const value = Number.parseInt(byte, 16);
+		if (!Number.isFinite(value)) throw new Error(`Invalid hex: ${hex}`);
+		bytes[i] = value;
+	}
+	return bytes;
+}
 function bytesToHex(bytes) {
 	return `0x${Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
 }
 //#endregion
-export { bytesToHex };
+export { bytesToHex, hexToBytes };
 
 //# sourceMappingURL=bytes.js.map

package/dist/esm/core/signingEngine/flows/signEvmFamily/signingFlow.js

@@ -4,9 +4,9 @@ import { parseDigestB64u, sha256Utf8DigestB64u } from "../../../../shared-ts/src
 import { SigningEventPhase, createSigningFlowEvent } from "../../../types/sdkSentEvents.js";
 import { SigningSessionIds } from "../../session/operationState/types.js";
 import { normalizeAuthenticationCredential } from "../../webauthnAuth/credentials/helpers.js";
+import { bytesToHex } from "../../chains/evm/bytes.js";
 import { isActiveWalletAuthoritySigningAuthPlan, isWarmSessionSigningAuthPlan } from "../../stepUpConfirmation/types.js";
 import { toManagedNonceReservationSnapshot } from "../../../rpcClients/evm/nonceBackend.js";
-import { bytesToHex } from "../../chains/evm/bytes.js";
 import { emitEcdsaSigningTiming } from "../../session/operationState/trace.js";
 import { parseSigningOperationFingerprintDigest } from "../../../../shared-ts/src/authorization/operationFingerprint.js";
 import { SigningOperationCommandKind, buildSigningOperationCommandSteps, createSigningOperationPlan, runSigningOperationCommandSteps, runUnplannedSigningOperationCommandSequence } from "../shared/signingStateMachine.js";

package/dist/esm/core/signingEngine/flows/signNear/shared/ed25519YaoNormalSigning.js

@@ -725,6 +725,82 @@ function routerAbEd25519NormalSigningMaterialFacts(args) {
 		relayerUrl: args.walletSessionState.relayerUrl
 	};
 }
+async function nearTransactionPrepareInputs(args, unsigned) {
+	const nearNetworkId = normalizeNearNetworkId(args.ctx);
+	const parsedTransaction = parseThresholdEd25519NearTransaction(args.txSigningRequest, "txSigningRequest");
+	return {
+		nearNetworkId,
+		parsedTransaction,
+		operationFingerprint: SigningSessionIds.signingOperationFingerprint(await thresholdEd25519NearTransactionOperationFingerprint({
+			nearAccountId: args.nearAccountId,
+			nearNetworkId,
+			relayerKeyId: args.thresholdKeyMaterial.relayerKeyId,
+			signerPublicKey: args.thresholdKeyMaterial.publicKey,
+			transactions: [parsedTransaction],
+			unsignedTransactionBorshB64u: unsigned.unsignedTransactionBorshB64u,
+			signingDigestB64u: unsigned.signingDigestB64u
+		}))
+	};
+}
+async function buildRouterAbEd25519NearTransactionWarmPrepare(args, unsigned, inputs) {
+	const scope = buildRouterAbNormalSigningScope({
+		activeClient: args.activeClient,
+		walletSessionState: args.walletSessionState,
+		walletId: args.walletId,
+		operationId: args.operationId
+	});
+	if (!scope) throw new Error("[SigningEngine][near] Router A/B Ed25519 signing scope is missing");
+	return await buildRouterAbEd25519NearTransactionPrepareRequestV2({
+		scope,
+		expiresAtMs: routerAbNormalSigningExpiresAtMs({
+			walletSessionExpiresAtMs: args.walletSessionState.signingWalletSession.expiresAtMs,
+			requestedTtlMs: ROUTER_AB_NORMAL_SIGNING_REQUEST_TTL_MS
+		}),
+		operationId: args.operationId,
+		operationFingerprint: inputs.operationFingerprint,
+		displayDigestB64u: args.displayDigest,
+		nearAccountId: args.nearAccountId,
+		nearNetworkId: inputs.nearNetworkId,
+		transactions: [{
+			receiverId: inputs.parsedTransaction.receiverId,
+			actionFingerprint: await routerAbNormalSigningActionFingerprint(inputs.parsedTransaction.actions)
+		}],
+		unsignedTransactionBorshB64u: unsigned.unsignedTransactionBorshB64u,
+		expectedSigningDigestB64u: unsigned.signingDigestB64u
+	});
+}
+/**
+* Sends the prepare of a warm-session transaction while the confirmation
+* dialog is open. The transaction context is the one the dialog reserved.
+*/
+async function startRouterAbEd25519NearTransactionPrepare(args) {
+	const unsigned = await buildThresholdEd25519NearTxUnsignedBorshWasm({
+		txSigningRequest: args.txSigningRequest,
+		transactionContext: args.transactionContext,
+		workerCtx: args.ctx
+	});
+	const prepare = await buildRouterAbEd25519NearTransactionWarmPrepare(args, unsigned, await nearTransactionPrepareInputs(args, unsigned));
+	const ready = requireRouterAbEd25519NormalSigningReadyState({
+		state: args.walletSessionState,
+		thresholdSessionId: args.thresholdSessionId,
+		nearAccountId: args.nearAccountId,
+		thresholdKeyMaterial: args.thresholdKeyMaterial
+	});
+	const sentAt = performance.now();
+	const response = prepareRouterAbNormalSigningV2({
+		relayServerUrl: args.walletSessionState.relayerUrl,
+		credential: ready.credential,
+		request: prepare.request
+	});
+	response.catch(() => {});
+	emitEd25519SigningTiming(String(args.operationId), "prepare_sent", sentAt);
+	return {
+		prepare,
+		displayDigest: args.displayDigest,
+		signingDigestB64u: unsigned.signingDigestB64u,
+		response
+	};
+}
 async function tryFinalizeRouterAbEd25519NearTransactionNormalSigning(args) {
 	const materialFacts = routerAbEd25519NormalSigningMaterialFacts(args);
 	if (!materialFacts.routerAbNormalSigning) throw new Error("[SigningEngine][near] Router A/B Ed25519 normal-signing state is missing");
@@ -739,17 +815,8 @@ async function tryFinalizeRouterAbEd25519NearTransactionNormalSigning(args) {
 		workerCtx: args.ctx
 	});
 	if (base64UrlDecode(unsigned.signingDigestB64u).length !== 32) throw new Error("Router A/B normal-signing NEAR payload digest must be 32 bytes");
-	const nearNetworkId = normalizeNearNetworkId(args.ctx);
-	const parsedTransaction = parseThresholdEd25519NearTransaction(args.txSigningRequest, "txSigningRequest");
-	const operationFingerprint = SigningSessionIds.signingOperationFingerprint(await thresholdEd25519NearTransactionOperationFingerprint({
-		nearAccountId: args.nearAccountId,
-		nearNetworkId,
-		relayerKeyId: args.thresholdKeyMaterial.relayerKeyId,
-		signerPublicKey: args.thresholdKeyMaterial.publicKey,
-		transactions: [parsedTransaction],
-		unsignedTransactionBorshB64u: unsigned.unsignedTransactionBorshB64u,
-		signingDigestB64u: unsigned.signingDigestB64u
-	}));
+	const prepareInputs = await nearTransactionPrepareInputs(args, unsigned);
+	let started = null;
 	let prepare;
 	let credential;
 	let issuedAuthorization;
@@ -772,31 +839,9 @@ async function tryFinalizeRouterAbEd25519NearTransactionNormalSigning(args) {
 		if (prepare.request.scope.authorization.kind !== "operation_step_up" || issued.kind !== "verified_step_up") throw new Error("[SigningEngine][near] issued operation step-up evidence changed identity");
 		issuedAuthorization = issued;
 	} else {
-		const scope = buildRouterAbNormalSigningScope({
-			activeClient: args.activeClient,
-			walletSessionState: args.walletSessionState,
-			walletId: args.walletId,
-			operationId: args.operationId
-		});
-		if (!scope) throw new Error("[SigningEngine][near] Router A/B Ed25519 signing scope is missing");
-		prepare = await buildRouterAbEd25519NearTransactionPrepareRequestV2({
-			scope,
-			expiresAtMs: routerAbNormalSigningExpiresAtMs({
-				walletSessionExpiresAtMs: args.walletSessionState.signingWalletSession.expiresAtMs,
-				requestedTtlMs: ROUTER_AB_NORMAL_SIGNING_REQUEST_TTL_MS
-			}),
-			operationId: args.operationId,
-			operationFingerprint,
-			displayDigestB64u: args.displayDigest,
-			nearAccountId: args.nearAccountId,
-			nearNetworkId,
-			transactions: [{
-				receiverId: parsedTransaction.receiverId,
-				actionFingerprint: await routerAbNormalSigningActionFingerprint(parsedTransaction.actions)
-			}],
-			unsignedTransactionBorshB64u: unsigned.unsignedTransactionBorshB64u,
-			expectedSigningDigestB64u: unsigned.signingDigestB64u
-		});
+		started = args.startedPrepare && args.startedPrepare.displayDigest === args.displayDigest && args.startedPrepare.signingDigestB64u === unsigned.signingDigestB64u ? args.startedPrepare : null;
+		if (args.startedPrepare && !started) abandonRouterAbEd25519StartedPrepare(args.startedPrepare);
+		prepare = started ? started.prepare : await buildRouterAbEd25519NearTransactionWarmPrepare(args, unsigned, prepareInputs);
 		credential = requireRouterAbEd25519NormalSigningReadyState({
 			state: args.walletSessionState,
 			thresholdSessionId: args.thresholdSessionId,
@@ -829,7 +874,8 @@ async function tryFinalizeRouterAbEd25519NearTransactionNormalSigning(args) {
 		signingPayloadLabel: "NEAR payload digest",
 		prepare,
 		credential,
-		authorization: "reusable_wallet_session"
+		authorization: "reusable_wallet_session",
+		startedResponse: started?.response
 	});
 	const finalized = await finalizeThresholdEd25519NearTxFromSignatureWasm({
 		unsignedTransactionBorshB64u: unsigned.unsignedTransactionBorshB64u,
@@ -871,6 +917,6 @@ async function tryFinalizeRouterAbEd25519NearTransactionNormalSigning(args) {
 	};
 }
 //#endregion
-export { abandonRouterAbEd25519StartedPrepare, buildNearEd25519OperationStepUpProof, buildNearEmailOtpEd25519OperationStepUpProof, finalizeThresholdEd25519DelegateSignatureResult, prepareRouterAbEd25519NearTransactionOperationStepUp, prepareRouterAbEd25519SignatureOnlyOperationStepUp, requireIssuedNearEd25519OperationStepUpAuthorization, requireNearEd25519OperationStepUpProof, startRouterAbEd25519SignatureOnlyPrepare, tryFinalizeRouterAbEd25519NearTransactionNormalSigning, tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning };
+export { abandonRouterAbEd25519StartedPrepare, buildNearEd25519OperationStepUpProof, buildNearEmailOtpEd25519OperationStepUpProof, finalizeThresholdEd25519DelegateSignatureResult, prepareRouterAbEd25519NearTransactionOperationStepUp, prepareRouterAbEd25519SignatureOnlyOperationStepUp, requireIssuedNearEd25519OperationStepUpAuthorization, requireNearEd25519OperationStepUpProof, startRouterAbEd25519NearTransactionPrepare, startRouterAbEd25519SignatureOnlyPrepare, tryFinalizeRouterAbEd25519NearTransactionNormalSigning, tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning };
 
 //# sourceMappingURL=ed25519YaoNormalSigning.js.map

package/dist/esm/core/signingEngine/flows/signNear/signTransactions.js

@@ -6,6 +6,7 @@ import { toAccountId } from "../../../types/accountIds.js";
 import { SigningEventPhase, createSigningFlowEvent } from "../../../types/sdkSentEvents.js";
 import { SigningOperationIntent, SigningSessionIds, SigningSessionPlanKind } from "../../session/operationState/types.js";
 import { nearEd25519SignerBindingFromBoundaryFields } from "../../session/identity/exactSigningLaneIdentity.js";
+import { computeUiIntentDigestFromTxs, orderActionForDigest } from "../../../../utils/intentDigest.js";
 import { isWarmSessionSigningAuthPlan } from "../../stepUpConfirmation/types.js";
 import { createSigningBoundaryTraceEvent, emitEd25519SigningTiming, emitSigningBoundaryTrace } from "../../session/operationState/trace.js";
 import { parseSigningOperationFingerprintDigest } from "../../../../shared-ts/src/authorization/operationFingerprint.js";
@@ -20,7 +21,7 @@ import { emitNearSigningConfirmationProgress } from "./shared/confirmationProgre
 import { buildNearEd25519StepUpAuthorization } from "./stepUpAuthorization.js";
 import { requiredNearTransactionSignatureUses } from "./signatureUses.js";
 import { clearNearOperationStepUpBuilder, consumePreparedNearOperationStepUp, registerNearOperationStepUpBuilder } from "./shared/operationStepUpPreparation.js";
-import { buildNearEd25519OperationStepUpProof, buildNearEmailOtpEd25519OperationStepUpProof, prepareRouterAbEd25519NearTransactionOperationStepUp, requireIssuedNearEd25519OperationStepUpAuthorization, requireNearEd25519OperationStepUpProof, tryFinalizeRouterAbEd25519NearTransactionNormalSigning } from "./shared/ed25519YaoNormalSigning.js";
+import { buildNearEd25519OperationStepUpProof, buildNearEmailOtpEd25519OperationStepUpProof, prepareRouterAbEd25519NearTransactionOperationStepUp, requireIssuedNearEd25519OperationStepUpAuthorization, requireNearEd25519OperationStepUpProof, startRouterAbEd25519NearTransactionPrepare, tryFinalizeRouterAbEd25519NearTransactionNormalSigning } from "./shared/ed25519YaoNormalSigning.js";
 import { fundNearImplicitAccountForOperationStepUp, resolveConfirmedNearTransactionContext } from "./implicitAccountFunding.js";
 import { clearNearImplicitAccountFunder, registerNearImplicitAccountFunder } from "./shared/implicitAccountFundingPort.js";
 import { nearOperationStepUpMaterialFacts, prepareNearOperationStepUpMaterial, resolveNearOperationStepUpMaterial, resolvePreparedNearEd25519YaoMaterial } from "./shared/ed25519YaoCapabilityResolution.js";
@@ -55,6 +56,34 @@ function requireWarmNearSigningMaterialTask(task) {
 	if (!task) throw new Error("[SigningEngine][near] warm signing material was not prepared");
 	return task;
 }
+async function startWarmNearTransactionPrepare(args) {
+	const resolved = await args.warmMaterial;
+	const walletSessionState = await args.sessionCoordinator.resolveActiveAuthorizedRouterAbEd25519WalletSessionState({
+		state: resolved.walletSessionState,
+		nowMs: Date.now()
+	});
+	if (!walletSessionState) return null;
+	const displayDigest = await computeUiIntentDigestFromTxs([{
+		receiverId: args.confirmationTransaction.receiverId,
+		actions: args.confirmationTransaction.actions.map(orderActionForDigest)
+	}]);
+	return await startRouterAbEd25519NearTransactionPrepare({
+		ctx: args.ctx,
+		thresholdSessionId: resolved.material.facts.thresholdSessionId,
+		thresholdKeyMaterial: args.thresholdKeyMaterial,
+		walletId: args.walletId,
+		nearAccountId: args.nearAccountId,
+		activeClient: resolved.material.activeClient,
+		walletSessionState,
+		operationId: args.operationId,
+		displayDigest,
+		txSigningRequest: args.txSigningRequest,
+		transactionContext: args.readiness.transactionContext
+	});
+}
+function ignoreStartedPrepareFailure() {
+	return null;
+}
 async function resolveNearTransactionOperationStepUpMaterial(args) {
 	if (args.authorization.kind === "passkey") {
 		if (args.material.kind !== "passkey_live" && args.material.kind !== "passkey_sealed") throw new Error("[SigningEngine][near] passkey transaction material changed factor");
@@ -553,6 +582,22 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 		}
 	});
 	emitEd25519SigningTiming(String(signingOperationId), "pre_confirmation", preConfirmationStartedAt);
+	let startedPrepareTask = null;
+	const startTransactionPrepare = (readiness) => {
+		if (startedPrepareTask || !warmSigningMaterialTask) return;
+		startedPrepareTask = startWarmNearTransactionPrepare({
+			ctx,
+			warmMaterial: warmSigningMaterialTask,
+			sessionCoordinator,
+			thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
+			walletId: commandSubject.walletSession.walletId,
+			nearAccountId,
+			operationId: signingOperation.operationId,
+			txSigningRequest,
+			confirmationTransaction,
+			readiness
+		}).catch(ignoreStartedPrepareFailure);
+	};
 	const confirmationStartedAt = performance.now();
 	let confirmation;
 	try {
@@ -567,6 +612,7 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 				chain: "near",
 				kind: "transaction",
 				...buildSigningConfirmationAuthParams({ signingAuthPlan: confirmationAuthPayload.signingAuthPlan }),
+				...warmSigningMaterialTask ? { onNearTransactionContextReady: startTransactionPrepare } : {},
 				walletId: String(signingLane.identity.signer.account.wallet.walletId),
 				txSigningRequests: [confirmationTransaction],
 				rpcCall: resolvedRpcCall,
@@ -785,7 +831,8 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 			displayDigest: confirmation.intentDigest,
 			txSigningRequest,
 			transactionContext,
-			authorization: { kind: "reusable_wallet_session" }
+			authorization: { kind: "reusable_wallet_session" },
+			startedPrepare: startedPrepareTask ? await startedPrepareTask : null
 		});
 		if (routerAbNormalSigningResult) return routerAbNormalSigningResult.okResponse;
 		throw new Error("[SigningEngine][near] Router A/B Ed25519 signing is unavailable");

package/dist/esm/core/signingEngine/uiConfirm/ui/transaction-display/abi/abiDecode.js

@@ -0,0 +1,315 @@
+import { keccak256Bytes } from "../../../../../../shared-ts/src/utils/keccak.js";
+import { bytesToHex, hexToBytes } from "../../../../chains/evm/bytes.js";
+import { deriveSelectorFromHexData, normalizeHexData, normalizeHexSelector } from "../../../../chains/evm/display/normalization.js";
+//#region src/core/signingEngine/uiConfirm/ui/transaction-display/abi/abiDecode.ts
+const WORD_SIZE = 32;
+const MAX_DECODE_ARRAY_LENGTH = 256;
+const ABI_FUNCTION_LOOKUP_CACHE = /* @__PURE__ */ new WeakMap();
+function selectorFromDataHex(dataHex) {
+	return deriveSelectorFromHexData(dataHex) || null;
+}
+function buildAbiFunctionEntries(abi) {
+	const out = [];
+	for (const entry of abi) {
+		if (!entry || typeof entry !== "object") continue;
+		const type = String(entry.type || "function").trim();
+		if (type !== "" && type !== "function") continue;
+		const name = String(entry.name || "").trim();
+		if (!name) continue;
+		const rawInputs = entry.inputs;
+		const inputs = Array.isArray(rawInputs) ? rawInputs : [];
+		const selector = selectorFromSignature(`${name}(${inputs.map((input) => canonicalAbiTypeFromParameter(input)).join(",")})`);
+		if (!selector) continue;
+		const normalizedInputs = normalizeAbiComponentNodes(inputs);
+		out.push({
+			name,
+			selector,
+			inputs: normalizedInputs
+		});
+	}
+	return out;
+}
+function resolveAbiFunctionLookup(abi) {
+	if (!Array.isArray(abi) || abi.length === 0) return void 0;
+	const cached = ABI_FUNCTION_LOOKUP_CACHE.get(abi);
+	if (cached) return cached;
+	const entries = buildAbiFunctionEntries(abi);
+	if (!entries.length) return void 0;
+	const bySelector = /* @__PURE__ */ new Map();
+	for (const entry of entries) if (!bySelector.has(entry.selector)) bySelector.set(entry.selector, entry);
+	const lookup = { bySelector };
+	ABI_FUNCTION_LOOKUP_CACHE.set(abi, lookup);
+	return lookup;
+}
+function selectorFromSignature(signature) {
+	const normalized = String(signature || "").trim();
+	if (!normalized) return null;
+	return normalizeHexSelector(bytesToHex(keccak256Bytes(new TextEncoder().encode(normalized)).slice(0, 4))) || null;
+}
+function canonicalAbiTypeFromParameter(input) {
+	const type = String(input?.type || "").trim().toLowerCase();
+	if (!type) return "";
+	const components = Array.isArray(input?.components) ? input.components : [];
+	if (type.startsWith("tuple")) {
+		const suffix = type.slice(5);
+		return `${`(${components.map((component) => canonicalAbiTypeFromParameter(component)).join(",")})`}${suffix}`;
+	}
+	return type;
+}
+function normalizeAbiComponentNodes(inputs) {
+	const out = [];
+	for (let index = 0; index < inputs.length; index += 1) {
+		const input = inputs[index];
+		const typeName = String(input?.type || "").trim().toLowerCase();
+		if (!typeName) continue;
+		const typeNode = parseAbiTypeNode({
+			type: typeName,
+			components: input?.components
+		});
+		if (!typeNode) continue;
+		const name = String(input?.name || "").trim();
+		out.push({
+			name: name || `arg${index}`,
+			typeName,
+			typeNode
+		});
+	}
+	return out;
+}
+function parseAbiTypeNode(args) {
+	const baseTypeRaw = String(args.type || "").trim().toLowerCase();
+	if (!baseTypeRaw) return null;
+	let baseType = baseTypeRaw;
+	const arrayDimensions = [];
+	while (baseType.endsWith("]")) {
+		const openBracket = baseType.lastIndexOf("[");
+		if (openBracket < 0) return null;
+		const rawLength = baseType.slice(openBracket + 1, -1).trim();
+		if (!/^\d*$/.test(rawLength)) return null;
+		const length = rawLength === "" ? null : Number.parseInt(rawLength, 10);
+		if (length != null && (!Number.isFinite(length) || length < 0)) return null;
+		arrayDimensions.push(length);
+		baseType = baseType.slice(0, openBracket);
+	}
+	let node = null;
+	if (baseType === "tuple") {
+		const normalizedComponents = normalizeAbiComponentNodes(Array.isArray(args.components) ? args.components : []);
+		node = {
+			kind: "tuple",
+			canonicalType: `(${normalizedComponents.map((component) => component.typeNode.canonicalType).join(",")})`,
+			dynamic: normalizedComponents.some((component) => component.typeNode.dynamic),
+			components: normalizedComponents
+		};
+	} else node = {
+		kind: "scalar",
+		typeName: baseType,
+		canonicalType: baseType,
+		dynamic: baseType === "bytes" || baseType === "string"
+	};
+	for (let i = arrayDimensions.length - 1; i >= 0; i -= 1) {
+		const length = arrayDimensions[i];
+		node = {
+			kind: "array",
+			canonicalType: `${node.canonicalType}[${length == null ? "" : String(length)}]`,
+			dynamic: length == null || node.dynamic,
+			item: node,
+			length
+		};
+	}
+	return node;
+}
+function readWord(bytes, offset) {
+	if (!Number.isInteger(offset) || offset < 0) return null;
+	if (offset + WORD_SIZE > bytes.length) return null;
+	return bytes.slice(offset, offset + WORD_SIZE);
+}
+function readWordBigInt(bytes, offset) {
+	const word = readWord(bytes, offset);
+	if (!word) return null;
+	let out = 0n;
+	for (const byte of word) out = (out << 8n) + BigInt(byte);
+	return out;
+}
+function readWordNumber(bytes, offset) {
+	const value = readWordBigInt(bytes, offset);
+	if (value == null) return null;
+	if (value > BigInt(Number.MAX_SAFE_INTEGER) || value < 0n) return null;
+	return Number(value);
+}
+function staticWordLength(typeNode) {
+	if (typeNode.dynamic) return 1;
+	if (typeNode.kind === "scalar") return 1;
+	if (typeNode.kind === "tuple") return typeNode.components.reduce((sum, component) => sum + staticWordLength(component.typeNode), 0);
+	if (typeNode.length == null) return 1;
+	return typeNode.length * staticWordLength(typeNode.item);
+}
+function decodeScalar(typeName, bytes, offset) {
+	const normalizedType = String(typeName || "").trim().toLowerCase();
+	if (!normalizedType) return null;
+	if (normalizedType === "bytes") {
+		const length = readWordNumber(bytes, offset);
+		if (length == null) return null;
+		const start = offset + WORD_SIZE;
+		const end = start + length;
+		if (end > bytes.length) return null;
+		return bytesToHex(bytes.slice(start, end)).toLowerCase();
+	}
+	if (normalizedType === "string") {
+		const length = readWordNumber(bytes, offset);
+		if (length == null) return null;
+		const start = offset + WORD_SIZE;
+		const end = start + length;
+		if (end > bytes.length) return null;
+		const valueBytes = bytes.slice(start, end);
+		try {
+			return new TextDecoder().decode(valueBytes);
+		} catch {
+			return bytesToHex(valueBytes).toLowerCase();
+		}
+	}
+	const word = readWord(bytes, offset);
+	if (!word) return null;
+	const wordValue = readWordBigInt(bytes, offset);
+	if (wordValue == null) return null;
+	if (normalizedType === "bool") return wordValue !== 0n;
+	if (normalizedType === "address") return bytesToHex(word.slice(12)).toLowerCase();
+	if (normalizedType === "function") return bytesToHex(word.slice(0, 24)).toLowerCase();
+	const fixedBytesMatch = normalizedType.match(/^bytes(\d{1,2})$/);
+	if (fixedBytesMatch) {
+		const byteLength = Number.parseInt(fixedBytesMatch[1], 10);
+		if (!Number.isFinite(byteLength) || byteLength <= 0 || byteLength > 32) return null;
+		return bytesToHex(word.slice(0, byteLength)).toLowerCase();
+	}
+	if (normalizedType.match(/^uint(\d{0,3})$/)) return wordValue.toString(10);
+	const intMatch = normalizedType.match(/^int(\d{0,3})$/);
+	if (intMatch) {
+		const bitsRaw = intMatch[1];
+		const bits = bitsRaw ? Number.parseInt(bitsRaw, 10) : 256;
+		if (!Number.isFinite(bits) || bits <= 0 || bits > 256 || bits % 8 !== 0) return wordValue.toString(10);
+		const bitWidth = BigInt(bits);
+		const modulus = 1n << bitWidth;
+		return (wordValue >= 1n << bitWidth - 1n ? wordValue - modulus : wordValue).toString(10);
+	}
+	return bytesToHex(word).toLowerCase();
+}
+function decodeTypeAt(typeNode, bytes, offset) {
+	if (typeNode.kind === "scalar") return decodeScalar(typeNode.typeName, bytes, offset);
+	if (typeNode.kind === "tuple") {
+		const decodedItems = decodeTupleComponents(typeNode.components, bytes, offset);
+		if (!decodedItems) return null;
+		const out = {};
+		for (let i = 0; i < typeNode.components.length; i += 1) {
+			const component = typeNode.components[i];
+			const baseName = String(component.name || "").trim() || `item${i}`;
+			let name = baseName;
+			let counter = 1;
+			while (Object.prototype.hasOwnProperty.call(out, name)) {
+				counter += 1;
+				name = `${baseName}_${counter}`;
+			}
+			out[name] = decodedItems[i];
+		}
+		return out;
+	}
+	const expectedLength = typeNode.length;
+	const isDynamicArray = expectedLength == null;
+	const arrayLength = isDynamicArray ? readWordNumber(bytes, offset) : expectedLength;
+	if (arrayLength == null) return null;
+	if (arrayLength < 0 || arrayLength > MAX_DECODE_ARRAY_LENGTH) return null;
+	const baseOffset = isDynamicArray ? offset + WORD_SIZE : offset;
+	const items = [];
+	if (typeNode.item.dynamic) {
+		for (let i = 0; i < arrayLength; i += 1) {
+			const itemRelativeOffset = readWordNumber(bytes, baseOffset + i * WORD_SIZE);
+			if (itemRelativeOffset == null) return null;
+			const decoded = decodeTypeAt(typeNode.item, bytes, baseOffset + itemRelativeOffset);
+			if (decoded == null) return null;
+			items.push(decoded);
+		}
+		return items;
+	}
+	const itemWords = staticWordLength(typeNode.item);
+	for (let i = 0; i < arrayLength; i += 1) {
+		const itemOffset = baseOffset + i * itemWords * WORD_SIZE;
+		const decoded = decodeTypeAt(typeNode.item, bytes, itemOffset);
+		if (decoded == null) return null;
+		items.push(decoded);
+	}
+	return items;
+}
+function decodeTupleComponents(components, bytes, tupleOffset) {
+	let cursorWords = 0;
+	const headOffsets = [];
+	for (const component of components) {
+		headOffsets.push(cursorWords * WORD_SIZE);
+		cursorWords += component.typeNode.dynamic ? 1 : staticWordLength(component.typeNode);
+	}
+	const out = [];
+	for (let i = 0; i < components.length; i += 1) {
+		const component = components[i];
+		const headOffset = tupleOffset + headOffsets[i];
+		if (component.typeNode.dynamic) {
+			const relativeOffset = readWordNumber(bytes, headOffset);
+			if (relativeOffset == null) return null;
+			const decoded = decodeTypeAt(component.typeNode, bytes, tupleOffset + relativeOffset);
+			if (decoded == null) return null;
+			out.push(decoded);
+			continue;
+		}
+		const decoded = decodeTypeAt(component.typeNode, bytes, headOffset);
+		if (decoded == null) return null;
+		out.push(decoded);
+	}
+	return out;
+}
+function formatDecodedArgumentsJsonText(args) {
+	if (!args.length) return void 0;
+	const payload = {};
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		const baseKey = String(arg.key || "").trim() || `arg${index}`;
+		let nextKey = baseKey;
+		let suffix = 2;
+		while (Object.prototype.hasOwnProperty.call(payload, nextKey)) {
+			nextKey = `${baseKey}_${suffix}`;
+			suffix += 1;
+		}
+		payload[nextKey] = arg.value;
+	}
+	try {
+		return JSON.stringify(payload, null, 2);
+	} catch {
+		return;
+	}
+}
+function decodeCallDataWithAbi(args) {
+	const selector = selectorFromDataHex(args.dataHex);
+	if (!selector) return void 0;
+	const abiLookup = resolveAbiFunctionLookup(args.abi);
+	if (!abiLookup) return void 0;
+	const matched = abiLookup.bySelector.get(selector);
+	if (!matched) return void 0;
+	const normalizedDataHex = normalizeHexData(args.dataHex, { lowercase: true });
+	let argsBytes;
+	try {
+		const bytes = hexToBytes(normalizedDataHex);
+		if (bytes.length < 4) return { functionLabel: `${matched.name}()` };
+		argsBytes = bytes.slice(4);
+	} catch {
+		return { functionLabel: `${matched.name}()` };
+	}
+	const decodedValues = decodeTupleComponents(matched.inputs, argsBytes, 0);
+	if (!decodedValues) return { functionLabel: `${matched.name}()` };
+	const decodedArguments = matched.inputs.map((input, index) => ({
+		key: String(input.name || "").trim() || `arg${index}`,
+		value: decodedValues[index]
+	}));
+	return {
+		functionLabel: `${matched.name}()`,
+		decodedArgumentsJsonText: formatDecodedArgumentsJsonText(decodedArguments)
+	};
+}
+//#endregion
+export { decodeCallDataWithAbi };
+
+//# sourceMappingURL=abiDecode.js.map