@seams/wallet 0.9.0 → 0.9.2

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

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

@@ -0,0 +1,77 @@
+import { decodeCallDataWithAbi } from "./abiDecode.js";
+//#region src/core/signingEngine/uiConfirm/ui/transaction-display/abi/enrichDisplayModelWithAbi.ts
+function isGenericContractCallOperation(operation) {
+	return operation.kind === "generic.contractCall";
+}
+function rewriteCallingLabel(label, functionLabel) {
+	const normalized = String(label || "").trim();
+	const match = normalized.match(/^Calling\s+.+?\s+using\s+(.+)$/i);
+	if (!match) return normalized;
+	return `Calling ${functionLabel} using ${match[1]}`;
+}
+function isDataField(field) {
+	return String(field.label || "").trim().toLowerCase() === "data";
+}
+function rewriteDataFieldWithDecodedArgs(args) {
+	const next = Array.isArray(args.fields) ? [...args.fields] : [];
+	const dataFieldIndex = next.findIndex((field) => isDataField(field));
+	const existingDataField = dataFieldIndex >= 0 ? next[dataFieldIndex] : void 0;
+	const rawFallbackValue = String(existingDataField?.value || "").trim() || String(args.fallbackRawDataHex || "").trim();
+	const rewrittenDataField = {
+		...existingDataField || { label: "Data" },
+		value: args.decodedArgsJsonText,
+		renderAs: "file-content",
+		hideChevron: typeof existingDataField?.hideChevron === "boolean" ? existingDataField.hideChevron : true,
+		contentVariants: {
+			decoded: args.decodedArgsJsonText,
+			raw: rawFallbackValue,
+			defaultMode: "decoded"
+		}
+	};
+	if (dataFieldIndex >= 0) {
+		next[dataFieldIndex] = rewrittenDataField;
+		return next;
+	}
+	next.push(rewrittenDataField);
+	return next;
+}
+function maybeDecodeOperationWithAbi(operation) {
+	const hint = operation.abiDecodeHint;
+	if (!hint || !Array.isArray(hint.abi) || hint.abi.length === 0) return operation;
+	const decoded = decodeCallDataWithAbi({
+		dataHex: hint.dataHex,
+		abi: hint.abi
+	});
+	if (!decoded) return operation;
+	const fields = decoded.decodedArgumentsJsonText ? rewriteDataFieldWithDecodedArgs({
+		fields: operation.fields,
+		decodedArgsJsonText: decoded.decodedArgumentsJsonText,
+		fallbackRawDataHex: hint.dataHex
+	}) : operation.fields;
+	return {
+		...operation,
+		label: rewriteCallingLabel(operation.label, decoded.functionLabel),
+		fields
+	};
+}
+function enrichOperation(operation) {
+	const children = Array.isArray(operation.children) ? operation.children.map((child) => enrichOperation(child)) : operation.children;
+	const operationWithChildren = children === operation.children ? operation : {
+		...operation,
+		children
+	};
+	if (!isGenericContractCallOperation(operationWithChildren)) return operationWithChildren;
+	return maybeDecodeOperationWithAbi(operationWithChildren);
+}
+function enrichDisplayModelWithAbi(model) {
+	if (!Array.isArray(model.operations) || model.operations.length === 0) return model;
+	const operations = model.operations.map((operation) => enrichOperation(operation));
+	return {
+		...model,
+		operations
+	};
+}
+//#endregion
+export { enrichDisplayModelWithAbi };
+
+//# sourceMappingURL=enrichDisplayModelWithAbi.js.map

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

@@ -1,4 +1,13 @@
 //#region src/core/signingEngine/uiConfirm/ui/transaction-display/formatters.ts
+function formatArgs(args) {
+	if (!args) return "";
+	if (typeof args === "string") return args;
+	try {
+		return JSON.stringify(args, (_k, v) => typeof v === "bigint" ? v.toString() : v, 2);
+	} catch {
+		return String(args);
+	}
+}
 function formatDeposit(deposit) {
 	if (!deposit || deposit === "0") return "0 NEAR";
 	try {
@@ -43,6 +52,6 @@ function formatCodeSize(code) {
 	return "unknown";
 }
 //#endregion
-export { formatCodeSize, formatDeposit, formatGas, shortenPubkey };
+export { formatArgs, formatCodeSize, formatDeposit, formatGas, shortenPubkey };
 
 //# sourceMappingURL=formatters.js.map

package/dist/esm/core/signingEngine/uiConfirm/ui/transaction-display/renderers/fallback.js

@@ -0,0 +1,52 @@
+import { buildFieldNodes } from "./types.js";
+//#region src/core/signingEngine/uiConfirm/ui/transaction-display/renderers/fallback.ts
+const renderFallbackDisplayOperation = ({ operation, depth, path, renderChild }) => {
+	const opId = String(operation.id || "").trim() || `op-${path}`;
+	const contractAddress = (() => {
+		const raw = String(operation.to || "").trim();
+		return /^0x[0-9a-fA-F]{40}$/.test(raw) ? raw : void 0;
+	})();
+	const description = String(operation.description || "").trim();
+	const childOps = Array.isArray(operation.children) ? operation.children.map((child, childIndex) => renderChild(child, depth + 1, `${path}.${childIndex}`)) : [];
+	const fieldNodes = buildFieldNodes(opId, operation.fields);
+	const metadataNodes = description ? [{
+		id: `${opId}-description`,
+		label: description,
+		type: "file",
+		open: false
+	}] : [];
+	if (operation.kind === "raw.fallback") {
+		const rawValue = String(operation.raw || "").trim();
+		if (rawValue) metadataNodes.push({
+			id: `${opId}-raw`,
+			label: "Raw payload",
+			type: "file",
+			open: false,
+			content: rawValue
+		});
+	}
+	const children = [
+		...metadataNodes,
+		...fieldNodes,
+		...childOps
+	];
+	if (children.length === 0) return {
+		id: opId,
+		label: String(operation.label || operation.kind),
+		type: "file",
+		open: false,
+		contractAddress
+	};
+	return {
+		id: opId,
+		label: String(operation.label || operation.kind),
+		type: "folder",
+		open: depth < 1,
+		contractAddress,
+		children
+	};
+};
+//#endregion
+export { renderFallbackDisplayOperation };
+
+//# sourceMappingURL=fallback.js.map

package/dist/esm/core/signingEngine/uiConfirm/ui/transaction-display/renderers/types.js

@@ -0,0 +1,62 @@
+//#region src/core/signingEngine/uiConfirm/ui/transaction-display/renderers/types.ts
+function sanitizeContentVariants(variants) {
+	if (!variants) return void 0;
+	const decoded = String(variants.decoded || "");
+	const raw = String(variants.raw || "");
+	if (!decoded || !raw) return void 0;
+	if (decoded === raw) return void 0;
+	return {
+		decoded,
+		raw,
+		defaultMode: variants.defaultMode === "raw" ? "raw" : "decoded"
+	};
+}
+function isZeroWeiDisplayField(label, value) {
+	if (!/Value \(wei\)$/i.test(label.trim())) return false;
+	const normalized = value.trim();
+	if (!normalized) return false;
+	if (normalized === "0") return true;
+	if (/^0x0+$/i.test(normalized)) return true;
+	try {
+		return BigInt(normalized) === 0n;
+	} catch {
+		return false;
+	}
+}
+function buildFieldNodes(parentId, fields) {
+	if (!Array.isArray(fields) || fields.length === 0) return [];
+	return fields.flatMap((field, fieldIndex) => {
+		const label = String(field.label || "").trim();
+		const value = String(field.value || "");
+		const renderAs = field.renderAs || "inline";
+		if (isZeroWeiDisplayField(label, value)) return [];
+		if (renderAs === "file-content") {
+			const contentVariants = sanitizeContentVariants(field.contentVariants);
+			const content = contentVariants?.defaultMode === "raw" ? contentVariants.raw : contentVariants?.decoded || value;
+			return [{
+				id: `${parentId}-field-${fieldIndex}`,
+				label: label ? `${label}:` : "",
+				fieldLabel: label ? `${label}:` : void 0,
+				type: "file",
+				open: false,
+				content,
+				...contentVariants ? { contentVariants } : {},
+				copyValue: typeof field.copyValue === "string" ? field.copyValue : void 0,
+				hideLabel: Boolean(field.hideLabel),
+				hideChevron: typeof field.hideChevron === "boolean" ? field.hideChevron : true
+			}];
+		}
+		return [{
+			id: `${parentId}-field-${fieldIndex}`,
+			label: label ? `${label}: ${value}` : value,
+			fieldLabel: label ? `${label}:` : void 0,
+			type: "file",
+			open: false,
+			copyValue: typeof field.copyValue === "string" ? field.copyValue : void 0
+		}];
+	});
+}
+//#endregion
+export { buildFieldNodes };
+
+//# sourceMappingURL=types.js.map