token-client: support wrap

also convert cli to use client for wrap

Author: 2501babe

Cargo.lock

@@ -497,16 +497,6 @@ async fn command_set_interest_rate(
     })
 }
 
-// XXX OK wtf do i need to do for this shit
-// create account needs to go through the client
-// create associated vs create aux with ext... pretty simple?
-// then i want to impl --immutable, also simple
-// error if the mint is tokenkeg, rebuke if the token is associated
-// XXX umm then for default... i think its not possible to use this for ata?
-// test it out quicky
-
-// XXX NEXT UP impl this shit for wrap. maybe put wrap/unwrap in the client?
-// and also reply to jon. i need to take a nap tho omg im dying
 async fn command_create_account(
     config: &Config<'_>,
     token_pubkey: Pubkey,
@@ -1199,6 +1189,7 @@ async fn command_thaw(
     })
 }
 
+// XXX TODO remove this when functionality moved into client
 fn native_mint(program_id: &Pubkey) -> Result<Pubkey, Error> {
     if program_id == &spl_token_2022::id() {
         Ok(spl_token_2022::native_mint::id())
@@ -1217,72 +1208,36 @@ async fn command_wrap(
     bulk_signers: BulkSigners,
 ) -> CommandResult {
     let lamports = sol_to_lamports(sol);
-
+    // XXX TODO i think i want a Token fn `new_native` that encapsulates the `native_mint` logic in one place
+    // also a function on it `is_native` maybe
     let native_mint = native_mint(&config.program_id)?;
-    let instructions = if let Some(wrapped_sol_account) = wrapped_sol_account {
-        println_display(
-            config,
-            format!("Wrapping {} SOL into {}", sol, wrapped_sol_account),
-        );
-        vec![
-            system_instruction::create_account(
-                &wallet_address,
-                &wrapped_sol_account,
-                lamports,
-                Account::LEN as u64,
-                &config.program_id,
-            ),
-            initialize_account(
-                &config.program_id,
-                &wrapped_sol_account,
-                &native_mint,
-                &wallet_address,
-            )?,
-        ]
-    } else {
-        let account = get_associated_token_address_with_program_id(
+    let token = token_client_from_config(config, &native_mint);
+
+    let account = wrapped_sol_account.unwrap_or_else(|| {
+        get_associated_token_address_with_program_id(
             &wallet_address,
             &native_mint,
             &config.program_id,
-        );
+        )
+    });
 
-        if !config.sign_only {
-            if let Some(account_data) = config
-                .rpc_client
-                .get_account_with_commitment(&account, config.rpc_client.commitment())
-                .await?
-                .value
-            {
-                if account_data.owner != system_program::id() {
-                    return Err(format!("Error: Account already exists: {}", account).into());
-                }
+    println_display(config, format!("Wrapping {} SOL into {}", sol, account));
+
+    if !config.sign_only {
+        if let Ok(account_data) = config.get_account_checked(&account).await {
+            if account_data.owner != system_program::id() {
+                return Err(format!("Error: Account already exists: {}", account).into());
             }
         }
 
-        println_display(config, format!("Wrapping {} SOL into {}", sol, account));
-        vec![
-            system_instruction::transfer(&wallet_address, &account, lamports),
-            create_associated_token_account(
-                &config.fee_payer.pubkey(),
-                &wallet_address,
-                &native_mint,
-                &config.program_id,
-            ),
-        ]
-    };
-    if !config.sign_only {
         check_wallet_balance(config, &wallet_address, lamports).await?;
     }
-    let tx_return = handle_tx(
-        &CliSignerInfo {
-            signers: bulk_signers,
-        },
-        config,
-        false,
-        0,
-        instructions,
-    )
-    .await?;
+
+    let res = token
+        .wrap_transferable(&account, &wallet_address, lamports, &bulk_signers)
+        .await?;
+
+    let tx_return = finish_tx(config, &res, false).await?;
     Ok(match tx_return {
         TransactionReturnData::CliSignature(signature) => {
             config.output_format.formatted_string(&signature)
@@ -3775,9 +3730,16 @@ mod tests {
         let address = auxiliary.pubkey();
         let bulk_signers: Vec<Arc<dyn Signer>> =
             vec![Arc::new(clone_keypair(payer)), Arc::new(auxiliary)];
-        command_create_account(config, mint, payer.pubkey(), Some(address), bulk_signers)
-            .await
-            .unwrap();
+        command_create_account(
+            config,
+            mint,
+            payer.pubkey(),
+            Some(address),
+            false,
+            bulk_signers,
+        )
+        .await
+        .unwrap();
         address
     }
 
@@ -3787,7 +3749,7 @@ mod tests {
         mint: Pubkey,
     ) -> Pubkey {
         let bulk_signers: Vec<Arc<dyn Signer>> = vec![Arc::new(clone_keypair(payer))];
-        command_create_account(config, mint, payer.pubkey(), None, bulk_signers)
+        command_create_account(config, mint, payer.pubkey(), None, false, bulk_signers)
             .await
             .unwrap();
         get_associated_token_address_with_program_id(&payer.pubkey(), &mint, &config.program_id)

token/cli/src/main.rs

@@ -17,6 +17,7 @@ solana-sdk = "=1.11.6"
 # testing token
 spl-associated-token-account = { version = "1.1", path = "../../associated-token-account/program", features = ["no-entrypoint"] }
 spl-memo = { version = "3.0.1", path = "../../memo/program", features = ["no-entrypoint"] }
+spl-token = { version = "3.5", path="../program", features = [ "no-entrypoint" ] }
 spl-token-2022 = { version = "0.4", path="../program-2022" }
 thiserror = "1.0"
 

token/client/Cargo.toml

@@ -21,7 +21,7 @@ use {
             confidential_transfer, default_account_state, interest_bearing_mint, memo_transfer,
             transfer_fee, ExtensionType, StateWithExtensionsOwned,
         },
-        instruction, native_mint,
+        instruction,
         solana_zk_token_sdk::{
             encryption::{auth_encryption::*, elgamal::*},
             errors::ProofError,
@@ -443,7 +443,7 @@ where
         program_id: &Pubkey,
         payer: Arc<dyn Signer>,
     ) -> TokenResult<Self> {
-        let token = Self::new(client, program_id, &native_mint::id(), payer);
+        let token = Self::new(client, program_id, &native_mint(program_id), payer);
         token
             .process_ixs::<[&dyn Signer; 0]>(
                 &[instruction::create_native_mint(
@@ -894,6 +894,87 @@ where
         .await
     }
 
+    pub async fn wrap<S: Signers>(
+        &self,
+        account: &Pubkey,
+        owner: &Pubkey,
+        lamports: u64,
+        signing_keypairs: &S,
+    ) -> TokenResult<T::Output> {
+        // mutable owner for Tokenkeg, immutable otherwise
+        let immutable_owner = self.program_id != spl_token::id();
+        let instructions = self.wrap_ixs(account, owner, lamports, immutable_owner)?;
+
+        self.process_ixs(&instructions, signing_keypairs).await
+    }
+
+    pub async fn wrap_transferable<S: Signers>(
+        &self,
+        account: &Pubkey,
+        owner: &Pubkey,
+        lamports: u64,
+        signing_keypairs: &S,
+    ) -> TokenResult<T::Output> {
+        let instructions = self.wrap_ixs(account, owner, lamports, false)?;
+
+        self.process_ixs(&instructions, signing_keypairs).await
+    }
+
+    /// Wrap lamports into native account
+    fn wrap_ixs(
+        &self,
+        account: &Pubkey,
+        owner: &Pubkey,
+        lamports: u64,
+        immutable_owner: bool,
+    ) -> TokenResult<Vec<Instruction>> {
+        if self.pubkey != native_mint(&self.program_id) {
+            return Err(TokenError::AccountInvalidMint);
+        }
+
+        let mut instructions = vec![];
+        if *account == self.get_associated_token_address(owner) {
+            instructions.push(system_instruction::transfer(owner, account, lamports));
+            instructions.push(create_associated_token_account(
+                &self.payer.pubkey(),
+                owner,
+                &self.pubkey,
+                &self.program_id,
+            ));
+        } else {
+            let extensions = if immutable_owner {
+                vec![ExtensionType::ImmutableOwner]
+            } else {
+                vec![]
+            };
+            let space = ExtensionType::get_account_len::<Account>(&extensions);
+
+            instructions.push(system_instruction::create_account(
+                &self.payer.pubkey(),
+                account,
+                lamports,
+                space as u64,
+                &self.program_id,
+            ));
+
+            if immutable_owner {
+                instructions.push(instruction::initialize_immutable_owner(
+                    &self.program_id,
+                    account,
+                )?)
+            }
+
+            instructions.push(instruction::initialize_account(
+                &self.program_id,
+                account,
+                &self.pubkey,
+                owner,
+            )?);
+        };
+
+        Ok(instructions)
+    }
+
     /// Sync native account lamports
     pub async fn sync_native(&self, account: &Pubkey) -> TokenResult<T::Output> {
         self.process_ixs::<[&dyn Signer; 0]>(
@@ -1925,3 +2006,13 @@ where
         .await
     }
 }
+
+fn native_mint(program_id: &Pubkey) -> Pubkey {
+    if program_id == &spl_token_2022::id() {
+        spl_token_2022::native_mint::id()
+    } else if program_id == &spl_token::id() {
+        spl_token::native_mint::id()
+    } else {
+        panic!("Unrecognized token program id: {}", program_id);
+    }
+}