mirror of
https://github.com/kremalicious/metamask-extension.git
synced 2024-12-23 01:39:44 +01:00
e6cd452506
* fix sentry warning * correct test * switch to using spyOn method
286 lines
9.3 KiB
TypeScript
286 lines
9.3 KiB
TypeScript
import { hasProperty, Hex, isObject, isStrictHexString } from '@metamask/utils';
|
|
import { BN } from 'ethereumjs-util';
|
|
import { cloneDeep, mapKeys } from 'lodash';
|
|
import log from 'loglevel';
|
|
|
|
type VersionedData = {
|
|
meta: { version: number };
|
|
data: Record<string, unknown>;
|
|
};
|
|
|
|
export const version = 88;
|
|
|
|
/**
|
|
* This migration does a few things:
|
|
*
|
|
* - Rebuilds `allNftContracts` and `allNfts` in NftController state to be keyed
|
|
* by a hex chain ID rather than a decimal chain ID.
|
|
* - Rebuilds `tokensChainsCache` in TokenListController to be keyed by a hex
|
|
* chain ID rather than a decimal chain ID.
|
|
* - Rebuilds `allTokens`, `allDetectedTokens`, and `allIgnoredTokens` in
|
|
* TokensController to be keyed by a hex chain ID rather than a decimal chain ID.
|
|
* - removes any entries in `allNftContracts`, `allNfts`, `tokensChainsCache`,
|
|
* `allTokens`, `allIgnoredTokens` or `allDetectedTokens` that are keyed by the
|
|
* string 'undefined'
|
|
*
|
|
* @param originalVersionedData - Versioned MetaMask extension state, exactly what we persist to dist.
|
|
* @param originalVersionedData.meta - State metadata.
|
|
* @param originalVersionedData.meta.version - The current state version.
|
|
* @param originalVersionedData.data - The persisted MetaMask state, keyed by controller.
|
|
* @returns Updated versioned MetaMask extension state.
|
|
*/
|
|
export async function migrate(
|
|
originalVersionedData: VersionedData,
|
|
): Promise<VersionedData> {
|
|
const versionedData = cloneDeep(originalVersionedData);
|
|
versionedData.meta.version = version;
|
|
migrateData(versionedData.data);
|
|
return versionedData;
|
|
}
|
|
|
|
function migrateData(state: Record<string, unknown>): void {
|
|
if (hasProperty(state, 'NftController') && isObject(state.NftController)) {
|
|
const nftControllerState = state.NftController;
|
|
|
|
// Migrate NftController.allNftContracts
|
|
if (
|
|
hasProperty(nftControllerState, 'allNftContracts') &&
|
|
isObject(nftControllerState.allNftContracts)
|
|
) {
|
|
const { allNftContracts } = nftControllerState;
|
|
|
|
if (
|
|
Object.keys(allNftContracts).every((address) =>
|
|
isObject(allNftContracts[address]),
|
|
)
|
|
) {
|
|
Object.keys(allNftContracts).forEach((address) => {
|
|
const nftContractsByChainId = allNftContracts[address];
|
|
|
|
if (isObject(nftContractsByChainId)) {
|
|
for (const chainId of Object.keys(nftContractsByChainId)) {
|
|
if (chainId === 'undefined' || chainId === undefined) {
|
|
delete nftContractsByChainId[chainId];
|
|
}
|
|
}
|
|
|
|
allNftContracts[address] = mapKeys(
|
|
nftContractsByChainId,
|
|
(_, chainId: string) => toHex(chainId),
|
|
);
|
|
}
|
|
});
|
|
}
|
|
} else if (hasProperty(nftControllerState, 'allNftContracts')) {
|
|
global.sentry?.captureException?.(
|
|
new Error(
|
|
`typeof state.NftController.allNftContracts is ${typeof nftControllerState.allNftContracts}`,
|
|
),
|
|
);
|
|
} else {
|
|
log.warn(
|
|
`typeof state.NftController.allNftContracts is ${typeof nftControllerState.allNftContracts}`,
|
|
);
|
|
}
|
|
|
|
// Migrate NftController.allNfts
|
|
if (
|
|
hasProperty(nftControllerState, 'allNfts') &&
|
|
isObject(nftControllerState.allNfts)
|
|
) {
|
|
const { allNfts } = nftControllerState;
|
|
|
|
if (Object.keys(allNfts).every((address) => isObject(allNfts[address]))) {
|
|
Object.keys(allNfts).forEach((address) => {
|
|
const nftsByChainId = allNfts[address];
|
|
|
|
if (isObject(nftsByChainId)) {
|
|
for (const chainId of Object.keys(nftsByChainId)) {
|
|
if (chainId === 'undefined' || chainId === undefined) {
|
|
delete nftsByChainId[chainId];
|
|
}
|
|
}
|
|
|
|
allNfts[address] = mapKeys(nftsByChainId, (_, chainId: string) =>
|
|
toHex(chainId),
|
|
);
|
|
}
|
|
});
|
|
}
|
|
} else if (hasProperty(nftControllerState, 'allNfts')) {
|
|
global.sentry?.captureException?.(
|
|
new Error(
|
|
`typeof state.NftController.allNfts is ${typeof nftControllerState.allNfts}`,
|
|
),
|
|
);
|
|
} else {
|
|
log.warn(
|
|
`typeof state.NftController.allNfts is ${typeof nftControllerState.allNfts}`,
|
|
);
|
|
}
|
|
|
|
state.NftController = nftControllerState;
|
|
} else if (hasProperty(state, 'NftController')) {
|
|
global.sentry?.captureException?.(
|
|
new Error(`typeof state.NftController is ${typeof state.NftController}`),
|
|
);
|
|
} else {
|
|
log.warn(`typeof state.NftController is undefined`);
|
|
}
|
|
|
|
if (
|
|
hasProperty(state, 'TokenListController') &&
|
|
isObject(state.TokenListController)
|
|
) {
|
|
const tokenListControllerState = state.TokenListController;
|
|
|
|
// Migrate TokenListController.tokensChainsCache
|
|
if (
|
|
hasProperty(tokenListControllerState, 'tokensChainsCache') &&
|
|
isObject(tokenListControllerState.tokensChainsCache)
|
|
) {
|
|
for (const chainId of Object.keys(
|
|
tokenListControllerState.tokensChainsCache,
|
|
)) {
|
|
if (chainId === 'undefined' || chainId === undefined) {
|
|
delete tokenListControllerState.tokensChainsCache[chainId];
|
|
}
|
|
}
|
|
|
|
tokenListControllerState.tokensChainsCache = mapKeys(
|
|
tokenListControllerState.tokensChainsCache,
|
|
(_, chainId: string) => toHex(chainId),
|
|
);
|
|
} else if (hasProperty(tokenListControllerState, 'tokensChainsCache')) {
|
|
global.sentry?.captureException?.(
|
|
new Error(
|
|
`typeof state.TokenListController.tokensChainsCache is ${typeof state
|
|
.TokenListController.tokensChainsCache}`,
|
|
),
|
|
);
|
|
} else {
|
|
log.warn(
|
|
`typeof state.TokenListController.tokensChainsCache is undefined`,
|
|
);
|
|
}
|
|
} else {
|
|
console.warn(
|
|
new Error(
|
|
`typeof state.TokenListController is ${typeof state.TokenListController}`,
|
|
),
|
|
);
|
|
}
|
|
|
|
if (
|
|
hasProperty(state, 'TokensController') &&
|
|
isObject(state.TokensController)
|
|
) {
|
|
const tokensControllerState = state.TokensController;
|
|
|
|
// Migrate TokensController.allTokens
|
|
if (
|
|
hasProperty(tokensControllerState, 'allTokens') &&
|
|
isObject(tokensControllerState.allTokens)
|
|
) {
|
|
const { allTokens } = tokensControllerState;
|
|
|
|
for (const chainId of Object.keys(allTokens)) {
|
|
if (chainId === 'undefined' || chainId === undefined) {
|
|
delete allTokens[chainId];
|
|
}
|
|
}
|
|
|
|
tokensControllerState.allTokens = mapKeys(
|
|
allTokens,
|
|
(_, chainId: string) => toHex(chainId),
|
|
);
|
|
} else if (hasProperty(tokensControllerState, 'allTokens')) {
|
|
global.sentry?.captureException?.(
|
|
new Error(
|
|
`typeof state.TokensController.allTokens is ${typeof tokensControllerState.allTokens}`,
|
|
),
|
|
);
|
|
} else {
|
|
log.warn(
|
|
`typeof state.TokensController.allTokens is ${typeof tokensControllerState.allTokens}`,
|
|
);
|
|
}
|
|
|
|
// Migrate TokensController.allIgnoredTokens
|
|
if (
|
|
hasProperty(tokensControllerState, 'allIgnoredTokens') &&
|
|
isObject(tokensControllerState.allIgnoredTokens)
|
|
) {
|
|
const { allIgnoredTokens } = tokensControllerState;
|
|
|
|
for (const chainId of Object.keys(allIgnoredTokens)) {
|
|
if (chainId === 'undefined' || chainId === undefined) {
|
|
delete allIgnoredTokens[chainId];
|
|
}
|
|
}
|
|
|
|
tokensControllerState.allIgnoredTokens = mapKeys(
|
|
allIgnoredTokens,
|
|
(_, chainId: string) => toHex(chainId),
|
|
);
|
|
} else if (hasProperty(tokensControllerState, 'allIgnoredTokens')) {
|
|
global.sentry?.captureException?.(
|
|
new Error(
|
|
`typeof state.TokensController.allIgnoredTokens is ${typeof tokensControllerState.allIgnoredTokens}`,
|
|
),
|
|
);
|
|
} else {
|
|
log.warn(
|
|
`typeof state.TokensController.allIgnoredTokens is ${typeof tokensControllerState.allIgnoredTokens}`,
|
|
);
|
|
}
|
|
|
|
// Migrate TokensController.allDetectedTokens
|
|
if (
|
|
hasProperty(tokensControllerState, 'allDetectedTokens') &&
|
|
isObject(tokensControllerState.allDetectedTokens)
|
|
) {
|
|
const { allDetectedTokens } = tokensControllerState;
|
|
|
|
for (const chainId of Object.keys(allDetectedTokens)) {
|
|
if (chainId === 'undefined' || chainId === undefined) {
|
|
delete allDetectedTokens[chainId];
|
|
}
|
|
}
|
|
|
|
tokensControllerState.allDetectedTokens = mapKeys(
|
|
allDetectedTokens,
|
|
(_, chainId: string) => toHex(chainId),
|
|
);
|
|
} else if (hasProperty(tokensControllerState, 'allDetectedTokens')) {
|
|
global.sentry?.captureException?.(
|
|
new Error(
|
|
`typeof state.TokensController.allDetectedTokens is ${typeof tokensControllerState.allDetectedTokens}`,
|
|
),
|
|
);
|
|
} else {
|
|
log.warn(
|
|
`typeof state.TokensController.allDetectedTokens is ${typeof tokensControllerState.allDetectedTokens}`,
|
|
);
|
|
}
|
|
|
|
state.TokensController = tokensControllerState;
|
|
} else {
|
|
global.sentry?.captureException?.(
|
|
new Error(
|
|
`typeof state.TokensController is ${typeof state.TokensController}`,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
function toHex(value: number | string | BN): Hex {
|
|
if (typeof value === 'string' && isStrictHexString(value)) {
|
|
return value;
|
|
}
|
|
const hexString = BN.isBN(value)
|
|
? value.toString(16)
|
|
: new BN(value.toString(), 10).toString(16);
|
|
return `0x${hexString}`;
|
|
}
|