When interacting with the peaq network, managing gas limits allows you to maintain predictable transaction costs, and safeguard against unexpected gas spikes. By explicitly setting a gas limit, you prevent overspending, if the network suddenly requires more gas than anticipated. Libraries like ethers.js, web3.js, etc. make it straightforward to configure this behavior. For the purpose of demonstration we’ll be using ethers.js.

​
Prerequisites

  • You understand basic concepts of EVM-like networks: transactions, gas, and gas pricing.
  • You have Node.js and ethers.js installed.
  • You have access to a funded account and the peaq RPC endpoint.
  • You know how to manage sensitive information using environment variables (e.g., .env files).

​
Instructions

​
1. Setting Up the Environment

  • Install Dependencies: Ensure you install the necessary packages:
npm install ethers dotenv
  • Set ESM Module: Add the following to your package.json to alllow for ESM modules.
"type": "module",
  • Configure Environment Variables: Create a .env file with the following content:
PRIVATE_KEY=0xYOUR_PRIVATE_KEY
PEAQ_RPC_URL=https://peaq.api.onfinality.io/public

Make sure your .env file is listed in .gitignore so it’s not checked into version control.

​
2. Setting up the Provider and Wallet

Create a sendTransaction.js file (for example) and load the environment variables using dotenv. Initialize the provider with the peaq RPC endpoint and load the wallet from the environment variable.

//sendTransaction.js

import dotenv from 'dotenv';
dotenv.config();
import { ethers } from 'ethers';

// Use environment variables from .env
const provider = new ethers.providers.JsonRpcProvider(process.env.PEAQ_RPC_URL);
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);

​
3. Deciding on a Gas Limit

Choose a suitable gas limit. Start with a safe upper bound, and adjust later as needed.

const gasLimit = 200000; // Example: Adjust as needed based on your transaction's complexity

​
4. Crafting the Transaction

Include the gasLimit in the transaction object. This ensures the transaction will revert if it exceeds the specified gas, protecting you from unexpected costs.

const tx = {
    to: '0xRECEIVER_ADDRESS', // Replace with the address you want to send to
    value: ethers.utils.parseEther('0.01'), // Example amount to send
    gasLimit: gasLimit
};

​
6. Sending the Transaction

Send the transaction and wait for it to be mined. If the transaction fails due to exceeding gas, you’ll catch the error in the try/catch block.

async function sendTransaction() {
    try {
        const response = await wallet.sendTransaction(tx);
        console.log('Transaction hash:', response.hash);

        const receipt = await response.wait();
        console.log('Transaction confirmed in block:', receipt.blockNumber);
    } catch (error) {
        // Failure could be due to insufficient gasLimit
        console.error('Transaction failed:', error);
    }
}

sendTransaction();

​
7. Adjusting Gas Limits Over Time

  • If your transaction often runs out of gas, consider raising the limit.
  • If you’re consistently using less gas than your limit, you might lower it to be more cost-effective.
  • For automated scripts or systems that regularly send transactions, predefining a gas limit helps protect against sudden gas spikes.
  • Consider a dynamic approach like Estimating Gas Fees in your calculation of a gas limit to prevent failed transactions.

​
Summary

By incorporating environment variables, you keep sensitive data secure and easily manage configurations for different environments. Using the ethers.js library, explicitly setting a gas limit gives you fine-grained control over your transaction costs on the peaq network. With a carefully chosen gas limit, you can execute transactions confidently, knowing you’re safeguarded against unexpected fee changes.