Token 22: Add functionality to update extra_account_metas after initializing.

libraries/tlv-account-resolution/src/state.rs

@@ -182,6 +182,22 @@ impl ExtraAccountMetaList {
         Ok(())
     }
 
+    /// Update pod slice data for the given instruction and its required
+    /// list of `ExtraAccountMeta`s
+    pub fn update<T: SplDiscriminate>(
+        data: &mut [u8],
+        extra_account_metas: &[ExtraAccountMeta],
+    ) -> Result<(), ProgramError> {
+        let mut state = TlvStateMut::unpack(data).unwrap();
+        let tlv_size = PodSlice::<ExtraAccountMeta>::size_of(extra_account_metas.len())?;
+        let bytes = state.realloc_first::<T>(tlv_size)?;
+        let mut validation_data = PodSliceMut::init(bytes)?;
+        for meta in extra_account_metas {
+            validation_data.push(*meta)?;
+        }
+        Ok(())
+    }
+
     /// Get the underlying `PodSlice<ExtraAccountMeta>` from an unpacked TLV
     ///
     /// Due to lifetime annoyances, this function can't just take in the bytes,

token/transfer-hook/cli/src/main.rs

@@ -17,7 +17,8 @@ use {
     },
     spl_tlv_account_resolution::state::ExtraAccountMetaList,
     spl_transfer_hook_interface::{
-        get_extra_account_metas_address, instruction::initialize_extra_account_meta_list,
+        get_extra_account_metas_address,
+        instruction::{initialize_extra_account_meta_list, update_extra_account_meta_list},
     },
     std::{fmt, process::exit, rc::Rc, str::FromStr},
     strum_macros::{EnumString, IntoStaticStr},
@@ -127,6 +128,71 @@ async fn process_create_extra_account_metas(
         .map_err(|err| format!("error: send transaction: {err}").into())
 }
 
+async fn process_update_extra_account_metas(
+    rpc_client: &RpcClient,
+    program_id: &Pubkey,
+    token: &Pubkey,
+    transfer_hook_accounts: Vec<AccountMeta>,
+    mint_authority: &dyn Signer,
+    payer: &dyn Signer,
+) -> Result<Signature, Box<dyn std::error::Error>> {
+    let extra_account_metas_address = get_extra_account_metas_address(token, program_id);
+    let extra_account_metas = transfer_hook_accounts
+        .into_iter()
+        .map(|v| v.into())
+        .collect::<Vec<_>>();
+
+    let length = extra_account_metas.len();
+    let account_size = ExtraAccountMetaList::size_of(length)?;
+    let required_lamports = rpc_client
+        .get_minimum_balance_for_rent_exemption(account_size)
+        .await
+        .map_err(|err| format!("error: unable to fetch rent-exemption: {err}"))?;
+    let extra_account_metas_account = rpc_client.get_account(&extra_account_metas_address).await;
+    if extra_account_metas_account.is_err() {
+        return Err(format!(
+            "error: extra account metas for mint {token} and program {program_id} does not exist"
+        )
+        .into());
+    }
+    let current_lamports = extra_account_metas_account.map(|a| a.lamports).unwrap_or(0);
+    let transfer_lamports = required_lamports.saturating_sub(current_lamports);
+
+    let mut ixs = vec![];
+    if transfer_lamports > 0 {
+        ixs.push(system_instruction::transfer(
+            &payer.pubkey(),
+            &extra_account_metas_address,
+            transfer_lamports,
+        ));
+    }
+    ixs.push(update_extra_account_meta_list(
+        program_id,
+        &extra_account_metas_address,
+        token,
+        &mint_authority.pubkey(),
+        &extra_account_metas,
+    ));
+
+    let mut transaction = Transaction::new_with_payer(&ixs, Some(&payer.pubkey()));
+    let blockhash = rpc_client
+        .get_latest_blockhash()
+        .await
+        .map_err(|err| format!("error: unable to get latest blockhash: {err}"))?;
+    let mut signers = vec![payer];
+    if payer.pubkey() != mint_authority.pubkey() {
+        signers.push(mint_authority);
+    }
+    transaction
+        .try_sign(&signers, blockhash)
+        .map_err(|err| format!("error: failed to sign transaction: {err}"))?;
+
+    rpc_client
+        .send_and_confirm_transaction_with_spinner(&transaction)
+        .await
+        .map_err(|err| format!("error: send transaction: {err}").into())
+}
+
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let app_matches = Command::new(crate_name!())
@@ -217,6 +283,49 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                         .global(true)
                         .help("Filepath or URL to mint-authority keypair [default: client keypair]"),
                 )
+        )
+        .subcommand(
+            Command::new("update-extra-metas")
+                .about("Update the extra account metas account for a transfer hook program")
+                .arg(
+                    Arg::with_name("program_id")
+                        .validator(clap_is_valid_pubkey)
+                        .value_name("TRANSFER_HOOK_PROGRAM")
+                        .takes_value(true)
+                        .index(1)
+                        .required(true)
+                        .help("The transfer hook program id"),
+                )
+                .arg(
+                    Arg::with_name("token")
+                        .validator(clap_is_valid_pubkey)
+                        .value_name("TOKEN_MINT_ADDRESS")
+                        .takes_value(true)
+                        .index(2)
+                        .required(true)
+                        .help("The token mint address for the transfer hook"),
+                )
+                .arg(
+                    Arg::with_name("transfer_hook_account")
+                        .value_parser(parse_transfer_hook_account)
+                        .value_name("PUBKEY:ROLE")
+                        .takes_value(true)
+                        .multiple(true)
+                        .min_values(0)
+                        .index(3)
+                        .help("Additional pubkey(s) required for a transfer hook and their \
+                            role, in the format \"<PUBKEY>:<ROLE>\". The role must be \
+                            \"readonly\", \"writable\". \"readonly-signer\", or \"writable-signer\".")
+                )
+                .arg(
+                    Arg::new("mint_authority")
+                        .long("mint-authority")
+                        .value_name("KEYPAIR")
+                        .validator(|s| is_valid_signer(s))
+                        .takes_value(true)
+                        .global(true)
+                        .help("Filepath or URL to mint-authority keypair [default: client keypair]"),
+                )
         ).get_matches();
 
     let (command, matches) = app_matches.subcommand().unwrap();
@@ -303,6 +412,45 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             });
             println!("Signature: {signature}");
         }
+        ("update-extra-metas", arg_matches) => {
+            let program_id = pubkey_of_signer(arg_matches, "program_id", &mut wallet_manager)
+                .unwrap()
+                .unwrap();
+            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
+                .unwrap()
+                .unwrap();
+            let transfer_hook_accounts = arg_matches
+                .get_many::<AccountMeta>("transfer_hook_account")
+                .unwrap_or_default()
+                .cloned()
+                .collect();
+            let mint_authority = DefaultSigner::new(
+                "mint_authority",
+                matches
+                    .value_of("mint_authority")
+                    .map(|s| s.to_string())
+                    .unwrap_or_else(|| cli_config.keypair_path.clone()),
+            )
+            .signer_from_path(matches, &mut wallet_manager)
+            .unwrap_or_else(|err| {
+                eprintln!("error: {err}");
+                exit(1);
+            });
+            let signature = process_update_extra_account_metas(
+                &rpc_client,
+                &program_id,
+                &token,
+                transfer_hook_accounts,
+                mint_authority.as_ref(),
+                config.default_signer.as_ref(),
+            )
+            .await
+            .unwrap_or_else(|err| {
+                eprintln!("error: send transaction: {err}");
+                exit(1);
+            });
+            println!("Signature: {signature}");
+        }
         _ => unreachable!(),
     };
 

token/transfer-hook/example/src/processor.rs

@@ -134,6 +134,59 @@ pub fn process_initialize_extra_account_meta_list(
     Ok(())
 }
 
+/// Processes a
+/// [UpdateExtraAccountMetaList](enum.TransferHookInstruction.html)
+/// instruction.
+pub fn process_update_extra_account_meta_list(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    extra_account_metas: &[ExtraAccountMeta],
+) -> ProgramResult {
+    let account_info_iter = &mut accounts.iter();
+
+    let extra_account_metas_info = next_account_info(account_info_iter)?;
+    let mint_info = next_account_info(account_info_iter)?;
+    let authority_info = next_account_info(account_info_iter)?;
+    let _system_program_info = next_account_info(account_info_iter)?;
+
+    // check that the mint authority is valid without fully deserializing
+    let mint_data = mint_info.try_borrow_data()?;
+    let mint = StateWithExtensions::<Mint>::unpack(&mint_data)?;
+    let mint_authority = mint
+        .base
+        .mint_authority
+        .ok_or(TransferHookError::MintHasNoMintAuthority)?;
+
+    // Check signers
+    if !authority_info.is_signer {
+        return Err(ProgramError::MissingRequiredSignature);
+    }
+    if *authority_info.key != mint_authority {
+        return Err(TransferHookError::IncorrectMintAuthority.into());
+    }
+
+    // Check validation account
+    let expected_validation_address = get_extra_account_metas_address(mint_info.key, program_id);
+    if expected_validation_address != *extra_account_metas_info.key {
+        return Err(ProgramError::InvalidSeeds);
+    }
+
+    let length = extra_account_metas.len();
+    let account_size = ExtraAccountMetaList::size_of(length)?;
+    let original_account_size = extra_account_metas_info.data_len();
+
+    // If the new extra_account_metas is larger resize the account
+    if account_size > original_account_size {
+        extra_account_metas_info.realloc(account_size, true)?;
+    }
+
+    // Update the data
+    let mut data = extra_account_metas_info.try_borrow_mut_data()?;
+    ExtraAccountMetaList::update::<ExecuteInstruction>(&mut data, extra_account_metas)?;
+
+    Ok(())
+}
+
 /// Processes an [Instruction](enum.Instruction.html).
 pub fn process(program_id: &Pubkey, accounts: &[AccountInfo], input: &[u8]) -> ProgramResult {
     let instruction = TransferHookInstruction::unpack(input)?;
@@ -149,5 +202,11 @@ pub fn process(program_id: &Pubkey, accounts: &[AccountInfo], input: &[u8]) -> P
             msg!("Instruction: InitializeExtraAccountMetaList");
             process_initialize_extra_account_meta_list(program_id, accounts, &extra_account_metas)
         }
+        TransferHookInstruction::UpdateExtraAccountMetaList {
+            extra_account_metas,
+        } => {
+            msg!("Instruction: UpdateExtraAccountMetaList");
+            process_update_extra_account_meta_list(program_id, accounts, &extra_account_metas)
+        }
     }
 }

token/transfer-hook/interface/src/instruction.rs

@@ -45,6 +45,19 @@ pub enum TransferHookInstruction {
         /// List of `ExtraAccountMeta`s to write into the account
         extra_account_metas: Vec<ExtraAccountMeta>,
     },
+    /// Updates the extra account metas on an account, writing into
+    /// the first open TLV space.
+    ///
+    /// Accounts expected by this instruction:
+    ///
+    ///   0. `[w]` Account with extra account metas
+    ///   1. `[]` Mint
+    ///   2. `[s]` Mint authority
+    ///   3. `[]` System program
+    UpdateExtraAccountMetaList {
+        /// List of `ExtraAccountMeta`s to write into the account
+        extra_account_metas: Vec<ExtraAccountMeta>,
+    },
 }
 /// TLV instruction type only used to define the discriminator. The actual data
 /// is entirely managed by `ExtraAccountMetaList`, and it is the only data
@@ -59,6 +72,12 @@ pub struct ExecuteInstruction;
 #[discriminator_hash_input("spl-transfer-hook-interface:initialize-extra-account-metas")]
 pub struct InitializeExtraAccountMetaListInstruction;
 
+/// TLV instruction type used to update extra account metas
+/// for the transfer hook
+#[derive(SplDiscriminate)]
+#[discriminator_hash_input("spl-transfer-hook-interface:update-extra-account-metas")]
+pub struct UpdateExtraAccountMetaListInstruction;
+
 impl TransferHookInstruction {
     /// Unpacks a byte buffer into a
     /// [TransferHookInstruction](enum.TransferHookInstruction.html).
@@ -83,6 +102,13 @@ impl TransferHookInstruction {
                     extra_account_metas,
                 }
             }
+            UpdateExtraAccountMetaListInstruction::SPL_DISCRIMINATOR_SLICE => {
+                let pod_slice = PodSlice::<ExtraAccountMeta>::unpack(rest)?;
+                let extra_account_metas = pod_slice.data().to_vec();
+                Self::UpdateExtraAccountMetaList {
+                    extra_account_metas,
+                }
+            }
             _ => return Err(ProgramError::InvalidInstructionData),
         })
     }
@@ -105,6 +131,15 @@ impl TransferHookInstruction {
                 buf.extend_from_slice(&(extra_account_metas.len() as u32).to_le_bytes());
                 buf.extend_from_slice(pod_slice_to_bytes(extra_account_metas));
             }
+            Self::UpdateExtraAccountMetaList {
+                extra_account_metas,
+            } => {
+                buf.extend_from_slice(
+                    UpdateExtraAccountMetaListInstruction::SPL_DISCRIMINATOR_SLICE,
+                );
+                buf.extend_from_slice(&(extra_account_metas.len() as u32).to_le_bytes());
+                buf.extend_from_slice(pod_slice_to_bytes(extra_account_metas));
+            }
         };
         buf
     }
@@ -189,6 +224,33 @@ pub fn initialize_extra_account_meta_list(
     }
 }
 
+/// Creates a `UpdateExtraAccountMetaList` instruction.
+pub fn update_extra_account_meta_list(
+    program_id: &Pubkey,
+    extra_account_metas_pubkey: &Pubkey,
+    mint_pubkey: &Pubkey,
+    authority_pubkey: &Pubkey,
+    extra_account_metas: &[ExtraAccountMeta],
+) -> Instruction {
+    let data = TransferHookInstruction::UpdateExtraAccountMetaList {
+        extra_account_metas: extra_account_metas.to_vec(),
+    }
+    .pack();
+
+    let accounts = vec![
+        AccountMeta::new(*extra_account_metas_pubkey, false),
+        AccountMeta::new_readonly(*mint_pubkey, false),
+        AccountMeta::new_readonly(*authority_pubkey, true),
+        AccountMeta::new_readonly(system_program::id(), false),
+    ];
+
+    Instruction {
+        program_id: *program_id,
+        accounts,
+        data,
+    }
+}
+
 #[cfg(test)]
 mod test {
     use {super::*, crate::NAMESPACE, solana_program::hash, spl_pod::bytemuck::pod_from_bytes};