@seams/wallet 0.7.1 → 0.8.0

package/dist/esm/sdk/enrichDisplayModelWithAbi-CwHKFqF4.js

@@ -0,0 +1,569 @@
+//#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
+//#region ../shared-ts/src/utils/keccak.ts
+const UINT64_MASK = (1n << 64n) - 1n;
+const KECCAK_RATE_BYTES = 136;
+const KECCAK256_OUTPUT_BYTES = 32;
+const ROTATION_OFFSETS = [
+	1,
+	3,
+	6,
+	10,
+	15,
+	21,
+	28,
+	36,
+	45,
+	55,
+	2,
+	14,
+	27,
+	41,
+	56,
+	8,
+	25,
+	43,
+	62,
+	18,
+	39,
+	61,
+	20,
+	44
+];
+const PI_LANE_INDEXES = [
+	10,
+	7,
+	11,
+	17,
+	18,
+	3,
+	5,
+	16,
+	8,
+	21,
+	24,
+	4,
+	15,
+	23,
+	19,
+	13,
+	12,
+	2,
+	20,
+	14,
+	22,
+	9,
+	6,
+	1
+];
+const ROUND_CONSTANTS = [
+	1n,
+	32898n,
+	9223372036854808714n,
+	9223372039002292224n,
+	32907n,
+	2147483649n,
+	9223372039002292353n,
+	9223372036854808585n,
+	138n,
+	136n,
+	2147516425n,
+	2147483658n,
+	2147516555n,
+	9223372036854775947n,
+	9223372036854808713n,
+	9223372036854808579n,
+	9223372036854808578n,
+	9223372036854775936n,
+	32778n,
+	9223372039002259466n,
+	9223372039002292353n,
+	9223372036854808704n,
+	2147483649n,
+	9223372039002292232n
+];
+function rotateLeft64(value, shift) {
+	const n = BigInt(shift);
+	return (value << n | value >> 64n - n) & UINT64_MASK;
+}
+function keccakF1600(state) {
+	const c = new Array(5);
+	const d = new Array(5);
+	for (let round = 0; round < 24; round += 1) {
+		for (let x = 0; x < 5; x += 1) c[x] = state[x] ^ state[x + 5] ^ state[x + 10] ^ state[x + 15] ^ state[x + 20];
+		for (let x = 0; x < 5; x += 1) d[x] = c[(x + 4) % 5] ^ rotateLeft64(c[(x + 1) % 5], 1);
+		for (let y = 0; y < 5; y += 1) {
+			const rowOffset = y * 5;
+			for (let x = 0; x < 5; x += 1) state[rowOffset + x] ^= d[x];
+		}
+		let lane = state[1];
+		for (let i = 0; i < 24; i += 1) {
+			const targetIndex = PI_LANE_INDEXES[i];
+			const nextLane = state[targetIndex];
+			state[targetIndex] = rotateLeft64(lane, ROTATION_OFFSETS[i]);
+			lane = nextLane;
+		}
+		for (let y = 0; y < 5; y += 1) {
+			const rowOffset = y * 5;
+			const lane0 = state[rowOffset];
+			const lane1 = state[rowOffset + 1];
+			const lane2 = state[rowOffset + 2];
+			const lane3 = state[rowOffset + 3];
+			const lane4 = state[rowOffset + 4];
+			state[rowOffset] = (lane0 ^ ~lane1 & UINT64_MASK & lane2) & UINT64_MASK;
+			state[rowOffset + 1] = (lane1 ^ ~lane2 & UINT64_MASK & lane3) & UINT64_MASK;
+			state[rowOffset + 2] = (lane2 ^ ~lane3 & UINT64_MASK & lane4) & UINT64_MASK;
+			state[rowOffset + 3] = (lane3 ^ ~lane4 & UINT64_MASK & lane0) & UINT64_MASK;
+			state[rowOffset + 4] = (lane4 ^ ~lane0 & UINT64_MASK & lane1) & UINT64_MASK;
+		}
+		state[0] ^= ROUND_CONSTANTS[round];
+	}
+}
+function absorbByte(state, offset, byte) {
+	const laneIndex = Math.floor(offset / 8);
+	const laneShift = BigInt(offset % 8 * 8);
+	state[laneIndex] ^= BigInt(byte) << laneShift;
+}
+function keccak256Bytes(input) {
+	const state = new Array(25).fill(0n);
+	let offset = 0;
+	for (let i = 0; i < input.length; i += 1) {
+		absorbByte(state, offset, input[i]);
+		offset += 1;
+		if (offset === KECCAK_RATE_BYTES) {
+			keccakF1600(state);
+			offset = 0;
+		}
+	}
+	absorbByte(state, offset, 1);
+	absorbByte(state, KECCAK_RATE_BYTES - 1, 128);
+	keccakF1600(state);
+	const out = new Uint8Array(KECCAK256_OUTPUT_BYTES);
+	for (let i = 0; i < KECCAK256_OUTPUT_BYTES; i += 1) {
+		const lane = state[Math.floor(i / 8)];
+		const laneShift = BigInt(i % 8 * 8);
+		out[i] = Number(lane >> laneShift & 255n);
+	}
+	return out;
+}
+//#endregion
+//#region src/core/signingEngine/chains/evm/display/normalization.ts
+const SELECTOR_HEX_RE = /^0x[0-9a-f]{8}$/;
+function normalizeHexData(value, options = {}) {
+	const raw = String(value || "").trim();
+	if (!raw) return "0x";
+	const prefixed = /^0x/i.test(raw) ? `0x${raw.slice(2)}` : `0x${raw}`;
+	const normalized = prefixed === "0x" ? "0x" : prefixed;
+	return options.lowercase ? normalized.toLowerCase() : normalized;
+}
+function normalizeHexSelector(value) {
+	const normalized = normalizeHexData(value, { lowercase: true });
+	if (!SELECTOR_HEX_RE.test(normalized)) return void 0;
+	return normalized;
+}
+function deriveSelectorFromHexData(dataHex) {
+	const normalized = normalizeHexData(dataHex, { lowercase: true });
+	if (!normalized.startsWith("0x") || normalized.length < 10) return void 0;
+	return normalizeHexSelector(normalized.slice(0, 10));
+}
+//#endregion
+//#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
+//#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 };

package/dist/esm/sdk/errors-DfbnsXjO.js

@@ -0,0 +1 @@
+function e(e){try{return typeof e==`string`?e:e&&typeof e.message==`string`?e.message:String(e??``)}catch{return``}}function t(e){return`${e}B64u`}t(`seed`),t(`canonicalSeed`),t(`xClientBase`),t(`clientOutputMask`),t(`clientRecoverableSecret`),t(`prfFirst`),t(`prfSecond`),t(`signingShare32`),t(`clientNonceHandle`);function n(t){if(t instanceof Error)return t;let n=Error(e(t));try{let e=t;typeof e?.name==`string`&&(n.name=e.name),typeof e?.stack==`string`&&(n.stack=e.stack),e&&e.code!==void 0&&(n.code=e.code),e&&e.details!==void 0&&(n.details=e.details)}catch{}return n}function r(t){let n=e(t);if(i(t))return!1;if(a(t))return!0;let r=n.toLowerCase();return n.includes(`The operation either timed out or was not allowed`)||n.includes(`NotAllowedError`)||n.includes(`AbortError`)||r.includes(`user cancelled`)||r.includes(`user canceled`)||r.includes(`user aborted`)||r.includes(`was cancelled`)||r.includes(`was canceled`)}function i(t){let n=e(t).toLowerCase();return n.includes(`relying party id`)||n.includes(`registrable domain suffix`)||n.includes(`claimed rp id`)||n.includes(`/.well-known/webauthn`)||n.includes(`.well-known/webauthn`)}function a(t){if(i(t))return!1;let n=e(t).toLowerCase(),r=t,a=String(r?.name||``).trim(),o=r?.code,s=String(o||``).trim().toLowerCase().replace(/[\s-]+/g,`_`);return o===4001||s===`4001`||s===`cancelled`||s===`canceled`||s===`abort_error`||s===`user_cancelled`||s===`user_canceled`||s===`user_rejected`||s===`action_rejected`||s===`request_rejected`||a===`NotAllowedError`||a===`AbortError`||n.includes(`user cancelled`)||n.includes(`user canceled`)||n.includes(`user rejected`)||n.includes(`request cancelled`)||n.includes(`request canceled`)||n.includes(`operation cancelled`)||n.includes(`operation canceled`)}function o(e){switch(e){case`registration`:return`Registration was cancelled. Please try again when you're ready to set up your passkey.`;case`login`:return`Login was cancelled. Please try again when you're ready to authenticate.`;default:return`Operation was cancelled. Please try again when you're ready.`}}function s(t,n=`registration`,a){let s=e(t);return i(t)?`${n===`registration`?`Registration`:`Login`} failed because the configured WebAuthn RP ID is not valid for this app origin. Check VITE_RP_ID_BASE and the /.well-known/webauthn related-origin configuration for this environment.`:r(t)?o(n):s.includes(`PRF outputs missing`)?`${n===`registration`?`Registration`:`Login`} failed because your browser did not return the required passkey PRF results. On some mobile browsers this is not available for create(); try updating your browser or use a desktop browser. We’re working on an alternate path for broader device support.`:s.includes(`one of the credentials already registered`)?`A passkey for '${a||`this account`}' already exists. Please try logging in instead.`:s.includes(`Cannot deserialize the contract state`)?`Contract state deserialization failed. This may be due to a contract upgrade. Please try again or contact support.`:s.includes(`Web3Authn contract registration check failed`)?`Contract registration check failed: ${s.replace(`Web3Authn contract registration check failed: `,``)}`:s.includes(`Unknown error occurred`)?`${n===`registration`?`Registration`:`Login`} failed due to an unknown error. Please check your connection and try again.`:s}export{i as a,a as i,s as n,n as o,r,e as t};

package/dist/esm/sdk/events-BJyVcnsn.js

@@ -0,0 +1 @@
+const e={TX_CONFIRMER_CANCEL:`seams:tx-confirmer-cancel`};export{e as t};

package/dist/esm/sdk/evmCryptoWasm-CwEXiLrC.js

@@ -0,0 +1 @@
+import{t as e}from"./executeWorkerOperation-CrFf3FkL.js";function t(e){if(e<0n)throw Error(`[evmCryptoWasm] negative bigint not supported`);return e.toString(10)}function n(e){if(typeof e==`bigint`){if(e<0n)throw Error(`[evmCryptoWasm] chainId must be a non-negative integer`);let t=Number(e);if(!Number.isSafeInteger(t))throw Error(`[evmCryptoWasm] chainId must be a non-negative safe integer`);return t}if(!Number.isSafeInteger(e)||e<0)throw Error(`[evmCryptoWasm] chainId must be a non-negative safe integer`);return e}function r(e){if(typeof e==`bigint`)return e;throw Error(`[evmCryptoWasm] missing tx nonce`)}function i(e){return{chainId:n(e.chainId),nonce:t(r(e.nonce)),maxPriorityFeePerGas:t(e.maxPriorityFeePerGas),maxFeePerGas:t(e.maxFeePerGas),gasLimit:t(e.gasLimit),to:e.to??null,value:t(e.value),data:e.data??`0x`,accessList:(e.accessList??[]).map(e=>({address:e.address,storageKeys:e.storageKeys}))}}const a=`evmCrypto`,o=2e4;async function s(t,n){let r=await e({ctx:n,kind:a,request:{type:`computeEip1559TxHash`,payload:{tx:i(t)},timeoutMs:o}});return new Uint8Array(r)}async function c(t){let n=t.signature65.slice().buffer,r=await e({ctx:t.workerCtx,kind:a,request:{type:`encodeEip1559SignedTxFromSignature65`,payload:{tx:i(t.tx),signature65:n},timeoutMs:o,transfer:[n]}});return new Uint8Array(r)}async function l(t){if(!(t.digest32 instanceof Uint8Array)||t.digest32.length!==32)throw Error(`digest32 must be 32 bytes`);if(!(t.signature65 instanceof Uint8Array)||t.signature65.length!==65)throw Error(`signature65 must be 65 bytes`);if(!(t.publicKey33 instanceof Uint8Array)||t.publicKey33.length!==33)throw Error(`publicKey33 must be 33 bytes`);let n=t.digest32.slice().buffer,r=t.signature65.slice().buffer,i=t.publicKey33.slice().buffer,s=await e({ctx:t.workerCtx,kind:a,request:{type:`verifySecp256k1RecoverableSignatureAgainstPublicKey33`,payload:{digest32:n,signature65:r,publicKey33:i},timeoutMs:o,transfer:[n,r,i]}}),c=new Uint8Array(s);if(c.length!==33)throw Error(`verifySecp256k1RecoverableSignatureAgainstPublicKey33 expected 33-byte output (got ${c.length})`);return c}async function u(t){if(!(t.publicKey33 instanceof Uint8Array)||t.publicKey33.length!==33)throw Error(`publicKey33 must be 33 bytes`);let n=t.publicKey33.slice(),r=await e({ctx:t.workerCtx,kind:a,request:{type:`validateSecp256k1PublicKey33`,payload:{publicKey33:n.buffer},timeoutMs:o,transfer:[n.buffer]}}),i=new Uint8Array(r);if(i.length!==33)throw Error(`validateSecp256k1PublicKey33 expected 33-byte output (got ${i.length})`);return i}async function d(t){if(!(t.left33 instanceof Uint8Array)||t.left33.length!==33)throw Error(`left33 must be 33 bytes`);if(!(t.right33 instanceof Uint8Array)||t.right33.length!==33)throw Error(`right33 must be 33 bytes`);let n=t.left33.slice(),r=t.right33.slice(),i=await e({ctx:t.workerCtx,kind:a,request:{type:`addSecp256k1PublicKeys33`,payload:{left33:n.buffer,right33:r.buffer},timeoutMs:o,transfer:[n.buffer,r.buffer]}}),s=new Uint8Array(i);if(s.length!==33)throw Error(`addSecp256k1PublicKeys33 expected 33-byte output (got ${s.length})`);return s}async function f(t){if(!(t.challenge32 instanceof Uint8Array)||t.challenge32.length!==32)throw Error(`challenge32 must be 32 bytes`);if(!(t.pubKeyX32 instanceof Uint8Array)||t.pubKeyX32.length!==32)throw Error(`pubKeyX32 must be 32 bytes`);if(!(t.pubKeyY32 instanceof Uint8Array)||t.pubKeyY32.length!==32)throw Error(`pubKeyY32 must be 32 bytes`);if(!(t.authenticatorData instanceof Uint8Array)||!t.authenticatorData.length)throw Error(`authenticatorData must be non-empty`);if(!(t.clientDataJSON instanceof Uint8Array)||!t.clientDataJSON.length)throw Error(`clientDataJSON must be non-empty`);if(!(t.signatureDer instanceof Uint8Array)||!t.signatureDer.length)throw Error(`signatureDer must be non-empty`);let n=t.challenge32.slice(),r=t.authenticatorData.slice(),i=t.clientDataJSON.slice(),s=t.signatureDer.slice(),c=t.pubKeyX32.slice(),l=t.pubKeyY32.slice(),u=await e({ctx:t.workerCtx,kind:a,request:{type:`buildWebauthnP256Signature`,payload:{challenge32:n.buffer,authenticatorData:r.buffer,clientDataJSON:i.buffer,signatureDer:s.buffer,pubKeyX32:c.buffer,pubKeyY32:l.buffer},timeoutMs:o,transfer:[n.buffer,r.buffer,i.buffer,s.buffer,c.buffer,l.buffer]}});return new Uint8Array(u)}async function p(t){if(!(t.cosePublicKey instanceof Uint8Array)||t.cosePublicKey.length===0)throw Error(`cosePublicKey must be non-empty`);let n=t.cosePublicKey.slice(),r=await e({ctx:t.workerCtx,kind:a,request:{type:`decodeCoseP256PublicKey`,payload:{cosePublicKey:n.buffer},timeoutMs:o,transfer:[n.buffer]}}),i=new Uint8Array(r);if(i.length!==64)throw Error(`decodeCoseP256PublicKey expected 64-byte output (got ${i.length})`);return{pubKeyX32:i.slice(0,32),pubKeyY32:i.slice(32,64)}}export{c as a,p as i,f as n,u as o,s as r,l as s,d as t};