@seams/wallet 0.22.0 → 0.24.0

package/dist/esm/node_modules/borsh/lib/esm/serialize.js

@@ -0,0 +1,127 @@
+import { integers } from "./types.js";
+import { EncodeBuffer } from "./buffer.js";
+import { expect_bigint, expect_enum, expect_same_size, expect_type, isArrayLike } from "./utils.js";
+//#region ../../node_modules/borsh/lib/esm/serialize.js
+var BorshSerializer = function() {
+	function BorshSerializer(checkTypes) {
+		this.encoded = new EncodeBuffer();
+		this.fieldPath = ["value"];
+		this.checkTypes = checkTypes;
+	}
+	BorshSerializer.prototype.encode = function(value, schema) {
+		this.encode_value(value, schema);
+		return this.encoded.get_used_buffer();
+	};
+	BorshSerializer.prototype.encode_value = function(value, schema) {
+		if (typeof schema === "string") {
+			if (integers.includes(schema)) return this.encode_integer(value, schema);
+			if (schema === "string") return this.encode_string(value);
+			if (schema === "bool") return this.encode_boolean(value);
+		}
+		if (typeof schema === "object") {
+			if ("option" in schema) return this.encode_option(value, schema);
+			if ("enum" in schema) return this.encode_enum(value, schema);
+			if ("array" in schema) return this.encode_array(value, schema);
+			if ("set" in schema) return this.encode_set(value, schema);
+			if ("map" in schema) return this.encode_map(value, schema);
+			if ("struct" in schema) return this.encode_struct(value, schema);
+		}
+	};
+	BorshSerializer.prototype.encode_integer = function(value, schema) {
+		var size = parseInt(schema.substring(1));
+		if (size <= 32 || schema == "f64") {
+			this.checkTypes && expect_type(value, "number", this.fieldPath);
+			this.encoded.store_value(value, schema);
+		} else {
+			this.checkTypes && expect_bigint(value, this.fieldPath);
+			this.encode_bigint(BigInt(value), size);
+		}
+	};
+	BorshSerializer.prototype.encode_bigint = function(value, size) {
+		var buffer_len = size / 8;
+		var buffer = new Uint8Array(buffer_len);
+		for (var i = 0; i < buffer_len; i++) {
+			buffer[i] = Number(value & BigInt(255));
+			value = value >> BigInt(8);
+		}
+		this.encoded.store_bytes(new Uint8Array(buffer));
+	};
+	BorshSerializer.prototype.encode_string = function(value) {
+		this.checkTypes && expect_type(value, "string", this.fieldPath);
+		var _value = value;
+		this.encoded.store_value(_value.length, "u32");
+		for (var i = 0; i < _value.length; i++) this.encoded.store_value(_value.charCodeAt(i), "u8");
+	};
+	BorshSerializer.prototype.encode_boolean = function(value) {
+		this.checkTypes && expect_type(value, "boolean", this.fieldPath);
+		this.encoded.store_value(value ? 1 : 0, "u8");
+	};
+	BorshSerializer.prototype.encode_option = function(value, schema) {
+		if (value === null || value === void 0) this.encoded.store_value(0, "u8");
+		else {
+			this.encoded.store_value(1, "u8");
+			this.encode_value(value, schema.option);
+		}
+	};
+	BorshSerializer.prototype.encode_enum = function(value, schema) {
+		this.checkTypes && expect_enum(value, this.fieldPath);
+		var valueKey = Object.keys(value)[0];
+		for (var i = 0; i < schema["enum"].length; i++) {
+			var valueSchema = schema["enum"][i];
+			if (valueKey === Object.keys(valueSchema.struct)[0]) {
+				this.encoded.store_value(i, "u8");
+				return this.encode_struct(value, valueSchema);
+			}
+		}
+		throw new Error("Enum key (".concat(valueKey, ") not found in enum schema: ").concat(JSON.stringify(schema), " at ").concat(this.fieldPath.join(".")));
+	};
+	BorshSerializer.prototype.encode_array = function(value, schema) {
+		if (isArrayLike(value)) return this.encode_arraylike(value, schema);
+		if (value instanceof ArrayBuffer) return this.encode_buffer(value, schema);
+		throw new Error("Expected Array-like not ".concat(typeof value, "(").concat(value, ") at ").concat(this.fieldPath.join(".")));
+	};
+	BorshSerializer.prototype.encode_arraylike = function(value, schema) {
+		if (schema.array.len) expect_same_size(value.length, schema.array.len, this.fieldPath);
+		else this.encoded.store_value(value.length, "u32");
+		for (var i = 0; i < value.length; i++) this.encode_value(value[i], schema.array.type);
+	};
+	BorshSerializer.prototype.encode_buffer = function(value, schema) {
+		if (schema.array.len) expect_same_size(value.byteLength, schema.array.len, this.fieldPath);
+		else this.encoded.store_value(value.byteLength, "u32");
+		this.encoded.store_bytes(new Uint8Array(value));
+	};
+	BorshSerializer.prototype.encode_set = function(value, schema) {
+		this.checkTypes && expect_type(value, "object", this.fieldPath);
+		var values = value instanceof Set ? Array.from(value.values()) : Object.values(value);
+		this.encoded.store_value(values.length, "u32");
+		for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
+			var value_1 = values_1[_i];
+			this.encode_value(value_1, schema.set);
+		}
+	};
+	BorshSerializer.prototype.encode_map = function(value, schema) {
+		this.checkTypes && expect_type(value, "object", this.fieldPath);
+		var isMap = value instanceof Map;
+		var keys = isMap ? Array.from(value.keys()) : Object.keys(value);
+		this.encoded.store_value(keys.length, "u32");
+		for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+			var key = keys_1[_i];
+			this.encode_value(key, schema.map.key);
+			this.encode_value(isMap ? value.get(key) : value[key], schema.map.value);
+		}
+	};
+	BorshSerializer.prototype.encode_struct = function(value, schema) {
+		this.checkTypes && expect_type(value, "object", this.fieldPath);
+		for (var _i = 0, _a = Object.keys(schema.struct); _i < _a.length; _i++) {
+			var key = _a[_i];
+			this.fieldPath.push(key);
+			this.encode_value(value[key], schema.struct[key]);
+			this.fieldPath.pop();
+		}
+	};
+	return BorshSerializer;
+}();
+//#endregion
+export { BorshSerializer };
+
+//# sourceMappingURL=serialize.js.map

package/dist/esm/node_modules/borsh/lib/esm/types.js

@@ -0,0 +1,19 @@
+//#region ../../node_modules/borsh/lib/esm/types.js
+var integers = [
+	"u8",
+	"u16",
+	"u32",
+	"u64",
+	"u128",
+	"i8",
+	"i16",
+	"i32",
+	"i64",
+	"i128",
+	"f32",
+	"f64"
+];
+//#endregion
+export { integers };
+
+//# sourceMappingURL=types.js.map

package/dist/esm/node_modules/borsh/lib/esm/utils.js

@@ -0,0 +1,104 @@
+import { integers } from "./types.js";
+//#region ../../node_modules/borsh/lib/esm/utils.js
+var __extends = (function() {
+	var extendStatics = function(d, b) {
+		extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+			d.__proto__ = b;
+		} || function(d, b) {
+			for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+		};
+		return extendStatics(d, b);
+	};
+	return function(d, b) {
+		if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+		extendStatics(d, b);
+		function __() {
+			this.constructor = d;
+		}
+		d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+	};
+})();
+function isArrayLike(value) {
+	return Array.isArray(value) || !!value && typeof value === "object" && "length" in value && typeof value.length === "number" && (value.length === 0 || value.length > 0 && value.length - 1 in value);
+}
+function expect_type(value, type, fieldPath) {
+	if (typeof value !== type) throw new Error("Expected ".concat(type, " not ").concat(typeof value, "(").concat(value, ") at ").concat(fieldPath.join(".")));
+}
+function expect_bigint(value, fieldPath) {
+	var basicType = [
+		"number",
+		"string",
+		"bigint",
+		"boolean"
+	].includes(typeof value);
+	var strObject = typeof value === "object" && value !== null && "toString" in value;
+	if (!basicType && !strObject) throw new Error("Expected bigint, number, boolean or string not ".concat(typeof value, "(").concat(value, ") at ").concat(fieldPath.join(".")));
+}
+function expect_same_size(length, expected, fieldPath) {
+	if (length !== expected) throw new Error("Array length ".concat(length, " does not match schema length ").concat(expected, " at ").concat(fieldPath.join(".")));
+}
+function expect_enum(value, fieldPath) {
+	if (typeof value !== "object" || value === null) throw new Error("Expected object not ".concat(typeof value, "(").concat(value, ") at ").concat(fieldPath.join(".")));
+}
+var VALID_STRING_TYPES = integers.concat(["bool", "string"]);
+var VALID_OBJECT_KEYS = [
+	"option",
+	"enum",
+	"array",
+	"set",
+	"map",
+	"struct"
+];
+var ErrorSchema = function(_super) {
+	__extends(ErrorSchema, _super);
+	function ErrorSchema(schema, expected) {
+		var message = "Invalid schema: ".concat(JSON.stringify(schema), " expected ").concat(expected);
+		return _super.call(this, message) || this;
+	}
+	return ErrorSchema;
+}(Error);
+function validate_schema(schema) {
+	if (typeof schema === "string" && VALID_STRING_TYPES.includes(schema)) return;
+	if (schema && typeof schema === "object") {
+		var keys = Object.keys(schema);
+		if (keys.length === 1 && VALID_OBJECT_KEYS.includes(keys[0])) {
+			var key = keys[0];
+			if (key === "option") return validate_schema(schema[key]);
+			if (key === "enum") return validate_enum_schema(schema[key]);
+			if (key === "array") return validate_array_schema(schema[key]);
+			if (key === "set") return validate_schema(schema[key]);
+			if (key === "map") return validate_map_schema(schema[key]);
+			if (key === "struct") return validate_struct_schema(schema[key]);
+		}
+	}
+	throw new ErrorSchema(schema, VALID_OBJECT_KEYS.join(", ") + " or " + VALID_STRING_TYPES.join(", "));
+}
+function validate_enum_schema(schema) {
+	if (!Array.isArray(schema)) throw new ErrorSchema(schema, "Array");
+	for (var _i = 0, schema_1 = schema; _i < schema_1.length; _i++) {
+		var sch = schema_1[_i];
+		if (typeof sch !== "object" || !("struct" in sch)) throw new Error("Missing \"struct\" key in enum schema");
+		if (typeof sch.struct !== "object" || Object.keys(sch.struct).length !== 1) throw new Error("The \"struct\" in each enum must have a single key");
+		validate_schema({ struct: sch.struct });
+	}
+}
+function validate_array_schema(schema) {
+	if (typeof schema !== "object") throw new ErrorSchema(schema, "{ type, len? }");
+	if (schema.len && typeof schema.len !== "number") throw new Error("Invalid schema: ".concat(schema));
+	if ("type" in schema) return validate_schema(schema.type);
+	throw new ErrorSchema(schema, "{ type, len? }");
+}
+function validate_map_schema(schema) {
+	if (typeof schema === "object" && "key" in schema && "value" in schema) {
+		validate_schema(schema.key);
+		validate_schema(schema.value);
+	} else throw new ErrorSchema(schema, "{ key, value }");
+}
+function validate_struct_schema(schema) {
+	if (typeof schema !== "object") throw new ErrorSchema(schema, "object");
+	for (var key in schema) validate_schema(schema[key]);
+}
+//#endregion
+export { expect_bigint, expect_enum, expect_same_size, expect_type, isArrayLike, validate_schema };
+
+//# sourceMappingURL=utils.js.map

package/dist/esm/plugins/plugin-utils.js

@@ -1,4 +1,3 @@
-import { escapeHtmlAttribute } from "./SeamsWeb/walletIframe/sanitization.js";
 import { normalizeWalletHostVariant, walletHostScriptFileForVariant } from "./core/browser/walletIframe/hostVariant.js";
 //#region src/plugins/plugin-utils.ts
 function withAssetVersion(url, assetVersion) {
@@ -6,19 +5,17 @@ function withAssetVersion(url, assetVersion) {
 	if (!version) return url;
 	return `${url}${url.includes("?") ? "&" : "?"}v=${encodeURIComponent(version)}`;
 }
-function buildWalletServiceHtml(sdkBasePath = "/sdk", assetVersion, walletHostVariant = "runtime", approvedRelayerOrigins = []) {
+function buildWalletServiceHtml(sdkBasePath = "/sdk", assetVersion, walletHostVariant = "runtime") {
 	const walletUiCss = withAssetVersion(`${sdkBasePath}/wallet-ui.css`, assetVersion);
 	const walletShimsJs = withAssetVersion(`${sdkBasePath}/wallet-shims.js`, assetVersion);
 	const walletHostScript = withAssetVersion(`${sdkBasePath}/${walletHostScriptFileForVariant(normalizeWalletHostVariant(walletHostVariant))}`, assetVersion);
-	let relayerPolicy = "";
-	for (const origin of approvedRelayerOrigins) relayerPolicy += `    <meta name="seams-wallet-relayer-origin" content="${escapeHtmlAttribute(origin)}" />\n`;
 	return `<!doctype html>
 <html lang="en">
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>Web3Authn Wallet Service</title>
-${relayerPolicy}    <!-- Surface styles are external so strict CSP can keep style-src 'self' -->
+    <!-- Surface styles are external so strict CSP can keep style-src 'self' -->
     <link rel="stylesheet" href="${walletUiCss}" />
     <!-- Minimal shims some ESM bundles expect (externalized to enable strict CSP) -->
     <script src="${walletShimsJs}"><\/script>

package/dist/esm/react/components/AccountMenuButton/AccountMenuButtonView.js

@@ -105,29 +105,17 @@ function AccountMenuButtonView({ buttonRef, dropdownRef, trigger, dropdown, clas
 					}),
 					/* @__PURE__ */ jsxs("footer", {
 						className: "seams-account-footer",
-						children: [
-							/* @__PURE__ */ jsxs("svg", {
-								width: "17",
-								height: "17",
-								viewBox: "0 0 24 24",
-								fill: "none",
-								stroke: "currentColor",
-								strokeWidth: "1.5",
-								children: [/* @__PURE__ */ jsx("path", { d: "m12 3 8 3v6c0 5-8 9-8 9s-8-4-8-9V6z" }), /* @__PURE__ */ jsx("path", { d: "m8 12 3 3 5-6" })]
-							}),
-							/* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(WalletText, { message: "Secured by" }) }),
-							/* @__PURE__ */ jsx("svg", {
-								className: "seams-account-wordmark",
-								viewBox: "0 0 1428 285",
-								role: "img",
-								"aria-label": "seams",
-								children: /* @__PURE__ */ jsx("path", {
-									d: SEAMS_STANDARD_WORDMARK_PATH,
-									fill: "currentColor",
-									fillRule: "evenodd"
-								})
+						children: [/* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(WalletText, { message: "Secured by" }) }), /* @__PURE__ */ jsx("svg", {
+							className: "seams-account-wordmark",
+							viewBox: "0 0 1428 285",
+							role: "img",
+							"aria-label": "seams",
+							children: /* @__PURE__ */ jsx("path", {
+								d: SEAMS_STANDARD_WORDMARK_PATH,
+								fill: "currentColor",
+								fillRule: "evenodd"
 							})
-						]
+						})]
 					})
 				]
 			})

package/dist/esm/react/components/AccountMenuButton/AccountMenuDeviceDetails.js

@@ -21,10 +21,10 @@ function AccountMenuDeviceDetails({ title, description, details, children, icon
 				/* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsx(WalletText, { copy: description }) })
 			]
 		}),
-		/* @__PURE__ */ jsx("dl", {
+		details.length > 0 ? /* @__PURE__ */ jsx("dl", {
 			className: "seams-account-inset",
 			children: details.map(renderDetail)
-		}),
+		}) : null,
 		children
 	] });
 }

package/dist/esm/react/components/AccountMenuButton/AccountMenuMockScreens.js

@@ -56,7 +56,7 @@ function deviceRow(setScreen, parent, device) {
 		onSelect: selectDevice.bind(null, setScreen, parent, device)
 	}, device.id);
 }
-function MethodTiles({ methods }) {
+function MethodTiles({ methods, inUse }) {
 	const locale = useWalletLocale();
 	return /* @__PURE__ */ jsxs("ul", {
 		className: "seams-account-method-tiles",
@@ -64,7 +64,8 @@ function MethodTiles({ methods }) {
 		children: [methods !== "email_otp" ? /* @__PURE__ */ jsx(AuthenticationMethodRow, {
 			kind: "passkey",
 			title: walletText(locale, "Passkey"),
-			description: walletText(locale, "Touch ID · This device")
+			description: walletText(locale, "Touch ID · This device"),
+			chip: inUse === "passkey" ? walletText(locale, "In use now") : void 0
 		}) : null, methods !== "passkey" ? /* @__PURE__ */ jsx(AuthenticationMethodRow, {
 			kind: "email_otp",
 			title: walletText(locale, "Email OTP"),
@@ -150,8 +151,10 @@ function AccountMenuMockScreens({ screen, setScreen, accounts, transactionSettin
 			onBack: back,
 			children: /* @__PURE__ */ jsx(AuthenticationMethodsView, {
 				walletLabel: walletId,
-				status: "Active",
-				children: /* @__PURE__ */ jsx(MethodTiles, { methods: "both" })
+				children: /* @__PURE__ */ jsx(MethodTiles, {
+					methods: "both",
+					inUse: "passkey"
+				})
 			})
 		});
 		case "linked": return /* @__PURE__ */ jsxs(AccountMenuScreen, {

package/dist/esm/react/components/AccountMenuButton/AddEvmAccount.js

@@ -0,0 +1,124 @@
+import { configuredThresholdEcdsaChainTargets } from "../../../core/signingEngine/interfaces/ecdsaChainTarget.js";
+import { WalletText } from "../../context/WalletLocale.js";
+import { accountMenuCapabilitiesForLoginState } from "../../context/reactLoginStateBuilders.js";
+import { useSeams } from "../../context/index.js";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/react/components/AccountMenuButton/AddEvmAccount.tsx
+function trackMount(mounted) {
+	mounted.current = true;
+	return clearMount.bind(null, mounted);
+}
+function clearMount(mounted) {
+	mounted.current = false;
+}
+function setupError(error) {
+	return error instanceof Error ? error.message : "The account could not be added. Try again.";
+}
+function assertCurrentWallet(context, walletId) {
+	const selected = context.seams.preferences.getCurrentWalletId();
+	if (!context.mounted.current || selected && selected !== walletId) throw new Error("Account added. Open this wallet again to finish setup.");
+}
+async function addAccount(context, state, walletId, targets) {
+	if (state.kind === "adding") return;
+	if (state.kind === "added" && state.walletId === walletId) return;
+	context.setState({
+		kind: "adding",
+		walletId
+	});
+	try {
+		const rpId = context.seams.configs.wallet.iframe.rpIdOverride || new URL(context.seams.configs.wallet.iframe.origin).hostname;
+		const result = await context.seams.registration.addSigner({
+			walletId,
+			rpId,
+			signerSelection: {
+				mode: "ecdsa",
+				ecdsa: {
+					chainTargets: [...targets],
+					participantIds: [1, 2]
+				}
+			}
+		});
+		if (!result.success) throw new Error(result.error);
+		if (result.kind !== "wallet_signer_added" || result.capabilities[0].kind !== "evm_family_ecdsa") throw new Error("The wallet did not return an EVM account.");
+		assertCurrentWallet(context, walletId);
+		context.setState({
+			kind: "added",
+			walletId,
+			evmAddress: result.capabilities[0].thresholdEcdsaEthereumAddress,
+			nearAccountId: context.nearAccountId
+		});
+	} catch (error) {
+		if (context.mounted.current) context.setState({
+			kind: "failed",
+			walletId,
+			message: setupError(error)
+		});
+		return;
+	}
+	await context.refreshSession(walletId);
+}
+/** The menu owns setup across navigation between its screens. */
+function useEvmAccountSetup() {
+	const { seams, refreshSession, loginState } = useSeams();
+	const [state, setState] = useState({ kind: "idle" });
+	const mounted = useRef(false);
+	useEffect(trackMount.bind(null, mounted), [mounted]);
+	return {
+		state,
+		add: addAccount.bind(null, {
+			seams,
+			refreshSession,
+			mounted,
+			setState,
+			nearAccountId: loginState.nearAccountId
+		}, state)
+	};
+}
+function AddEvmAccount({ walletId, setup }) {
+	const { seams, loginState } = useSeams();
+	const targets = useMemo(accountTargets.bind(null, seams.configs.network.chains), [seams.configs.network.chains]);
+	const state = setup.state;
+	const busy = state.kind === "adding";
+	const current = state.kind !== "idle" && state.walletId === walletId;
+	if (!targets || !busy && !(current && state.kind === "added") && (loginState.walletId !== walletId || accountMenuCapabilitiesForLoginState(loginState).kind !== "owner")) return null;
+	if (current && state.kind === "added") return /* @__PURE__ */ jsx("p", {
+		className: "seams-account-note",
+		role: "status",
+		children: /* @__PURE__ */ jsx(WalletText, { message: "EVM account added." })
+	});
+	if (loginState.thresholdEcdsaEthereumAddress && !busy) return null;
+	const hasPasskey = loginState.authMethods.some(isPasskey);
+	let actionLabel = /* @__PURE__ */ jsx(WalletText, { message: "Add EVM account" });
+	if (busy) actionLabel = /* @__PURE__ */ jsx(WalletText, { message: "Adding EVM account…" });
+	return /* @__PURE__ */ jsxs("div", { children: [
+		/* @__PURE__ */ jsx("button", {
+			type: "button",
+			className: "seams-account-action primary",
+			disabled: busy || !hasPasskey,
+			onClick: setup.add.bind(null, walletId, targets),
+			children: actionLabel
+		}),
+		/* @__PURE__ */ jsx("p", {
+			className: "seams-account-note",
+			role: busy ? "status" : void 0,
+			children: hasPasskey || busy ? /* @__PURE__ */ jsx(WalletText, { message: "Enable this app’s EVM networks with your passkey." }) : /* @__PURE__ */ jsx(WalletText, { message: "Add a passkey in Authentication methods first." })
+		}),
+		current && state.kind === "failed" ? /* @__PURE__ */ jsx("p", {
+			className: "seams-account-error",
+			role: "alert",
+			children: /* @__PURE__ */ jsx(WalletText, { copy: state.message })
+		}) : null
+	] });
+}
+function isPasskey(method) {
+	return method.kind === "passkey";
+}
+function accountTargets(chains) {
+	const [first, ...rest] = configuredThresholdEcdsaChainTargets(chains);
+	return first ? [first, ...rest] : null;
+}
+//#endregion
+export { AddEvmAccount, useEvmAccountSetup };
+
+//# sourceMappingURL=AddEvmAccount.js.map

package/dist/esm/react/components/AccountMenuButton/AuthenticationMethodRow.js

@@ -5,7 +5,31 @@ import { MailIcon } from "./icons/MailIcon.js";
 import "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 //#region src/react/components/AccountMenuButton/AuthenticationMethodRow.tsx
-function AuthenticationMethodRow({ kind, title, description, icon, action, onSelect, children }) {
+function methodIcon(kind) {
+	switch (kind) {
+		case "passkey": return /* @__PURE__ */ jsx(TouchIcon, {
+			width: 20,
+			height: 20,
+			strokeWidth: 1.5
+		});
+		case "email_otp": return /* @__PURE__ */ jsx(MailIcon, {
+			size: 20,
+			strokeWidth: 1.75
+		});
+		case "voiceid": return /* @__PURE__ */ jsx("svg", {
+			width: "20",
+			height: "20",
+			viewBox: "0 0 24 24",
+			fill: "none",
+			stroke: "currentColor",
+			strokeWidth: "1.75",
+			strokeLinecap: "round",
+			"aria-hidden": "true",
+			children: /* @__PURE__ */ jsx("path", { d: "M4 10v4m4-7v10m4-14v18m4-14v10m4-7v4" })
+		});
+	}
+}
+function AuthenticationMethodRow({ kind, title, description, chip, icon, action, footer, onSelect, children }) {
 	if (onSelect) return /* @__PURE__ */ jsx("li", {
 		className: "seams-account-method-list-item",
 		children: /* @__PURE__ */ jsxs("button", {
@@ -15,34 +39,21 @@ function AuthenticationMethodRow({ kind, title, description, icon, action, onSel
 			children: [
 				/* @__PURE__ */ jsx("span", {
 					className: "seams-account-avatar",
-					children: icon ?? (kind === "passkey" ? /* @__PURE__ */ jsx(TouchIcon, {
-						width: 20,
-						height: 20,
-						strokeWidth: 1.5
-					}) : /* @__PURE__ */ jsx(MailIcon, {
-						size: 20,
-						strokeWidth: 1.5
-					}))
+					children: icon ?? methodIcon(kind)
 				}),
-				/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("strong", { children: /* @__PURE__ */ jsx(WalletText, { copy: title }) }), /* @__PURE__ */ jsx("small", { children: /* @__PURE__ */ jsx(WalletText, { copy: description }) })] }),
+				/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("strong", { children: /* @__PURE__ */ jsx(WalletText, { copy: title }) }), /* @__PURE__ */ jsx("small", { children: renderDescription(description) })] }),
 				/* @__PURE__ */ jsx(HoverArrowIcon, {})
 			]
 		})
 	});
 	return /* @__PURE__ */ jsxs("li", {
 		className: "seams-linked-devices-modal-item seams-linked-devices-modal-item--row",
+		"data-auth-method": kind,
 		children: [
 			/* @__PURE__ */ jsx("span", {
 				className: "seams-linked-devices-modal-item-icon",
 				"aria-hidden": "true",
-				children: kind === "passkey" ? /* @__PURE__ */ jsx(TouchIcon, {
-					width: 20,
-					height: 20,
-					strokeWidth: 1.5
-				}) : /* @__PURE__ */ jsx(MailIcon, {
-					size: 20,
-					strokeWidth: 1.75
-				})
+				children: icon ?? methodIcon(kind)
 			}),
 			/* @__PURE__ */ jsxs("div", {
 				className: "seams-linked-devices-modal-item-content",
@@ -52,22 +63,29 @@ function AuthenticationMethodRow({ kind, title, description, icon, action, onSel
 						children: [/* @__PURE__ */ jsx("span", {
 							className: "seams-linked-devices-modal-item-name",
 							children: /* @__PURE__ */ jsx(WalletText, { copy: title })
-						}), /* @__PURE__ */ jsx("span", {
+						}), chip ? /* @__PURE__ */ jsx("span", {
 							className: "seams-linked-devices-modal-standing tone-active",
-							children: /* @__PURE__ */ jsx(WalletText, { message: "Active" })
-						})]
+							children: /* @__PURE__ */ jsx(WalletText, { copy: chip })
+						}) : null]
 					}),
 					/* @__PURE__ */ jsx("div", {
 						className: "seams-linked-devices-modal-item-detail",
-						children: /* @__PURE__ */ jsx(WalletText, { copy: description })
+						children: renderDescription(description)
 					}),
 					children
 				]
 			}),
-			action
+			action,
+			footer ? /* @__PURE__ */ jsx("div", {
+				className: "seams-auth-method-footer",
+				children: footer
+			}) : null
 		]
 	});
 }
+function renderDescription(description) {
+	return typeof description === "string" ? /* @__PURE__ */ jsx(WalletText, { copy: description }) : description;
+}
 //#endregion
 export { AuthenticationMethodRow };