token-cli: Downgrade to crates.io versions for release (#3371)

Author: joncinque

Cargo.lock

@@ -27,9 +27,9 @@ solana-logger = "=1.10.29"
 solana-remote-wallet = "=1.10.29"
 solana-sdk = "=1.10.29"
 solana-transaction-status = "=1.10.29"
-spl-token = { version = "3.3", path="../program", features = [ "no-entrypoint" ] }
-spl-associated-token-account = { version = "1.0.5", path="../../associated-token-account/program", features = [ "no-entrypoint" ] }
-spl-memo = { version = "3.0.1", path="../../memo/program", features = ["no-entrypoint"] }
+spl-token = { version = "3.3", features = [ "no-entrypoint" ] }
+spl-associated-token-account = { version = "1.0.5", features = [ "no-entrypoint" ] }
+spl-memo = { version = "3.0.1", features = ["no-entrypoint"] }
 strum = "0.24"
 strum_macros = "0.24"
 

token/cli/Cargo.toml

@@ -203,9 +203,7 @@ pub(crate) fn bench_process_command(
             signers.push(owner_signer);
             let from = pubkey_of_signer(arg_matches, "from", wallet_manager)
                 .unwrap()
-                .unwrap_or_else(|| {
-                    get_associated_token_address_with_program_id(&owner, &token, &config.program_id)
-                });
+                .unwrap_or_else(|| get_associated_token_address(&owner, &token));
 
             command_deposit_into_or_withdraw_from(
                 config, signers, &token, n, &owner, ui_amount, &from, true,
@@ -222,9 +220,7 @@ pub(crate) fn bench_process_command(
             signers.push(owner_signer);
             let to = pubkey_of_signer(arg_matches, "to", wallet_manager)
                 .unwrap()
-                .unwrap_or_else(|| {
-                    get_associated_token_address_with_program_id(&owner, &token, &config.program_id)
-                });
+                .unwrap_or_else(|| get_associated_token_address(&owner, &token));
 
             command_deposit_into_or_withdraw_from(
                 config, signers, &token, n, &owner, ui_amount, &to, false,

token/cli/src/bench.rs

@@ -75,7 +75,7 @@ impl<'a> Config<'a> {
                 eprintln!("error: {}", e);
                 exit(1);
             });
-        get_associated_token_address_with_program_id(&owner, &token, &self.program_id)
+        get_associated_token_address(&owner, &token)
     }
 
     // Checks if an explicit address was provided, otherwise return the default address.

token/cli/src/config.rs

@@ -42,7 +42,7 @@ use solana_sdk::{
     transaction::Transaction,
 };
 use spl_associated_token_account::{
-    get_associated_token_address_with_program_id, instruction::create_associated_token_account,
+    get_associated_token_address, instruction::create_associated_token_account,
 };
 use spl_token::{
     instruction::*,
@@ -404,8 +404,7 @@ fn command_create_account(
             ],
         )
     } else {
-        let account =
-            get_associated_token_address_with_program_id(&owner, &token, &config.program_id);
+        let account = get_associated_token_address(&owner, &token);
         println_display(config, format!("Creating account {}", account));
         (
             account,
@@ -414,7 +413,6 @@ fn command_create_account(
                 &config.fee_payer,
                 &owner,
                 &token,
-                &config.program_id,
             )],
         )
     };
@@ -540,11 +538,8 @@ fn command_authorize(
             }
         } else if let Ok(token_account) = Account::unpack(&target_account.data) {
             let check_associated_token_account = || -> Result<(), Error> {
-                let maybe_associated_token_account = get_associated_token_address_with_program_id(
-                    &token_account.owner,
-                    &token_account.mint,
-                    &config.program_id,
-                );
+                let maybe_associated_token_account =
+                    get_associated_token_address(&token_account.owner, &token_account.mint);
                 if account == maybe_associated_token_account
                     && !force_authorize
                     && Some(authority) != new_authority
@@ -683,7 +678,7 @@ fn command_transfer(
     let sender = if let Some(sender) = sender {
         sender
     } else {
-        get_associated_token_address_with_program_id(&sender_owner, &token, &config.program_id)
+        get_associated_token_address(&sender_owner, &token)
     };
     let (mint_pubkey, decimals) = resolve_mint_info(config, &sender, Some(token), mint_decimals)?;
     let maybe_transfer_balance =
@@ -769,11 +764,7 @@ fn command_transfer(
     };
 
     if !recipient_is_token_account {
-        recipient_token_account = get_associated_token_address_with_program_id(
-            &recipient,
-            &mint_pubkey,
-            &config.program_id,
-        );
+        recipient_token_account = get_associated_token_address(&recipient, &mint_pubkey);
         println_display(
             config,
             format!(
@@ -826,7 +817,6 @@ fn command_transfer(
                     &config.fee_payer,
                     &recipient,
                     &mint_pubkey,
-                    &config.program_id,
                 ));
             } else {
                 return Err(
@@ -1114,11 +1104,7 @@ fn command_wrap(
             )?,
         ]
     } else {
-        let account = get_associated_token_address_with_program_id(
-            &wallet_address,
-            &native_mint::id(),
-            &config.program_id,
-        );
+        let account = get_associated_token_address(&wallet_address, &native_mint::id());
 
         if !config.sign_only {
             if let Some(account_data) = config
@@ -1135,12 +1121,7 @@ fn command_wrap(
         println_display(config, format!("Wrapping {} SOL into {}", sol, account));
         vec![
             system_instruction::transfer(&wallet_address, &account, lamports),
-            create_associated_token_account(
-                &config.fee_payer,
-                &wallet_address,
-                &native_mint::id(),
-                &config.program_id,
-            ),
+            create_associated_token_account(&config.fee_payer, &wallet_address, &native_mint::id()),
         ]
     };
     if !config.sign_only {
@@ -1172,13 +1153,8 @@ fn command_unwrap(
     bulk_signers: BulkSigners,
 ) -> CommandResult {
     let use_associated_account = address.is_none();
-    let address = address.unwrap_or_else(|| {
-        get_associated_token_address_with_program_id(
-            &wallet_address,
-            &native_mint::id(),
-            &config.program_id,
-        )
-    });
+    let address = address
+        .unwrap_or_else(|| get_associated_token_address(&wallet_address, &native_mint::id()));
     println_display(config, format!("Unwrapping {}", address));
     if !config.sign_only {
         let lamports = config.rpc_client.get_balance(&address)?;
@@ -1469,8 +1445,7 @@ fn command_address(config: &Config, token: Option<Pubkey>, owner: Pubkey) -> Com
     };
     if let Some(token) = token {
         validate_mint(config, token)?;
-        let associated_token_address =
-            get_associated_token_address_with_program_id(&owner, &token, &config.program_id);
+        let associated_token_address = get_associated_token_address(&owner, &token);
         cli_address.associated_token_address = Some(associated_token_address.to_string());
     }
     Ok(config.output_format.formatted_string(&cli_address))
@@ -1484,8 +1459,7 @@ fn command_account_info(config: &Config, address: Pubkey) -> CommandResult {
         .unwrap();
     let mint = Pubkey::from_str(&account.mint).unwrap();
     let owner = Pubkey::from_str(&account.owner).unwrap();
-    let is_associated =
-        get_associated_token_address_with_program_id(&owner, &mint, &config.program_id) == address;
+    let is_associated = get_associated_token_address(&owner, &mint) == address;
     let cli_token_account = CliTokenAccount {
         address: address.to_string(),
         is_associated,
@@ -1595,8 +1569,7 @@ fn command_gc(
 
     for (token, accounts) in accounts_by_token.into_iter() {
         println_display(config, format!("Processing token: {}", token));
-        let associated_token_account =
-            get_associated_token_address_with_program_id(&owner, &token, &config.program_id);
+        let associated_token_account = get_associated_token_address(&owner, &token);
         let total_balance: u64 = accounts.values().map(|account| account.0).sum();
 
         if total_balance > 0 && !accounts.contains_key(&associated_token_account) {
@@ -1605,7 +1578,6 @@ fn command_gc(
                 &config.fee_payer,
                 &owner,
                 &token,
-                &config.program_id,
             )]);
             lamports_needed += minimum_balance_for_rent_exemption;
         }
@@ -3267,7 +3239,7 @@ mod tests {
     fn create_associated_account(config: &Config, payer: &Keypair, mint: Pubkey) -> Pubkey {
         let bulk_signers: Vec<Box<dyn Signer>> = vec![Box::new(clone_keypair(payer))];
         command_create_account(config, mint, payer.pubkey(), None, bulk_signers).unwrap();
-        get_associated_token_address_with_program_id(&payer.pubkey(), &mint, &config.program_id)
+        get_associated_token_address(&payer.pubkey(), &mint)
     }
 
     fn mint_tokens(
@@ -3376,11 +3348,7 @@ mod tests {
             ],
         );
         let value: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        let account = get_associated_token_address_with_program_id(
-            &payer.pubkey(),
-            &token,
-            &config.program_id,
-        );
+        let account = get_associated_token_address(&payer.pubkey(), &token);
         assert_eq!(value["address"], account.to_string());
         assert_eq!(value["mint"], token.to_string());
         assert_eq!(value["isAssociated"], true);
@@ -3480,11 +3448,7 @@ mod tests {
             &["spl-token", CommandName::Wrap.into(), "0.5"],
         )
         .unwrap();
-        let account = get_associated_token_address_with_program_id(
-            &payer.pubkey(),
-            &native_mint::id(),
-            &config.program_id,
-        );
+        let account = get_associated_token_address(&payer.pubkey(), &native_mint::id());
         let ui_account = config
             .rpc_client
             .get_token_account(&account)
@@ -3500,11 +3464,7 @@ mod tests {
         let config = test_config(&test_validator, &payer, &spl_token::id());
         let bulk_signers: Vec<Box<dyn Signer>> = vec![Box::new(clone_keypair(&payer))];
         command_wrap(&config, 0.5, payer.pubkey(), None, bulk_signers).unwrap();
-        let account = get_associated_token_address_with_program_id(
-            &payer.pubkey(),
-            &native_mint::id(),
-            &config.program_id,
-        );
+        let account = get_associated_token_address(&payer.pubkey(), &native_mint::id());
         let result = process_test_command(
             &config,
             &payer,
@@ -3658,11 +3618,7 @@ mod tests {
         let ui_amount = 10.0;
         command_wrap(&config, ui_amount, payer.pubkey(), None, bulk_signers).unwrap();
 
-        let recipient = get_associated_token_address_with_program_id(
-            &payer.pubkey(),
-            &native_mint::id(),
-            &config.program_id,
-        );
+        let recipient = get_associated_token_address(&payer.pubkey(), &native_mint::id());
         let _result = process_test_command(
             &config,
             &payer,

token/cli/src/main.rs

@@ -19,7 +19,7 @@ pub(crate) struct UnsupportedAccount {
 pub(crate) fn sort_and_parse_token_accounts(
     owner: &Pubkey,
     accounts: Vec<RpcKeyedAccount>,
-    program_id: &Pubkey,
+    _program_id: &Pubkey,
 ) -> (MintAccounts, Vec<UnsupportedAccount>, usize, bool) {
     let mut mint_accounts: MintAccounts = BTreeMap::new();
     let mut unsupported_accounts = vec![];
@@ -39,7 +39,9 @@ pub(crate) fn sort_and_parse_token_accounts(
                     Ok(TokenAccountType::Account(ui_token_account)) => {
                         let mint = ui_token_account.mint.clone();
                         let is_associated = if let Ok(mint) = Pubkey::from_str(&mint) {
-                            spl_associated_token_account::get_associated_token_address_with_program_id(owner, &mint, program_id).to_string() == address
+                            spl_associated_token_account::get_associated_token_address(owner, &mint)
+                                .to_string()
+                                == address
                         } else {
                             includes_aux = true;
                             false