Sync to t-22 CLI updates (#305)

* Sync to t-22 CLI updates

* change test rpc client to commitment level

Author: grod220

clients/cli/src/sync_metadata_to_token2022.rs

@@ -3,18 +3,25 @@ use {
         common::{parse_pubkey, process_transaction},
         config::Config,
         output::{format_output, println_display},
-        CommandResult,
+        CommandResult, Error,
     },
     clap::{ArgMatches, Args},
     mpl_token_metadata::accounts::Metadata as MetaplexMetadata,
     serde_derive::{Deserialize, Serialize},
     serde_with::{serde_as, DisplayFromStr},
     solana_cli_output::{display::writeln_name_value, QuietDisplay, VerboseDisplay},
+    solana_client::nonblocking::rpc_client::RpcClient,
     solana_pubkey::Pubkey,
     solana_remote_wallet::remote_wallet::RemoteWalletManager,
     solana_signature::Signature,
     solana_signer::Signer,
     solana_transaction::Transaction,
+    spl_token_2022::{
+        extension::{
+            metadata_pointer::MetadataPointer, BaseStateWithExtensions, PodStateWithExtensions,
+        },
+        pod::PodMint,
+    },
     spl_token_wrap::{
         get_wrapped_mint_address, get_wrapped_mint_authority,
         instruction::sync_metadata_to_token_2022,
@@ -31,20 +38,18 @@ pub struct SyncMetadataToToken2022Args {
     #[clap(value_parser = parse_pubkey)]
     pub unwrapped_mint: Pubkey,
 
-    /// Specify that the source metadata is from a `Metaplex` Token Metadata
-    /// account. The CLI will derive the PDA automatically.
-    #[clap(long)]
-    pub metaplex: bool,
-
-    /// Optional source metadata account when the unwrapped mint's metadata
-    /// pointer points to an external account or third-party program
-    #[clap(long, value_parser = parse_pubkey, conflicts_with = "metaplex", requires = "program-id")]
+    /// Optional source metadata account. If not provided, it will be derived
+    /// automatically. For SPL Token mints, this will be the `Metaplex`
+    /// Metadata PDA. For Token-2022 mints, the metadata pointer extension
+    /// is checked first, falling back to the `Metaplex` PDA if the pointer is
+    /// not set.
+    #[clap(long, value_parser = parse_pubkey)]
     pub metadata_account: Option<Pubkey>,
 
     /// Optional owner program for the source metadata account, when owned by a
     /// third-party program
-    #[clap(long, value_parser = parse_pubkey)]
-    pub program_id: Option<Pubkey>,
+    #[clap(long, value_parser = parse_pubkey, requires = "metadata-account")]
+    pub metadata_program_id: Option<Pubkey>,
 }
 
 #[serde_as]
@@ -64,7 +69,7 @@ pub struct SyncMetadataToToken2022Output {
     pub source_metadata: Option<Pubkey>,
 
     #[serde_as(as = "Option<DisplayFromStr>")]
-    pub owner_program: Option<Pubkey>,
+    pub metadata_program_id: Option<Pubkey>,
 
     pub signatures: Vec<Signature>,
 }
@@ -81,8 +86,8 @@ impl Display for SyncMetadataToToken2022Output {
         if let Some(src) = self.source_metadata {
             writeln_name_value(f, "Source metadata:", &src.to_string())?;
         }
-        if let Some(owner) = self.owner_program {
-            writeln_name_value(f, "Owner program:", &owner.to_string())?;
+        if let Some(id) = self.metadata_program_id {
+            writeln_name_value(f, "Metadata program id:", &id.to_string())?;
         }
 
         writeln!(f, "Signers:")?;
@@ -112,11 +117,10 @@ pub async fn command_sync_metadata_to_token2022(
     let wrapped_mint = get_wrapped_mint_address(&args.unwrapped_mint, &spl_token_2022::id());
     let wrapped_mint_authority = get_wrapped_mint_authority(&wrapped_mint);
 
-    let source_metadata = if args.metaplex {
-        let (metaplex_pda, _) = MetaplexMetadata::find_pda(&args.unwrapped_mint);
-        Some(metaplex_pda)
+    let source_metadata = if let Some(metadata_account) = args.metadata_account {
+        Some(metadata_account)
     } else {
-        args.metadata_account
+        resolve_source_metadata_account(&config.rpc_client, &args.unwrapped_mint).await?
     };
 
     println_display(
@@ -133,7 +137,7 @@ pub async fn command_sync_metadata_to_token2022(
         &wrapped_mint_authority,
         &args.unwrapped_mint,
         source_metadata.as_ref(),
-        args.program_id.as_ref(),
+        args.metadata_program_id.as_ref(),
     );
 
     let blockhash = config.rpc_client.get_latest_blockhash().await?;
@@ -148,9 +152,44 @@ pub async fn command_sync_metadata_to_token2022(
         wrapped_mint,
         wrapped_mint_authority,
         source_metadata,
-        owner_program: args.program_id,
+        metadata_program_id: args.metadata_program_id,
         signatures: transaction.signatures,
     };
 
     Ok(format_output(config, output))
 }
+
+pub async fn resolve_source_metadata_account(
+    rpc_client: &RpcClient,
+    unwrapped_mint: &Pubkey,
+) -> Result<Option<Pubkey>, Error> {
+    let acct = rpc_client.get_account(unwrapped_mint).await?;
+    let owner = acct.owner;
+
+    let metaplex_pda = Some(MetaplexMetadata::find_pda(unwrapped_mint).0);
+
+    if owner == spl_token::id() {
+        return Ok(metaplex_pda);
+    }
+
+    if owner == spl_token_2022::id() {
+        let mint_state = PodStateWithExtensions::<PodMint>::unpack(&acct.data)?;
+
+        let resolved = match mint_state.get_extension::<MetadataPointer>() {
+            Ok(pointer) => match Option::from(pointer.metadata_address) {
+                Some(addr) if addr == *unwrapped_mint => None,
+                Some(addr) => Some(addr),
+                None => metaplex_pda, // unset pointer → fallback
+            },
+            Err(_) => metaplex_pda, // no extension → fallback
+        };
+
+        return Ok(resolved);
+    }
+
+    Err(format!(
+        "Unwrapped mint {} is not an SPL Token or SPL Token-2022 mint",
+        unwrapped_mint
+    )
+    .into())
+}

clients/cli/tests/helpers.rs

@@ -1,9 +1,13 @@
 #![allow(dead_code)]
 
 use {
+    mpl_token_metadata::{
+        accounts::Metadata as MetaplexMetadata, instructions::CreateV1Builder, types::TokenStandard,
+    },
     serde_json::Value,
     solana_cli_config::Config as SolanaConfig,
     solana_client::nonblocking::rpc_client::RpcClient,
+    solana_commitment_config::CommitmentConfig,
     solana_keypair::{write_keypair_file, Keypair},
     solana_program_pack::Pack,
     solana_pubkey::Pubkey,
@@ -55,7 +59,10 @@ pub async fn start_validator() -> (TestValidator, Keypair) {
 
 pub async fn setup_test_env() -> TestEnv {
     let (validator, payer) = start_validator().await;
-    let rpc_client = Arc::new(validator.get_async_rpc_client());
+    let rpc_client = Arc::new(RpcClient::new_with_commitment(
+        validator.rpc_url(),
+        CommitmentConfig::confirmed(),
+    ));
 
     // Write payer keypair to a temporary file
     let keypair_file = NamedTempFile::new().unwrap();
@@ -123,6 +130,49 @@ pub async fn create_unwrapped_mint(env: &TestEnv, token_program_addr: &Pubkey) -
     mint_account.pubkey()
 }
 
+pub async fn create_metaplex_metadata(
+    env: &TestEnv,
+    mint: &Pubkey,
+    token_program: Pubkey,
+    name: String,
+    symbol: String,
+    uri: String,
+) -> Pubkey {
+    let (metaplex_pda, _) = MetaplexMetadata::find_pda(mint);
+
+    let mut builder = CreateV1Builder::new();
+    let create_ix = builder
+        .metadata(metaplex_pda)
+        .master_edition(None)
+        .mint(*mint, false)
+        .authority(env.payer.pubkey())
+        .payer(env.payer.pubkey())
+        .update_authority(env.payer.pubkey(), true)
+        .spl_token_program(Some(token_program))
+        .name(name)
+        .symbol(symbol)
+        .uri(uri)
+        .seller_fee_basis_points(0)
+        .primary_sale_happened(false)
+        .is_mutable(true)
+        .token_standard(TokenStandard::Fungible)
+        .decimals(9)
+        .instruction();
+
+    let meta_tx = Transaction::new_signed_with_payer(
+        &[create_ix],
+        Some(&env.payer.pubkey()),
+        &[&env.payer],
+        env.rpc_client.get_latest_blockhash().await.unwrap(),
+    );
+    env.rpc_client
+        .send_and_confirm_transaction(&meta_tx)
+        .await
+        .unwrap();
+
+    metaplex_pda
+}
+
 pub async fn execute_create_mint(
     env: &TestEnv,
     unwrapped_mint: &Pubkey,

clients/cli/tests/test_sync_metadata_to_spl_token.rs

@@ -1,17 +1,12 @@
 use {
     crate::helpers::{
-        create_unwrapped_mint, execute_create_mint, setup_test_env, TOKEN_WRAP_CLI_BIN,
-    },
-    mpl_token_metadata::{
-        accounts::Metadata as MetaplexMetadata,
-        instructions::{CreateMetadataAccountV3, CreateMetadataAccountV3InstructionArgs},
-        types::DataV2,
-        utils::clean,
+        create_metaplex_metadata, create_unwrapped_mint, execute_create_mint, setup_test_env,
+        TOKEN_WRAP_CLI_BIN,
     },
+    mpl_token_metadata::{accounts::Metadata as MetaplexMetadata, utils::clean},
     serde_json::Value,
     serial_test::serial,
     solana_keypair::Keypair,
-    solana_sdk_ids::system_program,
     solana_signer::Signer,
     solana_system_interface::instruction::transfer,
     solana_transaction::Transaction,
@@ -215,44 +210,18 @@ async fn test_sync_metadata_from_spl_token_to_spl_token() {
     let unwrapped_mint = create_unwrapped_mint(&env, &spl_token::id()).await;
 
     // 2. Create Metaplex metadata for the unwrapped mint
-    let (metaplex_pda, _) = MetaplexMetadata::find_pda(&unwrapped_mint);
     let name = "Unwrapped SPL".to_string();
     let symbol = "USPL".to_string();
     let uri = "http://uspl.com".to_string();
-
-    let create_meta_ix = CreateMetadataAccountV3 {
-        metadata: metaplex_pda,
-        mint: unwrapped_mint,
-        mint_authority: env.payer.pubkey(),
-        payer: env.payer.pubkey(),
-        update_authority: (env.payer.pubkey(), true),
-        system_program: system_program::id(),
-        rent: None,
-    }
-    .instruction(CreateMetadataAccountV3InstructionArgs {
-        data: DataV2 {
-            name: name.clone(),
-            symbol: symbol.clone(),
-            uri: uri.clone(),
-            seller_fee_basis_points: 0,
-            creators: None,
-            collection: None,
-            uses: None,
-        },
-        is_mutable: true,
-        collection_details: None,
-    });
-
-    let meta_tx = Transaction::new_signed_with_payer(
-        &[create_meta_ix],
-        Some(&env.payer.pubkey()),
-        &[&env.payer],
-        env.rpc_client.get_latest_blockhash().await.unwrap(),
-    );
-    env.rpc_client
-        .send_and_confirm_transaction(&meta_tx)
-        .await
-        .unwrap();
+    let metaplex_pda = create_metaplex_metadata(
+        &env,
+        &unwrapped_mint,
+        spl_token::id(),
+        name.clone(),
+        symbol.clone(),
+        uri.clone(),
+    )
+    .await;
 
     // 3. Create the corresponding wrapped SPL Token mint
     execute_create_mint(&env, &unwrapped_mint, &spl_token::id()).await;