@taqueria/plugin-taquito 0.22.2 → 0.23.0-rc.1

package/transfer.ts

@@ -1,149 +1,109 @@
 import {
-	getAccountPrivateKey,
 	getAddressOfAlias,
 	getCurrentEnvironment,
 	getCurrentEnvironmentConfig,
-	getDefaultAccount,
-	getNetworkConfig,
 	getParameter,
-	getSandboxAccountConfig,
-	getSandboxAccountNames,
-	getSandboxConfig,
 	sendAsyncErr,
-	sendErr,
 	sendJsonRes,
 } from '@taqueria/node-sdk';
-import { Environment, RequestArgs } from '@taqueria/node-sdk/types';
+import { Environment } from '@taqueria/node-sdk/types';
 import { Expr, Parser } from '@taquito/michel-codec';
-import { importKey, InMemorySigner } from '@taquito/signer';
-import { TezosToolkit } from '@taquito/taquito';
+import { TezosToolkit, WalletOperationBatch } from '@taquito/taquito';
+import { BatchWalletOperation } from '@taquito/taquito/dist/types/wallet/batch-operation';
+import {
+	configureToolKitForNetwork,
+	configureToolKitForSandbox,
+	getEnvTypeAndNodeConfig,
+	handleOpsError,
+	TransferOpts as Opts,
+} from './common';
 
-interface Opts extends RequestArgs.t {
-	contract: string;
-	tez?: string;
-	param?: string;
-	entrypoint?: string;
-}
+export type ContractInfo = {
+	contractAlias: string;
+	contractAddress: string;
+	parameter: string;
+	entrypoint: string;
+	mutezTransfer: number;
+};
 
 type TableRow = {
 	contractAlias: string;
 	contractAddress: string;
-	tezTransfer: string;
 	parameter: string;
 	entrypoint: string;
+	mutezTransfer: string;
 	destination: string;
 };
 
-const getFirstAccountAlias = (sandboxName: string, opts: Opts) => {
-	const aliases = getSandboxAccountNames(opts)(sandboxName);
-	return aliases.shift();
-};
-
-const configureToolKitWithSandbox = async (parsedArgs: Opts, sandboxName: string): Promise<TezosToolkit> => {
-	const sandbox = getSandboxConfig(parsedArgs)(sandboxName);
-	if (!sandbox) {
-		return sendAsyncErr(
-			`The current environment is configured to use a sandbox called '${sandboxName}'; however, no sandbox of this name has been configured in .taq/config.json.`,
-		);
-	}
-
-	let defaultAccount = getDefaultAccount(parsedArgs)(sandboxName);
-	if (!defaultAccount) {
-		const first = getFirstAccountAlias(sandboxName, parsedArgs);
-		if (first) {
-			defaultAccount = getSandboxAccountConfig(parsedArgs)(sandboxName)(first);
-			sendErr(
-				`Warning: A default account has not been specified for sandbox ${sandboxName}. Taqueria will use the account ${first} for this operation.\nA default account can be specified in .taq/config.json at JSON path: sandbox.${sandboxName}.accounts.default\n`,
-			);
-		}
-	}
-	if (!defaultAccount) {
-		return sendAsyncErr(`No accounts are available for the sandbox called ${sandboxName} to perform the operation.`);
-	}
-
-	const tezos = new TezosToolkit(sandbox.rpcUrl as string);
-	tezos.setProvider({
-		signer: new InMemorySigner((defaultAccount.secretKey as string).replace(/^unencrypted:/, '')),
-	});
-	return tezos;
-};
-
-const configureToolKitWithNetwork = async (parsedArgs: Opts, networkName: string): Promise<TezosToolkit> => {
-	const network = getNetworkConfig(parsedArgs)(networkName);
-	if (!network) {
-		return sendAsyncErr(
-			`The current environment is configured to use a network called '${networkName}'; however, no network of this name has been configured in .taq/config.json.`,
-		);
-	}
-
-	const tezos = new TezosToolkit(network.rpcUrl as string);
-	const key = await getAccountPrivateKey(parsedArgs, network, 'taqRootAccount');
-	await importKey(tezos, key);
-	return tezos;
-};
-
-const configureTezosToolKit = (parsedArgs: Opts, env: Environment.t): Promise<TezosToolkit> => {
-	const targetConstraintErrMsg = 'Each environment can only have one target, be it a sandbox or a network';
-	if (env.sandboxes?.length === 1 && env.networks?.length === 1) return sendAsyncErr(targetConstraintErrMsg);
-	if (env.sandboxes?.length === 1) return configureToolKitWithSandbox(parsedArgs, env.sandboxes[0]);
-	if (env.networks?.length === 1) return configureToolKitWithNetwork(parsedArgs, env.networks[0]);
-	return sendAsyncErr(targetConstraintErrMsg);
-};
-
 const isContractAddress = (contract: string): boolean =>
 	contract.startsWith('tz1') || contract.startsWith('tz2') || contract.startsWith('tz3') || contract.startsWith('KT1');
 
-const getContractInfo = async (parsedArgs: Opts, env: Environment.t, tezos: TezosToolkit): Promise<TableRow> => {
+const getContractInfo = async (parsedArgs: Opts, env: Environment.t): Promise<ContractInfo> => {
 	const contract = parsedArgs.contract;
 	return {
 		contractAlias: isContractAddress(contract) ? 'N/A' : contract,
 		contractAddress: isContractAddress(contract) ? contract : await getAddressOfAlias(env, contract),
-		tezTransfer: parsedArgs.tez ?? '0',
 		parameter: parsedArgs.param ? await getParameter(parsedArgs, parsedArgs.param) : 'Unit',
 		entrypoint: parsedArgs.entrypoint ?? 'default',
-		destination: tezos.rpc.getRpcUrl(),
+		mutezTransfer: parseInt(parsedArgs.mutez ?? '0'),
 	};
 };
 
-const performTransferOp = (tezos: TezosToolkit, contractInfo: TableRow, parsedArgs: Opts): Promise<string> => {
-	return tezos.contract
-		.transfer({
+const createBatchForTransfer = (tezos: TezosToolkit, contractsInfo: ContractInfo[]): WalletOperationBatch =>
+	contractsInfo.reduce((acc, contractInfo) =>
+		acc.withTransfer({
 			to: contractInfo.contractAddress,
-			amount: parseFloat(contractInfo.tezTransfer),
+			amount: contractInfo.mutezTransfer,
 			parameter: {
 				entrypoint: contractInfo.entrypoint,
 				value: new Parser().parseMichelineExpression(contractInfo.parameter) as Expr,
 			},
-		})
-		.then(op => op.confirmation().then(() => op.hash))
-		.catch(err => {
-			if (err instanceof Error) {
-				if (/empty_implicit_contract/.test(err.message)) {
-					const result = (err.message).match(/(?<="implicit":")tz[^"]+(?=")/);
-					const publicKeyHash = result ? result[0] : undefined;
-					if (publicKeyHash) {
-						return sendAsyncErr(
-							`The account ${publicKeyHash} for the target environment, "${
-								getCurrentEnvironment(parsedArgs)
-							}", may not be funded\nTo fund this account:\n1. Go to https://teztnets.xyz and click "Faucet" of the target testnet\n2. Copy and paste the above key into the 'wallet address field\n3. Request some Tez (Note that you might need to wait for a few seconds for the network to register the funds)`,
-						);
-					}
-				}
-			}
-			return sendAsyncErr(`Error during transfer operation:\n${err} ${JSON.stringify(err, null, 2)}`);
-		});
+			mutez: true,
+		}), tezos.wallet.batch());
+
+export const performTransferOps = async (
+	tezos: TezosToolkit,
+	env: string,
+	contractsInfo: ContractInfo[],
+): Promise<BatchWalletOperation> => {
+	const batch = createBatchForTransfer(tezos, contractsInfo);
+	try {
+		const op = await batch.send();
+		await op.confirmation();
+		return op;
+	} catch (err) {
+		return handleOpsError(err, env);
+	}
 };
 
-export const transfer = async (parsedArgs: Opts): Promise<void> => {
+const prepContractInfoForDisplay = (tezos: TezosToolkit, contractInfo: ContractInfo): TableRow => {
+	return {
+		contractAlias: contractInfo.contractAlias,
+		contractAddress: contractInfo.contractAddress,
+		parameter: contractInfo.parameter,
+		entrypoint: contractInfo.entrypoint,
+		mutezTransfer: contractInfo.mutezTransfer.toString(),
+		destination: tezos.rpc.getRpcUrl(),
+	};
+};
+
+const transfer = async (parsedArgs: Opts): Promise<void> => {
 	const env = getCurrentEnvironmentConfig(parsedArgs);
-	if (!env) return sendAsyncErr(`There is no environment called ${parsedArgs.env} in your config.json.`);
+	if (!env) return sendAsyncErr(`There is no environment called ${parsedArgs.env} in your config.json`);
 	try {
-		const tezos = await configureTezosToolKit(parsedArgs, env);
-		const contractInfo = await getContractInfo(parsedArgs, env, tezos);
-		await performTransferOp(tezos, contractInfo, parsedArgs);
-		return sendJsonRes([contractInfo]);
+		const [envType, nodeConfig] = await getEnvTypeAndNodeConfig(parsedArgs, env);
+		const tezos = await (envType === 'Network'
+			? configureToolKitForNetwork(parsedArgs, nodeConfig, parsedArgs.sender)
+			: configureToolKitForSandbox(nodeConfig, parsedArgs.sender));
+
+		const contractInfo = await getContractInfo(parsedArgs, env);
+
+		await performTransferOps(tezos, getCurrentEnvironment(parsedArgs), [contractInfo]);
+
+		const contractInfoForDisplay = prepContractInfoForDisplay(tezos, contractInfo);
+		return sendJsonRes([contractInfoForDisplay]);
 	} catch {
-		return sendAsyncErr('No operations performed.');
+		return sendAsyncErr('No operations performed');
 	}
 };