@seams/wallet 0.21.0 → 0.23.0

package/dist/esm/externalNear/wallets.js

@@ -0,0 +1,33 @@
+//#region src/externalNear/wallets.ts
+function nearWalletName(wallet) {
+	switch (wallet) {
+		case "meteor": return "Meteor Wallet";
+		case "hot": return "HOT Wallet";
+		case "intear": return "Intear Wallet";
+		default: return assertNever(wallet);
+	}
+}
+function assertNever(value) {
+	throw new Error(`Unknown NEAR wallet: ${value}`);
+}
+async function createNearWalletProvider(wallet, rpcUrl) {
+	switch (wallet) {
+		case "meteor": {
+			const { MeteorExtensionProvider } = await import("./meteor.js");
+			return new MeteorExtensionProvider(rpcUrl);
+		}
+		case "hot": {
+			const { HotExtensionProvider } = await import("./hot.js");
+			return new HotExtensionProvider();
+		}
+		case "intear": {
+			const { IntearWalletProvider } = await import("./intear.js");
+			return new IntearWalletProvider();
+		}
+		default: return assertNever(wallet);
+	}
+}
+//#endregion
+export { createNearWalletProvider, nearWalletName };
+
+//# sourceMappingURL=wallets.js.map

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

@@ -0,0 +1,67 @@
+//#region ../../node_modules/borsh/lib/esm/buffer.js
+var EncodeBuffer = function() {
+	function EncodeBuffer() {
+		this.offset = 0;
+		this.buffer_size = 256;
+		this.buffer = new ArrayBuffer(this.buffer_size);
+		this.view = new DataView(this.buffer);
+	}
+	EncodeBuffer.prototype.resize_if_necessary = function(needed_space) {
+		if (this.buffer_size - this.offset < needed_space) {
+			this.buffer_size = Math.max(this.buffer_size * 2, this.buffer_size + needed_space);
+			var new_buffer = new ArrayBuffer(this.buffer_size);
+			new Uint8Array(new_buffer).set(new Uint8Array(this.buffer));
+			this.buffer = new_buffer;
+			this.view = new DataView(new_buffer);
+		}
+	};
+	EncodeBuffer.prototype.get_used_buffer = function() {
+		return new Uint8Array(this.buffer).slice(0, this.offset);
+	};
+	EncodeBuffer.prototype.store_value = function(value, type) {
+		var bSize = type.substring(1);
+		var size = parseInt(bSize) / 8;
+		this.resize_if_necessary(size);
+		var toCall = type[0] === "f" ? "setFloat".concat(bSize) : type[0] === "i" ? "setInt".concat(bSize) : "setUint".concat(bSize);
+		this.view[toCall](this.offset, value, true);
+		this.offset += size;
+	};
+	EncodeBuffer.prototype.store_bytes = function(from) {
+		this.resize_if_necessary(from.length);
+		new Uint8Array(this.buffer).set(new Uint8Array(from), this.offset);
+		this.offset += from.length;
+	};
+	return EncodeBuffer;
+}();
+var DecodeBuffer = function() {
+	function DecodeBuffer(buf) {
+		this.offset = 0;
+		this.buffer_size = buf.length;
+		this.buffer = new ArrayBuffer(buf.length);
+		new Uint8Array(this.buffer).set(buf);
+		this.view = new DataView(this.buffer);
+	}
+	DecodeBuffer.prototype.assert_enough_buffer = function(size) {
+		if (this.offset + size > this.buffer.byteLength) throw new Error("Error in schema, the buffer is smaller than expected");
+	};
+	DecodeBuffer.prototype.consume_value = function(type) {
+		var bSize = type.substring(1);
+		var size = parseInt(bSize) / 8;
+		this.assert_enough_buffer(size);
+		var toCall = type[0] === "f" ? "getFloat".concat(bSize) : type[0] === "i" ? "getInt".concat(bSize) : "getUint".concat(bSize);
+		var ret = this.view[toCall](this.offset, true);
+		this.offset += size;
+		return ret;
+	};
+	DecodeBuffer.prototype.consume_bytes = function(size) {
+		this.assert_enough_buffer(size);
+		var ret = this.buffer.slice(this.offset, this.offset + size);
+		this.offset += size;
+		return ret;
+	};
+	return DecodeBuffer;
+}();
+//#endregion
+export { DecodeBuffer, EncodeBuffer };
+
+//# sourceMappingURL=buffer.js.map

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

@@ -0,0 +1,94 @@
+import { integers } from "./types.js";
+import { DecodeBuffer } from "./buffer.js";
+(function() {
+	function BorshDeserializer(bufferArray) {
+		this.buffer = new DecodeBuffer(bufferArray);
+	}
+	BorshDeserializer.prototype.decode = function(schema) {
+		return this.decode_value(schema);
+	};
+	BorshDeserializer.prototype.decode_value = function(schema) {
+		if (typeof schema === "string") {
+			if (integers.includes(schema)) return this.decode_integer(schema);
+			if (schema === "string") return this.decode_string();
+			if (schema === "bool") return this.decode_boolean();
+		}
+		if (typeof schema === "object") {
+			if ("option" in schema) return this.decode_option(schema);
+			if ("enum" in schema) return this.decode_enum(schema);
+			if ("array" in schema) return this.decode_array(schema);
+			if ("set" in schema) return this.decode_set(schema);
+			if ("map" in schema) return this.decode_map(schema);
+			if ("struct" in schema) return this.decode_struct(schema);
+		}
+		throw new Error("Unsupported type: ".concat(schema));
+	};
+	BorshDeserializer.prototype.decode_integer = function(schema) {
+		var size = parseInt(schema.substring(1));
+		if (size <= 32 || schema == "f64") return this.buffer.consume_value(schema);
+		return this.decode_bigint(size, schema.startsWith("i"));
+	};
+	BorshDeserializer.prototype.decode_bigint = function(size, signed) {
+		if (signed === void 0) signed = false;
+		var buffer_len = size / 8;
+		var buffer = new Uint8Array(this.buffer.consume_bytes(buffer_len));
+		var bits = buffer.reduceRight(function(r, x) {
+			return r + x.toString(16).padStart(2, "0");
+		}, "");
+		if (signed && buffer[buffer_len - 1]) return BigInt.asIntN(size, BigInt("0x".concat(bits)));
+		return BigInt("0x".concat(bits));
+	};
+	BorshDeserializer.prototype.decode_string = function() {
+		var len = this.decode_integer("u32");
+		var buffer = new Uint8Array(this.buffer.consume_bytes(len));
+		return String.fromCharCode.apply(null, buffer);
+	};
+	BorshDeserializer.prototype.decode_boolean = function() {
+		return this.buffer.consume_value("u8") > 0;
+	};
+	BorshDeserializer.prototype.decode_option = function(schema) {
+		var option = this.buffer.consume_value("u8");
+		if (option === 1) return this.decode_value(schema.option);
+		if (option !== 0) throw new Error("Invalid option ".concat(option));
+		return null;
+	};
+	BorshDeserializer.prototype.decode_enum = function(schema) {
+		var _a;
+		var valueIndex = this.buffer.consume_value("u8");
+		if (valueIndex > schema["enum"].length) throw new Error("Enum option ".concat(valueIndex, " is not available"));
+		var struct = schema["enum"][valueIndex].struct;
+		var key = Object.keys(struct)[0];
+		return _a = {}, _a[key] = this.decode_value(struct[key]), _a;
+	};
+	BorshDeserializer.prototype.decode_array = function(schema) {
+		var result = [];
+		var len = schema.array.len ? schema.array.len : this.decode_integer("u32");
+		for (var i = 0; i < len; ++i) result.push(this.decode_value(schema.array.type));
+		return result;
+	};
+	BorshDeserializer.prototype.decode_set = function(schema) {
+		var len = this.decode_integer("u32");
+		var result = /* @__PURE__ */ new Set();
+		for (var i = 0; i < len; ++i) result.add(this.decode_value(schema.set));
+		return result;
+	};
+	BorshDeserializer.prototype.decode_map = function(schema) {
+		var len = this.decode_integer("u32");
+		var result = /* @__PURE__ */ new Map();
+		for (var i = 0; i < len; ++i) {
+			var key = this.decode_value(schema.map.key);
+			var value = this.decode_value(schema.map.value);
+			result.set(key, value);
+		}
+		return result;
+	};
+	BorshDeserializer.prototype.decode_struct = function(schema) {
+		var result = {};
+		for (var key in schema.struct) result[key] = this.decode_value(schema.struct[key]);
+		return result;
+	};
+	return BorshDeserializer;
+})();
+//#endregion
+
+//# sourceMappingURL=deserialize.js.map

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

@@ -0,0 +1,13 @@
+import { validate_schema } from "./utils.js";
+import { BorshSerializer } from "./serialize.js";
+import "./deserialize.js";
+//#region ../../node_modules/borsh/lib/esm/index.js
+function serialize(schema, value, validate) {
+	if (validate === void 0) validate = true;
+	if (validate) validate_schema(schema);
+	return new BorshSerializer(validate).encode(value, schema);
+}
+//#endregion
+export { serialize };
+
+//# sourceMappingURL=index.js.map

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/ProfileDropdown.js

@@ -6,21 +6,35 @@ import "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 import "./ProfileDropdown.css";
 //#region src/react/components/AccountMenuButton/ProfileDropdown.tsx
-const SECURITY_ITEMS = [
+const MENU_ORDER = [
+	"accounts",
+	"transaction-settings",
 	"authentication-methods",
+	"recovery-codes",
+	"linked-devices",
 	"scan-link-device",
+	"export-keys"
+];
+const SECURITY_ITEMS = [
+	"authentication-methods",
+	"recovery-codes",
 	"linked-devices",
-	"recovery-codes"
+	"scan-link-device",
+	"export-keys"
 ];
 function isSecurityItem(item) {
 	return SECURITY_ITEMS.includes(item.id ?? "");
 }
-function compareSecurityItems(a, b) {
-	return SECURITY_ITEMS.indexOf(a.id ?? "") - SECURITY_ITEMS.indexOf(b.id ?? "");
-}
-function isAccountItem(item) {
+function isWalletItem(item) {
 	return !isSecurityItem(item);
 }
+function menuRank(item) {
+	const rank = MENU_ORDER.indexOf(item.id ?? "");
+	return rank === -1 ? MENU_ORDER.length : rank;
+}
+function compareMenuItems(a, b) {
+	return menuRank(a) - menuRank(b);
+}
 function storeMenuRef(refs, index, element) {
 	refs.current[index] = element;
 }
@@ -48,13 +62,13 @@ function ProfileDropdown(props) {
 		className: "seams-profile-dropdown-menu",
 		children: [
 			/* @__PURE__ */ jsx(MenuGroup, {
-				label: walletText(locale, "Addresses"),
-				items: props.menuItems.filter(isAccountItem),
+				label: walletText(locale, "Wallet"),
+				items: props.menuItems.filter(isWalletItem).sort(compareMenuItems),
 				props
 			}),
 			/* @__PURE__ */ jsx(MenuGroup, {
 				label: walletText(locale, "Security & devices"),
-				items: props.menuItems.filter(isSecurityItem).sort(compareSecurityItems),
+				items: props.menuItems.filter(isSecurityItem).sort(compareMenuItems),
 				props
 			}),
 			/* @__PURE__ */ jsx(LockMenuItem, {