Read settings from one storage snapshot

app/ts/background/background.ts

@@ -12,7 +12,7 @@ import { METAMASK_ERROR_FAILED_TO_PARSE_REQUEST, METAMASK_ERROR_NOT_AUTHORIZED,
 import { clearWebsiteConnectionIntent, finalizeWebsiteAccessChange, persistWebsiteAccessChange, sendAccountsChangedToPort, verifyAccess, withSuppressedUnscopedConnectionEventsForSocket } from './accessManagement.js'
 import { getActiveAddressEntryForChain, getWalletActiveAddressEntryForChain } from './metadataUtils.js'
 import { getActiveAddress } from './backgroundUtils.js'
-import { assertNever } from '../utils/typescript.js'
+import { assertNever, hasOwnKey } from '../utils/typescript.js'
 import { JsonRpcResponseError, reportUnexpectedError, isFailedToFetchError } from '../utils/errors.js'
 import { InterceptedRequest, type WebsiteSocket } from '../utils/requests.js'
 import { replyToInterceptedRequest } from './messageSending.js'
@@ -32,7 +32,7 @@ import { getActiveAddressForCurrentSignerState, getConfirmedSignerStateToken, is
 import { handleWatchAssetRequest, initializeWatchAssetWindowListeners, processWatchAssetQueue } from './windows/watchAsset.js'
 import { getSafeModeRpcPolicyReply } from '../safe/safeRequestPolicy.js'
 import { getWatchAssetRpcParseFailureReply } from './watchAssetRpc.js'
-import { createMethodHandlerFor, hasOwnKey } from '../utils/methodHandlers.js'
+import { createMethodHandlerFor } from '../utils/methodHandlers.js'
 import { getWalletCapabilities } from './walletCapabilities.js'
 import { getWalletGetCapabilitiesParseFailureReply } from './walletGetCapabilitiesRpc.js'
 import { hasAccess as getWebsiteAccessApprovalState, hasAddressAccess as getWebsiteAddressAccessApprovalState } from './websiteAccessPolicy.js'

app/ts/background/settings.ts

@@ -4,7 +4,7 @@ import { Semaphore } from '../utils/semaphore.js'
 import type { EthereumAddress } from '../types/wire-types.js'
 import type { Website, WebsiteAccessArray } from '../types/websiteAccessTypes.js'
 import type { BlockExplorer, RpcNetwork } from '../types/rpc.js'
-import { type RichListElement, browserStorageLocalGet, browserStorageLocalSafeParseGet, browserStorageLocalSet } from '../utils/storageUtils.js'
+import { type RichListElement, browserStorageLocalGet, browserStorageLocalSafeParse, browserStorageLocalSet } from '../utils/storageUtils.js'
 import { getUserAddressBookEntries, updateUserAddressBookEntries } from './storageVariables.js'
 import { getUniqueItemsByProperties } from '../utils/typed-arrays.js'
 import type { AddressBookEntry } from '../types/addressBookTypes.js'
@@ -13,6 +13,7 @@ import { DEFAULT_ACTIVE_ADDRESSES, DEFAULT_BLOCK_MANIPULATION, DEFAULT_RPCS } fr
 import { silenceChromeUnCaughtPromise } from '../utils/requests.js'
 import { mergeStoredWebsiteMetadata, sanitizeWebsiteAccess } from '../utils/websiteIcons.js'
 import type { SigningAddressPreference, SigningAddressPreferences } from '../types/signerTypes.js'
+import { hasOwnKey } from '../utils/typescript.js'
 
 export const defaultActiveAddresses = DEFAULT_ACTIVE_ADDRESSES
 
@@ -54,9 +55,10 @@ type StartupStorageDefaults = {
 	signingAddressPreferences: SigningAddressPreferences
 }
 
-async function getParsedStorageValueOrDefault<Key extends keyof StartupStorageDefaults>(key: Key, defaultValue: StartupStorageDefaults[Key]): Promise<StartupStorageDefaults[Key]> {
-	const rawValue = (await browser.storage.local.get(key))[key]
-	const parsedValue: Readonly<Partial<StartupStorageDefaults>> | undefined = await browserStorageLocalSafeParseGet(key)
+async function getParsedStorageValueOrDefaultFromItems<Key extends keyof StartupStorageDefaults>(storedItems: Readonly<Record<string, unknown>>, key: Key, defaultValue: StartupStorageDefaults[Key]): Promise<StartupStorageDefaults[Key]> {
+	const rawValue = storedItems[key]
+	const storedItem = hasOwnKey(storedItems, key) ? { [key]: rawValue } : {}
+	const parsedValue: Readonly<Partial<StartupStorageDefaults>> | undefined = browserStorageLocalSafeParse(storedItem)
 	if (parsedValue !== undefined && key in parsedValue) return parsedValue[key] as StartupStorageDefaults[Key]
 	if (rawValue === undefined) return defaultValue
 	console.warn(`${ key } was corrupt:`)
@@ -65,16 +67,29 @@ async function getParsedStorageValueOrDefault<Key extends keyof StartupStorageDe
 	return defaultValue
 }
 
+async function getParsedStorageValueOrDefault<Key extends keyof StartupStorageDefaults>(key: Key, defaultValue: StartupStorageDefaults[Key]): Promise<StartupStorageDefaults[Key]> {
+	return await getParsedStorageValueOrDefaultFromItems(await browser.storage.local.get(key), key, defaultValue)
+}
+
 export async function getSettings() : Promise<Settings> {
 	if (defaultRpcs[0] === undefined || defaultActiveAddresses[0] === undefined) throw new Error('default rpc or default address was missing')
 	const defaultPage: Page = { page: 'Home' }
-	const activeSimulationAddressPromise = silenceChromeUnCaughtPromise(getParsedStorageValueOrDefault('independentActiveSimulationAddress', defaultActiveAddresses[0].address))
-	const activeSigningSafeAddressPromise = silenceChromeUnCaughtPromise(getParsedStorageValueOrDefault('activeSigningSafeAddress', undefined))
-	const openedPagePromise = silenceChromeUnCaughtPromise(getParsedStorageValueOrDefault('openedPageV2', defaultPage))
-	const useSignersAddressAsActiveAddressPromise = silenceChromeUnCaughtPromise(getParsedStorageValueOrDefault('useSignersAddressAsActiveAddress', false))
-	const websiteAccessPromise = silenceChromeUnCaughtPromise(getWebsiteAccess())
-	const simulationModePromise = silenceChromeUnCaughtPromise(getParsedStorageValueOrDefault('simulationMode', defaultSimulationMode))
-	const activeRpcNetworkPromise = silenceChromeUnCaughtPromise(getParsedStorageValueOrDefault('activeRpcNetwork', defaultRpcs[0]))
+	const storedItems = await silenceChromeUnCaughtPromise(browser.storage.local.get([
+		'independentActiveSimulationAddress',
+		'activeSigningSafeAddress',
+		'openedPageV2',
+		'useSignersAddressAsActiveAddress',
+		'websiteAccess',
+		'simulationMode',
+		'activeRpcNetwork',
+	]))
+	const activeSimulationAddressPromise = silenceChromeUnCaughtPromise(getParsedStorageValueOrDefaultFromItems(storedItems, 'independentActiveSimulationAddress', defaultActiveAddresses[0].address))
+	const activeSigningSafeAddressPromise = silenceChromeUnCaughtPromise(getParsedStorageValueOrDefaultFromItems(storedItems, 'activeSigningSafeAddress', undefined))
+	const openedPagePromise = silenceChromeUnCaughtPromise(getParsedStorageValueOrDefaultFromItems(storedItems, 'openedPageV2', defaultPage))
+	const useSignersAddressAsActiveAddressPromise = silenceChromeUnCaughtPromise(getParsedStorageValueOrDefaultFromItems(storedItems, 'useSignersAddressAsActiveAddress', false))
+	const websiteAccessPromise = silenceChromeUnCaughtPromise(getParsedStorageValueOrDefaultFromItems(storedItems, 'websiteAccess', []).then(sanitizeWebsiteAccess))
+	const simulationModePromise = silenceChromeUnCaughtPromise(getParsedStorageValueOrDefaultFromItems(storedItems, 'simulationMode', defaultSimulationMode))
+	const activeRpcNetworkPromise = silenceChromeUnCaughtPromise(getParsedStorageValueOrDefaultFromItems(storedItems, 'activeRpcNetwork', defaultRpcs[0]))
 	const [activeSimulationAddress, activeSigningSafeAddress, openedPage, useSignersAddressAsActiveAddress, websiteAccess, activeRpcNetwork, simulationMode] = await Promise.all([
 		activeSimulationAddressPromise,
 		activeSigningSafeAddressPromise,

app/ts/types/popupMessageProtocol.ts

@@ -1,5 +1,5 @@
 import type { PopupMessage } from './interceptor-messages.js'
-import { hasOwnKey } from '../utils/methodHandlers.js'
+import { hasOwnKey } from '../utils/typescript.js'
 
 export type PopupMessageDomain = 'address-book' | 'confirmation' | 'diagnostics' | 'home' | 'navigation' | 'safe' | 'settings' | 'simulation' | 'website-access'
 

app/ts/utils/methodHandlers.ts

@@ -1,9 +1,5 @@
 type MethodValue = { readonly method: string }
 
-export function hasOwnKey<ObjectType extends object>(value: ObjectType, key: PropertyKey): key is keyof ObjectType {
-	return Object.prototype.hasOwnProperty.call(value, key)
-}
-
 function hasMethod<Union extends MethodValue, Method extends Union['method']>(
 	value: Union,
 	method: Method,

app/ts/utils/storageUtils.ts

@@ -13,7 +13,7 @@ import { UnexpectedErrorOccured } from '../types/interceptor-reply-messages.js'
 import { InterceptorErrorDiagnostic } from '../types/errorDiagnostics.js'
 import { InterceptedRequestForward } from '../types/interceptor-messages.js'
 import { ICON_ACCESS_DENIED } from './constants.js'
-import { hasOwnKey } from './methodHandlers.js'
+import { hasOwnKey } from './typescript.js'
 
 type IdsOfOpenedTabs = funtypes.Static<typeof IdsOfOpenedTabs>
 const IdsOfOpenedTabs = funtypes.Intersect(
@@ -167,11 +167,14 @@ export async function browserStorageLocalSet2(items: LocalStorageItems2) {
 export async function browserStorageLocalGet(keys: LocalStorageKey | LocalStorageKey[]): Promise<LocalStorageItems> {
 	return LocalStorageItems.parse(await browser.storage.local.get(Array.isArray(keys) ? keys : [keys]))
 }
-export async function browserStorageLocalSafeParseGet(keys: LocalStorageKey | LocalStorageKey[]): Promise<LocalStorageItems | undefined> {
-	const parsed = LocalStorageItems.safeParse(await browser.storage.local.get(Array.isArray(keys) ? keys : [keys]))
+export function browserStorageLocalSafeParse(items: unknown): LocalStorageItems | undefined {
+	const parsed = LocalStorageItems.safeParse(items)
 	if (parsed.success) return parsed.value
 	return undefined
 }
+export async function browserStorageLocalSafeParseGet(keys: LocalStorageKey | LocalStorageKey[]): Promise<LocalStorageItems | undefined> {
+	return browserStorageLocalSafeParse(await browser.storage.local.get(Array.isArray(keys) ? keys : [keys]))
+}
 
 export async function browserStorageLocalRemove(keys: LocalStorageKey | LocalStorageKey[]) {
 	return await browser.storage.local.remove(Array.isArray(keys) ? keys : [keys])

app/ts/utils/typescript.ts

@@ -18,6 +18,10 @@ const isNumber = (value: unknown): value is number => typeof value === 'number'
 export const isBigint = (value: unknown): value is bigint => typeof value === 'bigint'
 export const isNumberOrBigint = (value: unknown): value is number | bigint => isNumber(value) || isBigint(value)
 
+export function hasOwnKey<ObjectType extends object>(value: ObjectType, key: PropertyKey): key is keyof ObjectType {
+	return Object.prototype.hasOwnProperty.call(value, key)
+}
+
 function isObject(maybe: unknown): maybe is Object {
 	return typeof maybe === 'object' && maybe !== null && !Array.isArray(maybe)
 }

test/tests/backgroundAccountPermissions.test.ts

@@ -1270,7 +1270,7 @@ describe('background eth_accounts', () => {
 			configurable: true,
 			value: async (keys?: string | string[] | Record<string, unknown> | null) => {
 				const result = await originalStorageGet(keys)
-				if (delayNextSafeAppsModeRead && keys === 'simulationMode') {
+				if (delayNextSafeAppsModeRead && (keys === 'simulationMode' || (Array.isArray(keys) && keys.includes('simulationMode')))) {
 					delayNextSafeAppsModeRead = false
 					delayedReadStarted.resolve(undefined)
 					await releaseDelayedRead.promise

test/tests/methodHandlers.test.ts

@@ -1,6 +1,6 @@
 import * as assert from 'assert'
 import { test } from 'bun:test'
-import { createMethodHandlerFor, hasOwnKey } from '../../app/ts/utils/methodHandlers.js'
+import { createMethodHandlerFor } from '../../app/ts/utils/methodHandlers.js'
 
 type TestMessage =
 	| { readonly method: 'double', readonly value: number }
@@ -22,9 +22,3 @@ test('method handler tables dispatch narrowed messages and reject mismatched dir
 		/Handler for double received length/,
 	)
 })
-
-test('handler table key checks reject properties inherited from Object.prototype', () => {
-	assert.equal(hasOwnKey(handlers, 'double'), true)
-	assert.equal(hasOwnKey(handlers, 'toString'), false)
-	assert.equal(hasOwnKey(handlers, 'constructor'), false)
-})

test/tests/settingsSnapshot.test.ts

@@ -0,0 +1,76 @@
+import * as assert from 'assert'
+import { test } from 'bun:test'
+
+const firstSnapshot = {
+	independentActiveSimulationAddress: '0x1111111111111111111111111111111111111111',
+	activeSigningSafeAddress: '0x3333333333333333333333333333333333333333',
+	openedPageV2: { page: 'Home' },
+	useSignersAddressAsActiveAddress: false,
+	websiteAccess: [],
+	simulationMode: true,
+	activeRpcNetwork: {
+		name: 'First network',
+		chainId: '0x1',
+		httpsRpc: 'https://first.example',
+		currencyName: 'Ether',
+		currencyTicker: 'ETH',
+		primary: true,
+		minimized: true,
+	},
+}
+
+const secondSnapshot = {
+	independentActiveSimulationAddress: '0x2222222222222222222222222222222222222222',
+	activeSigningSafeAddress: '0x4444444444444444444444444444444444444444',
+	openedPageV2: { page: 'Settings' },
+	useSignersAddressAsActiveAddress: true,
+	websiteAccess: [],
+	simulationMode: false,
+	activeRpcNetwork: {
+		name: 'Second network',
+		chainId: '0xa',
+		httpsRpc: 'https://second.example',
+		currencyName: 'Ether',
+		currencyTicker: 'ETH',
+		primary: true,
+		minimized: true,
+	},
+}
+
+let storageReadCount = 0
+
+Object.defineProperty(globalThis, 'browser', {
+	configurable: true,
+	writable: true,
+	value: {
+		storage: {
+			local: {
+				async get(keys: string | readonly string[]) {
+					const snapshot = storageReadCount++ === 0 ? firstSnapshot : secondSnapshot
+					const requestedKeys = Array.isArray(keys) ? keys : [keys]
+					return Object.fromEntries(Object.entries(snapshot).filter(([key]) => requestedKeys.includes(key)))
+				},
+				async set() {
+					throw new Error('Valid settings should not require repair writes')
+				},
+			},
+		},
+	},
+})
+
+const { getSettings } = await import('../../app/ts/background/settings.js')
+
+test('getSettings returns one atomic browser storage snapshot', async () => {
+	storageReadCount = 0
+
+	const settings = await getSettings()
+
+	assert.equal(storageReadCount, 1)
+	assert.equal(settings.activeSimulationAddress, 0x1111111111111111111111111111111111111111n)
+	assert.equal(settings.activeSigningSafeAddress, 0x3333333333333333333333333333333333333333n)
+	assert.deepEqual(settings.openedPage, { page: 'Home' })
+	assert.equal(settings.useSignersAddressAsActiveAddress, false)
+	assert.equal(settings.simulationMode, true)
+	assert.equal(settings.activeRpcNetwork.name, 'First network')
+	assert.equal(settings.activeRpcNetwork.chainId, 1n)
+})

test/tests/typescriptUtils.test.ts

@@ -1,11 +1,18 @@
 import { describe, test } from 'bun:test'
 import * as assert from 'assert'
-import { isNumberOrBigint } from '../../app/ts/utils/typescript.js'
+import { hasOwnKey, isNumberOrBigint } from '../../app/ts/utils/typescript.js'
 
 describe('typescript utils', () => {
 	test('isNumberOrBigint accepts numeric primitive values', () => {
 		assert.equal(isNumberOrBigint(6), true)
 		assert.equal(isNumberOrBigint(6n), true)
 		assert.equal(isNumberOrBigint('6'), false)
 	})
+
+	test('hasOwnKey rejects properties inherited from Object.prototype', () => {
+		const value = { ownProperty: true }
+		assert.equal(hasOwnKey(value, 'ownProperty'), true)
+		assert.equal(hasOwnKey(value, 'toString'), false)
+		assert.equal(hasOwnKey(value, 'constructor'), false)
+	})
 })