lang: Add state size override (#121)

CHANGELOG.md

@@ -14,6 +14,7 @@ incremented for features.
 ## Features
 
 * cli: Specify test files to run ([#118](https://github.com/project-serum/anchor/pull/118)).
+* lang: Allow overriding the `#[state]` account's size ([#121](https://github.com/project-serum/anchor/pull/121)).
 
 ## [0.3.0] - 2021-03-12
 

examples/misc/programs/misc/src/lib.rs

@@ -8,13 +8,30 @@ use anchor_lang::prelude::*;
 #[program]
 pub mod misc {
  use super::*;
+
+ pub const SIZE: u64 = 99;
+
+ #[state(SIZE)]
+ pub struct MyState {
+ pub v: Vec<u8>,
+ }
+
+ impl MyState {
+ pub fn new(_ctx: Context<Ctor>) -> Result<Self, ProgramError> {
+ Ok(Self { v: vec![] })
+ }
+ }
+
  pub fn initialize(ctx: Context<Initialize>, udata: u128, idata: i128) -> ProgramResult {
  ctx.accounts.data.udata = udata;
  ctx.accounts.data.idata = idata;
  Ok(())
  }
 }
 
+#[derive(Accounts)]
+pub struct Ctor {}
+
 #[derive(Accounts)]
 pub struct Initialize<'info> {
  #[account(init)]

examples/misc/tests/misc.js

@@ -5,10 +5,19 @@ const assert = require("assert");
 describe("misc", () => {
  // Configure the client to use the local cluster.
  anchor.setProvider(anchor.Provider.env());
+ const program = anchor.workspace.Misc;
+
+ it("Can allocate extra space for a state constructor", async () => {
+ const tx = await program.state.rpc.new();
+ const addr = await program.state.address();
+ const state = await program.state();
+ const accountInfo = await program.provider.connection.getAccountInfo(addr);
+ assert.ok(state.v.equals(Buffer.from([])));
+ assert.ok(accountInfo.data.length === 99);
+ });
 
  it("Can use u128 and i128", async () => {
  const data = new anchor.web3.Account();
- const program = anchor.workspace.Misc;
  const tx = await program.rpc.initialize(
  new anchor.BN(1234),
  new anchor.BN(22),

lang/attribute/account/src/lib.rs

@@ -19,23 +19,15 @@ use syn::parse_macro_input;
 /// and the account deserialization will exit with an error.
 #[proc_macro_attribute]
 pub fn account(
- args: proc_macro::TokenStream,
+ _args: proc_macro::TokenStream,
  input: proc_macro::TokenStream,
 ) -> proc_macro::TokenStream {
- let namespace = args.to_string().replace("\"", "");
-
  let account_strct = parse_macro_input!(input as syn::ItemStruct);
  let account_name = &account_strct.ident;
 
  let discriminator: proc_macro2::TokenStream = {
  // Namespace the discriminator to prevent collisions.
- let discriminator_preimage = {
- if namespace.is_empty() {
- format!("account:{}", account_name.to_string())
- } else {
- format!("{}:{}", namespace, account_name.to_string())
- }
- };
+ let discriminator_preimage = format!("account:{}", account_name.to_string());
  let mut discriminator = [0u8; 8];
  discriminator.copy_from_slice(
  &anchor_syn::hash::hash(discriminator_preimage.as_bytes()).to_bytes()[..8],
@@ -57,7 +49,6 @@ pub fn account(
  }
 
  impl anchor_lang::AccountDeserialize for #account_name {
-
  fn try_deserialize(buf: &mut &[u8]) -> std::result::Result<Self, ProgramError> {
  if buf.len() < #discriminator.len() {
  return Err(ProgramError::AccountDataTooSmall);

lang/attribute/state/src/lib.rs

@@ -5,15 +5,52 @@ use syn::parse_macro_input;
 
 /// The `#[state]` attribute defines the program's state struct, i.e., the
 /// program's global account singleton giving the program the illusion of state.
+///
+/// To allocate space into the account on initialization, pass in the account
+/// size into the macro, e.g., `#[state(SIZE)]`. Otherwise, the size of the
+/// account returned by the struct's `new` constructor will determine the
+/// account size. When determining a size, make sure to reserve enough space
+/// for the 8 byte account discriminator prepended to the account. That is,
+/// always use 8 extra bytes.
 #[proc_macro_attribute]
 pub fn state(
- _args: proc_macro::TokenStream,
+ args: proc_macro::TokenStream,
  input: proc_macro::TokenStream,
 ) -> proc_macro::TokenStream {
  let item_struct = parse_macro_input!(input as syn::ItemStruct);
+ let struct_ident = &item_struct.ident;
+
+ let size_override = {
+ if args.is_empty() {
+ // No size override given. The account size is whatever is given
+ // as the initialized value. Use the default implementation.
+ quote! {
+ impl anchor_lang::AccountSize for #struct_ident {
+ fn size(&self) -> Result<u64, ProgramError> {
+ Ok(8 + self
+ .try_to_vec()
+ .map_err(|_| ProgramError::Custom(1))?
+ .len() as u64)
+ }
+ }
+ }
+ } else {
+ let size = proc_macro2::TokenStream::from(args);
+ // Size override given to the macro. Use it.
+ quote! {
+ impl anchor_lang::AccountSize for #struct_ident {
+ fn size(&self) -> Result<u64, ProgramError> {
+ Ok(#size)
+ }
+ }
+ }
+ }
+ };
 
  proc_macro::TokenStream::from(quote! {
  #[account]
  #item_struct
+
+ #size_override
  })
 }

lang/src/lib.rs

@@ -169,6 +169,12 @@ pub trait InstructionData: AnchorSerialize {
  fn data(&self) -> Vec<u8>;
 }
 
+/// Calculates the size of an account, which may be larger than the deserialized
+/// data in it. This trait is currently only used for `#[state]` accounts.
+pub trait AccountSize: AnchorSerialize {
+ fn size(&self) -> Result<u64, ProgramError>;
+}
+
 /// The prelude contains all commonly used components of the crate.
 /// All programs should include it via `anchor_lang::prelude::*;`.
 pub mod prelude {

lang/syn/src/codegen/program.rs

@@ -420,17 +420,16 @@ pub fn generate_non_inlined_handlers(program: &Program) -> proc_macro2::TokenStr
  let seed = anchor_lang::ProgramState::<#name>::seed();
  let owner = ctor_accounts.program.key;
  let to = Pubkey::create_with_seed(&base, seed, owner).unwrap();
- // Add 8 for the account discriminator.
- let space = 8 + instance.try_to_vec().map_err(|_| ProgramError::Custom(1))?.len();
- let lamports = ctor_accounts.rent.minimum_balance(space);
+ let space = anchor_lang::AccountSize::size(&instance)?;
+ let lamports = ctor_accounts.rent.minimum_balance(std::convert::TryInto::try_into(space).unwrap());
  let seeds = &[&[nonce][..]];
  let ix = anchor_lang::solana_program::system_instruction::create_account_with_seed(
  from,
  &to,
  &base,
  seed,
  lamports,
- space as u64,
+ space,
  owner,
  );
  anchor_lang::solana_program::program::invoke_signed(