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, this listing would be effectively be capped at 32 address per transaction. With the help of Address Lookup Tables, a transaction would be now be able to raise that limit to 256 addresses per transaction.
After all the desired address have been stored on chain in an Address Lookup Table, each address can be referenced inside a transaction by its 1-byte index within the table (instead of their full 32-byte address). This lookup method effectively "compresses" a 32-byte address into a 1-byte index value.
This "compression" enables storing up to 256 address in a single lookup table for use inside any given transaction.
To utilize an Address Lookup Table inside a transaction, developers must use v0 transactions that were introduced with the new Versioned Transaction format.
Creating a new lookup table with the
@solana/web3.js library is similar to the older
legacy transactions, but with some differences.
@solana/web3.js library, you can use the
createLookupTable function to construct the instruction needed to create a new lookup table, as well as determine its address:
NOTE: Address lookup tables can be created with either a
v0transaction or a
legacytransaction. But the Solana runtime can only retrieve and handle the additional addresses within a lookup table while using v0 Versioned Transactions.
Adding addresses to a lookup table is known as "extending". Using the the
@solana/web3.js library, you can create a new extend instruction using the
NOTE: Due to the same memory limits of
legacytransactions, any transaction used to extend an Address Lookup Table is also limited in how many addresses can be added at a time. Because of this, you will need to use multiple transactions to extend any table with more addresses (~20) that can fit withing a single transaction's memory limits.
Once these address have been inserted into the table, and stored on chain, you will be able to utilize the Address Lookup Table in future transactions. Enabling up to 256 address in those future transactions.
Similar to requesting another account (or PDA) from the cluster, you can fetch a complete Address Lookup Table with the
lookupTableAccount variable will now be a
AddressLookupTableAccount object which we can parse to read the listing of all the addresses stored on chain in the lookup table:
After you have created your lookup table, and stored your needed address on chain (via extending the lookup table), you can create a
v0 transaction to utilize the on chain lookup capabilities.
Just like older
legacy transactions, you can create all the instructions your transaction will execute on chain. You can then provide an array of these instructions to the Message used in the `v0 transaction.
NOTE: The instructions used inside a
v0transaction can be constructed using the same methods and functions used to create the instructions in the past. There is no required change to the instructions used involving an Address Lookup Table.
NOTE: When sending a
VersionedTransactionto the cluster, it must be signed BEFORE calling the
sendAndConfirmTransactionmethod. If you pass an array of
legacytransactions) the method will trigger an error!