πŸ’Έ Sending Transactions Using Web3 and Alchemy

This is a beginners guide for sending Ethereum transactions using web3 and Alchemy.

There are three main steps in order to send a transaction to the ethereum blockchain: create, sign, and broadcast. We'll go through all three, hopefully answering any questions you might have!

NOTE: This guide is for singing your transactions on the backend for your app, if you want to integrate signing your transactions on the frontend, you'll need to integrate a browser provider with Alchemy Web3.

The Basics

Like most blockchain developers when they first start, you might have done some research on how to send a transaction (something that should be pretty simple) and ran into a plethora of guides, each saying different things and leaving you a bit overwhelmed and confused. If you're in that boat, don't worry; we all were at some point! So, before we start, let's get a few things straight:

1. Alchemy does not store your private keys

  • This means that Alchemy cannot sign and send transactions on your behalf. The reason for this is security purposes. Alchemy will never ask you to share your private key, and you should never share your private key with a hosted node (or anyone for that matter).

  • You can read from the blockchain using Alchemy's core API, but to write to it you'll need to use something to sign your transactions before sending them through Alchemy.

2. What is a "signer"?

  • Signers will sign transactions for you using your private key. In this tutorial we'll be using alchemy web3 to sign our transaction, but you could also use any other web3 library.

  • In the frontend, a good example of a signer would be metamask, which will sign and send transactions on your behalf.

3. Why do I need to sign my transactions?

  • Every user that wants to send a transaction on the Ethereum network must sign the transaction first in order to validate that the origin of the transaction is who it claims to be.

  • It is super important to protect this private key, since having access to it grants full control over your Ethereum account, allowing you (or anyone with access) to perform transactions on your behalf.

4. How do I protect my private key?

  • There are many ways to protect your private key and to use it to send off transactions. In this tutorial we will be using a .env file. However, you could also use a separate provider that stores private keys, use a keystore file, or other options.

5. What is the difference between eth_sendTransaction and eth_sendRawTransaction?

eth_sendTransaction and eth_sendRawTransaction are both Ethereum API functions which broadcast a transaction to the Ethereum network so it will be added to a future block. They differ in how they handle signing of the transactions.

  • ​eth_sendTransaction is used for sending unsigned transactions, which means the node you are sending to must manage your private key so it can sign the transaction before broadcasting it to the chain. Since Alchemy doesn't hold user's private keys, we do not support this method.

  • ​eth_sendRawTransaction is used to broadcast transactions that have already been signed. This means you first have to usesignTransaction(tx, private_key), then pass in the result into eth_sendRawTransaction.

When using web3, eth_sendRawTransaction is accessed by calling the function web3.eth.sendSignedTransaction. This is what we will be using in our tutorial.

6. What is the web3 library?

  • Web3 is a wrapper library around the standard JSON-RPC calls that is quite common to use in Ethereum development.

  • There are many different web3 libraries for different languages. In this tutorial we'll be using Alchemy web3 which is written in JavaScript. You can check out other options here.

Okay, now that we have a few of these questions out of the way, let's move on to the tutorial. Feel free to ask questions anytime in our discord!

NOTE: This guide assumes you have an Alchemy account, an Ethereum address or Metamask wallet, NodeJs, and npm installed. If not, follow these steps:

  1. ​Create Metamask account (or get an Ethereum account)

Steps to Sending your Transaction

1. Create an Alchemy app on the Rinkeby testnet

Navigate to your Alchemy Dashboard and create a new app, choosing Rinkeby (or any other testnet) for your network.

2. Request Eth from the Rinkeby faucet​

Follow the instructions on the faucet homepage to receive Eth. You will have to share on social media for this specific faucet. Make sure to include your Rinkeby Ethereum address (from Metamask) and not another network. After following the instructions, double check that you've received the Eth in your wallet.

3. Create a new project directory and cd into it

Create a new project directory from the command line (terminal for macs) and navigate into it:

mkdir sendtx-example
cd sendtx-example

4. Install Alchemy Web3 (or any web3 library)

Run the following command in your project directory:

npm install @alch/alchemy-web3

5. Install dotenv

We'll use a .env file to safely store our API key and private key.

npm install dotenv --save

6. Create the .env file

Create a .env file in your project directory and add the following (replacing "your-api-key" and "your-private-key")

  • To find your Alchemy API URL, navigate to the app details page of the app you just created on your dashboard, click "View Key" in the top right corner, and grab the HTTP URL.

  • To find your private key using Metamask, check out this guide.

API_URL = "https://eth-ropsten.alchemyapi.io/v2/your-api-key"
PRIVATE_KEY = "your-private-key"

7. Create sendTx.js file

Great, now that we have our sensitive data protected in a .env file, let's start coding. For our send transaction example, we'll be sending Eth back to the Rinkeby faucet.

Create a sendTx.js file, which is where we will configure and send our example transaction, and add the following lines of code to it:

async function main() {
require('dotenv').config();
const { API_URL, PRIVATE_KEY } = process.env;
const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
const web3 = createAlchemyWeb3(API_URL);
const myAddress = '0x610Ae88399fc1687FA7530Aac28eC2539c7d6d63'
const nonce = await web3.eth.getTransactionCount(myAddress, 'latest'); // nonce starts counting from 0
​
const transaction = {
'to': '0x31B98D14007bDEe637298086988A0bBd31184523', // faucet address to return eth
'value': 1000000000000000000, // 1 ETH
'gas': 30000,
'nonce': nonce,
};
const signedTx = await web3.eth.accounts.signTransaction(transaction, PRIVATE_KEY);
await web3.eth.sendSignedTransaction(signedTx.rawTransaction);
}
main();

Before we jump into running this code, let's talk about some of the components here.

  • nonce : The nonce specification is used to keep track of the number of transactions sent from your address. We need this for security purposes and to prevent replay attacks. To get the number of transactions sent from your address we use getTransactionCount.

  • transaction: The transaction object has a few aspects we need to specify

    • to: This is the address we want to send Eth to. In this case, we are sending Eth back to the Rinkeby faucet we initially requested from.

    • value: This is the amount we wish to send, specified in wei where 10^18 wei = 1 ETH

    • gas: There are many ways to determine the right amount of gas to include with your transaction. Alchemy even has a gas price webhook to notify you when the gas price falls within a certain threshold. For mainnet transactions, it's good practice to check a gas estimator like Eth Gas Station to determine the right amount of gas to include. 21000 is the minimum amount of gas an operation on Ethereum will use, so to ensure our transaction will be executed we put 30000 here.

    • nonce: see above nonce definition. Nonce starts counting from zero.

  • signedTx: To sign our transaction object we will use the signTransaction method with our PRIVATE_KEY

  • sendSignedTransaction: Once we have a signed transaction, we can send it off to be included in a subsequent block by using sendSignedTransaction

8. Run the code using node sendTx.js

Navigate back to your terminal or command line and run:

node sendTx.js

9. See your transaction in the Mempool

Open up the Mempool page in your Alchemy dashboard and filter by the app you created to find your transaction. This is where we can watch our transaction transition from pending state to mined state (if successful) or dropped state if unsuccessful. Make sure to keep it on "All" so that you capture "mined", "pending", and "dropped" transactions. You can also search for your transaction by looking for transactions sent to address 0x31b98d14007bdee637298086988a0bbd31184523

To view the details of your transaction once you've found it, select the tx hash, which should take you to a view that looks like this:

From there you can view your transaction on Etherscan by clicking on the icon circled in red!

Yippieeee! You just sent your first Ethereum transaction using Alchemy πŸŽ‰

For feedback and suggestions about this guide, please message Elan on Alchemy's Discord!