![I work for a school system who is making us get overtime approved the day before [closed]](https://cdn.sstatic.net/Sites/workplace/Img/apple-touch-icon@2.png?v=d39b333f5c58)
Advanced Developer Tutorial on Address Lookup Tables
Since the early times when data begun to be used to compute values, there has always been a need to store complex data in such a way that they would always be easy to access. In ancient times this was accomplished with sine tables and a 98-column multiplication, advances in computing technology has impacted the way data is stored and retrieved. In the early years of computer technology, processing input/output was particularly slow and would consume more resource and time. To solve this problem, it made sense to reduce significantly the process of reading operations and operations data. A very efficient method that was introduced to solve this problem was Caching (which involves storing data so that it can be available for future request at faster speeds due to an earlier computation of the data stored elsewhere). However, while systemwide Caching tries to automate the process of fetching commonly occurring data items, to enable a much faster mechanism for obtaining data items that possess a sort of immutability, lookup tables were introduced. What is a Lookup Table As if defined in computer science, 1 a lookup table(LUT) is an array that replaces runtime computation with a simpler array indexing operation. This process of utilizing array indexing to compute the running phase of a program is also known as direct addressing. It is much faster and less expensive since data is retrieved from memory using indexes as reference compared to the processing input/output approach. The tables may be pre-calculated and stored in static program storage, calculated (or "pre-fetched") as part of a program's initialization phase, or even stored in hardware in application-specific platforms. A lookup table is more efficient in terms of lookup operation and has a guaranteed O(1) time complexity. However, it is not possible for two entities to have the same lookup key k, and as the size of the datasets grow increasingly larger, in the magnitude of considering all forms of allottable data, it becomes less practical to stored a LUT in memory. Address Lookup Table (ALTs) As defined on the Solana documentation, 2 An address Lookup Tables, commonly referred to as "lookup tables" or "ALTs" for short, allow developers to create a collection of related addresses to efficiently load more addresses in a single transaction. Since each transaction on the Solana blockchain requires a listing of every address that is interacted with as part of the transaction; without ALTs, this listing would effectively be capped at 32 addresses per transaction, but with ALTs, it would be effectively raise the addresses per transaction to 256 ALTs are part of additional functionalities that were introduced in the versioned transaction format which is quite similar to the legacy transaction format with just slight differences in libraries used. How to Create An Address Lookup Table(ALTs) This tutorial is going to show you how you can implement ALTs on your projects and help you see the benefits and advantages they offer. What We Will Implement in This Tutorial In this Tutorial, we will: Create and execute a Version 0 (V0) Transaction Create and Populate an Address Lookup Table Compare the transaction size of two nearly identical transactions where one would implement a lookup table and the other would not Perquisites: Node.js Intermediate Experience with Typescript/JavaScript ts-node basic or solid experience in running Solana transactions all necessary imports including classes from Solana Web3 library create a wallet and fund it with some devnet SOL set up API endpoint to connect with the Solana network Your setup Environment should look similar to this: Steps to Creating ALTs Executing Versioned Transaction V(0) To use Lookup Tables, you must execute a versioned transactions. We can do this by Let's start by creating a new function, createAndSendV0Tx, that accepts an array of TransactionInstructions, txInstructions: async function createAndSendV0Tx(txInstructions: TransactionInstruction[]) { // Step 1 - Fetch Latest Blockhash let latestBlockhash =await SOLANA_CONNECTION.getLatestBlockhash('finalized'); console.log(" ✅ - Fetched latest blockhash. Last valid height:", latestBlockhash.lastValidBlockHeight) ; // Step 2 - Generate Transaction Message const messageV0 = new TransactionMessage({ payerKey: SIGNER_WALLET.publicKey, recentBlockhash: latestBlockhash.blockhash, instructions: txInstructions }).compileToV0Message(); console.log(" ✅ - Compiled transaction message"); const transaction = new VersionedTransaction(messageV0); // Step 3 - Sign your transaction with the required `Signers` transaction.sign([SIGNER_WALLET]); console.log(" ✅ - Transaction Signed"); // Step 4 - Send our v0 transaction to the cluster const txid = await SOLANA_CONNECTION.sendTransaction(transaction, { maxRetries: 5 }); console.log(" ✅ - Transaction sent to network"
Since the early times when data begun to be used to compute values, there has always been a need to store complex data in such a way that they would always be easy to access. In ancient times this was accomplished with sine tables and a 98-column multiplication, advances in computing technology has impacted the way data is stored and retrieved.
In the early years of computer technology, processing input/output was particularly slow and would consume more resource and time. To solve this problem, it made sense to reduce significantly the process of reading operations and operations data. A very efficient method that was introduced to solve this problem was Caching (which involves storing data so that it can be available for future request at faster speeds due to an earlier computation of the data stored elsewhere).
However, while systemwide Caching tries to automate the process of fetching commonly occurring data items, to enable a much faster mechanism for obtaining data items that possess a sort of immutability, lookup tables were introduced.
What is a Lookup Table
As if defined in computer science, 1
a lookup table(LUT) is an array that replaces runtime computation with a simpler array indexing operation. This process of utilizing array indexing to compute the running phase of a program is also known as direct addressing. It is much faster and less expensive since data is retrieved from memory using indexes as reference compared to the processing input/output approach. The tables may be pre-calculated and stored in static program storage, calculated (or "pre-fetched") as part of a program's initialization phase, or even stored in hardware in application-specific platforms.
A lookup table is more efficient in terms of lookup operation and has a guaranteed O(1) time complexity. However, it is not possible for two entities to have the same lookup key k, and as the size of the datasets grow increasingly larger, in the magnitude of considering all forms of allottable data, it becomes less practical to stored a LUT in memory.
Address Lookup Table (ALTs)
As defined on the Solana documentation, 2
An address Lookup Tables, commonly referred to as "lookup tables" or "ALTs" for short, allow developers to create a collection of related addresses to efficiently load more addresses in a single transaction. Since each transaction on the Solana blockchain requires a listing of every address that is interacted with as part of the transaction; without ALTs, this listing would effectively be capped at 32 addresses per transaction, but with ALTs, it would be effectively raise the addresses per transaction to 256
ALTs are part of additional functionalities that were introduced in the versioned transaction format which is quite similar to the legacy transaction format with just slight differences in libraries used.
How to Create An Address Lookup Table(ALTs)
This tutorial is going to show you how you can implement ALTs on your projects and help you see the benefits and advantages they offer.
What We Will Implement in This Tutorial
In this Tutorial, we will:
Create and execute a Version 0 (V0) Transaction
Create and Populate an Address Lookup Table
Compare the transaction size of two nearly identical transactions where one would implement a lookup table and the other would not
Perquisites:
Your setup Environment should look similar to this:
Steps to Creating ALTs
Executing Versioned Transaction V(0)
To use Lookup Tables, you must execute a versioned transactions.
We can do this by Let's start by creating a new function, createAndSendV0Tx, that accepts an array of TransactionInstructions, txInstructions:
async function createAndSendV0Tx(txInstructions: TransactionInstruction[]) {
// Step 1 - Fetch Latest Blockhash
let latestBlockhash =await SOLANA_CONNECTION.getLatestBlockhash('finalized'); console.log(" ✅ - Fetched latest blockhash. Last valid height:", latestBlockhash.lastValidBlockHeight)
;
// Step 2 - Generate Transaction Message
const messageV0 = new TransactionMessage({ payerKey: SIGNER_WALLET.publicKey, recentBlockhash: latestBlockhash.blockhash, instructions: txInstructions }).compileToV0Message(); console.log(" ✅ - Compiled transaction message");
const transaction = new VersionedTransaction(messageV0);
// Step 3 - Sign your transaction with the required `Signers` transaction.sign([SIGNER_WALLET]); console.log(" ✅ - Transaction Signed"); // Step 4 - Send our v0 transaction to the cluster const txid = await SOLANA_CONNECTION.sendTransaction(transaction, { maxRetries: 5 }); console.log(" ✅ - Transaction sent to network");
// Step 5 - Confirm Transaction
const confirmation = await SOLANA_CONNECTION.confirmTransaction({signature: txid, blockhash: latestBlockhash.blockhash, lastValidBlockHeight: latestBlockhash.lastValidBlockHeight }); if (confirmation.value.err) { throw new Error(" ❌ - Transaction not confirmed.") } console.log(' 
