packages/config/src/configDefaults.ts
import * as path from "path";
import Provider from "@truffle/provider";
import TruffleConfig from "./";
export const getInitialConfig = ({
truffleDirectory,
workingDirectory,
network
}: {
truffleDirectory?: string;
workingDirectory?: string;
network?: string;
}) => {
const truffle_directory =
truffleDirectory || path.resolve(path.join(__dirname, "../"));
const working_directory = workingDirectory || process.cwd();
return {
truffle_directory,
working_directory,
network,
networks: {
dashboard: {
network_id: "*",
networkCheckTimeout: 120000,
url: "http://localhost:24012/rpc",
skipDryRun: true
}
},
verboseRpc: false,
solidityLog: {
displayPrefix: "",
preventConsoleLogMigration: false
},
debugGlobal: "debug",
gas: null,
gasPrice: null,
maxFeePerGas: null,
maxPriorityFeePerGas: null,
type: undefined, //don't use null here!
from: null,
confirmations: 0,
timeoutBlocks: 0,
production: false,
skipDryRun: false,
build: null,
resolver: null,
artifactor: null,
quiet: false,
dashboard: {
host: "localhost",
port: 24012,
autoOpen: true,
verbose: false
},
ens: {
enabled: false,
registryAddress: undefined
},
mocha: {
bail: false,
grep: null
},
compilers: {
solc: {
settings: {
//Note: The default solc version is *not* set here!
//It's set in compilerSupplier/index.js in compile-solidity
optimizer: {
enabled: false,
runs: 200
},
remappings: []
}
},
vyper: {
settings: {}
}
},
console: {
require: null
},
logger: console
};
};
export const configProps = ({
configObject
}: {
configObject: TruffleConfig;
}) => {
const resolveDirectory = (value: string): string =>
path.resolve(configObject.working_directory, value);
return {
// These are already set.
truffle_directory() {},
working_directory() {},
network() {},
networks() {},
verboseRpc() {},
solidityLog() {},
build() {},
resolver() {},
artifactor() {},
dashboard() {},
logger() {},
compilers() {},
ens() {},
console() {},
mocha() {},
quiet() {},
debugGlobal() {},
build_directory: {
default: () => path.join(configObject.working_directory, "build"),
transform: resolveDirectory
},
contracts_directory: {
default: () => path.join(configObject.working_directory, "contracts"),
transform: resolveDirectory
},
contracts_build_directory: {
default: () => path.join(configObject.build_directory, "contracts"),
transform: resolveDirectory
},
migrations_directory: {
default: () => path.join(configObject.working_directory, "migrations"),
transform: resolveDirectory
},
migrations_file_extension_regexp() {
return /^\.(js|ts|es6?)$/;
},
test_directory: {
default: () => path.join(configObject.working_directory, "test"),
transform: resolveDirectory
},
test_file_extension_regexp() {
return /.*\.(js|ts|es|es6|jsx|sol)$/;
},
example_project_directory: {
default: () => path.join(configObject.truffle_directory, "example"),
transform: resolveDirectory
},
network_id: {
get() {
try {
return configObject.network_config.network_id;
} catch (e) {
return null;
}
},
set() {
throw new Error(
"Do not set config.network_id. Instead, set config.networks and then config.networks[<network name>].network_id"
);
}
},
network_config: {
get() {
const network = configObject.network;
if (network === null || network === undefined) {
throw new Error("Network not set. Cannot determine network to use.");
}
let config = configObject.networks[network];
if (config === null || config === undefined) {
config = {};
}
if (network === "dashboard") {
const { host: configuredHost, port } = configObject.dashboard;
const host =
configuredHost === "0.0.0.0" ? "localhost" : configuredHost;
const userOverrides = config;
config = {
network_id: "*",
networkCheckTimeout: 120000,
...userOverrides,
url: `http://${host}:${port}/rpc`,
skipDryRun: true
};
}
return config;
},
set() {
throw new Error(
"Don't set config.network_config. Instead, set config.networks with the desired values."
);
}
},
from: {
get() {
try {
return configObject.network_config.from;
} catch (e) {
return null;
}
},
set() {
throw new Error(
"Don't set config.from directly. Instead, set config.networks and then config.networks[<network name>].from"
);
}
},
gas: {
get() {
try {
return configObject.network_config.gas;
} catch (e) {
return null;
}
},
set() {
throw new Error(
"Don't set config.gas directly. Instead, set config.networks and then config.networks[<network name>].gas"
);
}
},
gasPrice: {
get() {
try {
return configObject.network_config.gasPrice;
} catch (e) {
return null;
}
},
set() {
throw new Error(
"Don't set config.gasPrice directly. Instead, set config.networks and then config.networks[<network name>].gasPrice"
);
}
},
maxFeePerGas: {
get() {
try {
return configObject.network_config.maxFeePerGas;
} catch (e) {
return null;
}
},
set() {
throw new Error(
"Don't set config.maxFeePerGas directly. Instead, set config.networks and then config.networks[<network name>].maxFeePerGas"
);
}
},
maxPriorityFeePerGas: {
get() {
try {
return configObject.network_config.maxPriorityFeePerGas;
} catch (e) {
return null;
}
},
set() {
throw new Error(
"Don't set config.maxPriorityFeePerGas directly. Instead, set config.networks and then config.networks[<network name>].maxPriorityFeePerGas"
);
}
},
type: {
get() {
try {
return configObject.network_config.type;
} catch (e) {
return null;
}
},
set() {
throw new Error(
"Don't set config.type directly. Instead, set config.networks and then config.networks[<network name>].type"
);
}
},
provider: {
get() {
if (!configObject.network) {
return null;
}
const options = configObject.network_config;
options.verboseRpc = configObject.verboseRpc;
options.events = configObject.events;
return Provider.create(options);
},
set() {
throw new Error(
"Don't set config.provider directly. Instead, set config.networks and then set config.networks[<network name>].provider"
);
}
},
confirmations: {
get() {
try {
return configObject.network_config.confirmations;
} catch (e) {
return 0;
}
},
set() {
throw new Error(
"Don't set config.confirmations directly. Instead, set config.networks and then config.networks[<network name>].confirmations"
);
}
},
production: {
get() {
try {
return configObject.network_config.production;
} catch (e) {
return false;
}
},
set() {
throw new Error(
"Don't set config.production directly. Instead, set config.networks and then config.networks[<network name>].production"
);
}
},
timeoutBlocks: {
get() {
try {
return configObject.network_config.timeoutBlocks;
} catch (e) {
return 0;
}
},
set() {
throw new Error(
"Don't set config.timeoutBlocks directly. Instead, set config.networks and then config.networks[<network name>].timeoutBlocks"
);
}
},
ensRegistry: {
get() {
let networkConfig;
try {
networkConfig = configObject.network_config;
} catch {
//if this throws, then there's no network config, whatever
}
//prefer specific over generic. if there are two specific and they conflict,
//or two generic and they conflict (w/o specific to shadow), throw error.
//note: we treat null as a legitimate value here.
let address;
if (
networkConfig?.registry !== undefined &&
networkConfig?.ens?.registry !== undefined
) {
throw new Error(
"<network_config>.registry and <network_config>.ens.registry both defined"
);
}
let specificAddressInsideRegistry =
networkConfig?.ens?.registry?.address !== undefined
? networkConfig?.ens?.registry?.address
: networkConfig?.registry?.address;
if (
specificAddressInsideRegistry !== undefined ||
networkConfig?.registryAddress !== undefined
) {
if (
specificAddressInsideRegistry !== undefined &&
networkConfig?.registryAddress !== undefined
) {
if (
specificAddressInsideRegistry === networkConfig?.registryAddress
) {
//if both are defined and they're equal, use either one
address = specificAddressInsideRegistry;
} else {
//if both are defined but they're unequal, throw an error
throw new Error(
"Conflicting values for registry address found in network config"
);
}
} else {
//if only one is defined, use that one
address =
specificAddressInsideRegistry !== undefined
? specificAddressInsideRegistry
: networkConfig?.registryAddress;
}
} else if (
configObject.ens?.registry?.address !== undefined ||
configObject.ens?.registryAddress !== undefined
) {
if (
configObject.ens?.registry?.address !== undefined &&
configObject.ens?.registryAddress !== undefined
) {
if (
configObject.ens?.registry?.address ===
configObject.ens?.registryAddress
) {
//if both are defined and they're equal, use either one
address = configObject.ens?.registry?.address;
} else {
//if both are defined but they're unequal, throw an error
throw new Error(
"Conflicting values for registry address found in project ens config"
);
}
} else {
//if only one is defined, use that one
address =
configObject.ens?.registry?.address ||
configObject.ens?.registryAddress;
}
}
//otherwise, address is just undefined
return { address };
},
set() {
throw new Error(
"Don't set config.ensRegistry directly. Instead, set config.networks[<network name>].registry, or config.networks[<network name>].registryAddress, or config.ens.registry, or config.ens.registryAddress."
);
}
}
};
};