Add Fumadocs

.gitignore

@@ -41,3 +41,4 @@ public/sitemap*
 
 coverage
 .env.local
+.source

content/authors.json

@@ -0,0 +1,10 @@
+[
+  {
+    "id": "unboxed",
+    "title": "Unboxed Software with updates from the Solana Foundation",
+    "github": "Unboxed-Software",
+    "twitter": "unboxedsoftware",
+    "website": "https://www.beunboxed.com/",
+    "image": "unboxed.png"
+  }
+]

content/cookbook/accounts/calculate-rent.mdx

@@ -0,0 +1,47 @@
+---
+title: How to Calculate Account Creation Cost
+description:
+  "Every time you create an account, that creation costs an amount of SOL. Learn
+  how to calculate how much an account costs at creation."
+---
+
+Keeping accounts alive on Solana incurs a storage cost called rent. For the
+calculation, you need to consider the amount of data you intend to store in the
+account. Rent can be reclaimed in full if the account is closed.
+
+<Tabs groupId="language" items={['web3.js v2', 'web3.js v1']}>
+
+<Tab value="web3.js v2">
+
+```typescript title="calculate-rent.ts"
+import { createSolanaRpc } from "@solana/web3.js";
+
+const rpc = createSolanaRpc("https://api.devnet.solana.com");
+// 1.5k bytes
+const space = 1500n;
+
+const lamports = await rpc.getMinimumBalanceForRentExemption(space).send();
+console.log("Minimum balance for rent exception:", lamports);
+```
+
+</Tab>
+
+<Tab value="web3.js v1">
+
+```typescript
+import { Connection, clusterApiUrl } from "@solana/web3.js";
+
+const connection = new Connection(clusterApiUrl("devnet"), "confirmed");
+
+// length of data in bytes in the account to calculate rent for
+const dataLength = 1500;
+const rentExemptionAmount =
+  await connection.getMinimumBalanceForRentExemption(dataLength);
+console.log({
+  rentExemptionAmount,
+});
+```
+
+</Tab>
+
+</Tabs>

content/cookbook/accounts/close-account.mdx

@@ -0,0 +1,44 @@
+---
+title: How to Close an Account
+description:
+  "When an account is no longer needed, you can close the account to reclaim the
+  rent. Learn how to close accounts efficiently on Solana."
+---
+
+Closing accounts enables you to reclaim the SOL that was used to open the
+account, but requires deleting of all information in the account. When an
+account is closed, make sure that the data is zeroed out in the same instruction
+to avoid people reopening the account in the same transaction and getting access
+to the data. This is because the account is not actually closed until the
+transaction is completed.
+
+```rust title="close-account.rs" {18-25}
+use solana_program::{
+    account_info::next_account_info, account_info::AccountInfo, entrypoint,
+    entrypoint::ProgramResult, pubkey::Pubkey,
+};
+
+entrypoint!(process_instruction);
+
+fn process_instruction(
+    _program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    _instruction_data: &[u8],
+) -> ProgramResult {
+    let account_info_iter = &mut accounts.iter();
+
+    let source_account_info = next_account_info(account_info_iter)?;
+    let dest_account_info = next_account_info(account_info_iter)?;
+
+    let dest_starting_lamports = dest_account_info.lamports();
+    **dest_account_info.lamports.borrow_mut() = dest_starting_lamports
+        .checked_add(source_account_info.lamports())
+        .unwrap();
+    **source_account_info.lamports.borrow_mut() = 0;
+
+    source_account_info.assign(&system_program::ID);
+    source_account_info.realloc(0, false).map_err(Into::into)
+
+    Ok(())
+}
+```

content/cookbook/accounts/create-account.mdx

@@ -0,0 +1,149 @@
+---
+title: How to Create an Account
+description:
+  "Accounts are the basic building blocks of anything on Solana. Learn how to
+  create accounts on the Solana blockchain."
+---
+
+Creating an account requires using the System Program `createAccount`
+instruction. The Solana runtime will grant the owner program of an account,
+access to write to its data or transfer lamports. When creating an account, we
+have to preallocate a fixed storage space in bytes (space) and enough lamports
+to cover the rent.
+
+<Tabs groupId="language" items={['web3.js v2', 'web3.js v1']}>
+
+<Tab value="web3.js v2">
+
+```typescript title="create-account.ts"
+import {
+  pipe,
+  createSolanaRpc,
+  appendTransactionMessageInstructions,
+  createSolanaRpcSubscriptions,
+  createTransactionMessage,
+  generateKeyPairSigner,
+  getSignatureFromTransaction,
+  sendAndConfirmTransactionFactory,
+  setTransactionMessageFeePayerSigner,
+  setTransactionMessageLifetimeUsingBlockhash,
+  signTransactionMessageWithSigners,
+} from "@solana/web3.js";
+import { getSetComputeUnitPriceInstruction } from "@solana-program/compute-budget";
+import {
+  getCreateAccountInstruction,
+  SYSTEM_PROGRAM_ADDRESS,
+} from "@solana-program/system";
+
+const rpc = createSolanaRpc("https://api.devnet.solana.com");
+const rpcSubscriptions = createSolanaRpcSubscriptions(
+  "wss://api.devnet.solana.com",
+);
+
+const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({
+  rpc,
+  rpcSubscriptions,
+});
+
+const space = 0n; // any extra space in the account
+const rentLamports = await rpc.getMinimumBalanceForRentExemption(space).send();
+console.log("Minimum balance for rent exception:", rentLamports);
+
+// todo: load your own signer with SOL
+const signer = await generateKeyPairSigner();
+
+// generate a new keypair and address to create
+const newAccountKeypair = await generateKeyPairSigner();
+console.log("New account address:", newAccountKeypair.address);
+
+const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+
+const transactionMessage = pipe(
+  createTransactionMessage({ version: "legacy" }),
+  tx => setTransactionMessageFeePayerSigner(signer, tx),
+  tx => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+  tx =>
+    appendTransactionMessageInstructions(
+      [
+        // add a priority fee
+        getSetComputeUnitPriceInstruction({
+          microLamports: 200_000,
+        }),
+        // create the new account
+        getCreateAccountInstruction({
+          lamports: rentLamports,
+          newAccount: newAccountKeypair,
+          payer: signer,
+          space: space,
+          // "wallet" accounts are owned by the system program
+          programAddress: SYSTEM_PROGRAM_ADDRESS,
+        }),
+      ],
+      tx,
+    ),
+);
+
+const signedTransaction =
+  await signTransactionMessageWithSigners(transactionMessage);
+const signature = getSignatureFromTransaction(signedTransaction);
+
+await sendAndConfirmTransaction(signedTransaction, {
+  commitment: "confirmed",
+});
+console.log("Signature:", signature);
+```
+
+</Tab>
+
+<Tab value="web3.js v1">
+
+```typescript title="create-account.ts"
+import {
+  SystemProgram,
+  Keypair,
+  Transaction,
+  sendAndConfirmTransaction,
+  Connection,
+  clusterApiUrl,
+  LAMPORTS_PER_SOL,
+} from "@solana/web3.js";
+
+const connection = new Connection(clusterApiUrl("devnet"), "confirmed");
+const fromPubkey = Keypair.generate();
+
+// Airdrop SOL for transferring lamports to the created account
+const airdropSignature = await connection.requestAirdrop(
+  fromPubkey.publicKey,
+  LAMPORTS_PER_SOL,
+);
+await connection.confirmTransaction(airdropSignature);
+
+// amount of space to reserve for the account
+const space = 0;
+
+// Seed the created account with lamports for rent exemption
+const rentExemptionAmount =
+  await connection.getMinimumBalanceForRentExemption(space);
+
+const newAccountPubkey = Keypair.generate();
+const createAccountParams = {
+  fromPubkey: fromPubkey.publicKey,
+  newAccountPubkey: newAccountPubkey.publicKey,
+  lamports: rentExemptionAmount,
+  space,
+  programId: SystemProgram.programId,
+};
+
+const createAccountTransaction = new Transaction().add(
+  SystemProgram.createAccount(createAccountParams),
+);
+
+await sendAndConfirmTransaction(connection, createAccountTransaction, [
+  fromPubkey,
+  newAccountPubkey,
+]);
+```
+
+</Tab>
+
+</Tabs>