@taqueria/plugin-flextesa
Version:
A plugin for Taqueria providing local sandbox capabilities built on Flextesa
672 lines (666 loc) • 29.4 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// index.ts
var import_node_sdk5 = require("@taqueria/node-sdk");
// proxy.ts
var import_node_sdk3 = require("@taqueria/node-sdk");
var import_node_sdk4 = require("@taqueria/node-sdk");
var import_types = require("@taqueria/node-sdk/types");
var import_async_retry = __toESM(require("async-retry"));
var import_bignumber = require("bignumber.js");
var import_portfinder = require("portfinder");
var import_rambda = require("rambda");
// tzkt-manager.ts
var import_node_sdk = require("@taqueria/node-sdk");
var getTzKtDockerImages = (opts) => ({
postgres: `postgres:14.5-alpine`,
sync: `bakingbad/tzkt-sync:latest`,
api: `bakingbad/tzkt-api:latest`
});
var getTzKtContainerNames = async (sandboxName, parsedArgs) => {
const uniqueSandboxName = await getUniqueSandboxName(sandboxName, parsedArgs.projectDir);
return {
postgres: `taq-postgres-${uniqueSandboxName}`,
sync: `taq-tzkt-sync-${uniqueSandboxName}`,
api: `taq-tzkt-api-${uniqueSandboxName}`
};
};
var getTzKtContainerEnvironments = async (sandboxName, sandbox, opts) => {
const containerNames = await getTzKtContainerNames(sandboxName, opts);
const sandboxContainerName = await getContainerName(opts);
const connectionStringEnv = `ConnectionStrings__DefaultConnection="host=${containerNames.postgres};port=5432;database=sandbox_data;username=tzkt;password=${sandboxName};"`;
return {
postgres: `--env POSTGRES_PASSWORD=${sandboxName} --env POSTGRES_USER=tzkt`,
sync: `--env ${connectionStringEnv} --env TezosNode__Endpoint="http://${sandboxContainerName}:20000/" --env Protocols__Fallback="PtLimaPtLMwfNinJi9rCfDPWea8dFgTZ1MeJ9f1m2SRic6ayiwW"`,
api: `--env ${connectionStringEnv} --env Kestrel__Endpoints__Http__Url="http://*:5000" --env MaxAttemptsForMigrations=120`
};
};
var getTzKtStartCommands = async (sandboxName, sandbox, opts) => {
var _a, _b;
const pgPort = ((_a = sandbox.tzkt) == null ? void 0 : _a.postgresqlPort) ?? 5432;
const newPGPort = await getNewPortIfPortInUse(pgPort);
const apiPort = ((_b = sandbox.tzkt) == null ? void 0 : _b.apiPort) ?? 5e3;
const newAPIPort = await getNewPortIfPortInUse(apiPort);
if (newPGPort !== pgPort || newAPIPort !== apiPort) {
if (newPGPort !== pgPort) {
console.log(
`${pgPort} is already in use, ${newPGPort} will be used for postgresql in ${sandboxName} instead and .taq/config.json will be updated to reflect this.`
);
}
if (newAPIPort !== apiPort) {
console.log(
`${apiPort} is already in use, ${newAPIPort} will be used for TzKt API in ${sandboxName} instead and .taq/config.json will be updated to reflect this.`
);
}
await updateConfig(opts, (config) => {
var _a2;
const sandbox2 = (_a2 = config.sandbox) == null ? void 0 : _a2[sandboxName];
if (typeof sandbox2 === "string" || sandbox2 === void 0) {
return void 0;
}
const oldTzKt = (sandbox2 == null ? void 0 : sandbox2.tzkt) ?? {
disableAutostartWithSandbox: false,
apiPort: 5e3,
postgresqlPort: 5432
};
const updatedConfig = {
...config,
sandbox: {
...config.sandbox,
[sandboxName]: {
...sandbox2,
tzkt: {
...oldTzKt,
postgresqlPort: newPGPort,
apiPort: newAPIPort
}
}
}
};
return updatedConfig;
});
}
const containerNames = await getTzKtContainerNames(sandboxName, opts);
const arch = await (0, import_node_sdk.getArch)();
const images = getTzKtDockerImages(opts);
const environmentVariables = await getTzKtContainerEnvironments(sandboxName, sandbox, opts);
return {
postgres: `docker run --network sandbox_${sandboxName}_net --name ${containerNames.postgres} --rm --detach --platform ${arch} -p ${newPGPort}:5432 ${environmentVariables.postgres} ${images.postgres}`,
sync: `docker run --network sandbox_${sandboxName}_net --name ${containerNames.sync} --rm --detach --platform ${arch} ${environmentVariables.sync} ${images.sync}`,
api: `docker run --network sandbox_${sandboxName}_net --name ${containerNames.api} --rm --detach --platform ${arch} -p ${newAPIPort}:5000 ${environmentVariables.api} ${images.api}`
};
};
// docker.ts
var import_node_sdk2 = require("@taqueria/node-sdk");
var TAQ_FLEXTESA_IMAGE_ENV_VAR = "TAQ_FLEXTESA_IMAGE";
var getDefaultDockerImage = (opts) => `registry.gitlab.com/tezos/flextesa:018ac39a-run`;
var getImage = (opts) => (0, import_node_sdk2.getDockerImage)(getDefaultDockerImage(opts), TAQ_FLEXTESA_IMAGE_ENV_VAR);
// proxy.ts
var { Url } = import_types.Protocol;
var getUniqueSandboxName = async (sandboxName, projectDir) => {
const hash = String(await (0, import_node_sdk3.stringToSHA256)(sandboxName + projectDir));
return `${sandboxName.substring(0, 10)}-${hash.substring(0, 5)}`;
};
var getContainerName = async (parsedArgs) => {
const uniqueSandboxName = await getUniqueSandboxName(parsedArgs.sandboxName, parsedArgs.projectDir);
return `taq-flextesa-${uniqueSandboxName}`;
};
var getNewPortIfPortInUse = async (port) => {
const newPort = await (0, import_portfinder.getPortPromise)({ port });
return newPort;
};
var replaceRpcUrlInConfig = async (newPort, oldUrl, sandboxName, opts) => {
await updateConfig(opts, (config) => {
const newUrl = oldUrl.replace(/:\d+/, ":" + newPort);
const sandbox = config.sandbox;
const sandboxConfig = sandbox ? sandbox[sandboxName] : void 0;
if (typeof sandboxConfig === "string" || sandboxConfig === void 0) {
return;
}
const updatedConfig = {
...config,
sandbox: {
...sandbox,
[sandboxName]: {
...sandboxConfig,
rpcUrl: newUrl
}
}
};
return updatedConfig;
});
};
var updateConfig = async (opts, update) => {
const config = await (0, import_node_sdk3.readJsonFile)(opts.config.configFile);
const updatedConfig = update(config);
if (!updatedConfig) {
return;
}
await (0, import_node_sdk3.writeJsonFile)(opts.config.configFile)(updatedConfig);
return config;
};
var getFlextesaAnnotations = (sandbox) => {
const defaults = {
baking: "enabled",
block_time: 1
};
const settings = {
...defaults,
...sandbox.annotations
};
if (!["enabled", "disabled"].includes(settings.baking)) {
return Promise.reject(
'The "baking" setting of a Flextesa Sandbox must to set to either "enabled" or "disabled".'
);
} else if (!Number.isInteger(settings.block_time)) {
return Promise.reject(
'The "block_time" setting of a Flextesa Sandbox must be an integer, and set to a value greater than 0.'
);
} else if (settings.block_time <= 0) {
return Promise.reject(
'The "block_time" setting of a Flextesa Sandbox must be set to a value greater than 0. If you are trying to disable baking, please set the "baking" setting to "disabled" instead.'
);
}
return Promise.resolve(settings);
};
var getBakingFlags = (sandbox) => getFlextesaAnnotations(sandbox).then((settings) => {
if (settings.baking === "enabled") {
return [
`--time-b ${settings.block_time}`,
``
];
} else if (settings.baking === "disabled") {
return [
"--no-baking",
`--time-b 1`
];
}
return [
"--no-baking",
`--time-b 1`
];
});
var getSupportedProtocolKinds = /* @__PURE__ */ (() => {
let protocols = [];
const getAll = (opts) => {
const image = getImage(opts);
return (0, import_node_sdk3.execCmd)(`docker run --rm ${image} flextesa mini-net --protocol-kind=foobar`).catch((err) => {
const { stderr } = err;
const protocols2 = stderr.match(/'[A-Z][a-z]+'/gm) ?? [];
return Promise.resolve(protocols2.map((protocol) => protocol.replace(/'/gm, "")));
});
};
return async (opts) => {
if (protocols.length == 0) protocols = await getAll(opts);
return protocols ?? ["Alpha"];
};
})();
var getProtocolKind = (sandbox, opts) => getSupportedProtocolKinds(opts).then((protocols) => {
const validProtocols = protocols.filter((p) => p != "Alpha" && p != "Oxford");
if (!sandbox.protocol || sandbox.protocol.includes("lpha")) {
return (0, import_rambda.last)(validProtocols);
}
return validProtocols.reduce(
(retval, protocolKind) => {
if (retval) return retval;
const givenProtocolHash = sandbox.protocol.toLowerCase();
const testProtocol = protocolKind.toLowerCase().slice(0, 4);
return givenProtocolHash.includes(testProtocol) ? protocolKind : void 0;
},
void 0
) ?? (0, import_rambda.last)(validProtocols);
});
var getBootstrapBalance = (opts) => Object.values(opts.config.accounts || {}).reduce(
(retval, amount) => retval.plus(new import_bignumber.BigNumber(amount.replaceAll("_", ""))),
new import_bignumber.BigNumber(0).multipliedBy(1e6)
).multipliedBy(1e3);
var getMininetCommand = (sandboxName, sandbox, opts) => Promise.all([
// getAccountFlags(sandbox, opts.config),
getBakingFlags(sandbox),
getProtocolKind(sandbox, opts)
]).then(([bakingFlags, protocolKind]) => [
"flextesa mini-net",
"--root /tmp/mini-box",
"--set-history-mode N000:archive",
// TODO: Add annotation for this setting
"--until-level 200_000_000",
// TODO: Add annotation for this setting
`--number-of-b 1`,
`--protocol-kind="${protocolKind}"`,
"--size 1",
`--balance-of-bootstrap-accounts=mutez:${getBootstrapBalance(opts)}`,
// ...accountFlags,
...bakingFlags
]).then((flags) => flags.join(" "));
var getStartCommand = async (sandboxName, sandbox, opts) => {
const port = new URL(sandbox.rpcUrl).port;
const newPort = (await getNewPortIfPortInUse(parseInt(port))).toString();
if (newPort !== port) {
console.log(
`${port} is already in use, ${newPort} will be used for sandbox ${sandboxName} instead and .taq/config.json will be updated to reflect this.`
);
await replaceRpcUrlInConfig(newPort, sandbox.rpcUrl.toString(), sandboxName, opts);
}
const ports = `-p ${newPort}:20000 --expose 20000`;
const containerName = await getContainerName(opts);
const mininetCmd = await getMininetCommand(sandboxName, sandbox, opts);
const arch = await (0, import_node_sdk3.getArch)();
const image = getImage(opts);
const projectDir = process.env.PROJECT_DIR ?? opts.config.projectDir;
const proxyAbsPath = `${__dirname}/proxy.py`;
return `docker run -i --network sandbox_${sandboxName}_net --name ${containerName} --rm --detach --platform ${arch} ${ports} -v ${projectDir}:/project ${image} /bin/sh -c "flextesa_node_cors_origin=* ${mininetCmd}"`;
};
var startSandbox = (sandboxName, sandbox, opts) => {
if (doesNotUseFlextesa(sandbox)) {
return (0, import_node_sdk3.sendAsyncErr)(`Cannot start ${sandbox.label} as its configured to use the ${sandbox.plugin} plugin.`);
}
return Promise.resolve(opts).then(addSandboxAccounts).then((loadedConfig) => {
console.log("Booting sandbox...");
return getStartCommand(sandboxName, sandbox, opts).then(import_node_sdk3.execCmd).then(() => {
console.log("Importing accounts...");
return importSandboxAccounts(opts)(loadedConfig);
});
}).then(() => importBaker(opts)).then(() => configureTezosClient(sandboxName, opts)).then(() => {
console.log("Waiting for bootstrapping to complete...");
return waitForBootstrap(opts);
}).then(() => {
console.log("Funding declared accounts (please wait)...");
return new Promise((resolve) => setTimeout(resolve, 1e4)).then(() => fundDeclaredAccounts(opts));
}).then(() => {
console.log(`The sandbox "${sandboxName}" is ready.`);
});
};
var getConfigureCommand = async (opts) => {
const containerName = await getContainerName(opts);
return `docker exec -d ${containerName} octez-client --endpoint http://localhost:20000 config update`;
};
var doesUseFlextesa = (sandbox) => !sandbox.plugin || sandbox.plugin === "flextesa";
var doesNotUseFlextesa = (sandbox) => !doesUseFlextesa(sandbox);
var waitForBootstrap = (parsedArgs) => {
const sandbox = getValidSandbox(parsedArgs.sandboxName, parsedArgs.config);
const containerName = getContainerName(parsedArgs);
return getContainerName(parsedArgs).then((container) => (0, import_node_sdk3.execCmd)(`docker exec ${container} octez-client bootstrapped`)).catch(({ stderr }) => {
if (stderr.includes("Failed to acquire the protocol version from the node")) return waitForBootstrap(parsedArgs);
throw stderr;
});
};
var createTransferList = (sandbox, parsedArgs) => {
const transferList = Object.keys(sandbox.accounts ?? {}).reduce(
(retval, accountName) => {
if (accountName === "default") return retval;
const balance = new import_bignumber.BigNumber(parsedArgs.config.accounts[accountName].replaceAll("_", "")).div(1e6);
return [...retval, { destination: accountName, amount: balance.toString() }];
},
[]
);
return transferList;
};
var writeTransferList = (containerName, transferList) => {
const fileAbsPath = "/tmp/transferList.json";
const cmd = `docker cp ${fileAbsPath} ${containerName}:${fileAbsPath}`;
return (0, import_node_sdk3.writeJsonFile)(fileAbsPath)(transferList).then(() => (0, import_node_sdk3.execCmd)(cmd)).then(() => fileAbsPath);
};
var fundDeclaredAccounts = async (parsedArgs) => {
const sandbox = getValidSandbox(parsedArgs.sandboxName, parsedArgs.config);
const transferList = createTransferList(sandbox, parsedArgs);
try {
const containerName = await getContainerName(parsedArgs);
const transferListAbsPath = await writeTransferList(containerName, transferList);
const cmd = `docker exec ${containerName} octez-client multiple transfers from baker0 using ${transferListAbsPath} --burn-cap 1`;
const result = await (0, import_node_sdk3.execCmd)(cmd);
return result;
} catch (e) {
if (parsedArgs.debug) console.warn(e);
return (0, import_node_sdk3.sendAsyncErr)("Failed to fund declared accounts.");
}
};
var startContainer = async (container) => {
console.log(`Starting ${container.name}`);
try {
const result = await (0, import_node_sdk3.execCmd)(container.command);
if (result.stderr) {
console.error(result.stderr);
}
console.log(result.stdout);
} catch (e) {
throw e;
}
};
var startInstance = async (sandboxName, sandbox, opts) => {
var _a;
await (0, import_node_sdk3.execCmd)(
`docker network ls | grep 'sandbox_${sandboxName}_net' > /dev/null || docker network create --driver bridge sandbox_${sandboxName}_net`
);
const isRunning = await isSandboxRunning(opts.sandboxName, opts);
if (isRunning) {
await (0, import_node_sdk3.sendAsyncRes)("Already running.");
return;
}
await startSandbox(sandboxName, sandbox, opts);
if (((_a = sandbox.tzkt) == null ? void 0 : _a.disableAutostartWithSandbox) === true) {
return;
}
const { postgres, sync, api } = await getTzKtStartCommands(sandboxName, sandbox, opts);
const tzKtContainers = [
{ name: "postgresql", command: postgres },
{ name: "TzKt.Sync", command: sync },
{ name: "TzKt.Api", command: api }
];
for (const container of tzKtContainers) {
await startContainer(container);
}
};
var configureTezosClient = (sandboxName, opts) => (0, import_async_retry.default)(
() => getConfigureCommand(opts).then(import_node_sdk3.execCmd).then(({ stderr, stdout }) => {
if (stderr.length) return Promise.reject(stderr);
return { stderr, stdout };
})
);
var importBaker = (opts) => getContainerName(opts).then(
(container) => `docker exec -d ${container} octez-client import secret key baker0 unencrypted:edsk3RFgDiCt7tWB2oe96w1eRw72iYiiqZPLu9nnEY23MYRp2d8Kkx`
).then(import_node_sdk3.execCmd);
var getSandbox = ({ sandboxName, config }) => {
if (sandboxName && config.sandbox && config.sandbox[sandboxName]) {
const sandboxConfig = config.sandbox[sandboxName];
return sandboxConfig;
}
return void 0;
};
var getValidSandbox = (sandboxName, config) => {
const retval = config.sandbox[sandboxName];
retval.rpcUrl = retval.rpcUrl && retval.rpcUrl.length > 0 ? retval.rpcUrl : Url.create("http://localhost:20000");
return retval;
};
var startSandboxTask = (parsedArgs) => {
const sandbox = getValidSandbox(parsedArgs.sandboxName, parsedArgs.config);
return sandbox ? startInstance(parsedArgs.sandboxName, sandbox, parsedArgs) : (0, import_node_sdk3.sendAsyncErr)(`There is no sandbox configuration with the name ${parsedArgs.sandboxName}.`);
};
var isSandboxRunning = (sandboxName, opts) => {
return getContainerName(opts).then((containerName) => (0, import_node_sdk3.execCmd)(`docker ps --filter name=${containerName} | grep -w ${containerName}`)).then((_) => true).catch((_) => false);
};
var getAccountBalances = (sandboxName, sandbox, opts) => {
const processes = Object.entries(sandbox.accounts ?? {}).reduce(
(retval, [accountName, accountDetails]) => {
if (accountName === "default") return retval;
const getBalanceProcess = (0, import_node_sdk3.getArch)().then((_) => getContainerName(opts)).then((containerName) => `docker exec ${containerName} octez-client get balance for ${accountName.trim()}`).then(import_node_sdk3.execCmd).then(({ stdout, stderr }) => {
if (stderr.length > 0) (0, import_node_sdk3.sendErr)(stderr);
return {
account: accountName,
balance: stdout.trim(),
address: accountDetails.publicKeyHash
};
}).catch((err) => {
(0, import_node_sdk3.sendErr)(err.message);
return {
account: accountName,
balance: "Error",
address: accountDetails.publicKeyHash
};
});
return [...retval, getBalanceProcess];
},
[]
);
return Promise.all(processes);
};
var listAccountsTask = async (parsedArgs) => {
if (parsedArgs.sandboxName) {
const sandbox = getSandbox(parsedArgs);
if (sandbox) {
if (doesUseFlextesa(sandbox)) {
return await isSandboxRunning(parsedArgs.sandboxName, parsedArgs) ? getAccountBalances(parsedArgs.sandboxName, sandbox, parsedArgs).then(import_node_sdk3.sendJsonRes) : (0, import_node_sdk3.sendAsyncErr)(`The ${parsedArgs.sandboxName} sandbox is not running.`);
}
return (0, import_node_sdk3.sendAsyncErr)(
`Cannot start ${sandbox.label} as its configured to use the ${sandbox.plugin} plugin.`
);
}
return (0, import_node_sdk3.sendAsyncErr)(`There is no sandbox configuration with the name ${parsedArgs.sandboxName}.`);
}
return (0, import_node_sdk3.sendAsyncErr)(`Please specify a sandbox. E.g. taq list accounts local`);
};
var stopSandboxTask = async (parsedArgs) => {
if (parsedArgs.sandboxName) {
const sandbox = getSandbox(parsedArgs);
if (sandbox) {
if (doesUseFlextesa(sandbox)) {
await isSandboxRunning(parsedArgs.sandboxName, parsedArgs) ? (0, import_node_sdk3.execCmd)(`docker kill ${await getContainerName(parsedArgs)}`).then((_) => (0, import_node_sdk3.sendAsyncRes)(`Stopped ${parsedArgs.sandboxName}.`)) : (0, import_node_sdk3.sendAsyncRes)(`The ${parsedArgs.sandboxName} sandbox was not running.`);
await stopTzKtContainers(parsedArgs.sandboxName, sandbox, parsedArgs);
return;
}
return (0, import_node_sdk3.sendAsyncErr)(`Cannot stop ${sandbox.label} as its configured to use the ${sandbox.plugin} plugin.`);
}
return (0, import_node_sdk3.sendAsyncErr)(`There is no sandbox configuration with the name ${parsedArgs.sandboxName}.`);
}
return (0, import_node_sdk3.sendAsyncErr)(`No sandbox specified`);
};
var restartSandboxTask = async (parsedArgs) => {
await stopSandboxTask(parsedArgs);
await startSandboxTask(parsedArgs);
};
var stopTzKtContainers = async (sandboxName, sandbox, parsedArgs) => {
const containerNames = await getTzKtContainerNames(sandboxName, parsedArgs);
const containersToStop = [containerNames.api, containerNames.sync, containerNames.postgres];
for (const container of containersToStop) {
try {
const result = await (0, import_node_sdk3.execCmd)(`docker stop ${container}`);
if (result.stderr) {
console.error(result.stderr);
}
console.log(result.stdout);
} catch (e) {
}
}
};
var listProtocolsTask = (parsedArgs) => {
const image = getImage(parsedArgs);
const cmd = `docker run --rm ${image} octez-client -M mockup list mockup protocols 2>/dev/null`;
return (0, import_node_sdk3.execCmd)(cmd).then(({ stdout }) => stdout.trim().split("\n").map((hash) => ({ "protocols": hash }))).then(import_node_sdk3.sendJsonRes);
};
var bakeTask = (parsedArgs) => getContainerName(parsedArgs).then(async (containerName) => {
if (parsedArgs.watch) {
console.log("Baking on demand as operations are injected.");
console.log("Press CTRL-C to stop and exit.");
console.log();
while (true) {
console.log("Waiting for operations to be injected...");
while (true) {
const { stdout } = await (0, import_node_sdk3.execCmd)(
`docker exec ${containerName} octez-client rpc get /chains/main/mempool/pending_operations`
);
const ops = JSON.parse(stdout);
if (Array.isArray(ops.applied) && ops.applied.length > 0 || Array.isArray(ops.validated) && ops.validated.length > 0) break;
}
await (0, import_node_sdk3.spawnCmd)(`docker exec ${containerName} octez-client bake for baker0`);
(0, import_node_sdk3.noop)();
}
}
return (0, import_node_sdk3.spawnCmd)(`docker exec ${containerName} octez-client bake for baker0`).then(import_node_sdk3.noop);
});
var instantiateAccounts = (parsedArgs) => {
console.log("Generating account keys...");
return Object.entries(parsedArgs.config.accounts).reduce(
(lastConfig, [accountName, _]) => (
// TODO: This could probably be more performant by generating the key pairs using TS rather than proxy to docker/flextesa
lastConfig.then((_2) => (0, import_node_sdk3.execCmd)(`docker run --rm ${getImage(parsedArgs)} flextesa key ${accountName}`)).then((result) => result.stdout.trim().split(",")).then(
([_alias, encryptedKey, publicKeyHash, secretKey]) => import_types.SandboxAccountConfig.create({
encryptedKey,
publicKeyHash,
secretKey
})
).then(async (accountConfig) => {
const config = await lastConfig;
const accounts = config.sandbox[parsedArgs.sandboxName].accounts ?? { "default": import_node_sdk3.NonEmptyString.create(accountName) };
accounts[accountName] = accountConfig;
config.sandbox[parsedArgs.sandboxName].accounts = accounts;
return config;
})
),
Promise.resolve(parsedArgs.config)
).then(import_node_sdk4.Config.create).then((config) => (0, import_node_sdk3.writeJsonFile)(parsedArgs.config.configFile)(config).then((_) => config)).then(
(config) => import_types.LoadedConfig.create({
...parsedArgs.config,
...config
})
);
};
var hasInstantiatedAccounts = (parsedArgs) => {
const sandbox = getValidSandbox(parsedArgs.sandboxName, parsedArgs.config);
const accounts = sandbox.accounts ?? {};
return Object.keys(accounts).length > 0;
};
var maybeInstantiateAccounts = (parsedArgs) => {
return hasInstantiatedAccounts(parsedArgs) ? Promise.resolve(parsedArgs.config) : instantiateAccounts(parsedArgs);
};
var importSandboxAccounts = (parsedArgs) => async (updatedConfig) => {
const containerName = await getContainerName(parsedArgs);
const cmds = Object.entries(getValidSandbox(parsedArgs.sandboxName, updatedConfig).accounts ?? {}).reduce(
(retval, [accountName, account]) => typeof account === "string" ? retval : [...retval, `octez-client import secret key ${accountName} ${account.secretKey} --force`],
[]
);
await (0, import_node_sdk3.execCmd)(`docker exec -d ${containerName} sh -c '${cmds.join(" && ")}'`);
};
var addSandboxAccounts = (parsedArgs) => maybeInstantiateAccounts(parsedArgs);
var getDefaultSandboxName = (parsedArgs) => {
const env = parsedArgs.config.environment[parsedArgs.env];
if (env.sandboxes && env.sandboxes.length > 0) {
return env.sandboxes[0];
}
return void 0;
};
var taskMap = {
"list accounts": listAccountsTask,
"show protocols": listProtocolsTask,
"list protocols": listProtocolsTask,
"start sandbox": startSandboxTask,
"start flextesa": startSandboxTask,
"stop sandbox": stopSandboxTask,
"stop flextesa": stopSandboxTask,
"bake": bakeTask,
"b": bakeTask,
"restart sandbox": restartSandboxTask,
"restart flextesa": restartSandboxTask
};
var validateRequest = async (unparsedArgs) => {
const origSandboxName = unparsedArgs.sandboxName;
const sandboxName = unparsedArgs.sandboxName ?? getDefaultSandboxName(unparsedArgs);
const modifiedArgs = { ...unparsedArgs, sandboxName };
const sandbox = getSandbox(modifiedArgs);
if (!sandbox) {
return (0, import_node_sdk3.sendAsyncErr)(
unparsedArgs.sandboxName ? `There is no sandbox called ${origSandboxName} in your .taq/config.json.` : `No sandbox name was specified. We couldn't find a valid sandbox config for the current environment.`
);
}
if (!unparsedArgs.task || !Object.keys(taskMap).includes(unparsedArgs.task)) {
return await (0, import_node_sdk3.sendAsyncErr)(`${unparsedArgs.task} is not an understood task by the Flextesa plugin`);
}
if (doesNotUseFlextesa(sandbox)) {
return (0, import_node_sdk3.sendAsyncErr)(
`Cannot ${unparsedArgs.task} for ${sandbox.label} as its configured to use the ${sandbox.plugin} plugin.`
);
}
if (!unparsedArgs.config.accounts || Object.keys(unparsedArgs.config.accounts).length === 0) {
return await (0, import_node_sdk3.sendAsyncErr)(`This task required a list of declared accounts in your .taq/config.json.`);
}
return modifiedArgs;
};
var proxy = (unparsedArgs) => {
if (unparsedArgs.task && (unparsedArgs.task == "list protocols" || unparsedArgs.task === "show protocols")) {
return listProtocolsTask(unparsedArgs);
} else {
return validateRequest(unparsedArgs).then((modifiedArgs) => {
const parsedArgs = modifiedArgs;
return taskMap[parsedArgs.task](parsedArgs);
});
}
};
var proxy_default = proxy;
// index.ts
import_node_sdk5.Plugin.create((_i18n) => ({
alias: "flextesa",
schema: "1.0",
version: "0.1",
tasks: [
import_node_sdk5.Task.create({
task: "start sandbox",
command: "start sandbox",
aliases: ["start flextesa"],
description: "Starts a flextesa sandbox",
options: [],
handler: "proxy",
encoding: "none"
}),
import_node_sdk5.Task.create({
task: "stop sandbox",
command: "stop sandbox",
aliases: ["stop flextesa"],
description: "Stops a flextesa sandbox",
options: [],
handler: "proxy"
}),
import_node_sdk5.Task.create({
task: "restart sandbox",
command: "restart sandbox",
aliases: ["restart flextesa"],
description: "Restarts a flextesa sandbox",
options: [],
handler: "proxy"
}),
import_node_sdk5.Task.create({
task: "list accounts",
command: "list accounts",
aliases: [],
description: "List the balances of all sandbox accounts",
options: [],
handler: "proxy",
encoding: "json"
}),
import_node_sdk5.Task.create({
task: "bake",
command: "bake",
aliases: ["b"],
description: 'Manually bake a block. Use when the "baking" setting of a flextesa sandbox is set to "disabled".',
options: [
import_node_sdk5.Option.create({
flag: "watch",
shortFlag: "w",
description: "Watch for operations as they are injected into the mempool and bake them as immediate as possible.",
boolean: true
})
],
handler: "proxy",
encoding: "none"
}),
import_node_sdk5.Task.create({
task: "show protocols",
command: "show protocols",
aliases: ["list protocols"],
description: "List protocols understood by this version of Flextesa",
options: [],
handler: "proxy",
encoding: "json"
})
],
proxy: proxy_default
}), process.argv);
//# sourceMappingURL=index.js.map