test: Add mint and account creation ixs in proxy

tests/spl/token-proxy/programs/token-proxy/src/lib.rs

@@ -1,6 +1,7 @@
 //! This example demonstrates the use of the `anchor_spl::token` CPI client.
 
 use anchor_lang::prelude::*;
+use anchor_spl::associated_token::AssociatedToken;
 use anchor_spl::token_interface::{
  self, Burn, Mint, MintTo, SetAuthority, TokenAccount, TokenInterface, Transfer,
 };
@@ -31,6 +32,20 @@ mod token_proxy {
  ) -> Result<()> {
  token_interface::set_authority(ctx.accounts.into(), authority_type.into(), new_authority)
  }
+
+ pub fn proxy_create_token_account(_ctx: Context<ProxyCreateTokenAccount>) -> Result<()> {
+ Ok(())
+ }
+
+ pub fn proxy_create_associated_token_account(
+ _ctx: Context<ProxyCreateAssociatedTokenAccount>,
+ ) -> Result<()> {
+ Ok(())
+ }
+
+ pub fn proxy_create_mint(_ctx: Context<ProxyCreateMint>, _name: String) -> Result<()> {
+ Ok(())
+ }
 }
 
 #[derive(AnchorSerialize, AnchorDeserialize)]
@@ -92,6 +107,57 @@ pub struct ProxySetAuthority<'info> {
  pub token_program: Interface<'info, TokenInterface>,
 }
 
+#[derive(Accounts)]
+pub struct ProxyCreateTokenAccount<'info> {
+ #[account(mut)]
+ pub authority: Signer<'info>,
+ pub mint: InterfaceAccount<'info, Mint>,
+ #[account(init,
+ token::mint = mint,
+ token::authority = authority,
+ seeds = [authority.key().as_ref(), mint.key().as_ref(), b"token-proxy-account"],
+ bump,
+ payer = authority
+ )]
+ pub token_account: InterfaceAccount<'info, TokenAccount>,
+ pub system_program: Program<'info, System>,
+ pub token_program: Interface<'info, TokenInterface>,
+}
+
+#[derive(Accounts)]
+pub struct ProxyCreateAssociatedTokenAccount<'info> {
+ #[account(mut)]
+ pub authority: Signer<'info>,
+ #[account(
+ init,
+ associated_token::mint = mint,
+ payer = authority,
+ associated_token::authority = authority,
+ )]
+ pub token_account: InterfaceAccount<'info, TokenAccount>,
+ pub mint: InterfaceAccount<'info, Mint>,
+ pub system_program: Program<'info, System>,
+ pub token_program: Interface<'info, TokenInterface>,
+ pub associated_token_program: Program<'info, AssociatedToken>,
+}
+
+#[derive(Accounts)]
+#[instruction(name: String)]
+pub struct ProxyCreateMint<'info> {
+ #[account(mut)]
+ pub authority: Signer<'info>,
+ #[account(init,
+ mint::decimals = 9,
+ mint::authority = authority,
+ seeds = [authority.key().as_ref(), name.as_bytes(), b"token-proxy-mint"],
+ bump,
+ payer = authority
+ )]
+ pub mint: InterfaceAccount<'info, Mint>,
+ pub system_program: Program<'info, System>,
+ pub token_program: Interface<'info, TokenInterface>,
+}
+
 impl<'a, 'b, 'c, 'info> From<&mut ProxyTransfer<'info>>
  for CpiContext<'a, 'b, 'c, 'info, Transfer<'info>>
 {

tests/spl/token-proxy/tests/token-proxy.js

@@ -29,6 +29,68 @@ describe("program", () => {
  to = await createTokenAccount(tokenProgram, mint, provider.wallet.publicKey);
  });
 
+ it("Creates a token account", async () => {
+ const newMint = await createMint(tokenProgram);
+ const authority = provider.wallet.publicKey;
+ const [tokenAccount] = anchor.web3.PublicKey.findProgramAddressSync(
+ [authority.toBytes(), newMint.toBytes(), Buffer.from("token-proxy-account")],
+ program.programId
+ );
+ await program.rpc.proxyCreateTokenAccount({
+ accounts: {
+ authority,
+ mint: newMint,
+ tokenAccount,
+ systemProgram: anchor.web3.SystemProgram.programId,
+ tokenProgram: tokenProgram.programId,
+ },
+ });
+ const account = await getTokenAccount(provider, tokenAccount);
+ assert.isTrue(account.amount.eq(new anchor.BN(0)));
+ });
+
+ it("Creates an associated token account", async () => {
+ const newMint = await createMint(tokenProgram);
+ const authority = provider.wallet.publicKey;
+ const associatedTokenProgram = new anchor.web3.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+ const [tokenAccount] = anchor.web3.PublicKey.findProgramAddressSync(
+ [authority.toBytes(), tokenProgram.programId.toBytes(), newMint.toBytes()],
+ associatedTokenProgram
+ );
+
+ await program.rpc.proxyCreateAssociatedTokenAccount({
+ accounts: {
+ tokenAccount,
+ mint: newMint,
+ authority,
+ systemProgram: anchor.web3.SystemProgram.programId,
+ tokenProgram: tokenProgram.programId,
+ associatedTokenProgram,
+ },
+ });
+ const account = await getTokenAccount(provider, tokenAccount);
+ assert.isTrue(account.amount.eq(new anchor.BN(0)));
+ });
+
+ it("Creates a mint", async () => {
+ const authority = provider.wallet.publicKey;
+ const [newMint] = anchor.web3.PublicKey.findProgramAddressSync(
+ [authority.toBytes(), Buffer.from(name), Buffer.from("token-proxy-mint")],
+ program.programId
+ );
+ await program.rpc.proxyCreateMint(
+ name,
+ {
+ accounts: {
+ authority,
+ mint: newMint,
+ systemProgram: anchor.web3.SystemProgram.programId,
+ tokenProgram: tokenProgram.programId,
+ },
+ }
+ );
+ });
+
  it("Mints a token", async () => {
  await program.rpc.proxyMintTo(new anchor.BN(1000), {
  accounts: {