1. Introduction
Interaction with blockchain paves the way for developers aiming to leverage blockchain technology. It helps you build decentralized apps, execute smart contracts, and integrate blockchain functionalities. This article provides you, with all the prerequisites and steps needed to set up a suitable environment, perform operations, and develop better solutions and applications in blockchain. So are you ready?
2. Setting Up the Environment
While configuring your environment, it’s essential to choose the right tools according to your interests and requirements.
- Node Connection:
Node connection as the name refers is connecting the node in the network. This node is a gateway to the access of blockchain data and services.
Most of the blockchain nodes provide Remote Procedure Call (RPC) and WebSocket endpoints. Where RPC is mostly used in synchronous requests and Websocket is used in real-time data and event description.
3. Establishing Connections
- Libraries and Tools:
There are various libraries available for establishing connections most of them are based on the two most popular programming languages Python and JavaScript.
JavaScript libraries are Web3.js and ethers.js mostly used for interaction with Ethereum nodes. Web3.py is the equivalent of web3.js in Python which is also used for Ethereum node interactions.
Also, some other libraries are Go-Ethereum based on Golang, and Nethereum based on C#.
Further, for other programming languages, you can check the documentation of various languages and their libraries for configuration.
- API Integration:
Using APIs and libraries to interact with external networks simplifies the interaction. Some popular APIs are Infura which provides scalable infrastructure, Alchemy used for Ethereum development.Infura Infura offers robust infrastructure to link up with the Ethereum network. Infura makes it easy to connect to Ethereum providing dependable and expandable API services. Some other APIs are Quicknode, Moralis, and Cloudflare’s Ethereum gateway.
There are various APIs available but the setup process has the same generic steps as follows:
- Creating an account
- Generating the API key
- Use the generated key to configure your connection.
4. Querying the Blockchain
Querying in blockchain is similar to querying any other database for time-series data. You can request data access to retrieve it and read it.
- Reading Data:
You can get different kinds of information from the blockchain, like block details, transaction data, and account balances. The libraries we talked about before have functions to do read operations. For example, Web3.js has methods such as web3.eth.getBlock() and web3.eth.getTransaction().
- Event Listening:
Blockchain networks create events for specific actions. Setting up listeners lets you respond to these events as they occur in real time. Use WebSocket connections or polling to keep up with the newest events and data and this is a type of handling the data.
5. Writing to the Blockchain
Putting data on a blockchain requires you to create and sign transactions, and work with smart contracts. This section will show you how to do these things using well-known libraries.
- Creating Transactions:
Building and signing transactions:
Javascript(Web3.js)
const account = web3.eth.accounts.privateKeyToAccount(‘YOUR_PRIVATE_KEY’);
web3.eth.accounts.wallet.add(account);
web3.eth.defaultAccount = account.address;
const tx = {
from: account.address,
to: ‘RECIPIENT_ADDRESS’,
value: web3.utils.toWei(‘0.1’, ‘ether’),
gas: 21000,
};
web3.eth.sendTransaction(tx)
.on(‘receipt’, console.log)
.on(‘error’, console.error);
Using Web3.py(Python code)
web3 = Web3(Web3.HTTPProvider(‘https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID’))
account = web3.eth.account.privateKeyToAccount(‘YOUR_PRIVATE_KEY’)
tx = { ‘from’: account.address, ‘to’: ‘RECIPIENT_ADDRESS’, ‘value’: web3.toWei(0.1, ‘ether’), ‘gas’: 21000, ‘nonce’: web3.eth.getTransactionCount(account.address),
}
signed_tx = account.signTransaction(tx)tx_hash = web3.eth.sendRawTransaction(signed_tx.rawTransaction)receipt = web3.eth.waitForTransactionReceipt(tx_hash)print(receipt)
Now once you have written the transaction it is sent to the blockchain network for validation and getting included in the block.
web3.eth.sendSignedTransaction(signedTx.rawTransaction)
.on(‘receipt’, console.log)
.on(‘error’, console.error);
tx_hash = web3.eth.sendRawTransaction(signed_tx.rawTransaction)receipt = web3.eth.waitForTransactionReceipt(tx_hash)print(receipt)
- Smart Contract Interaction:
Dealing with smart contracts that are already up and running means you need to use certain functions to read and change the contract’s saved information(state variables). This back-and-forth lets you tap into everything the smart contract can do making it possible to create complex features in your dApps (decentralized applications).
Interacting with smart contracts:
const Web3 = require(‘web3’);const web3 = new Web3(‘https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID’);
Reading from the smart contract:
const contractABI = [/ABI array */];const contractAddress = ‘YOUR_CONTRACT_ADDRESS’;const contract = new web3.eth.Contract(contractABI, contractAddress);
Calling a function:
contract.methods.getBalance(‘0xYourAccountAddress’).call()
.then(balance => {
console.log(‘Balance:’, balance);
})
.catch(error => {
console.error(‘Error:’, error);
});
Writing:
const account = web3.eth.accounts.privateKeyToAccount(‘YOUR_PRIVATE_KEY’);
web3.eth.accounts.wallet.add(account);
web3.eth.defaultAccount = account.address;
const data = contract.methods.transfer(‘0xRecipientAddress’, web3.utils.toWei(‘1’, ‘ether’)).encodeABI();
const tx = {
from: account.address,
to: contractAddress,
gas: 2000000,
data: data,
};
web3.eth.sendTransaction(tx)
.on(‘receipt’, receipt => {
console.log(‘Transaction receipt:’, receipt);
})
.on(‘error’, error => {
console.error(‘Error:’, error);
});
6. Handling Responses
Handling responses from blockchain interactions the right way is key to creating dependable and easy-to-use apps. This means getting a grip on transaction receipts and figuring out how to parse logs and events that smart contracts generate.
- Transaction Receipts:
Post every transaction a receipt is generated which contains information such as:
- Transaction hash: It is a unique identification code
- Status: Gives the status of transactions as 0 or 1
- Block Number: The block in which the transaction was included
- Gas Used: The amount of gas utilized for the transaction
- Logs: The logs generated by transaction for parsing the ev