@taqueria/plugin-taquito 0.2.1 → 0.4.0-rc1

package/originate.ts

@@ -1,201 +1,234 @@
-import { SanitizedArgs, PluginResponse, AccountDetails, Failure, LikeAPromise, Config, NetworkConfig, SandboxConfig} from "@taqueria/node-sdk/types";
-import glob from 'fast-glob'
-import {join} from 'path'
-import { TezosToolkit } from '@taquito/taquito';
-import {readFile} from 'fs/promises'
-import { InMemorySigner, importKey } from '@taquito/signer';
-import { sendAsyncJsonRes } from "@taqueria/node-sdk";
-
-type Opts = SanitizedArgs & Record<string, unknown>
-
-interface OriginationResult {
-    contract: string
-    address: string
-    destination: string
-}
-
-const getContractAbspath = (contractFilename: string, parsedArgs: Opts) => 
-    join(parsedArgs.artifactsDir, /\.tz$/.test(contractFilename) ? contractFilename : `${contractFilename}.tz`)
-
-
-const originateContractToSandbox = async (contractFilename: string, parsedArgs: Opts, storage: unknown, sandboxName: string, sandbox: SandboxConfig | undefined): LikeAPromise<OriginationResult, Failure<unknown>> => {
-    try {
-        if (sandbox && sandbox.rpcUrl) {
-            const contractAbspath = getContractAbspath(contractFilename, parsedArgs)
-            const tezos = new TezosToolkit(sandbox.rpcUrl)
-            const secretKey = getAccountSecretKey(sandbox)
-            if (secretKey) {
-                tezos.setProvider({
-                    signer: new InMemorySigner(secretKey),
-                });
-
-                const contractData = await readFile(contractAbspath, "utf-8")
-                return tezos.contract.originate({
-                    code: contractData,
-                    storage: storage
-                })
-                .then(operation => ({
-                    contract: contractFilename,
-                    address: operation.contractAddress as string,
-                    destination: sandboxName
-                }))
-                .catch(previous => Promise.reject({
-                    errCode: "E_ORIGINATE",
-                    errMsg: `Could not originate ${contractFilename} on the sandbox '${sandboxName}'`,
-                    previous
-                }))
-            }
-            else {
-                return Promise.reject({
-                    errCode: "E_INVALID_SANDBOX_ACCOUNT",
-                    errMsg: `Please configure a default account for the ${sandboxName} to be used for origination.`,
-                    context: sandbox
-                })
-            }
-        }
-        return Promise.reject({
-            errCode: "E_INVALID_SANDBOX_URL",
-            errMsg: 'The sandbox configuration is invalid and missing the RPC url',
-            context: sandbox
-        })
-    }
-    catch (err) {
-        return Promise.reject({
-            errCode: "E_ORIGINATE",
-            errMsg: "An unexpected error occured when trying to originate a contract",
-            previous: err
-        })
-    }
-}
-
-const originateContractToNetwork = async (contractFilename: string, parsedArgs: Opts, storage: unknown, networkName: string, network: NetworkConfig|undefined): LikeAPromise<OriginationResult, Failure<unknown>> => {
-    try {
-        if (network && network.rpcUrl) {
-            const contractAbspath = getContractAbspath(contractFilename, parsedArgs)
-            const tezos = new TezosToolkit(network.rpcUrl)
-            if (network.faucet) {
-                await importKey(tezos, network.faucet.email, network.faucet.password, network.faucet.mnemonic.join(' '), network.faucet.activation_code)
-
-                const contractData = await readFile(contractAbspath, "utf-8")
-                return tezos.contract.originate({
-                    code: contractData,
-                    storage: storage
-                })
-                .then(operation => ({
-                    contract: contractFilename,
-                    address: operation.contractAddress as string,
-                    destination: networkName
-                }))
-                .catch(previous => Promise.reject({
-                    errCode: "E_ORIGINATE",
-                    errMsg: `Could not originate ${contractFilename} on the network '${networkName}'`,
-                    previous
-                }))
-            }
-            else {
-                return Promise.reject({
-                    errCode: "E_INVALID_NETWORK_FAUCET",
-                    errMsg: `Please configure a faucet for the ${network} network to be used for origination.`,
-                    context: network
-                })
-            }
-        }
-        return Promise.reject({
-            errCode: "E_INVALID_NETWORK_URL",
-            errMsg: 'The network configuration is invalid and missing the RPC url',
-            context: network
-        })
-    }
-    catch (err) {
-        return Promise.reject({
-            errCode: "E_ORIGINATE",
-            errMsg: "An unexpected error occured when trying to originate a contract",
-            previous: err
-        })
-    }
-}
-
-const getNetworkConfig = (networkName: string, config: Config) => {
-    return !config.network[networkName]
-        ? undefined
-        : config.network[networkName]
+import {
+	getCurrentEnvironmentConfig,
+	getDefaultAccount,
+	getInitialStorage,
+	getNetworkConfig,
+	getSandboxAccountConfig,
+	getSandboxAccountNames,
+	getSandboxConfig,
+	sendAsyncErr,
+	sendErr,
+	sendJsonRes,
+} from '@taqueria/node-sdk';
+import { LikeAPromise, PluginResponse, Protocol, RequestArgs, TaqError } from '@taqueria/node-sdk/types';
+import { OperationContentsAndResultOrigination } from '@taquito/rpc';
+import { importKey, InMemorySigner } from '@taquito/signer';
+import { TezosToolkit, WalletOperationBatch } from '@taquito/taquito';
+import { BatchWalletOperation } from '@taquito/taquito/dist/types/wallet/batch-operation';
+import glob from 'fast-glob';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+
+interface Opts extends RequestArgs.t {
+	contract?: string;
 }
 
-const getSandboxConfig = (sandboxName: string, config: Config) => {
-    return !config.sandbox[sandboxName]
-    ? undefined
-    : config.sandbox[sandboxName]
+interface ContractStorageMapping {
+	filename: string;
+	storage?: unknown;
 }
 
-const getAccountSecretKey = (sandbox: SandboxConfig) => {
-    if (sandbox.accounts && sandbox.accounts.default) {
-        const accountName = (sandbox.accounts.default as string);
-        const accountDetails = sandbox.accounts[accountName] as AccountDetails
-        if (accountDetails.keys) return accountDetails.keys.secretKey.replace(/unencrypted:/, '')
-    }
-
-    return undefined        
-}
-
-const originateContract = (parsedArgs: Opts) => (contractFilename: string) => {
-    // TODO: Should getting the default environment be provided by the SDK or the framework?
-    const currentEnv = parsedArgs.env
-        ? (parsedArgs.env as string)
-        : (
-            parsedArgs.config.environment
-                ? parsedArgs.config.environment.default
-                : 'development'
-        )
-    const env = parsedArgs.config.environment && parsedArgs.config.environment[currentEnv]
-            ? parsedArgs.config.environment[currentEnv]
-            : undefined
-
-    if (!env) {
-        return Promise.reject({
-            errCode: "E_INVALID_ENV",
-            errMsg: `No environment configured in your configuration file called ${parsedArgs.env}`,
-            context: parsedArgs.config
-        })    
-    }
-
-    if (!env.storage || !env.storage[contractFilename]) {
-        return Promise.reject({
-            errCode: "E_INVALID_STORAGE",
-            errMsg: `No storage configured in your configuration file for ${contractFilename}`,
-            context: env
-        })
-    }
-
-    const networkProcesses = !env.networks ? [] : env.networks.reduce(
-        (retval: LikeAPromise<OriginationResult, Failure<unknown>>[], network) => 
-            getNetworkConfig(network, parsedArgs.config)
-                ? [...retval, originateContractToNetwork(contractFilename, parsedArgs, env.storage[contractFilename], network, getNetworkConfig(network, parsedArgs.config))]
-                : retval,
-        []
-    )
-
-    const allProcesses = !env.sandboxes ? [] : env.sandboxes.reduce(
-        (retval: LikeAPromise<OriginationResult, Failure<unknown>>[], sandbox) => getSandboxConfig(sandbox, parsedArgs.config)
-            ? [...retval, originateContractToSandbox(contractFilename, parsedArgs, env.storage[contractFilename], sandbox, getSandboxConfig(sandbox, parsedArgs.config))]
-            : retval            
-        ,
-        networkProcesses
-    )
-            
-    return Promise.all(allProcesses)
-}
-
-const originateAll = (parsedArgs: Opts) =>
-    glob("**/*.tz", {cwd: parsedArgs.artifactsDir})
-    .then(files => Promise.all(files.map(originateContract(parsedArgs))))
-    .then(results => results.flat(1))
-
-export const originate = <T>(parsedArgs: Opts): LikeAPromise<PluginResponse, Failure<T>> => {
-    const p = parsedArgs.contract
-        ? originateContract(parsedArgs) (parsedArgs.contract as string)
-        : originateAll(parsedArgs)
-
-    return p.then(sendAsyncJsonRes)
+interface OriginationResult {
+	contract: string;
+	address: string;
+	destination: string;
 }
 
-export default originate
+const getFirstAccountAlias = (sandboxName: string, opts: Opts) => {
+	const aliases = getSandboxAccountNames(opts)(sandboxName);
+	return aliases.shift();
+};
+
+const getContractAbspath = (contractFilename: string, parsedArgs: Opts) =>
+	join(parsedArgs.config.artifactsDir, /\.tz$/.test(contractFilename) ? contractFilename : `${contractFilename}.tz`);
+
+const addOrigination = (parsedArgs: Opts, batch: Promise<WalletOperationBatch>) =>
+	async (mapping: ContractStorageMapping) => {
+		const contractAbspath = getContractAbspath(mapping.filename, parsedArgs);
+		const contractData = await readFile(contractAbspath, 'utf-8');
+		return (await batch).withOrigination({
+			code: contractData,
+			storage: mapping.storage,
+		});
+	};
+
+const getValidContracts = async (parsedArgs: Opts) => {
+	const contracts = parsedArgs.contract
+		? [parsedArgs.contract]
+		: (await glob('**/*.tz', { cwd: parsedArgs.config.artifactsDir })) as string[];
+
+	return contracts.reduce(
+		(retval, filename) => {
+			const storage = getInitialStorage(parsedArgs)(filename);
+			if (!storage) throw (`No initial storage provided for ${filename}`);
+			return [...retval, { filename, storage }];
+		},
+		[] as ContractStorageMapping[],
+	);
+};
+
+const mapOpToContract = async (contracts: ContractStorageMapping[], op: BatchWalletOperation, destination: string) => {
+	const results = await op.operationResults();
+
+	return contracts.reduce(
+		(retval, contract) => {
+			// If initial storage was provided for the contract
+			// then we submitted an operation to originate that contract
+			if (contract.storage) {
+				// WARNING - using side effect here.
+				// For each iteration of reduce, results array is being modified-in-place.
+				// TODO: Adjust to use recursion to avoid side-effect.
+				const result = results.shift() as OperationContentsAndResultOrigination;
+				const address = result && result.metadata.operation_result.originated_contracts
+					? result.metadata.operation_result.originated_contracts.join(',')
+					: 'Error';
+
+				return [
+					...retval,
+					{
+						contract: contract.filename,
+						address,
+						destination,
+					},
+				];
+			}
+
+			return [
+				...retval,
+				{
+					contract: contract.filename,
+					address: 'Error',
+					destination,
+				},
+			];
+		},
+		[] as OriginationResult[],
+	);
+};
+
+const createBatch = async (parsedArgs: Opts, tezos: TezosToolkit, destination: string) => {
+	const contracts = await getValidContracts(parsedArgs);
+
+	const batch = await contracts.reduce(
+		(batch, contractMapping) =>
+			contractMapping.storage
+				? addOrigination(parsedArgs, batch)(contractMapping)
+				: batch,
+		Promise.resolve(tezos.wallet.batch()),
+	);
+
+	try {
+		const op = await batch.send();
+		const confirmed = await op.confirmation();
+		return await mapOpToContract(contracts, op, destination);
+	} catch (err) {
+		const error = (err as { message: string });
+		if (error.message) sendErr(error.message);
+		return undefined;
+	}
+};
+
+const originateToNetworks = (parsedArgs: Opts, currentEnv: Protocol.Environment.t) =>
+	currentEnv.networks
+		? currentEnv.networks.reduce(
+			(retval, networkName) => {
+				const network = getNetworkConfig(parsedArgs)(networkName);
+				if (network) {
+					if (network.rpcUrl) {
+						if (network.faucet) {
+							const result = (async () => {
+								const tezos = new TezosToolkit(network.rpcUrl as string);
+								await importKey(
+									tezos,
+									network.faucet.email,
+									network.faucet.password,
+									network.faucet.mnemonic.join(' '),
+									network.faucet.activation_code,
+								);
+								return await createBatch(parsedArgs, tezos, networkName);
+							})();
+
+							return [...retval, result];
+						} else sendErr(`Network ${networkName} requires a valid faucet in config.json.`);
+					} else sendErr(`Network "${networkName} is missing an RPC url in config.json."`);
+				} else {
+					sendErr(
+						`The current environment is configured to use a network called '${networkName}'; however, no network of this name has been configured in .taq/config.json.`,
+					);
+				}
+
+				return retval;
+			},
+			[] as Promise<OriginationResult[] | undefined>[],
+		)
+		: [];
+
+const originateToSandboxes = (parsedArgs: Opts, currentEnv: Protocol.Environment.t) =>
+	currentEnv.sandboxes
+		? currentEnv.sandboxes.reduce(
+			(retval, sandboxName) => {
+				const sandbox = getSandboxConfig(parsedArgs)(sandboxName);
+				if (sandbox) {
+					if (sandbox.rpcUrl) {
+						let defaultAccount = getDefaultAccount(parsedArgs)(sandboxName);
+						if (!defaultAccount) {
+							const first = getFirstAccountAlias(sandboxName, parsedArgs);
+							if (first) {
+								defaultAccount = getSandboxAccountConfig(parsedArgs)(sandboxName)(first);
+								sendErr(
+									`No default account has been configured for the sandbox called ${sandboxName}. Using the account called ${first} for origination.`,
+								);
+							}
+						}
+						if (defaultAccount) {
+							const secretKey = defaultAccount.secretKey;
+							const result = (async () => {
+								const tezos = new TezosToolkit(sandbox.rpcUrl as string);
+								tezos.setProvider({
+									signer: new InMemorySigner(secretKey.replace(/^unencrypted:/, '')),
+								});
+								return await createBatch(parsedArgs, tezos, sandboxName);
+							})();
+
+							return [...retval, result];
+						} else sendErr(`No accounts are available for the sandbox called ${sandboxName} to perform origination.`);
+					} else sendErr(`Sandbox "${sandboxName} is missing an RPC url in config.json."`);
+				} else {
+					sendErr(
+						`The current environment is configured to use a sandbox called '${sandboxName}'; however, no sandbox of this name has been configured in .taq/config.json.`,
+					);
+				}
+
+				return retval;
+			},
+			[] as Promise<OriginationResult[] | undefined>[],
+		)
+		: [];
+
+export const originate = <T>(parsedArgs: Opts): LikeAPromise<PluginResponse, TaqError.t> => {
+	const env = getCurrentEnvironmentConfig(parsedArgs);
+
+	if (!env) {
+		return sendAsyncErr(`There is no environment called ${parsedArgs.env} in your config.json.`);
+	}
+
+	const jobs = [
+		...originateToNetworks(parsedArgs, env),
+		...originateToSandboxes(parsedArgs, env),
+	];
+
+	return Promise.all(jobs)
+		.then(jobs =>
+			jobs.reduce(
+				(retval, originations) => {
+					return originations
+						? [...retval as OriginationResult[], ...originations]
+						: retval;
+				},
+				[],
+			)
+		)
+		.then(results => results && results.length > 0 ? sendJsonRes(results) : sendErr(`No contracts originated.`));
+};
+
+export default originate;

package/package.json

@@ -1,54 +1,54 @@
 {
-  "name": "@taqueria/plugin-taquito",
-  "version": "0.2.1",
-  "description": "A taqueria plugin for originating smart contracts using Taquito",
-  "targets": {
-    "default": {
-      "source": "./index.ts",
-      "distDir": "./",
-      "context": "node",
-      "isLibrary": true
-    }
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "pluginInfo": "npx ts-node index.ts --taqRun pluginInfo --i18n {\"foo:\"\"bar\"}",
-    "build": "npx parcel build --no-cache 2>&1",
-    "debugPluginInfo": "node --inspect-brk index.js --taqRun pluginInfo --i18n {\"foo:\"\"bar\"}"
-  },
-  "keywords": [
-    "taqueria",
-    "tezos",
-    "originate",
-    "deploy",
-    "ecad",
-    "ecadlabs",
-    "plugin",
-    "taquito",
-    "smart contract"
-  ],
-  "engines": {
-    "node": ">=16"
-  },
-  "author": "ECAD Labs",
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/ecadlabs/taqueria.git",
-    "directory": "taqueria-plugin-taquito"
-  },
-  "bugs": {
-    "url": "https://github.com/ecadlabs/taqueria/issues"
-  },
-  "homepage": "https://github.com/ecadlabs/taqueria#readme",
-  "devDependencies": {
-    "parcel": "^2.0.1",
-    "typescript": "4.5.4"
-  },
-  "dependencies": {
-    "@taquito/signer": "^11.1.0",
-    "@taquito/taquito": "^11.0.2",
-    "fast-glob": "^3.2.10",
-    "@taqueria/node-sdk": "^0.2.1"
-  }
+	"name": "@taqueria/plugin-taquito",
+	"version": "0.4.0-rc1",
+	"description": "A taqueria plugin for originating smart contracts using Taquito",
+	"targets": {
+		"default": {
+			"source": "./index.ts",
+			"distDir": "./",
+			"context": "node",
+			"isLibrary": true
+		}
+	},
+	"scripts": {
+		"test": "echo \"Error: no test specified\" && exit 1",
+		"pluginInfo": "npx ts-node index.ts --taqRun pluginInfo --i18n {\"foo:\"\"bar\"}",
+		"build": "npx tsc -noEmit && npx parcel build --no-cache 2>&1",
+		"debugPluginInfo": "node --inspect-brk index.js --taqRun pluginInfo --i18n {\"foo:\"\"bar\"}"
+	},
+	"keywords": [
+		"taqueria",
+		"tezos",
+		"originate",
+		"deploy",
+		"ecad",
+		"ecadlabs",
+		"plugin",
+		"taquito",
+		"smart contract"
+	],
+	"engines": {
+		"node": ">=16"
+	},
+	"author": "ECAD Labs",
+	"license": "Apache-2.0",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/ecadlabs/taqueria.git",
+		"directory": "taqueria-plugin-taquito"
+	},
+	"bugs": {
+		"url": "https://github.com/ecadlabs/taqueria/issues"
+	},
+	"homepage": "https://github.com/ecadlabs/taqueria#readme",
+	"devDependencies": {
+		"parcel": "^2.6.0",
+		"typescript": "^4.7.2"
+	},
+	"dependencies": {
+		"@taqueria/node-sdk": "^0.4.0",
+		"@taquito/signer": "^12.1.1",
+		"@taquito/taquito": "^12.1.1",
+		"fast-glob": "^3.2.11"
+	}
 }