Ashutosh Modanwal (Backend-Associate Consultant - Development)

Introduction to Solana Transactions

Solana is a high-performance blockchain that supports smart contracts and blockchain app development or dApps development. One of the cornerstones of Solana's efficiency is its parallel processing of transactions via the Proof of History (PoH) approach combined with the Tower BFT consensus.

Key aspects of Solana transactions:

• A Solana transaction can contain one or more instructions.
• Each instruction targets a specific program (smart contract) on Solana.
• Transactions need to be signed by the relevant authority (or authorities).

• Solana has a limit on the overall size of the transaction (including signatures, account addresses, instruction data, etc.).

   

  Also, Read | Building a Solana NFT Rarity Ranking Tool

   

What Are Batch Transactions?

Batch Transactions in the context of Solana refer to creating a single transaction that includes multiple instructions. By bundling several instructions or even sub-transactions together into one “batch,” you can reduce overhead, save on network fees, and ensure atomicity for related operations.

• Instead of sending multiple separate transactions (each costing a network fee), you send one transaction that encapsulates all the instructions you need.
• If one of the instructions fails, the entire transaction fails, ensuring atomic behavior (all or nothing).
• Batching reduces the round trips to the cluster, which helps speed up execution in certain use cases.

Why Batch Transactions Matter

• Efficiency: Batching can reduce the overhead cost (in fees) and network usage by combining multiple actions into a single transaction.
• Atomicity: Ensures that either all actions succeed or none of them are applied.
• Speed: Fewer network requests can mean faster end-to-end confirmations from a client perspective.

• Simplified Workflow: Dealing with a single transaction instead of multiple transactions can simplify the logic in your dApp or backend.

   

  Also, Check | Building a Cross-Chain NFT Bridge using Solana Wormhole

   

Key Concepts in Solana Transaction Batching

Instructions

An instruction specifies which on-chain program to invoke, which accounts to pass to that program, and what data the program should receive. A transaction can hold multiple instructions.

Accounts

Solana programs require accounts to store both code (the program itself) and data (the state used by the program). For a batch transaction, you must ensure all required accounts are included in the transaction for each instruction.

Signers

Each transaction must be signed by the account(s) that have the authority for the instructions included.

• If multiple instructions require different signers (e.g., multi-signature scenarios), you need to collect all the signatures before sending the transaction.

   

Transaction Size and Limitations

Solana transactions have size limits (currently around 1232 bytes). While you can include multiple instructions, you must keep the total size under this limit.

Atomicity

If one instruction in the batch fails, the entire transaction is rolled back. This is beneficial for many use-cases where partial execution doesn't make sense (e.g., token swaps, multi-step state changes).

Also, Discover | Build a Crypto Payment Gateway Using Solana Pay and React

Constructing Batch Transactions: Step-by-Step

Initialize a Transaction Object

Using Solana's client libraries (e.g., @solana/web3.js in JavaScript/TypeScript), you start with creating a Transaction instance.

Create Instructions

• For each action you want to perform, build the instruction using the relevant program's client library.
• Each instruction specifies the program ID, relevant accounts, and instruction data.

Add Instructions to the Transaction

• Once you have your instructions, add them sequentially to the Transaction.

Specify Signers

• Collect all signers (wallets or keypairs) whose signatures are required.
• This step might involve multiple Keypairs if the instructions require them.

Send and Confirm

• Use a connection to a Solana cluster (mainnet-beta, devnet, or testnet).
• Sign and send the transaction using sendAndConfirmTransaction or similar methods.
• Wait for confirmation.

Examples (JavaScript/TypeScript)

Below is a simplified TypeScript example that demonstrates a batch transaction using the @solana/web3.js library. We'll show two hypothetical instructions:

• Transfer some SOL to another wallet.
• Invoke a program to update some data in an account.

Prerequisites

Install the Solana web3 library (if not already installed):

npm install @solana/web3.js

Make sure you have a funded Keypair in your local environment or a connected wallet for the signer.

Example: Batching Two Instructions

import {
  Connection,
  PublicKey,
  Keypair,
  SystemProgram,
  Transaction,
  sendAndConfirmTransaction,
  LAMPORTS_PER_SOL
} from "@solana/web3.js";

// For demonstration, we generate a new keypair (in practice, use your own)
const payer = Keypair.generate(); 
const recipient = Keypair.generate(); 

(async () => {
  // 1. Establish a connection to the cluster
  const connection = new Connection("https://api.devnet.solana.com", "confirmed");

  // Airdrop to the payer so it has some SOL to pay for fees and transfers
  // This step is only for Devnet usage. On Mainnet you have to purchase or receive SOL.
  const airdropSignature = await connection.requestAirdrop(
    payer.publicKey,
    2 * LAMPORTS_PER_SOL  // 2 SOL
  );
  await connection.confirmTransaction(airdropSignature);

  // 2. Create a Transaction
  let transaction = new Transaction();

  // 3. Build Instruction #1: Transfer some SOL to another account
  const transferInstruction = SystemProgram.transfer({
    fromPubkey: payer.publicKey,
    toPubkey: recipient.publicKey,
    lamports: 0.5 * LAMPORTS_PER_SOL, // transferring 0.5 SOL
  });

  // 4. Build Instruction #2: Example of calling a program (SystemProgram as placeholder)
  //    Here, we'll do a transfer of 0.1 SOL to the same account, 
  //    just to demonstrate multiple instructions in one transaction.
  const anotherTransferInstruction = SystemProgram.transfer({
    fromPubkey: payer.publicKey,
    toPubkey: recipient.publicKey,
    lamports: 0.1 * LAMPORTS_PER_SOL,
  });

  // 5. Add both instructions to the transaction
  transaction.add(transferInstruction).add(anotherTransferInstruction);

  // 6. Send and confirm the transaction
  try {
    const txSignature = await sendAndConfirmTransaction(
      connection,
      transaction,
      [payer] // List all signers here
    );
    console.log("Transaction Signature: ", txSignature);
  } catch (error) {
    console.error("Error sending batch transaction:", error);
  }
})();

Explanation:

1. We create two instructions, both from SystemProgram.transfer.
2. We add both instructions to a Transaction.
3. We sign the transaction using the payer Keypair and send it.
4. The result is a single transaction that executes two SOL transfers.

Advanced Example: Program Instruction

If you wanted to call a custom program (e.g., an Anchor-based program), you would construct the instruction using that program's IDL (Interface Definition Language) and client code, then add it the same way.

Also, Check | How to Create a Multi-Signature Wallet on Solana using Rust

Practical Use Cases

• Token Swaps: In a decentralized exchange (DEX), you might want to swap tokens and update user balances in a single atomic transaction.
• NFT Minting and Transfer: Minting an NFT and transferring it to a user's wallet within one batch can simplify user flows.
• Protocol Interactions: Complex DeFi protocols might require multiple steps (e.g., deposit, borrow, stake) which can be done in a single transaction for a better user experience.

• Multi-Signature Wallet Operations: Combine multiple approvals or instructions into one transaction for clarity and atomicity.

   

Best Practices and Considerations

• Transaction Size: Always watch out for the maximum transaction size limit (~1232 bytes). The more instructions (and signers) you add, the bigger the transaction.
• Parallel Execution: Solana can process many transactions in parallel, but if your instructions require modifying the same accounts, they won't be processed in parallel. Keep account locking in mind.
• Error Handling: If any instruction fails, the entire transaction fails. Make sure all instructions are valid before sending.
• Signers vs. Non-Signers: Only include signers who are absolutely necessary to reduce overhead.

• Testing on Devnet: Always test your batched transactions on Devnet or a local test validator to ensure correctness and gather performance metrics.

   

Potential Pitfalls

• Unexpected Atomic Rollback: If part of your multi-instruction logic has a potential to fail (like insufficient funds), the entire transaction will fail.
• Too Many Instructions: You can exceed the transaction size limit quickly if you're not careful.
• Account Locking: Batching instructions that modify the same account multiple times can lead to locking conflicts.

• Exceeding Compute Budget: Complex or heavy instruction logic might exceed the default compute budget for a single transaction.

   

  You may also like to explore | Integrate Raydium Swap Functionality on a Solana Program

   

Conclusion

Batch transactions in Solana are a powerful feature that can improve efficiency, reduce fees, and ensure atomic operations. By combining multiple instructions into a single transaction, dApp developers can streamline user workflows and create more robust decentralized applications. However, it's crucial to plan carefully, manage transaction size, handle signers correctly, and consider the atomic nature of the batch.

When used correctly, batch transactions can greatly enhance the user experience and reliability of your Solana-based applications. If you are planning to build and launch your project leveraging the potential of Solana, connect with our skilled blockchain developers to get started, 

Blockchain technology relies on consensus algorithms to validate transactions and maintain network integrity. While public blockchains use popular algorithms like Proof of Work (PoW) or Proof of Stake (PoS), private blockchains often require a custom consensus mechanism tailored to their specific needs. In this blog, we'll explore how to build a custom consensus algorithm for a private blockchain, ensuring it's secure, efficient, and meets your business requirements. For more about blockchain, visit our blockchain development services. 

What is a Consensus Algorithm?

A consensus algorithm is a mechanism that allows all participants in a blockchain network to agree on the state of the ledger. This agreement ensures that the data in the blockchain is accurate and prevents fraudulent transactions or data tampering.

Why Build a Custom Consensus Algorithm for a Private Blockchain?

Control: Private blockchains are often used by organizations that want control over who can participate in the network.

Efficiency: Custom algorithms can be designed to be more efficient for smaller networks, reducing transaction confirmation times.

Security: Tailored algorithms provide an extra layer of security by addressing specific threats relevant to the private blockchain environment.

Also, Check | How to Create Your Own Private Blockchain using Cosmos

Choosing a Suitable Consensus Algorithm

Before we start building, let's briefly discuss different consensus algorithms that can inspire your custom model:

Proof of Authority (PoA): 

Only trusted nodes can validate transactions, suitable for private networks with a small number of participants.

Raft Consensus:

A leader-based approach where one node is elected as the leader to manage transactions.

Practical Byzantine Fault Tolerance (PBFT): 

Handles faulty nodes and works efficiently in networks with up to one-third of malicious participants.

Also, Explore | How to Utilize Rollup-as-a-Service for Maximum Efficiency

Step-by-Step Guide to Building the Custom Consensus Algorithm

Step 1: Define the Blockchain Structure

Block Class
class Block {
 constructor(index, timestamp, data, previousHash = '') {
   this.index = index; // Position of the block in the chain
   this.timestamp = timestamp; // The time when this block was created
   this.data = data; // Information to be stored in the block (e.g., transactions)
   this.previousHash = previousHash; // Hash of the previous block in the chain
   this.hash = this.calculateHash(); // Unique identifier generated for this block
   this.validator = null; // The validator node that approves this block
 }
delves
 calculateHash() {
   return CryptoJS.SHA256(
     this.index + this.timestamp + JSON.stringify(this.data) + this.previousHash
   ).toString();
 }
}

Detailed Breakdown:

Each block has an index, timestamp, data, previousHash, hash, and validator. The calculateHash() function combines the block's properties and generates a unique hash using the SHA-256 algorithm. This hash ensures that even a small change in the block's data will result in a completely different hash, making the blockchain tamper-resistant.

Key Point: In blockchain, the hash acts like a digital fingerprint for each block. It's crucial because it ensures that data within the block hasn't been altered.

Also, Read | How ShadCN is better than AndD

Blockchain Class
class Blockchain {
 constructor() {
   this.chain = [this.createGenesisBlock()]; // Initialize the blockchain with the first block
   this.validators = ['Node1', 'Node2', 'Node3']; // Nodes authorized to validate new blocks
 }
 createGenesisBlock() {
   return new Block(0, '01/01/2024', 'Genesis Block', '0'); // First block with no previous hash
 }
 getLatestBlock() {
   return this.chain[this.chain.length - 1]; // Fetch the last block added to the chain
 }
 addBlock(newBlock) {
   newBlock.previousHash = this.getLatestBlock().hash; // Connect the new block to the previous one
   newBlock.hash = newBlock.calculateHash(); // Calculate the hash based on the new block's data
   // Apply the consensus mechanism
   newBlock.validator = this.selectValidator();
   if (this.isBlockValid(newBlock)) {
     this.chain.push(newBlock); // Add the block to the chain if valid
     console.log(`Block approved by: ${newBlock.validator}`);
   } else {
     console.log('Block rejected');
   }
 }
 isBlockValid(block) {
   // Ensure the selected validator is authorized
   return this.validators.includes(block.validator);
 }
 selectValidator() {
   // Randomly choose a validator to approve the block
   const selectedValidator = this.validators[Math.floor(Math.random() * this.validators.length)];
   return selectedValidator;
 }
 isChainValid() {
   for (let i = 1; i < this.chain.length; i++) {
     const currentBlock = this.chain[i];
     const previousBlock = this.chain[i - 1];
     // Check the integrity of the block
     if (currentBlock.hash !== currentBlock.calculateHash()) return false;
     // Verify the chain linkage
     if (currentBlock.previousHash !== previousBlock.hash) return false;
   }
   return true;
 }
}

Genesis Block:

The genesis block is the first block in the blockchain. It's created with index = 0 and has a previousHash of '0' because it doesn't have any predecessor.

addBlock(newBlock):

The addBlock function adds a new block to the blockchain, ensuring the chain's integrity by setting previousHash to the hash of the latest block.The selectValidator function randomly picks a validator node to approve the block. If approved by an authorized validator, the block is added to the blockchain.

selectValidator():

The selectValidator function represents the core of our Proof of Authority (PoA) consensus mechanism. Here, validators are chosen at random, but you can enhance this logic based on factors like node reputation or stake.

isChainValid():

This function verifies the integrity of the entire blockchain. It ensures that each block's hash matches the recalculated hash using calculateHash() and that previousHash correctly links to the preceding block.

Important Concept: The blockchain maintains its integrity through these hashes. Any change to a block's data would alter its hash, breaking the chain's continuity and making tampering evident.

You may also like | How to Swap Tokens on Uniswap V3

Step 2: Testing the Blockchain

Let's test our custom blockchain:

let myBlockchain = new Blockchain();
myBlockchain.addBlock(new Block(1, '02/01/2024', { amount: 100 }));
myBlockchain.addBlock(new Block(2, '03/01/2024', { amount: 200 }));
console.log(JSON.stringify(myBlockchain, null, 4));
console.log('Is blockchain valid? ' + myBlockchain.isChainValid());

Explanation:

We create an instance of Blockchain and add two blocks with transaction data { amount: 100 } and { amount: 200 }.

Finally, we print the entire blockchain to see its structure and check its validity using isChainValid().

Also, Discover | How to Develop a Layer 1 Blockchain

Enhancing the Consensus Mechanism: Voting

The basic algorithm randomly selects a validator to approve a block. For more security, we introduced a voting mechanism where multiple validators decide.

Voting Mechanism Example
 

addBlock(newBlock) {
 newBlock.previousHash = this.getLatestBlock().hash;
 newBlock.hash = newBlock.calculateHash();
 let approvalCount = 0;
 // Simulate voting by validators
 this.validators.forEach(validator => {
   if (Math.random() > 0.4) {
     console.log(`${validator} approved the block`);
     approvalCount++;
   } else {
     console.log(`${validator} rejected the block`);
   }
 });
 if (approvalCount >= 2) {
   this.chain.push(newBlock);
   console.log(`Block approved with ${approvalCount} votes`);
 } else {
   console.log('Block rejected');
 }
}

Detailed Explanation:

The block requires approval from at least 2 out of 3 validators. For each validator, there's a 60% chance of approving the block (Math.random() > 0.4). This mechanism ensures that no single validator can make decisions, providing greater security and trust.

 Also, Read | How to Access Private Data in Smart Contracts

Real-World Significance

Private Network: In a corporate setting, this custom algorithm ensures that only authorized participants can validate transactions.

Security: By implementing a voting mechanism, you reduce the risk of fraudulent activities, as multiple validators must approve each transaction.

Scalability: Custom algorithms are optimised for small, private networks, reducing transaction confirmation times compared to public blockchains.

Also, Check | How to Fork Ethereum with Hardhat

Conclusion

This detailed explanation covers how to create a custom consensus algorithm tailored to a private blockchain using concepts from the Proof of Authority (PoA) and introduces voting mechanisms. By understanding how validators are selected, how blocks are validated, and how consensus is achieved, you now have a solid foundation for implementing custom blockchain solutions.

You can expand this model into a more robust solution by implementing advanced features like reputation tracking, penalty mechanisms for dishonest nodes, or integrating cryptographic signatures for additional security.

By experimenting with this code, you'll gain practical experience and develop a deeper understanding of consensus algorithms, preparing you for more advanced blockchain projects. Feel free to modify and experiment with the code to match your specific requirements!

Key Takeaways

Understand your network's needs: Tailor your algorithm for efficiency, security, and control.

Customize validation logic: Implement mechanisms like voting or reputation to enhance the consensus process.

Experiment and iterate: Continuously test and refine your algorithm to achieve optimal performance.

This blog should help you understand how to build a custom consensus algorithm and implement it in a private blockchain. Feel free to modify and enhance the code to suit your specific requirements. In case if you are looking for blockchain development services, connect with our skilled blockchain developers to get started.