solana: populate an address lookup table to reduce tx size

Author: kcsongor

sdk/__tests__/utils.ts

@@ -545,6 +545,15 @@ async function deploySolana(ctx: Ctx): Promise<Ctx> {
     await signSendWait(ctx.context, initTxs, signer);
     console.log("Initialized ntt at", manager.program.programId.toString());
 
+    // NOTE: this is a hack. The next instruction will fail if we don't wait
+    // here, because the address lookup table is not yet available, despite
+    // the transaction having been confirmed.
+    // Looks like a bug, but I haven't investigated further. In practice, this
+    // won't be an issue, becase the address lookup table will have been
+    // created well before anyone is trying to use it, but we might want to be
+    // mindful in the deploy script too.
+    await new Promise((resolve) => setTimeout(resolve, 400));
+
     const registrTxs = manager.registerTransceiver({
       payer: keypair,
       owner: keypair,

sdk/solana/src/ntt.ts

@@ -1,10 +1,12 @@
-import { Program } from "@coral-xyz/anchor";
+import { Program, web3 } from "@coral-xyz/anchor";
 import * as splToken from "@solana/spl-token";
 import {
   createAssociatedTokenAccountInstruction,
   getAssociatedTokenAddressSync,
 } from "@solana/spl-token";
 import {
+  AddressLookupTableAccount,
+  AddressLookupTableProgram,
   Connection,
   Keypair,
   PublicKey,
@@ -71,6 +73,7 @@ export class SolanaNtt<N extends Network, C extends SolanaChains>
   program: Program<NttBindings.NativeTokenTransfer>;
   config?: NttBindings.Config;
   quoter?: NttQuoter<N, C>;
+  addressLookupTable?: AddressLookupTableAccount;
 
   constructor(
     readonly network: N,
@@ -263,6 +266,100 @@ export class SolanaNtt<N extends Network, C extends SolanaChains>
       { transaction: tx, signers: [] },
       "Ntt.Initialize"
     );
+
+    yield* this.initializeOrUpdateLUT({ payer: args.payer });
+  }
+
+  // This function should be called after each upgrade. If there's nothing to
+  // do, it won't actually submit a transaction, so it's cheap to call.
+  async *initializeOrUpdateLUT(args: { payer: Keypair }) {
+    // TODO: find a more robust way of fetching a recent slot
+    const slot = (await this.program.provider.connection.getSlot()) - 1;
+
+    const [_, lutAddress] = web3.AddressLookupTableProgram.createLookupTable({
+      authority: this.pdas.lutAuthority(),
+      payer: args.payer.publicKey,
+      recentSlot: slot,
+    });
+
+    const whAccs = utils.getWormholeDerivedAccounts(
+      this.program.programId,
+      this.core.address
+    );
+    const config = await this.getConfig();
+
+    const entries = {
+      config: this.pdas.configAccount(),
+      custody: config.custody,
+      tokenProgram: config.tokenProgram,
+      mint: config.mint,
+      tokenAuthority: this.pdas.tokenAuthority(),
+      outboxRateLimit: this.pdas.outboxRateLimitAccount(),
+      wormhole: {
+        bridge: whAccs.wormholeBridge,
+        feeCollector: whAccs.wormholeFeeCollector,
+        sequence: whAccs.wormholeSequence,
+        program: this.core.address,
+        systemProgram: SystemProgram.programId,
+        clock: web3.SYSVAR_CLOCK_PUBKEY,
+        rent: web3.SYSVAR_RENT_PUBKEY,
+      },
+    };
+
+    // collect all pubkeys in entries recursively
+    const collectPubkeys = (obj: any): Array<PublicKey> => {
+      const pubkeys = new Array<PublicKey>();
+      for (const key in obj) {
+        const value = obj[key];
+        if (value instanceof PublicKey) {
+          pubkeys.push(value);
+        } else if (typeof value === "object") {
+          pubkeys.push(...collectPubkeys(value));
+        }
+      }
+      return pubkeys;
+    };
+    const pubkeys = collectPubkeys(entries).map((pk) => pk.toBase58());
+
+    var existingLut: web3.AddressLookupTableAccount | null = null;
+    try {
+      existingLut = await this.getAddressLookupTable(false);
+    } catch {
+      // swallow errors here, it just means that lut doesn't exist
+    }
+
+    if (existingLut !== null) {
+      const existingPubkeys =
+        existingLut.state.addresses?.map((a) => a.toBase58()) ?? [];
+
+      // if pubkeys contains keys that are not in the existing LUT, we need to
+      // add them to the LUT
+      const missingPubkeys = pubkeys.filter(
+        (pk) => !existingPubkeys.includes(pk)
+      );
+
+      if (missingPubkeys.length === 0) {
+        return existingLut;
+      }
+    }
+
+    const ix = await this.program.methods
+      .initializeLut(new BN(slot))
+      .accountsStrict({
+        payer: args.payer.publicKey,
+        authority: this.pdas.lutAuthority(),
+        lutAddress,
+        lut: this.pdas.lutAccount(),
+        lutProgram: AddressLookupTableProgram.programId,
+        systemProgram: SystemProgram.programId,
+        entries,
+      })
+      .instruction();
+
+    const tx = new Transaction().add(ix);
+    tx.feePayer = args.payer.publicKey;
+
+    yield this.createUnsignedTx({ transaction: tx }, "Ntt.InitializeLUT");
   }
 
   async *registerTransceiver(args: {
@@ -294,7 +391,7 @@ export class SolanaNtt<N extends Network, C extends SolanaChains>
     );
     const broadcastIx = await this.program.methods
       .broadcastWormholeId()
-      .accounts({
+      .accountsStrict({
         payer: args.payer.publicKey,
         config: this.pdas.configAccount(),
         mint: config.mint,
@@ -306,6 +403,8 @@ export class SolanaNtt<N extends Network, C extends SolanaChains>
           sequence: whAccs.wormholeSequence,
           program: this.core.address,
           systemProgram: SystemProgram.programId,
+          clock: web3.SYSVAR_CLOCK_PUBKEY,
+          rent: web3.SYSVAR_RENT_PUBKEY,
         },
       })
       .instruction();
@@ -346,7 +445,7 @@ export class SolanaNtt<N extends Network, C extends SolanaChains>
         .instruction(),
       this.program.methods
         .broadcastWormholePeer({ chainId: toChainId(peer.chain) })
-        .accounts({
+        .accountsStrict({
           payer: sender,
           config: this.pdas.configAccount(),
           peer: this.pdas.transceiverPeerAccount(peer.chain),
@@ -357,6 +456,9 @@ export class SolanaNtt<N extends Network, C extends SolanaChains>
             feeCollector: whAccs.wormholeFeeCollector,
             sequence: whAccs.wormholeSequence,
             program: this.core.address,
+            clock: web3.SYSVAR_CLOCK_PUBKEY,
+            rent: web3.SYSVAR_RENT_PUBKEY,
+            systemProgram: SystemProgram.programId,
           },
         })
         .instruction(),
@@ -751,7 +853,7 @@ export class SolanaNtt<N extends Network, C extends SolanaChains>
       .releaseWormholeOutbound({
         revertOnDelay: args.revertOnDelay,
       })
-      .accounts({
+      .accountsStrict({
         payer: args.payer,
         config: { config: this.pdas.configAccount() },
         outboxItem: args.outboxItem,
@@ -764,6 +866,8 @@ export class SolanaNtt<N extends Network, C extends SolanaChains>
           sequence: whAccs.wormholeSequence,
           program: this.core.address,
           systemProgram: SystemProgram.programId,
+          clock: web3.SYSVAR_CLOCK_PUBKEY,
+          rent: web3.SYSVAR_RENT_PUBKEY,
         },
       })
       .instruction();
@@ -943,6 +1047,32 @@ export class SolanaNtt<N extends Network, C extends SolanaChains>
     }
   }
 
+  async getAddressLookupTable(
+    useCache = true
+  ): Promise<AddressLookupTableAccount> {
+    if (!useCache || !this.addressLookupTable) {
+      const lut = await this.program.account.lut.fetchNullable(
+        this.pdas.lutAccount()
+      );
+      if (!lut)
+        throw new Error(
+          "Address lookup table not found. Did you forget to call initializeLUT?"
+        );
+
+      const response = await this.connection.getAddressLookupTable(lut.address);
+      if (response.value === null) throw new Error("Could not fetch LUT");
+
+      this.addressLookupTable = response.value;
+    }
+
+    if (!this.addressLookupTable)
+      throw new Error(
+        "Address lookup table not found. Did you forget to call initializeLUT?"
+      );
+
+    return this.addressLookupTable;
+  }
+
   createUnsignedTx(
     txReq: SolanaTransaction,
     description: string,

sdk/solana/src/utils.ts

@@ -112,6 +112,8 @@ export const nttAddresses = (programId: PublicKeyInitData) => {
     derivePda(["transceiver_message", chainToBytes(chain), id], programId);
   const wormholeMessageAccount = (outboxItem: PublicKey): PublicKey =>
     derivePda(["message", outboxItem.toBytes()], programId);
+  const lutAccount = (): PublicKey => derivePda("lut", programId);
+  const lutAuthority = (): PublicKey => derivePda("lut_authority", programId);
   const sessionAuthority = (sender: PublicKey, args: TransferArgs): PublicKey =>
     derivePda(
       [
@@ -142,6 +144,8 @@ export const nttAddresses = (programId: PublicKeyInitData) => {
     transceiverPeerAccount,
     transceiverMessageAccount,
     registeredTransceiver,
+    lutAccount,
+    lutAuthority,
   };
 };
 

solana/Cargo.lock

@@ -47,6 +47,7 @@ anchor-spl = "0.29.0"
 solana-program = "=1.18.10"
 solana-program-runtime = "=1.18.10"
 solana-program-test = "=1.18.10"
+solana-address-lookup-table-program = "=1.18.10"
 spl-token = "4.0.0"
 spl-token-2022 = "3.0.2"