How to Cancel a Transaction on Ethereum

Once your transaction gets confirmed on the Ethereum network, you cannot cancel it. However, you can effectively cancel transactions still in the Mempool by creating a second transaction with the same nonce (number only used once) but a higher gas fee. Since miners are incentivized to include the second transaction (with the higher gas fee) first, the nonce will be “used,” and the original transaction will be dropped from the mempool.

Here are some possible reasons you might cancel a transaction:

• You sent a transaction with a meager gas fee that is now stuck in a pending state.
• You already know the transaction is going to fail.
• You want to create a failsafe if something goes wrong with your transaction.

Cancel Transaction: MetaMask

Metamask has a built-in feature that allows you to cancel pending transactions with one click.

Cancel Transaction: Alchemy’s SDK

In this section, we will create our own cancellation transaction using Alchemy’s SDK. (Web3.js code examples are also included.)

Prerequisites

Before you begin this tutorial, please ensure you have the following:

• An Alchemy account (Create a free Alchemy account).
• An Ethereum address or MetaMask wallet (Create a MetaMask wallet).
• NodeJS and npm installed (Install NodeJs and NPM).

Connect to Alchemy

1. From the Alchemy Dashboard, hover over Apps, then click +Create App.
2. Name your app: Cancel-Tx.
3. Select Ethereum as your chain and Sepolia as your network.
4. Click Create app.

Request ETH from the Alchemy Sepolia faucet

1. From Sepolia Faucet, sign in with your Alchemy account.
2. Paste your MetaMask address and click Send me ETH.

Setup Project Environment

Open VS Code (or your preferred IDE) and enter the following in the terminal:

$
mkdir cancel-tx
>
cd cancel-tx

Once inside our project directory, initialize npm (node package manager) with the following command:

$
npm init

Press enter and answer the project prompt as follows:

1
package name: (cancel-tx)
2
version: (1.0.0)
3
description: 
4
entry point: (index.js)
5
test command: 
6
git repository: 
7
keywords: 
8
author: 
9
license: (ISC)

Press enter again to complete the prompt. If successful, a package.json file will have been created in your directory.

Install environment tools

The tools you will need to complete this tutorial are:

• Alchemy’s SDK
• dotenv (so that you can store your private key and API key safely)

To install the above tools, ensure you are still inside your root folder and type the following commands in your terminal:

Alchemy SDK:

$
npm install alchemy-sdk

Dotenv:

$
npm install dotenv --save

Create a Dotenv File

Create a .env file in your root folder. The file must be named .env or it will not be recognized.

In the .env file, we will store all of our sensitive information (i.e., our Alchemy API key and MetaMask private key).

Copy the following into your .env file:

1
API_KEY = "{YOUR_ALCHEMY_API_KEY}"
2
PRIVATE_KEY = "{YOUR_PRIVATE_KEY}"

• Replace {YOUR_ALCHEMY_API_KEY} with your Alchemy API key found in your app’s dashboard, under VIEW KEY:

• Replace {YOUR_PRIVATE_KEY}with your MetaMask private key.

To retrieve your MetaMask private key:

1. Open the extension, click on the three dots menu, and choose Account Details.

2. Click Export Private Key and enter your MetaMask password.

3. Replace the Private Key in your .env file with your MetaMask Private Key.

Create cancelTx.js file

Create a file named cancelTx.js and add the following code:

1
const cancelTx = async () => {
2
  require("dotenv").config();
3
  // Imports the secret .env file where our Private Key and API are stored
4
  // We can now use these aliases instead of using our actual keys.
5
  const { API_KEY, PRIVATE_KEY } = process.env;
6
7
  // Import the Alchemy SDK
8
  const { Network, Alchemy, Wallet } = require("alchemy-sdk");
9
10
  // Initializes Alchemy SDK with our settings config
11
  const settings = {
12
    apiKey: API_KEY,
13
    network: Network.ETH_SEPOLIA,
14
  };
15
  const alchemy = new Alchemy(settings);
16
17
  // The Wallet holds the private key and signs transactions for you.
18
  const walletInst = new Wallet(PRIVATE_KEY);
19
20
  // Gets the latest nonce for our wallet address
21
  const nonce = await alchemy.core.getTransactionCount(walletInst.address);
22
};
23
24
cancelTx();

The code above sets up our Alchemy SDK to connect to the blockchain and send transactions.

Next, let’s create two transactions. The first will be the transaction we intend to cancel and the second will be our cancellation transaction. See the code below, noting specifically lines 17-29:

1
const cancelTx = async () => {
2
  require("dotenv").config();
3
  const { API_KEY, PRIVATE_KEY } = process.env;
4
  const { Network, Alchemy, Wallet, Utils } = require("alchemy-sdk");
5
6
  const settings = {
7
    apiKey: API_KEY,
8
    network: Network.ETH_SEPOLIA,
9
  };
10
  const alchemy = new Alchemy(settings);
11
12
  const walletInst = new Wallet(PRIVATE_KEY);
13
  const nonce = await alchemy.core.getTransactionCount(walletInst.address);
14
15
  const transaction = {
16
    gasLimit: "53000",
17
    maxPriorityFeePerGas: Utils.parseUnits("1", "gwei"),
18
    nonce: nonce,
19
    type: 2,
20
    chainId: 5,
21
  };
22
23
  const replacementTx = {
24
    gasLimit: "53000",
25
    maxPriorityFeePerGas: Utils.parseUnits("1.55", "gwei"),
26
    maxFeePerGas: Utils.parseUnits("1.8", "gwei"),
27
    nonce: nonce,
28
    type: 2,
29
    chainId: 5,
30
  };
31
};
32
33
cancelTx();

Here’s an overview of the transaction parameters:

• gasLimit: The maximum amount of gas used to execute our transaction. 21000 wei is the minimum amount of gas an operation on Ethereum will use, so to ensure our transaction will be executed we put 53000 wei here.
• maxPriorityFeePerGas: The miner’s tip. (Check out Alchemy’s guide to learn more)
• maxFeePerGas: Transaction base fee + miner’s tip
• nonce: (number only used once) used to keep track of transactions for a specific address.
• type: The EIP-2718 type of the transaction envelope.

Finally, let’s send our transactions! For this, add the following try-catch statement, noting specifically lines 31-49:

1
const cancelTx = async () => {
2
  require("dotenv").config();
3
  const { API_KEY, PRIVATE_KEY } = process.env;
4
  const { Network, Alchemy, Wallet, Utils } = require("alchemy-sdk");
5
6
  const settings = {
7
    apiKey: API_KEY,
8
    network: Network.ETH_SEPOLIA,
9
  };
10
  const alchemy = new Alchemy(settings);
11
12
  const walletInst = new Wallet(PRIVATE_KEY);
13
  const nonce = await alchemy.core.getTransactionCount(walletInst.address);
14
15
  const transaction = {
16
    gasLimit: "53000",
17
    maxPriorityFeePerGas: Utils.parseUnits("1", "gwei"),
18
    nonce: nonce,
19
    type: 2,
20
    chainId: 5,
21
  };
22
23
  const replacementTx = {
24
    gasLimit: "53000",
25
    maxPriorityFeePerGas: Utils.parseUnits("1.55", "gwei"),
26
    maxFeePerGas: Utils.parseUnits("1.8", "gwei"),
27
    nonce: nonce,
28
    type: 2,
29
    chainId: 5,
30
  };
31
32
  try {
33
    const signedTx = await walletInst.signTransaction(transaction);
34
    const signedReplacementTx = await walletInst.signTransaction(replacementTx);
35
36
    const txResult = await alchemy.core.sendTransaction(signedTx);
37
    const replacementTxResult = await alchemy.core.sendTransaction(
38
      replacementTx
39
    );
40
41
    console.log(
42
      "The hash of the transaction we are going to cancel is:",
43
      txResult.hash
44
    );
45
    console.log(
46
      "The hash of your replacement transaction is:",
47
      replacementTxResult.hash,
48
      "\n Check Alchemy's Mempool to view the status of your transactions!"
49
    );
50
  } catch (error) {
51
    console.log(
52
      "Something went wrong while submitting your transactions:",
53
      error
54
    );
55
  }
56
};
57
58
cancelTx();

Above, we call the sendTransaction function and pass in our transaction.

To run our script, type this command in terminal:

$
node cancelTx.js

If successful, you should see an output similar to the following:

$
The hash of the transaction we are going to cancel is: 0x48b35baed265c5c7b31a16cf527a66f622923ad6cbe02c77a4af6438d528c199
>
The hash of your replacement transaction is: 0x1145ea775a7889cdbdf1a29d41decd681adb9894b2351a324bf82923dfbd8b09 
>
 Check Alchemy's Mempool to view the status of your transactions!

On Alchemy, head to your app’s dashboard and navigate to the Mempool tab.

After your replacement transaction has been mined, you should see that your first transaction was dropped and replaced:

Nice work! You successfully created then canceled a transaction using Alchemy’s SDK!

Feel free to reach out to us in the Alchemy Discord for help or chat with us @Alchemy on Twitter!