Marketplace has launched, further enabling blockchain developers! Learn more

How to do a non-custodial transaction with QuickNode

September 09, 2022

Overview

Private keys are one of the most sensitive pieces of data when it comes to cryptography and the blockchain. However, there has always been debate/confusion about choosing between custodial wallets (where the wallet provider has custody of the user’s private key) and non-custodial wallets (where the wallet user has custody of the private key). This guide will take a deep dive into understanding the difference between custodial and non-custodial wallets and how to make a non-custodial transaction using QuickNode.

Prerequisites
  • Node.js installed on your system.
  • Text editor.
  • Terminal aka Command-Line.

What is a non-custodial wallet?

A non-custodial wallet is a blockchain wallet where the wallet owner is in complete control and has custody of the private key. A non-custodial wallet can be made and accessed using two methods. Using the private key (an alphanumeric string) or using a mnemonic seed phrase, a 12-24 word phrase stored on the wallet owner’s end (generally written down and stored in a secure place, off the internet and computer).

Following are some advantages of a non-custodial wallet:

  • Autonomy - users are in complete control of their funds - as the user is the only entity with complete control over their funds. They don’t have to depend on any third party to manage or secure their wallet.
  • Safety -as the users store their private keys off the internet or any computer,  the chances of a security breach are almost negligible.
  • Instant withdrawal - with non-custodial wallets, users don’t have to depend on any third party to confirm their withdrawal request. This streamlines the whole process and allows for instant withdrawals.

Non-custodial wallet vs. custodial wallet

  • Custodian of Private key - The foremost factor to consider when comparing crypto wallets is possession of the private key. In the case of a non-custodial wallet, the user has custody of the private key. A third party (usually a wallet provider or exchange) controls the private key with custodial wallets.
  • Transaction Type - The transactions made by non-custodial wallets are visible instantly on-chain. In contrast, the transaction made by custodial wallets has to go through various checks by the third party and are prone to latency.
  • Security - In non-custodial wallets, the user has the private key stored locally. The wallet is very secure unless the user shares the private key or the device gets stolen. In custodial wallets, all the sensitive user data like private keys are stored on hot data storage (updated instantly) and cold data storage (updated from time to time), usually prone to hacking.
  • Offline Accessibility - Non-custodial wallets don’t need an internet connection actively. Custodial wallets need an internet connection as the data is usually stored on a centralized server.
  • Backup and Recovery - The only drawback with non-custodial wallets is that once the private key/mnemonic seed is lost, there is no way to recover the wallet. In contrast, custodial wallet users can request a third party for recovery.

Using a non-custodial node

At QuickNode, we run many nodes globally. All of these nodes are constantly connected to the internet and are dynamic. The QuickNode API is connected to a global network of powerful nodes. These nodes are not always connected to a single infrastructure component. The API is designed to perform dynamic switches between single infrastructure components to facilitate better stability and uptime. This makes storing any sensitive data on a node less than ideal as they are constantly in flux. There is also a security aspect to this as these nodes are facing the internet. We don’t allow them to store private keys for the security of our user’s data.  Because they are dynamic, they change their state often to provide better performance. This means the keys can be lost, resulting in the user’s data being lost. These were the reasons for running non-custodial nodes and having our users be the sole controller of their wallets. In the coming sections, we’ll see how to create a wallet using a library, make a non-custodial transaction, and send it using QuickNode.

Booting an Ethereum node

We could use pretty much any Ethereum client, such as Geth or OpenEthereum (fka Parity), for our purposes today. Since that is a bit too involved for sending transactions, we'll just grab a free trial endpoint from QuickNode to make this easy. We’ll use the Kovan Test Chain to make the transfers. After you've created your free trial Ethereum endpoint, copy your HTTP Provider URL:

A screenshot of the Quicknode Ethereum endpoint Getting Started page with an HTTP link and WSS
 

You'll need this later, so copy and save it.

Creating a wallet and getting some test ETH

We could use any of the many available web3 libraries to create a wallet. Today we’ll use ethers.js, a javascript library, to create a wallet that will sign and send transactions. You can also refer to our guides on creating an Ethereum wallet in Go / Python / RubyPHP.

We’ll install ethers using npm (Node Package Manager), which comes with node.js. Open your cmd/terminal and type the following to check if node.js is installed or not:

creating a wallet and getting some test eth

Copy
node -v 

This should return the installed version of node.js; if not installed, download the LTS version of node.js from its official website.

Let’s create a new directory for our project, and make that directory as our current working directory in the cmd/terminal:

creating a wallet and getting some test eth

Copy
mkdir noncusTransaction
cd noncusTransaction

Now install ethers by typing the following:

creating a wallet and getting some test eth

Copy
npm i ethers

The most common issue at this step is an internal failure with `node-gyp`. You can follow node-gyp installation instructions here.

Note: You will need to have your python version match one of the compatible versions listed in the instructions above if you encounter the node-gyp issue. 

Another common issue is a stale cache; clear your npm cache by simply typing the below into your cmd/terminal:

creating a wallet and getting some test eth

Copy
npm cache clean

If everything goes right, ethers.js will be installed on your system.

Now, open a text editor and create a new javascript file called transaction.js. Copy-paste the following into the file.

creating a wallet and getting some test eth

Copy
var ethers = require('ethers');  
var privateKey = "0x0111111111111111111122222222222222222223333333333333333333344445";
var wallet = new ethers.Wallet(privateKey);
console.log("Address: " + wallet.address);

Explanation of the code above:

Line 1: Importing the ethers library.

Line 2: Storing a private key in variable privateKey, make sure to get your own private key. You can learn how to generate one by following this guide on generating a private key using JavaScript.

Note: If you were to put your code on the internet, (such as a public github repo) then It’s always a good practice to store the private key in a .env file and import it in your main code through an environment variable. 

Line 3: Creating a new wallet address using the private key and storing it in the variable wallet.

Line 4: Printing the wallet address along with a string.

Now, save the file and run the script.

creating a wallet and getting some test eth

Copy
node transaction

It should look like this.


Now, let’s get some test ETH to send during the transaction and to pay the gas fee. Copy the address from the output, go to Kovan faucet login with GitHub or GitLab, paste the wallet address into the text field in the faucet, then click "Send me KETH!".


You can check if you received the test ETH or not by pasting the address into the Kovan Etherscan, and you will see the ETH balance.

Sending a non-custodial transaction

Let us create a token transfer transaction using the wallet we created earlier and send the transaction to the chain using QuickNode.

Update your transaction.js as following:

sending a non custodial transaction

Copy
var ethers = require('ethers');  
var url = ''ADD_YOUR_ETHEREUM_NODE_URL'';
var customHttpProvider = new ethers.providers.JsonRpcProvider(url);
var privateKey = "0x0111111111111111111122222222222222222223333333333333333333344445";
var wallet = new ethers.Wallet(privateKey);
console.log("Address: " + wallet.address);
tx = {
  to: "0x6E0d01A76C3Cf4288372a29124A26D4353EE51BE",
  value: ethers.utils.parseEther("0.05"),
  chainId: 42,
  nonce: 11
}
customHttpProvider.estimateGas(tx).then(function(estimate) {
    tx.gasLimit = estimate;
    tx.gasPrice = ethers.utils.parseUnits("3.14085197", "gwei");
    wallet.signTransaction(tx).then((signedTX)=>{
    customHttpProvider.sendTransaction(signedTX).then(console.log);
    });
});

So go ahead and replace `ADD_YOUR_ETHEREUM_NODE_URL` with the HTTP provider from the section above.

Explanation of the code above.

Line 1: Importing ethers library.

Line 2: Storing our QuickNode URL in the url variable.

Line 3: Instantiating new ethers provider and storing in variable customHttpProvider.

Line 4: Storing private key in privateKey variable (you must generate your private key).

Line 5: Creating a new wallet from the private key.

Line 6: Printing the wallet address along with a string.

Line 7-12: Initializing our transaction object, and supplying parameters like ‘to’, which has the receiver's address (any address to which the transaction is to be sent). Secondly, ‘value’ which has the value of ETH to be transferred. Thirdly, ‘chainId’ is the network id of the chain (42 here because we are using Kovan testnet). Last of all, ‘nonce’ which is the count of transactions a sender has sent. The value here should always be the number of previous transactions +1.

 We can also obtain the nonce for a given address using the getTransactionCount() method of ethers.js.

Line 13-14: Estimating gas using the provider, then storing it in the gasLimit variable of the transaction object.

Line 15: Setting gas price and storing it in gasPrice variable of transaction.

Line 16: Signing the transaction using the wallet.

Line 17: Sending the signed transaction using the provider and printing the transaction details to the console.

Save the file and run it using:

sending a non custodial transaction

Copy
node transaction

It will give an output similar to this:


Copy the transaction hash and paste it into the search bar of Kovan Etherscan to check if it got confirmed or not.

Conclusion

Congratulations on making a non-custodial transaction and being the sole controller of your funds. Never share your private key with anyone; always store it in a safe place for the better safety of your wallet and funds.

Subscribe to our newsletter for more articles and guides on Ethereum. If you have any feedback, feel free to reach out to us via Twitter. You can always chat with us on our Discord community server, featuring some of the coolest developers you’ll ever meet :)

Related articles 35

How to Set Up a Near Project from Scratch
Originally Published On: Jan 27, 2022
Updated On: Sep 9, 2022

In this tutorial we will look at... In this section, we will... In this section, we will look at... In this section, we will look at... When writing smart contracts on... In the last section, we looked... In the last section, we looked... In the last section, we looked... We have finally come to the end...

Continue reading
Estimating gas price using pending transactions in Python
Originally Published On: Feb 20, 2021
Updated On: Sep 9, 2022

To send a transaction on the... Gas is the unit to measure the... Why do we want to estimate gas?... Our first step here would be to... For our purposes today, we could... The first thing we’re going to... Now you know how to estimate gas...

Continue reading
Como crear y lanzar un ERC-721 (NFT)
Originally Published On: Dec 27, 2021
Updated On: Sep 9, 2022

Coleccionables digitales que son... Fungible significa que es lo... ERC es la abreviación para... Ahora que conocemos qué es y... Antes de escribir nuestro... Felicidades por crear tu propio...

Continue reading
How to Access Bitcoin Mempool
Originally Published On: Aug 16, 2021
Updated On: Sep 21, 2022

Bitcoin is the father of... The transactions which are sent... For our purpose today, we need a... We will use Bitcoin RPC methods... Congratulations on mastering the...

Continue reading
How to Mint an NFT on Polygon with Ethers.js
Originally Published On: Mar 28, 2022
Updated On: Sep 9, 2022

This guide demonstrates how to... Ethers.js is a complete Ethereum... As a reminder, the act of... We will deploy our contract on... Time to write the code! Start by... Note, you will need some... That’s it! You have minted an...

Continue reading
How to access Ethereum Mempool
Originally Published On: Oct 15, 2020
Updated On: Sep 15, 2022

On Ethereum, when a transaction... In blockchain terminology, a... For the purpose of this guide,... First, query the Let’s examine how to subscribe... This short guide showed you how...

Continue reading
The Web3 Developer Stack
Originally Published On: Jul 3, 2021
Updated On: Sep 15, 2022

A developer stack is a bag of... If we can imagine web3 as a car... The Chainlink price feed... Head over to the We’ll need a Kovan node to... We’ll now write a short... Congratulations :D You’ve taken...

Continue reading
How to Mint NFTs on the Stacks Blockchain
Originally Published On: Aug 19, 2022
Updated On: Sep 9, 2022

Stacks is an emerging blockchain... The Stacks ecosystem has adopted... Open up a terminal window and... Implementing the SIP-009... This section will demonstrate... The moment you've been waiting... Awesome Work! You’ve learned how...

Continue reading
Introduction to Scaffold-ETH 🏗
Originally Published On: Oct 7, 2021
Updated On: Sep 9, 2022

Developing applications involves... First of all, before getting... Scaffold-ETH comes with a demo... We will set up a QuickNode... Congratulations, and thank you...

Continue reading
How to connect to Ethereum using PHP
Originally Published On: Jun 11, 2021
Updated On: Sep 9, 2022

PHP is a very popular choice... Before installing the web3.php,... We could use pretty much any... Now, make a PHP script file... Congratulations on connecting to...

Continue reading
How to use Subspace with QuickNode
Originally Published On: Sep 8, 2020
Updated On: Sep 9, 2022

In this guide, we'll understand... To install Subspace, we'll need... For our purposes today, we could... Now let's create a short script,... Run the file using the node...

Continue reading
How to Connect Your Dapp With MetaMask Using Ethers.js
Originally Published On: Dec 13, 2021
Updated On: Sep 9, 2022

In our dApp, we will have a... A dApp is an application that... We will need to install the... Ethers.js is a lightweight... With this application, we will... Next, we will create a function... After connecting to MetaMask, we... To handle the wallet address of... This section will show us how to... In this tutorial, we...

Continue reading
How to Lazy Mint an NFT on Rarible with Rarepress
Originally Published On: Feb 23, 2022
Updated On: Sep 9, 2022

NFTs are great for creators to... To mint an NFT, you write data... Lazy Minting is a process in... We will write some JavaScript... Rarepress interacts with the... Now that we have everything in... Congratulations on listing your...

Continue reading
How to get the balance of an ERC-20 token
Originally Published On: Jun 14, 2021
Updated On: Sep 21, 2022

When a new token is made on the... You could use any Ethereum... Now that you've done the legwork... Getting the ERC20-Token Balance... In the top of your... ABI is short for You will most likely interact... You can use a similar process... We now have a connection to an... Having made it to the end, you...

Continue reading