fix: allow disable last remaining network on namespace

[salimtb]

Explanation

This change allows the last remaining network in a namespace to be disabled. The reason is to align with BIP-44, where account groups shouldn’t be forced to always keep at least one active network

References

Checklist

• I've updated the test suite for new or updated code as appropriate
• I've updated documentation (JSDoc, Markdown, etc.) for new or updated code as appropriate
• I've communicated my changes to consumers by updating changelogs for packages I've changed, highlighting breaking changes as necessary
• I've prepared draft pull requests for clients and consumer packages to resolve any breaking changes

[cursor]

Bug: Network Enablement Feature Removed

The NetworkEnablementController no longer subscribes to TransactionController:transactionSubmitted events. This removes the automatic network enablement feature when users submit transactions. Additionally, several existing tests that publish these events are now ineffective and misleading, as the controller no longer processes them.

packages/network-enablement-controller/src/NetworkEnablementController.test.ts#L200-L300

core/packages/network-enablement-controller/src/NetworkEnablementController.test.ts

Lines 200 to 300 in c93bc57

	it('handles TransactionController:transactionSubmitted with missing chainId gracefully', async () => {
	const { controller, messenger } = setupInitializedController();
	const initialState = { ...controller.state };
	// Publish a transaction submitted event without chainId
	messenger.publish('TransactionController:transactionSubmitted', {
	transactionMeta: {
	networkClientId: 'test-network',
	id: 'test-tx-id',
	status: TransactionStatus.submitted,
	time: Date.now(),
	txParams: {
	from: '0x123',
	to: '0x456',
	value: '0x0',
	},
	// chainId is missing
	} as TransactionMeta, // Simplified structure for testing
	});
	await advanceTime({ clock, duration: 1 });
	// State should remain unchanged
	expect(controller.state).toStrictEqual(initialState);
	});
	it('handles TransactionController:transactionSubmitted with malformed structure gracefully', async () => {
	const { controller, messenger } = setupInitializedController();
	const initialState = { ...controller.state };
	// Publish a transaction submitted event with malformed structure
	// @ts-expect-error - Testing runtime safety for malformed payload
	messenger.publish('TransactionController:transactionSubmitted', {
	// Missing transactionMeta entirely
	});
	await advanceTime({ clock, duration: 1 });
	// State should remain unchanged
	expect(controller.state).toStrictEqual(initialState);
	});
	it('handles TransactionController:transactionSubmitted with null/undefined transactionMeta gracefully', async () => {
	const { controller, messenger } = setupInitializedController();
	const initialState = { ...controller.state };
	// Test with null transactionMeta
	messenger.publish('TransactionController:transactionSubmitted', {
	// @ts-expect-error - Testing runtime safety for null transactionMeta
	transactionMeta: null,
	});
	await advanceTime({ clock, duration: 1 });
	// State should remain unchanged
	expect(controller.state).toStrictEqual(initialState);
	// Test with undefined transactionMeta
	messenger.publish('TransactionController:transactionSubmitted', {
	// @ts-expect-error - Testing runtime safety for undefined transactionMeta
	transactionMeta: undefined,
	});
	await advanceTime({ clock, duration: 1 });
	// State should still remain unchanged
	expect(controller.state).toStrictEqual(initialState);
	});
	it('does fallback to ethereum when removing the last enabled network', async () => {
	const { controller, messenger } = setupInitializedController();
	// disable all networks except linea
	controller.disableNetwork('0x1'); // Ethereum Mainnet
	controller.disableNetwork('0x2105'); // Base Mainnet
	// Publish an update with linea network removed
	messenger.publish('NetworkController:networkRemoved', {
	chainId: '0xe708', // Linea Mainnet
	blockExplorerUrls: [],
	defaultRpcEndpointIndex: 0,
	name: 'Linea',
	nativeCurrency: 'ETH',
	rpcEndpoints: [
	{
	url: 'https://linea-mainnet.infura.io/v3/1234567890',
	networkClientId: 'id',
	type: RpcEndpointType.Custom,
	},
	],
	});
	await advanceTime({ clock, duration: 1 });
	expect(controller.state).toStrictEqual({
	enabledNetworkMap: {
	[KnownCaipNamespace.Eip155]: {

packages/network-enablement-controller/src/NetworkEnablementController.ts#L179-L192

core/packages/network-enablement-controller/src/NetworkEnablementController.ts

Lines 179 to 192 in c93bc57

	});
	}
	/**
	* Enables or disables a network for the user.
	*
	* This method accepts either a Hex chain ID (for EVM networks) or a CAIP-2 chain ID
	* (for any blockchain network). The method will automatically convert Hex chain IDs
	* to CAIP-2 format internally. This dual parameter support allows for backward
	* compatibility with existing EVM chain ID formats while supporting newer
	* multi-chain standards.
	*
	* When enabling a non-popular network, this method will disable all other networks
	* to ensure only one network is active at a time (exclusive mode).

 

---