Add CreateNativeMint instruction

Author: mvines

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

@@ -17,7 +17,7 @@ use {
     spl_token_2022::{
         error::TokenError,
         extension::{mint_close_authority::MintCloseAuthority, transfer_fee, ExtensionType},
-        instruction,
+        instruction, native_mint,
         state::Mint,
     },
     spl_token_client::token::ExtensionInitializationParams,
@@ -474,3 +474,17 @@ async fn fail_fee_init_after_mint_init() {
         TransactionError::InstructionError(1, InstructionError::InvalidAccountData)
     );
 }
+
+#[tokio::test]
+async fn create_native_mint() {
+    let mut context = TestContext::new().await;
+    context.init_token_with_native_mint().await.unwrap();
+    let TokenContext { token, .. } = context.token_context.unwrap();
+
+    let mint = token.get_mint_info().await.unwrap();
+    assert_eq!(mint.base.decimals, native_mint::DECIMALS);
+    assert_eq!(mint.base.mint_authority, COption::None,);
+    assert_eq!(mint.base.supply, 0);
+    assert!(mint.base.is_initialized);
+    assert_eq!(mint.base.freeze_authority, COption::None);
+}

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

@@ -3,7 +3,7 @@
 use {
     solana_program_test::{processor, tokio::sync::Mutex, ProgramTest, ProgramTestContext},
     solana_sdk::signer::{keypair::Keypair, Signer},
-    spl_token_2022::{id, processor::Processor},
+    spl_token_2022::{id, native_mint, processor::Processor},
     spl_token_client::{
         client::{ProgramBanksClient, ProgramBanksClientProcessTransaction, ProgramClient},
         token::{ExtensionInitializationParams, Token, TokenResult},
@@ -97,6 +97,26 @@ impl TestContext {
 
         Ok(())
     }
+
+    pub async fn init_token_with_native_mint(&mut self) -> TokenResult<()> {
+        let payer = keypair_clone(&self.context.lock().await.payer);
+        let client: Arc<dyn ProgramClient<ProgramBanksClientProcessTransaction>> =
+            Arc::new(ProgramBanksClient::new_from_context(
+                Arc::clone(&self.context),
+                ProgramBanksClientProcessTransaction,
+            ));
+
+        let token = Token::create_native_mint(Arc::clone(&client), &id(), payer).await?;
+        self.token_context = Some(TokenContext {
+            decimals: native_mint::DECIMALS,
+            mint_authority: Keypair::new(), /*bogus*/
+            token,
+            alice: Keypair::new(),
+            bob: Keypair::new(),
+            freeze_authority: None,
+        });
+        Ok(())
+    }
 }
 
 fn keypair_clone(kp: &Keypair) -> Keypair {

token/program-2022/src/instruction.rs

@@ -527,6 +527,19 @@ pub enum TokenInstruction {
     /// See `extension::memo_transfer::instruction::RequiredMemoTransfersInstruction` for
     /// further details about the extended instructions that share this instruction prefix
     MemoTransferExtension,
+    /// Creates the native mint.
+    ///
+    /// This instruction only needs to be invoked once after deployment and is permissionless,
+    /// Wrapped SOL (`native_mint::id()`) will not be available until this instruction is
+    /// successfully executed.
+    ///
+    /// Accounts expected by this instruction:
+    ///
+    ///   0. `[writeable,signer]` Funding account (must be a system account)
+    ///   1. `[writable]` The native mint address
+    ///   2. `[]` System program for mint account funding
+    ///
+    CreateNativeMint,
 }
 impl TokenInstruction {
     /// Unpacks a byte buffer into a [TokenInstruction](enum.TokenInstruction.html).
@@ -646,6 +659,7 @@ impl TokenInstruction {
                 Self::Reallocate { extension_types }
             }
             28 => Self::MemoTransferExtension,
+            29 => Self::CreateNativeMint,
             _ => return Err(TokenError::InvalidInstruction.into()),
         })
     }
@@ -781,6 +795,9 @@ impl TokenInstruction {
             &Self::MemoTransferExtension => {
                 buf.push(28);
             }
+            &Self::CreateNativeMint => {
+                buf.push(29);
+            }
         };
         buf
     }
@@ -1568,6 +1585,24 @@ pub fn reallocate(
     })
 }
 
+/// Creates a `CreateNativeMint` instruction
+pub fn create_native_mint(
+    token_program_id: &Pubkey,
+    payer: &Pubkey,
+) -> Result<Instruction, ProgramError> {
+    check_program_account(token_program_id)?;
+
+    Ok(Instruction {
+        program_id: *token_program_id,
+        accounts: vec![
+            AccountMeta::new(*payer, true),
+            AccountMeta::new(crate::native_mint::id(), false),
+            AccountMeta::new_readonly(system_program::id(), false),
+        ],
+        data: TokenInstruction::CreateNativeMint.pack(),
+    })
+}
+
 /// Utility function that checks index is between MIN_SIGNERS and MAX_SIGNERS
 pub fn is_valid_signer_index(index: usize) -> bool {
     (MIN_SIGNERS..=MAX_SIGNERS).contains(&index)
@@ -1820,5 +1855,12 @@ mod test {
         assert_eq!(packed, expect);
         let unpacked = TokenInstruction::unpack(&expect).unwrap();
         assert_eq!(unpacked, check);
+
+        let check = TokenInstruction::CreateNativeMint;
+        let packed = check.pack();
+        let expect = vec![29u8];
+        assert_eq!(packed, expect);
+        let unpacked = TokenInstruction::unpack(&expect).unwrap();
+        assert_eq!(unpacked, check);
     }
 }

token/program-2022/src/native_mint.rs

@@ -4,11 +4,17 @@
 pub const DECIMALS: u8 = 9;
 
 // The Mint for native SOL Token accounts
-solana_program::declare_id!("So11111111111111111111111111111111111111112");
+solana_program::declare_id!("9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP");
+
+/// Seed for the native_mint's program-derived address
+pub const PROGRAM_ADDRESS_SEEDS: &[&[u8]] = &["native-mint".as_bytes(), &[255]];
 
 #[cfg(test)]
 mod tests {
-    use {super::*, solana_program::native_token::*};
+    use {
+        super::*,
+        solana_program::{native_token::*, pubkey::Pubkey},
+    };
 
     #[test]
     fn test_decimals() {
@@ -20,4 +26,11 @@ mod tests {
             crate::ui_amount_to_amount(42., DECIMALS)
         );
     }
+
+    #[test]
+    fn expected_native_mint_id() {
+        let native_mint_id =
+            Pubkey::create_program_address(PROGRAM_ADDRESS_SEEDS, &crate::id()).unwrap();
+        assert_eq!(id(), native_mint_id);
+    }
 }

token/program-2022/src/processor.rs

@@ -15,6 +15,7 @@ use {
             ExtensionType, StateWithExtensions, StateWithExtensionsMut,
         },
         instruction::{is_valid_signer_index, AuthorityType, TokenInstruction, MAX_SIGNERS},
+        native_mint,
         state::{Account, AccountState, Mint, Multisig},
     },
     num_traits::FromPrimitive,
@@ -24,12 +25,13 @@ use {
         decode_error::DecodeError,
         entrypoint::ProgramResult,
         msg,
-        program::set_return_data,
+        program::{invoke, invoke_signed, set_return_data},
         program_error::{PrintProgramError, ProgramError},
         program_memory::sol_memset,
         program_option::COption,
         program_pack::Pack,
         pubkey::Pubkey,
+        system_instruction,
         sysvar::{rent::Rent, Sysvar},
     },
     std::convert::{TryFrom, TryInto},
@@ -164,7 +166,7 @@ impl Processor {
         account.base.delegate = COption::None;
         account.base.delegated_amount = 0;
         account.base.state = starting_state;
-        if cmp_pubkeys(mint_info.key, &crate::native_mint::id()) {
+        if cmp_pubkeys(mint_info.key, &native_mint::id()) {
             let rent_exempt_reserve = rent.minimum_balance(new_account_info_data_len);
             account.base.is_native = COption::Some(rent_exempt_reserve);
             account.base.amount = new_account_info
@@ -1024,6 +1026,51 @@ impl Processor {
         token_account.init_extension::<ImmutableOwner>().map(|_| ())
     }
 
+    /// Processes a [CreateNativeMint](enum.TokenInstruction.html) instruction
+    pub fn process_create_native_mint(accounts: &[AccountInfo]) -> ProgramResult {
+        let account_info_iter = &mut accounts.iter();
+        let payer_info = next_account_info(account_info_iter)?;
+        let native_mint_info = next_account_info(account_info_iter)?;
+        let system_program_info = next_account_info(account_info_iter)?;
+
+        if *native_mint_info.key != native_mint::id() {
+            return Err(TokenError::InvalidMint.into());
+        }
+
+        let rent = Rent::get()?;
+        let new_minimum_balance = rent.minimum_balance(Mint::get_packed_len());
+        let lamports_diff = new_minimum_balance.saturating_sub(native_mint_info.lamports());
+        invoke(
+            &system_instruction::transfer(payer_info.key, native_mint_info.key, lamports_diff),
+            &[
+                payer_info.clone(),
+                native_mint_info.clone(),
+                system_program_info.clone(),
+            ],
+        )?;
+
+        invoke_signed(
+            &system_instruction::allocate(native_mint_info.key, Mint::get_packed_len() as u64),
+            &[native_mint_info.clone(), system_program_info.clone()],
+            &[native_mint::PROGRAM_ADDRESS_SEEDS],
+        )?;
+
+        invoke_signed(
+            &system_instruction::assign(native_mint_info.key, &crate::id()),
+            &[native_mint_info.clone(), system_program_info.clone()],
+            &[native_mint::PROGRAM_ADDRESS_SEEDS],
+        )?;
+
+        Mint::pack(
+            Mint {
+                decimals: native_mint::DECIMALS,
+                is_initialized: true,
+                ..Mint::default()
+            },
+            &mut native_mint_info.data.borrow_mut(),
+        )
+    }
+
     /// Processes an [Instruction](enum.Instruction.html).
     pub fn process(program_id: &Pubkey, accounts: &[AccountInfo], input: &[u8]) -> ProgramResult {
         let instruction = TokenInstruction::unpack(input)?;
@@ -1161,6 +1208,10 @@ impl Processor {
             TokenInstruction::MemoTransferExtension => {
                 memo_transfer::processor::process_instruction(program_id, accounts, &input[1..])
             }
+            TokenInstruction::CreateNativeMint => {
+                msg!("Instruction: CreateNativeMint");
+                Self::process_create_native_mint(accounts)
+            }
         }
     }
 
@@ -1443,7 +1494,7 @@ mod tests {
                 &crate::native_mint::id(),
                 &Pubkey::default(),
                 None,
-                9,
+                crate::native_mint::DECIMALS,
             )
             .unwrap(),
             vec![&mut mint_account, &mut rent_sysvar],

token/rust/src/token.rs

@@ -17,7 +17,7 @@ use spl_token_2022::{
     extension::{
         default_account_state, memo_transfer, transfer_fee, ExtensionType, StateWithExtensionsOwned,
     },
-    instruction,
+    instruction, native_mint,
     state::{Account, AccountState, Mint},
 };
 use std::{
@@ -272,6 +272,26 @@ where
         Ok(token)
     }
 
+    /// Create native mint
+    pub async fn create_native_mint(
+        client: Arc<dyn ProgramClient<T>>,
+        program_id: &Pubkey,
+        payer: S,
+    ) -> TokenResult<Self> {
+        let token = Self::new(client, program_id, &native_mint::id(), payer);
+        token
+            .process_ixs(
+                &[instruction::create_native_mint(
+                    program_id,
+                    &token.payer.pubkey(),
+                )?],
+                &[&token.payer],
+            )
+            .await?;
+
+        Ok(token)
+    }
+
     /// Get the address for the associated token account.
     pub fn get_associated_token_address(&self, owner: &Pubkey) -> Pubkey {
         get_associated_token_address_with_program_id(owner, &self.pubkey, &self.program_id)