Add smoketest to e2e tests

e2e_test/debug-fee-currency/lib.sh

@@ -50,7 +50,7 @@ function cleanup_fee_currency() {
 # 		replace the transaction with a transaction of higher priority-fee when
 # 		there is no receipt after the `waitBlocks` time passed
 function cip_64_tx() {
-	$SCRIPT_DIR/js-tests/send_tx.mjs "$(cast chain-id)" $ACC_PRIVKEY $1 $2 $3
+	$SCRIPT_DIR/js-tests/send_tx.mjs $1 $2 $3
 }
 
 # use this function to assert the cip_64_tx return value, by using a pipe like

e2e_test/js-tests/send_tx.mjs

@@ -1,50 +1,10 @@
 #!/usr/bin/env node
 import {
-  createWalletClient,
-  createPublicClient,
-  http,
-  defineChain,
   TransactionReceiptNotFoundError,
 } from "viem";
-import { celoAlfajores } from "viem/chains";
-import { privateKeyToAccount } from "viem/accounts";
+import { publicClient, walletClient, account } from "./viem_setup.mjs"
 
-const [chainId, privateKey, feeCurrency, waitBlocks, replaceTxAfterWait] =
-  process.argv.slice(2);
-const devChain = defineChain({
-  ...celoAlfajores,
-  id: parseInt(chainId, 10),
-  name: "local dev chain",
-  network: "dev",
-  rpcUrls: {
-    default: {
-      http: ["http://127.0.0.1:8545"],
-    },
-  },
-});
-
-var chain;
-switch(process.env.NETWORK) {
-	case "alfajores":
-		chain = celoAlfajores;
-		break;
-	default:
-		chain = devChain;
-		// Code to run if no cases match
-};
-
-const account = privateKeyToAccount(privateKey);
-
-const publicClient = createPublicClient({
-  account,
-  chain: chain,
-  transport: http(),
-});
-const walletClient = createWalletClient({
-  account,
-  chain: chain,
-  transport: http(),
-});
+const [feeCurrency, waitBlocks, replaceTxAfterWait] = process.argv.slice(2);
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));

e2e_test/js-tests/test_viem_smoketest.mjs

@@ -0,0 +1,134 @@
+import { assert } from "chai";
+import "mocha";
+import {
+	parseAbi,
+} from "viem";
+import fs from "fs";
+import { publicClient, walletClient } from "./viem_setup.mjs"
+
+// Load compiled contract
+const testContractJSON = JSON.parse(fs.readFileSync(process.env.COMPILED_TEST_CONTRACT, 'utf8'));
+
+// check checks that the receipt has status success and that the transaction
+// type matches the expected type, since viem sometimes mangles the type when
+// building txs.
+async function check(txHash, type) {
+	const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+	assert.equal(receipt.status, "success", "receipt status 'failure'");
+	const transaction = await publicClient.getTransaction({ hash: txHash });
+	assert.equal(transaction.type, type, "transaction type does not match");
+}
+
+// sendTypedTransaction sends a transaction with the given type and an optional
+// feeCurrency.
+async function sendTypedTransaction(type, feeCurrency) {
+	return await walletClient.sendTransaction({
+		to: "0x00000000000000000000000000000000DeaDBeef",
+		value: 1,
+		type: type,
+		feeCurrency: feeCurrency,
+	});
+}
+
+// sendTypedSmartContractTransaction initiates a token transfer with the given type
+// and an optional feeCurrency.
+async function sendTypedSmartContractTransaction(type, feeCurrency) {
+	const abi = parseAbi(['function transfer(address to, uint256 value) external returns (bool)']);
+	return await walletClient.writeContract({
+		abi: abi,
+		address: process.env.TOKEN_ADDR,
+		functionName: 'transfer',
+		args: ['0x00000000000000000000000000000000DeaDBeef', 1n],
+		type: type,
+		feeCurrency: feeCurrency,
+	});
+}
+
+// sendTypedCreateTransaction sends a create transaction with the given type
+// and an optional feeCurrency.
+async function sendTypedCreateTransaction(type, feeCurrency) {
+	return await walletClient.deployContract({
+		type: type,
+		feeCurrency: feeCurrency,
+		bytecode: testContractJSON.bytecode.object,
+		abi: testContractJSON.abi,
+		// The constructor args for the test contract at ../debug-fee-currency/DebugFeeCurrency.sol
+		args: [1n, true, true, true],
+	});
+}
+
+["legacy", "eip2930", "eip1559", "cip64"].forEach(function (type) {
+	describe("viem smoke test, tx type " + type, () => {
+		const feeCurrency = type == "cip64" ? process.env.FEE_CURRENCY : undefined;
+		it("send tx", async () => {
+			const send = await sendTypedTransaction(type, feeCurrency);
+			await check(send, type);
+		});
+		it("send create tx", async () => {
+			const create = await sendTypedCreateTransaction(type, feeCurrency);
+			await check(create, type);
+		});
+		it("send contract interaction tx", async () => {
+			const contract = await sendTypedSmartContractTransaction(type, feeCurrency);
+			await check(contract, type);
+		});
+	});
+});
+describe("viem smoke test, unsupported txs", () => {
+	// This test is failing because the produced transaction is of type cip64.
+	// I guess this is a problem with the viem internals.
+	it.skip("cip42", async () => {
+		const type = "cip42";
+		await sendTypedTransaction(type);
+	});
+
+	it("legacy tx with fee currency", async () => {
+		const type = "legacy";
+		try {
+			const hash = await sendTypedTransaction(type, process.env.FEE_CURRENCY);
+
+			// When using the devnet an exception is thrown from
+			// sendTypedTransaction, on alfajores the transaction is submitted so we
+			// get a hash but it's not included. So we validate here that the
+			// transaction was not included.
+			let blockNumber = await publicClient.getBlockNumber();
+			const oldBlockNumber = blockNumber;
+			while (blockNumber == oldBlockNumber) {
+				// Sleep 100ms
+				await new Promise(r => setTimeout(r, 100));
+				blockNumber = await publicClient.getBlockNumber();
+			}
+			const tx = await publicClient.getTransaction({ hash: hash });
+			assert.isNull(tx);
+		} catch (error) {
+			// Expect error to be thrown
+			return
+			// exceptionThrown += 1;
+		}
+		assert.fail("Managed to send unsupported legacy tx with fee currency");
+	});
+
+	it("legacy create tx with fee currency", async () => {
+		const type = "legacy";
+		try {
+			const hash = await sendTypedCreateTransaction(type, process.env.FEE_CURRENCY);
+
+			// When using the devnet an exception is thrown from
+			// sendTypedTransaction, on alfajores the transaction is submitted so we
+			// get a hash but it's not included. So we validate here that the
+			// transaction was not included.
+			let blockNumber = await publicClient.getBlockNumber();
+			const oldBlockNumber = blockNumber;
+			while (blockNumber == oldBlockNumber) {
+				blockNumber = await publicClient.getBlockNumber();
+			}
+			const tx = await publicClient.getTransaction({ hash: hash });
+			assert.isNull(tx);
+		} catch (error) {
+			// Expect error to be thrown
+			return
+			// exceptionThrown += 1;
+		}
+		assert.fail("Managed to send unsupported legacy tx with fee currency");
+	});
+});

e2e_test/js-tests/test_viem_tx.mjs

@@ -1,48 +1,9 @@
 import { assert } from "chai";
 import "mocha";
 import {
-	createPublicClient,
-	createWalletClient,
-	http,
-	defineChain,
 	parseAbi,
 } from "viem";
-import { celoAlfajores } from "viem/chains";
-import { privateKeyToAccount } from "viem/accounts";
-
-// Setup up chain
-const devChain = defineChain({
-	...celoAlfajores,
-	id: 1337,
-	name: "local dev chain",
-	network: "dev",
-	rpcUrls: {
-		default: {
-			http: [process.env.ETH_RPC_URL],
-		},
-	},
-});
-
-const chain = (() => {
-	switch (process.env.NETWORK) {
-		case 'alfajores':
-			return celoAlfajores
-		default:
-			return devChain
-	};
-})();
-
-// Set up clients/wallet
-const publicClient = createPublicClient({
-	chain: chain,
-	transport: http(),
-});
-const account = privateKeyToAccount(process.env.ACC_PRIVKEY);
-const walletClient = createWalletClient({
-	account,
-	chain: chain,
-	transport: http(),
-});
+import { publicClient, walletClient } from "./viem_setup.mjs"
 
 // Returns the base fee per gas for the current block multiplied by 2 to account for any increase in the subsequent block.
 async function getGasFees(publicClient, tip, feeCurrency) {
@@ -60,13 +21,12 @@ const testNonceBump = async (
 	shouldReplace,
 ) => {
 	const syncBarrierRequest = await walletClient.prepareTransactionRequest({
-		account,
+
 		to: "0x00000000000000000000000000000000DeaDBeef",
 		value: 2,
 		gas: 22000,
 	});
 	const firstTxHash = await walletClient.sendTransaction({
-		account,
 		to: "0x00000000000000000000000000000000DeaDBeef",
 		value: 2,
 		gas: 171000,
@@ -78,7 +38,6 @@ const testNonceBump = async (
 	var secondTxHash;
 	try {
 		secondTxHash = await walletClient.sendTransaction({
-			account,
 			to: "0x00000000000000000000000000000000DeaDBeef",
 			value: 3,
 			gas: 171000,
@@ -95,7 +54,7 @@ const testNonceBump = async (
 			shouldReplace
 		) {
 			throw err; // Only throw if unexpected error.
-	  }
+		}
 	}
 	const syncBarrierSignature =
 		await walletClient.signTransaction(syncBarrierRequest);
@@ -115,7 +74,6 @@ const testNonceBump = async (
 describe("viem send tx", () => {
 	it("send basic tx and check receipt", async () => {
 		const request = await walletClient.prepareTransactionRequest({
-			account,
 			to: "0x00000000000000000000000000000000DeaDBeef",
 			value: 1,
 			gas: 21000,
@@ -130,7 +88,6 @@ describe("viem send tx", () => {
 
 	it("send basic tx using viem gas estimation and check receipt", async () => {
 		const request = await walletClient.prepareTransactionRequest({
-			account,
 			to: "0x00000000000000000000000000000000DeaDBeef",
 			value: 1,
 		});
@@ -145,7 +102,6 @@ describe("viem send tx", () => {
 	it("send fee currency tx with explicit gas fields and check receipt", async () => {
 		const [maxFeePerGas, tip] = await getGasFees(publicClient, 2n, process.env.FEE_CURRENCY);
 		const request = await walletClient.prepareTransactionRequest({
-			account,
 			to: "0x00000000000000000000000000000000DeaDBeef",
 			value: 2,
 			gas: 171000,
@@ -163,7 +119,6 @@ describe("viem send tx", () => {
 
 	it("test gas price difference for fee currency", async () => {
 		const request = await walletClient.prepareTransactionRequest({
-			account,
 			to: "0x00000000000000000000000000000000DeaDBeef",
 			value: 2,
 			gas: 171000,
@@ -208,8 +163,8 @@ describe("viem send tx", () => {
 		// The expected value for the max fee should be the (baseFeePerGas * multiplier) + maxPriorityFeePerGas
 		// Instead what is currently returned is (maxFeePerGas * multiplier) + maxPriorityFeePerGas
 		const maxPriorityFeeInFeeCurrency = (maxPriorityFeePerGasNative * numerator) / denominator;
-    const maxFeeInFeeCurrency = ((block.baseFeePerGas +maxPriorityFeePerGasNative)*numerator) /denominator;
-		assert.equal(fees.maxFeePerGas, ((maxFeeInFeeCurrency*12n)/10n) + maxPriorityFeeInFeeCurrency);
+		const maxFeeInFeeCurrency = ((block.baseFeePerGas + maxPriorityFeePerGasNative) * numerator) / denominator;
+		assert.equal(fees.maxFeePerGas, ((maxFeeInFeeCurrency * 12n) / 10n) + maxPriorityFeeInFeeCurrency);
 		assert.equal(fees.maxPriorityFeePerGas, maxPriorityFeeInFeeCurrency);
 
 		// check that the prepared transaction request uses the
@@ -220,7 +175,6 @@ describe("viem send tx", () => {
 
 	it("send fee currency with gas estimation tx and check receipt", async () => {
 		const request = await walletClient.prepareTransactionRequest({
-			account,
 			to: "0x00000000000000000000000000000000DeaDBeef",
 			value: 2,
 			feeCurrency: process.env.FEE_CURRENCY,
@@ -286,7 +240,6 @@ describe("viem send tx", () => {
 
 	it("send tx with unregistered fee currency", async () => {
 		const request = await walletClient.prepareTransactionRequest({
-			account,
 			to: "0x00000000000000000000000000000000DeaDBeef",
 			value: 2,
 			gas: 171000,
@@ -334,11 +287,11 @@ describe("viem send tx", () => {
 			assert.fail(`Converted base fee (${convertedBaseFee}) not less than native base fee (${block.baseFeePerGas})`);
 		}
 		const request = await walletClient.prepareTransactionRequest({
-			account,
 			to: "0x00000000000000000000000000000000DeaDBeef",
 			value: 2,
 			gas: 171000,
 			feeCurrency: process.env.FEE_CURRENCY,
+			feeCurrency: fc,
 			maxFeePerGas: convertedBaseFee +2n,
 			maxPriorityFeePerGas: 2n,
 		});
@@ -352,13 +305,13 @@ describe("viem send tx", () => {
 });
 
 async function getRate(feeCurrencyAddress) {
-		const abi = parseAbi(['function getExchangeRate(address token) public view returns (uint256 numerator, uint256 denominator)']);
-		const [numerator, denominator] = await publicClient.readContract({
-			address: process.env.FEE_CURRENCY_DIRECTORY_ADDR,
-			abi: abi,
-			functionName: 'getExchangeRate',
-			args: [feeCurrencyAddress],
-		});
+	const abi = parseAbi(['function getExchangeRate(address token) public view returns (uint256 numerator, uint256 denominator)']);
+	const [numerator, denominator] = await publicClient.readContract({
+		address: process.env.FEE_CURRENCY_DIRECTORY_ADDR,
+		abi: abi,
+		functionName: 'getExchangeRate',
+		args: [feeCurrencyAddress],
+	});
 	return {
 		toFeeCurrency: (v) => (v * numerator) / denominator,
 		toNative: (v) => (v * denominator) / numerator,