Solana Account Lookup Table (ALT) Message Dropping

[mdulin2]

Description

The v0 version of Solana transactions added address lookup tables. These are accounts that store accounts that can then be referenced as a single index in the instruction instead of all the bytes of a public key.

ALTs can be deleted. There are protections in place to mitigate the impact on on-chain usage, such as preventing reinitialization.

In the Wormhole watcher, to fill out the accounts correctly, there's a call to getAccountInfo() that will get all of the addresses associated with an ALT. Then it fixes the AccountKeys() structure to ensure processing proceeds as expected.

If an account was stored within a deleted ALT that is being observed by the Guardian, it cannot be consumed. For many accounts, this is fine because a reobservation on that particular account could see the TX. For the shim, which doesn't look at the account but the full transaction information, this would prevent the message from being consumed.

As a result, this is largely a self-denial of service. Not a must-fix, but something to consider in the future.

[mdulin2]

The Meta field in the block information includes a list of accounts used from ALTs. Since this TransactionMeta includes the field LoadedAddresses and is already being used here in txRpc.Meta, I think this field can be used for account population instead of the current mechanism of reading each ALT individually.

In addition to preventing the DoS issue described above, this would improve performance, as we currently issue an RPC request for each ALT lookup on each message. If we used the LoadedAddresses field, we would no longer need to do that.

[mdulin2]

I'm unsure if Pythnet and Fogo would work with the change above; I'm mostly just looking at the Solana RPC docs for this.

[mdulin2]

The change would be something like this:

diff --git a/node/pkg/watchers/solana/client.go b/node/pkg/watchers/solana/client.go
index 3097ba71d..147b838cb 100644
--- a/node/pkg/watchers/solana/client.go
+++ b/node/pkg/watchers/solana/client.go
@@ -656,14 +656,12 @@ func (s *SolanaWatcher) fetchBlock(ctx context.Context, logger *zap.Logger, slot
 // processTransaction processes a transaction and publishes any Wormhole events.
 func (s *SolanaWatcher) processTransaction(ctx context.Context, rpcClient *rpc.Client, tx *solana.Transaction, meta *rpc.TransactionMeta, slot uint64, isReobservation bool) (numObservations uint32) {
        signature := tx.Signatures[0]
-       err := s.populateLookupTableAccounts(ctx, rpcClient, tx)
-       if err != nil {
-               s.logger.Error("failed to fetch lookup table accounts for transaction",
-                       zap.Uint64("slot", slot),
-                       zap.Stringer("signature", signature),
-                       zap.Error(err),
-               )
-               return
+
+       // Use LoadedAddresses from transaction metadata instead of fetching ALT accounts via RPC.
+       // This avoids failures when ALT accounts have been deleted after tx execution.
+       if tx.Message.IsVersioned() {
+               tx.Message.AccountKeys = append(tx.Message.AccountKeys,
+                       append(meta.LoadedAddresses.Writable, meta.LoadedAddresses.ReadOnly...)...)
        }
 
        var programIndex uint16

[mdulin2]

If we were worried about these values not being populated, we could use the other path as a fallback. I believe these should always be populated correctly on Solana, though.