Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
18 changes: 12 additions & 6 deletions basics/realloc/native/program/src/instructions/reallocate.rs
Original file line number Diff line number Diff line change
Expand Up @@ -2,7 +2,7 @@ use borsh::{BorshDeserialize, BorshSerialize};
use {
solana_account_info::{next_account_info, AccountInfo},
solana_cpi::invoke,
solana_program_error::ProgramResult,
solana_program_error::{ProgramError, ProgramResult},
solana_sysvar::{rent::Rent, Sysvar},
};

Expand All @@ -14,17 +14,23 @@ pub fn reallocate_without_zero_init(accounts: &[AccountInfo], args: EnhancedAddr
let payer = next_account_info(accounts_iter)?;
let system_program = next_account_info(accounts_iter)?;

if !payer.is_signer {
return Err(ProgramError::MissingRequiredSignature);
}

let address_info_data = AddressInfo::try_from_slice(&target_account.data.borrow())?;
let enhanced_address_info_data = EnhancedAddressInfo::from_address_info(address_info_data, args.state, args.zip);

let account_span = borsh::to_vec(&enhanced_address_info_data)?.len();
let lamports_required = (Rent::get()?).minimum_balance(account_span);

let diff = lamports_required - target_account.lamports();
invoke(
&solana_system_interface::instruction::transfer(payer.key, target_account.key, diff),
&[payer.clone(), target_account.clone(), system_program.clone()],
)?;
let rent_shortfall = lamports_required.saturating_sub(target_account.lamports());
if rent_shortfall > 0 {
invoke(
&solana_system_interface::instruction::transfer(payer.key, target_account.key, rent_shortfall),
&[payer.clone(), target_account.clone(), system_program.clone()],
)?;
}

target_account.resize(account_span)?;

Expand Down
104 changes: 102 additions & 2 deletions basics/realloc/native/tests/realloc.test.ts
Original file line number Diff line number Diff line change
@@ -1,4 +1,5 @@
import {
AccountRole,
type Address,
appendTransactionMessageInstruction,
createTransactionMessage,
Expand All @@ -10,6 +11,7 @@ import {
setTransactionMessageFeePayerSigner,
signTransactionMessageWithSigners,
} from '@solana/kit';
import { getTransferSolInstruction } from '@solana-program/system';
import { assert } from 'chai';
import { FailedTransactionMetadata, LiteSVM } from 'litesvm';
import {
Expand All @@ -26,25 +28,30 @@ describe('Realloc!', () => {
let programId: Address;
let payer: KeyPairSigner;
let testAccount: KeyPairSigner;
let feePayer: KeyPairSigner;

before(async () => {
programId = (await generateKeyPairSigner()).address;
svm.addProgramFromFile(programId, 'tests/fixtures/realloc_program.so');
payer = await generateKeyPairSigner();
svm.airdrop(payer.address, lamports(1_000_000_000n));
testAccount = await generateKeyPairSigner();

feePayer = await generateKeyPairSigner();
svm.airdrop(feePayer.address, lamports(1_000_000_000n));
});

async function sendTransaction(ix: Instruction) {
const transactionMessage = pipe(
createTransactionMessage({ version: 0 }),
m => setTransactionMessageFeePayerSigner(payer, m),
m => setTransactionMessageFeePayerSigner(feePayer, m),
m => svm.setTransactionMessageLifetimeUsingLatestBlockhash(m),
m => appendTransactionMessageInstruction(ix, m),
);
const signedTx = await signTransactionMessageWithSigners(transactionMessage);
const result = svm.sendTransaction(signedTx);
assert(!(result instanceof FailedTransactionMetadata), `transaction failed: ${result.toString()}`);
return result;
}

it('Create the account with data', async () => {
Expand All @@ -59,7 +66,25 @@ describe('Realloc!', () => {
it('Reallocate WITHOUT zero init', async () => {
const ix = createReallocateWithoutZeroInitInstruction(testAccount.address, payer, programId, 'Illinois', 12345);

await sendTransaction(ix);
const targetBefore = svm.getAccount(testAccount.address);
assert(targetBefore.exists);
const payerBefore = svm.getAccount(payer.address);
assert(payerBefore.exists);
const result = await sendTransaction(ix);

const account = svm.getAccount(testAccount.address);
assert(account.exists);
assert.equal(account.lamports, svm.minimumBalanceForRentExemption(BigInt(account.data.length)));
assert.equal(svm.getBalance(payer.address), payerBefore.lamports - (account.lamports - targetBefore.lamports));
assert.lengthOf(result.innerInstructions().flat(), 1);
assert.deepEqual(enhancedAddressInfoDecoder.decode(account.data), {
name: 'Jacob',
house_number: 123,
street: 'Main St.',
city: 'Chicago',
state: 'Illinois',
zip: 12345,
});

printEnhancedAddressInfo(testAccount.address);
});
Expand All @@ -80,6 +105,81 @@ describe('Realloc!', () => {
printWorkInfo(testAccount.address);
});

async function prepareFundedReallocation(excess: bigint) {
const target = await generateKeyPairSigner();
await sendTransaction(createCreateInstruction(target, payer, programId, 'Jacob', 123, 'Main St.', 'Chicago'));

const createdAccount = svm.getAccount(target.address);
assert(createdAccount.exists);
const reallocIx = createReallocateWithoutZeroInitInstruction(
target.address,
payer,
programId,
'Illinois',
12345,
);
// the payload appends the new fields, so its first byte is the instruction tag
const newSize = createdAccount.data.length + reallocIx.data.length - 1;
const fundedBalance = svm.minimumBalanceForRentExemption(BigInt(newSize)) + excess;
await sendTransaction(
getTransferSolInstruction({
source: payer,
destination: target.address,
amount: lamports(fundedBalance - createdAccount.lamports),
}),
);

return { target, reallocIx, newSize, fundedBalance };
}

for (const excess of [0n, 1_000_000n]) {
it(`Reallocates an account funded ${excess} lamports above its new rent minimum`, async () => {
const { target, reallocIx, newSize, fundedBalance } = await prepareFundedReallocation(excess);
const payerBefore = svm.getAccount(payer.address);
assert(payerBefore.exists);
const result = await sendTransaction(reallocIx);

const account = svm.getAccount(target.address);
assert(account.exists);
assert.equal(account.data.length, newSize);
assert.equal(account.lamports, fundedBalance);
assert.equal(svm.getBalance(payer.address), payerBefore.lamports);
assert.deepEqual(enhancedAddressInfoDecoder.decode(account.data), {
name: 'Jacob',
house_number: 123,
street: 'Main St.',
city: 'Chicago',
state: 'Illinois',
zip: 12345,
});
assert.isEmpty(result.innerInstructions().flat());
});
}

it('Rejects an unsigned payer when rent is already funded', async () => {
const { target, reallocIx } = await prepareFundedReallocation(0n);
const targetBefore = svm.getAccount(target.address);
assert(targetBefore.exists);
const unsignedPayer = (await generateKeyPairSigner()).address;
const unsignedIx: Instruction = {
...reallocIx,
accounts: reallocIx.accounts.map((account, index) =>
index === 1 ? { address: unsignedPayer, role: AccountRole.WRITABLE } : account,
),
};
const message = pipe(
createTransactionMessage({ version: 0 }),
m => setTransactionMessageFeePayerSigner(feePayer, m),
m => svm.setTransactionMessageLifetimeUsingLatestBlockhash(m),
m => appendTransactionMessageInstruction(unsignedIx, m),
);
const failedResult = svm.sendTransaction(await signTransactionMessageWithSigners(message));
assert(failedResult instanceof FailedTransactionMetadata, 'expected the unsigned payer to be rejected');
assert.include(failedResult.err().toString(), 'MissingRequiredSignature');

assert.deepEqual(svm.getAccount(target.address), targetBefore);
});

function printAddressInfo(address: Address): void {
const account = svm.getAccount(address);
if (account.exists) {
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -13,12 +13,17 @@ pub fn reallocate_without_zero_init(accounts: &mut [AccountView], instruction_da
return Err(ProgramError::NotEnoughAccountKeys);
};

if !payer.is_signer() {
return Err(ProgramError::MissingRequiredSignature);
}

let account_span = EnhancedAddressInfo::LEN;
let lamports_required = (Rent::get()?).try_minimum_balance(account_span)?;

let diff = lamports_required - target_account.lamports();

Transfer { from: payer, to: target_account, lamports: diff }.invoke()?;
let rent_shortfall = lamports_required.saturating_sub(target_account.lamports());
if rent_shortfall > 0 {
Transfer { from: payer, to: target_account, lamports: rent_shortfall }.invoke()?;
}

target_account.resize(account_span)?;

Expand Down
119 changes: 103 additions & 16 deletions basics/realloc/pinocchio/tests/realloc.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -21,7 +21,7 @@ import {
setTransactionMessageFeePayerSigner,
signTransactionMessageWithSigners,
} from '@solana/kit';
import { SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
import { getTransferSolInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
import { assert } from 'chai';
import { FailedTransactionMetadata, LiteSVM } from 'litesvm';

Expand Down Expand Up @@ -78,6 +78,7 @@ describe('Realloc!', () => {
let programId: Address;
let payer: KeyPairSigner;
let testAccount: KeyPairSigner;
let feePayer: KeyPairSigner;

before(async () => {
programId = (await generateKeyPairSigner()).address;
Expand All @@ -87,18 +88,22 @@ describe('Realloc!', () => {
svm.airdrop(payer.address, lamports(1_000_000_000n));

testAccount = await generateKeyPairSigner();

feePayer = await generateKeyPairSigner();
svm.airdrop(feePayer.address, lamports(1_000_000_000n));
});

async function sendInstruction(ix: Instruction) {
const transactionMessage = pipe(
createTransactionMessage({ version: 0 }),
m => setTransactionMessageFeePayerSigner(payer, m),
m => setTransactionMessageFeePayerSigner(feePayer, m),
m => svm.setTransactionMessageLifetimeUsingLatestBlockhash(m),
m => appendTransactionMessageInstruction(ix, m),
);
const signedTx = await signTransactionMessageWithSigners(transactionMessage);
const result = svm.sendTransaction(signedTx);
assert(!(result instanceof FailedTransactionMetadata), `transaction failed: ${result.toString()}`);
return result;
}

function getTestAccountData(): Uint8Array {
Expand All @@ -107,11 +112,11 @@ describe('Realloc!', () => {
return new Uint8Array(account.data);
}

it('Create the account with data', async () => {
const ix = {
function createAccountInstruction(target: KeyPairSigner) {
return {
programAddress: programId,
accounts: [
{ address: testAccount.address, role: AccountRole.WRITABLE_SIGNER, signer: testAccount },
{ address: target.address, role: AccountRole.WRITABLE_SIGNER, signer: target },
{ address: payer.address, role: AccountRole.WRITABLE_SIGNER, signer: payer },
{ address: SYSTEM_PROGRAM_ADDRESS, role: AccountRole.READONLY },
],
Expand All @@ -123,8 +128,22 @@ describe('Realloc!', () => {
city: 'Chicago',
}),
};
}

await sendInstruction(ix);
function createReallocateInstruction(target: Address) {
return {
programAddress: programId,
accounts: [
{ address: target, role: AccountRole.WRITABLE },
{ address: payer.address, role: AccountRole.WRITABLE_SIGNER, signer: payer },
{ address: SYSTEM_PROGRAM_ADDRESS, role: AccountRole.READONLY },
],
data: reallocWithoutZeroInitEncoder.encode({ discriminator: 1, state: 'Illinois', zip: 12345 }),
};
}

it('Create the account with data', async () => {
await sendInstruction(createAccountInstruction(testAccount));

const data = getTestAccountData();
assert.strictEqual(data.length, 25);
Expand All @@ -137,17 +156,17 @@ describe('Realloc!', () => {
});

it('Reallocate WITHOUT zero init', async () => {
const ix = {
programAddress: programId,
accounts: [
{ address: testAccount.address, role: AccountRole.WRITABLE },
{ address: payer.address, role: AccountRole.WRITABLE_SIGNER, signer: payer },
{ address: SYSTEM_PROGRAM_ADDRESS, role: AccountRole.READONLY },
],
data: reallocWithoutZeroInitEncoder.encode({ discriminator: 1, state: 'Illinois', zip: 12345 }),
};
const targetBefore = svm.getAccount(testAccount.address);
assert(targetBefore.exists);
const payerBefore = svm.getAccount(payer.address);
assert(payerBefore.exists);
const result = await sendInstruction(createReallocateInstruction(testAccount.address));

await sendInstruction(ix);
const rentMinimum = svm.minimumBalanceForRentExemption(BigInt(enhancedAddressInfoDecoder.fixedSize));
const rentShortfall = rentMinimum - targetBefore.lamports;
assert.equal(svm.getBalance(testAccount.address), rentMinimum);
assert.equal(svm.getBalance(payer.address), payerBefore.lamports - rentShortfall);
assert.lengthOf(result.innerInstructions().flat(), 1);

const data = getTestAccountData();
assert.strictEqual(data.length, 37);
Expand Down Expand Up @@ -182,4 +201,72 @@ describe('Realloc!', () => {
assert.strictEqual(workInfo.company, 'Anza');
assert.strictEqual(workInfo.yearsEmployed, 2);
});

async function prepareFundedReallocation(excess: bigint) {
const target = await generateKeyPairSigner();
await sendInstruction(createAccountInstruction(target));

const createdAccount = svm.getAccount(target.address);
assert(createdAccount.exists);
const newSize = enhancedAddressInfoDecoder.fixedSize;
const fundedBalance = svm.minimumBalanceForRentExemption(BigInt(newSize)) + excess;
await sendInstruction(
getTransferSolInstruction({
source: payer,
destination: target.address,
amount: lamports(fundedBalance - createdAccount.lamports),
}),
);

const reallocIx = createReallocateInstruction(target.address);
return { target, reallocIx, newSize, fundedBalance };
}

for (const excess of [0n, 1_000_000n]) {
it(`Reallocates an account funded ${excess} lamports above its new rent minimum`, async () => {
const { target, reallocIx, newSize, fundedBalance } = await prepareFundedReallocation(excess);
const payerBefore = svm.getAccount(payer.address);
assert(payerBefore.exists);
const result = await sendInstruction(reallocIx);

const account = svm.getAccount(target.address);
assert(account.exists);
assert.equal(account.data.length, newSize);
assert.equal(account.lamports, fundedBalance);
assert.equal(svm.getBalance(payer.address), payerBefore.lamports);
assert.deepEqual(enhancedAddressInfoDecoder.decode(account.data), {
name: 'Jacob',
houseNumber: 123,
street: 'Main St.',
city: 'Chicago',
state: 'Illinois',
zip: 12345,
});
assert.isEmpty(result.innerInstructions().flat());
});
}

it('Rejects an unsigned payer when rent is already funded', async () => {
const { target, reallocIx } = await prepareFundedReallocation(0n);
const targetBefore = svm.getAccount(target.address);
assert(targetBefore.exists);
const unsignedPayer = (await generateKeyPairSigner()).address;
const unsignedIx: Instruction = {
...reallocIx,
accounts: reallocIx.accounts.map((account, index) =>
index === 1 ? { address: unsignedPayer, role: AccountRole.WRITABLE } : account,
),
};
const message = pipe(
createTransactionMessage({ version: 0 }),
m => setTransactionMessageFeePayerSigner(feePayer, m),
m => svm.setTransactionMessageLifetimeUsingLatestBlockhash(m),
m => appendTransactionMessageInstruction(unsignedIx, m),
);
const failedResult = svm.sendTransaction(await signTransactionMessageWithSigners(message));
assert(failedResult instanceof FailedTransactionMetadata, 'expected the unsigned payer to be rejected');
assert.include(failedResult.err().toString(), 'MissingRequiredSignature');

assert.deepEqual(svm.getAccount(target.address), targetBefore);
});
});
Loading