token-cli: final fixes for client conversion

Author: 2501babe

token/cli/src/main.rs

@@ -783,6 +783,7 @@ async fn command_transfer(
     let mint_info = config.get_mint_info(&token_pubkey, mint_decimals).await?;
 
     // if the user got the decimals wrong, they may well have calculated the transfer amount wrong
+    // we only check in online mode, because in offline, mint_info.decimals is always 9
     if !config.sign_only && mint_decimals.is_some() && mint_decimals != Some(mint_info.decimals) {
         return Err(format!(
             "Decimals {} was provided, but actual value is {}",
@@ -793,6 +794,10 @@ async fn command_transfer(
     }
 
     // decimals determines whether transfer_checked is used or not
+    // in online mode, mint_decimals may be None but mint_info.decimals is always correct
+    // in offline mode, mint_info.decimals may be wrong, but mint_decimals is always provided
+    // and in online mode, when mint_decimals is provided, it is verified correct
+    // hence the fallthrough logic here
     let decimals = if use_unchecked_instruction {
         None
     } else if mint_decimals.is_some() {
@@ -808,21 +813,13 @@ async fn command_transfer(
         token.get_associated_token_address(&sender_owner)
     };
 
-    // in any sign_only block, we can safely unwrap this
-    let maybe_sender_state = match token.get_account_info(&sender).await {
-        Ok(a) => Some(a),
-        Err(_) if config.sign_only => None,
-        Err(e) => {
-            return Err(format!("Error: failed to fetch sender account {}: {}", sender, e).into())
-        }
-    };
-
+    // the amount the user wants to tranfer, as a f64
     let maybe_transfer_balance =
         ui_amount.map(|ui_amount| spl_token::ui_amount_to_amount(ui_amount, mint_info.decimals));
 
     // the amount we will transfer, as a u64
     let transfer_balance = if !config.sign_only {
-        let sender_balance = maybe_sender_state.unwrap().base.amount;
+        let sender_balance = token.get_account_info(&sender).await?.base.amount;
         let transfer_balance = maybe_transfer_balance.unwrap_or(sender_balance);
 
         println_display(
@@ -959,17 +956,30 @@ async fn command_transfer(
     }
 
     // ...and, finally, the transfer
-    let res = token
-        .transfer(
-            &sender,
-            &recipient_token_account,
-            &sender_owner,
-            transfer_balance,
-            decimals,
-            fundable_owner,
-            &bulk_signers,
-        )
-        .await?;
+    let res = if let Some(recipient_owner) = fundable_owner {
+        token
+            .create_recipient_associated_account_and_transfer(
+                &sender,
+                &recipient_token_account,
+                &recipient_owner,
+                &sender_owner,
+                transfer_balance,
+                decimals,
+                &bulk_signers,
+            )
+            .await?
+    } else {
+        token
+            .transfer(
+                &sender,
+                &recipient_token_account,
+                &sender_owner,
+                transfer_balance,
+                decimals,
+                &bulk_signers,
+            )
+            .await?
+    };
 
     let tx_return = finish_tx(config, &res, no_wait).await?;
     Ok(match tx_return {
@@ -1367,21 +1377,28 @@ async fn command_close(
     recipient: Pubkey,
     bulk_signers: BulkSigners,
 ) -> CommandResult {
-    let source_account = config.get_account_checked(&account).await?;
+    let mint_pubkey = if !config.sign_only {
+        let source_account = config.get_account_checked(&account).await?;
+
+        let source_state = StateWithExtensionsOwned::<Account>::unpack(source_account.data)
+            .map_err(|_| format!("Could not deserialize token account {}", account))?;
+        let source_amount = source_state.base.amount;
 
-    let source_state = StateWithExtensionsOwned::<Account>::unpack(source_account.data)
-        .map_err(|_| format!("Could not deserialize token account {}", account))?;
-    let source_amount = source_state.base.amount;
+        if !source_state.base.is_native() && source_amount > 0 {
+            return Err(format!(
+                "Account {} still has {} tokens; empty the account in order to close it.",
+                account, source_amount,
+            )
+            .into());
+        }
 
-    if !source_state.base.is_native() && source_amount > 0 {
-        return Err(format!(
-            "Account {} still has {} tokens; empty the account in order to close it.",
-            account, source_amount,
-        )
-        .into());
-    }
+        source_state.base.mint
+    } else {
+        // default is safe here because close doesnt use it
+        Pubkey::default()
+    };
 
-    let token = token_client_from_config(config, &source_state.base.mint);
+    let token = token_client_from_config(config, &mint_pubkey);
     let res = token
         .close_account(&account, &recipient, &close_authority, &bulk_signers)
         .await?;
@@ -1655,9 +1672,13 @@ async fn command_gc(
         println_display(config, format!("Processing token: {}", token_pubkey));
 
         let token = token_client_from_config(config, &token_pubkey);
-        let associated_token_account = token.get_associated_token_address(&owner);
         let total_balance: u64 = accounts.values().map(|account| account.0).sum();
 
+        let associated_token_account = token.get_associated_token_address(&owner);
+        if !accounts.contains_key(&associated_token_account) && total_balance > 0 {
+            token.create_associated_token_account(&owner).await?;
+        }
+
         for (address, (amount, decimals, frozen, close_authority)) in accounts {
             let is_associated = address == associated_token_account;
 
@@ -1676,6 +1697,10 @@ async fn command_gc(
                 continue;
             }
 
+            if is_associated {
+                println!("Closing associated account {}", address);
+            }
+
             // this logic is quite fiendish, but its more readable this way than if/else
             let maybe_res = match (close_authority == owner, is_associated, amount == 0) {
                 // owner authority, associated or auxiliary, empty -> close
@@ -1687,9 +1712,10 @@ async fn command_gc(
                 // owner authority, auxiliary, nonempty -> empty and close
                 (true, false, false) => Some(
                     token
-                        .empty_and_close_auxiliary_account(
+                        .empty_and_close_account(
                             &address,
                             &owner,
+                            &associated_token_account,
                             &owner,
                             decimals,
                             &bulk_signers,
@@ -1705,7 +1731,6 @@ async fn command_gc(
                             &owner,
                             amount,
                             Some(decimals),
-                            Some(owner),
                             &bulk_signers,
                         )
                         .await,

token/client/src/token.rs

@@ -52,8 +52,10 @@ pub enum TokenError {
     AccountInvalidOwner,
     #[error("invalid account mint")]
     AccountInvalidMint,
-    #[error("invalid account")]
-    AccountInvalidAccount,
+    #[error("invalid associated account address")]
+    AccountInvalidAssociatedAddress,
+    #[error("invalid auxiliary account address")]
+    AccountInvalidAuxiliaryAddress,
     #[error("proof error: {0}")]
     Proof(ProofError),
     #[error("maximum deposit transfer amount exceeded")]
@@ -77,7 +79,8 @@ impl PartialEq for TokenError {
             (Self::AccountNotFound, Self::AccountNotFound) => true,
             (Self::AccountInvalidOwner, Self::AccountInvalidOwner) => true,
             (Self::AccountInvalidMint, Self::AccountInvalidMint) => true,
-            (Self::AccountInvalidAccount, Self::AccountInvalidAccount) => true,
+            (Self::AccountInvalidAssociatedAddress, Self::AccountInvalidAssociatedAddress) => true,
+            (Self::AccountInvalidAuxiliaryAddress, Self::AccountInvalidAuxiliaryAddress) => true,
             (
                 Self::MaximumDepositTransferAmountExceeded,
                 Self::MaximumDepositTransferAmountExceeded,
@@ -408,7 +411,6 @@ where
         Ok(transaction)
     }
 
-    // XXX TODO remove process_ixs from program-2022-test/tests/close_account.rs and private this function
     pub async fn process_ixs<S: Signers>(
         &self,
         token_instructions: &[Instruction],
@@ -712,26 +714,64 @@ where
         authority: &Pubkey,
         amount: u64,
         decimals: Option<u8>,
-        fundable_owner: Option<Pubkey>,
         signing_keypairs: &S,
     ) -> TokenResult<T::Output> {
         let signing_pubkeys = signing_keypairs.pubkeys();
         let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
 
-        let mut instructions = vec![];
+        let instructions = if let Some(decimals) = decimals {
+            [instruction::transfer_checked(
+                &self.program_id,
+                source,
+                &self.pubkey,
+                destination,
+                authority,
+                &multisig_signers,
+                amount,
+                decimals,
+            )?]
+        } else {
+            #[allow(deprecated)]
+            [instruction::transfer(
+                &self.program_id,
+                source,
+                destination,
+                authority,
+                &multisig_signers,
+                amount,
+            )?]
+        };
 
-        if let Some(recipient) = fundable_owner {
-            if *destination != self.get_associated_token_address(&recipient) {
-                return Err(TokenError::AccountInvalidAccount);
-            }
+        self.process_ixs(&instructions, signing_keypairs).await
+    }
 
-            instructions.push(create_associated_token_account_idempotent(
+    /// Transfer tokens to an associated account, creating it if it does not exist
+    #[allow(clippy::too_many_arguments)]
+    pub async fn create_recipient_associated_account_and_transfer<S: Signers>(
+        &self,
+        source: &Pubkey,
+        destination: &Pubkey,
+        destination_owner: &Pubkey,
+        authority: &Pubkey,
+        amount: u64,
+        decimals: Option<u8>,
+        signing_keypairs: &S,
+    ) -> TokenResult<T::Output> {
+        let signing_pubkeys = signing_keypairs.pubkeys();
+        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
+
+        if *destination != self.get_associated_token_address(destination_owner) {
+            return Err(TokenError::AccountInvalidAssociatedAddress);
+        }
+
+        let mut instructions = vec![
+            (create_associated_token_account_idempotent(
                 &self.payer.pubkey(),
-                &recipient,
+                destination_owner,
                 &self.pubkey,
                 &self.program_id,
-            ));
-        };
+            )),
+        ];
 
         if let Some(decimals) = decimals {
             instructions.push(instruction::transfer_checked(
@@ -923,11 +963,12 @@ where
         self.process_ixs(&instructions, signing_keypairs).await
     }
 
-    /// Close an auxiliary account, reclaiming its lamports and consolidating its tokens
-    pub async fn empty_and_close_auxiliary_account<S: Signers>(
+    /// Close an account, reclaiming its lamports and tokens
+    pub async fn empty_and_close_account<S: Signers>(
         &self,
-        auxiliary_account: &Pubkey,
+        account_to_close: &Pubkey,
         lamports_destination: &Pubkey,
+        tokens_destination: &Pubkey,
         authority: &Pubkey,
         decimals: u8,
         signing_keypairs: &S,
@@ -936,39 +977,17 @@ where
         let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
 
         // this implicitly validates that the mint on self is correct
-        let account_state = self.get_account_info(auxiliary_account).await?;
-        let account_owner = &account_state.base.owner;
-
-        // we move tokens to the owner of the closed account, NOT the authority that authorizes its closure
-        let associated_account = self.get_associated_token_address(account_owner);
-        if *auxiliary_account == associated_account {
-            return Err(TokenError::AccountInvalidAccount);
-        }
+        let account_state = self.get_account_info(account_to_close).await?;
 
         let mut instructions = vec![];
 
         if !self.is_native() && account_state.base.amount > 0 {
-            match self.get_account(&associated_account).await {
-                Err(TokenError::AccountNotFound) => {
-                    instructions.push(create_associated_token_account(
-                        &self.payer.pubkey(),
-                        account_owner,
-                        &self.pubkey,
-                        &self.program_id,
-                    ))
-                }
-                Err(e) => return Err(e),
-                _ => {}
-            };
-
-            // we sign the transfer with authority, rather than owner
-            // which means that if a separate close authority is being used, it must be a delegate also
-            // this is to avoid overcomplicating the interface for a twice-niche usecase (closing nonempty nonowned)
+            // if a separate close authority is being used, it must be a delegate also
             instructions.push(instruction::transfer_checked(
                 &self.program_id,
-                auxiliary_account,
+                account_to_close,
                 &self.pubkey,
-                &associated_account,
+                tokens_destination,
                 authority,
                 &multisig_signers,
                 account_state.base.amount,
@@ -978,7 +997,7 @@ where
 
         instructions.push(instruction::close_account(
             &self.program_id,
-            auxiliary_account,
+            account_to_close,
             lamports_destination,
             authority,
             &multisig_signers,

token/client/tests/program-test.rs

@@ -310,7 +310,6 @@ async fn transfer() {
             &alice.pubkey(),
             transfer_amount,
             Some(decimals),
-            None,
             &vec![&alice],
         )
         .await

token/program-2022-test/tests/burn.rs

@@ -236,7 +236,6 @@ async fn run_burn_and_close_system_or_incinerator(context: TestContext, non_owne
             &alice.pubkey(),
             1,
             Some(decimals),
-            None,
             &vec![&alice],
         )
         .await

token/program-2022-test/tests/confidential_transfer.rs

@@ -154,7 +154,7 @@ impl ConfidentialTokenAccountMeta {
             .unwrap();
 
         token
-            .enable_required_transfer_memos(&token_account, &owner.pubkey(), &vec![owner])
+            .enable_required_transfer_memos(&token_account, &owner.pubkey(), &[owner])
             .await
             .unwrap();