106 lines
3.4 KiB
TypeScript
106 lines
3.4 KiB
TypeScript
import { InsecureWalletName, SecureWalletName, WalletName, walletNames } from 'config';
|
|
import { EXTRA_PATHS } from 'config/dpaths';
|
|
import sortedUniq from 'lodash/sortedUniq';
|
|
import difference from 'lodash/difference';
|
|
import {
|
|
CustomNetworkConfig,
|
|
StaticNetworkConfig,
|
|
NetworkConfig,
|
|
DPathFormats
|
|
} from 'types/network';
|
|
|
|
export function makeCustomNetworkId(config: CustomNetworkConfig): string {
|
|
return config.chainId ? `${config.chainId}` : `${config.name}:${config.unit}`;
|
|
}
|
|
|
|
export function makeNetworkConfigFromCustomConfig(
|
|
config: CustomNetworkConfig
|
|
): StaticNetworkConfig {
|
|
// TODO - re-enable this block and classify customConfig after user-inputted dPaths are implemented
|
|
// -------------------------------------------------
|
|
// this still provides the type safety we want
|
|
// as we know config coming in is CustomNetworkConfig
|
|
// meaning name will be a string
|
|
// then we cast it as any to keep it as a network key
|
|
// interface Override extends StaticNetworkConfig {
|
|
// name: any;
|
|
// }
|
|
// -------------------------------------------------
|
|
|
|
// TODO - allow for user-inputted dPaths so we don't need to use any below and can use supplied dPaths
|
|
// In the meantime, networks with an unknown chainId will have HD wallets disabled
|
|
const customConfig: any = {
|
|
...config,
|
|
color: '#000',
|
|
tokens: [],
|
|
contracts: []
|
|
};
|
|
|
|
return customConfig;
|
|
}
|
|
|
|
type PathType = keyof DPathFormats;
|
|
|
|
type DPathFormat =
|
|
| SecureWalletName.TREZOR
|
|
| SecureWalletName.LEDGER_NANO_S
|
|
| InsecureWalletName.MNEMONIC_PHRASE;
|
|
|
|
export function getPaths(pathType: PathType): DPath[] {
|
|
const networkPaths: DPath[] = [];
|
|
Object.values(NETWORKS).forEach(networkConfig => {
|
|
const path = networkConfig.dPathFormats ? networkConfig.dPathFormats[pathType] : [];
|
|
if (path) {
|
|
networkPaths.push(path as DPath);
|
|
}
|
|
});
|
|
const paths = networkPaths.concat(EXTRA_PATHS);
|
|
return sortedUniq(paths);
|
|
}
|
|
|
|
export function getSingleDPath(format: DPathFormat, network: NetworkConfig): DPath {
|
|
const dPathFormats = network.dPathFormats;
|
|
return dPathFormats[format];
|
|
}
|
|
|
|
export function isNetworkUnit(network: NetworkConfig, unit: string) {
|
|
const validNetworks = Object.values(NETWORKS).filter((n: NetworkConfig) => n.unit === unit);
|
|
return validNetworks.includes(network);
|
|
}
|
|
|
|
export function isWalletFormatSupportedOnNetwork(
|
|
format: WalletName,
|
|
network: NetworkConfig
|
|
): boolean {
|
|
const CHECK_FORMATS: DPathFormat[] = [
|
|
SecureWalletName.LEDGER_NANO_S,
|
|
SecureWalletName.TREZOR,
|
|
InsecureWalletName.MNEMONIC_PHRASE
|
|
];
|
|
|
|
const isHDFormat = (f: string): f is DPathFormat => CHECK_FORMATS.includes(f as DPathFormat);
|
|
|
|
// Ensure DPath's are found
|
|
if (isHDFormat(format)) {
|
|
const dPath = network.dPathFormats && network.dPathFormats[format];
|
|
return !!dPath;
|
|
}
|
|
|
|
// Ensure Web3 is only enabled on ETH or ETH Testnets (MetaMask does not support other networks)
|
|
if (format === SecureWalletName.WEB3) {
|
|
return isNetworkUnit(network, 'ETH');
|
|
}
|
|
|
|
// All other wallet formats are supported
|
|
return true;
|
|
}
|
|
|
|
export function allWalletFormatsSupportedOnNetwork(network: NetworkConfig): WalletName[] {
|
|
return walletNames.filter(walletName => isWalletFormatSupportedOnNetwork(walletName, network));
|
|
}
|
|
|
|
export function unSupportedWalletFormatsOnNetwork(network: NetworkConfig): WalletName[] {
|
|
const supportedFormats = allWalletFormatsSupportedOnNetwork(network);
|
|
return difference(walletNames, supportedFormats);
|
|
}
|