Solana Transaction Fundamentals

┌─────────────────────────────────────────────────────────────┐
│                      Transaction                             │
├─────────────────────────────────────────────────────────────┤
│  Signatures: [sig1, sig2, ...]                              │
│                                                             │
│  Message:                                                   │
│    ├── Header                                               │
│    │     ├── num_required_signatures                        │
│    │     ├── num_readonly_signed_accounts                   │
│    │     └── num_readonly_unsigned_accounts                 │
│    │                                                        │
│    ├── Account Keys: [pubkey1, pubkey2, ...]               │
│    │                                                        │
│    ├── Recent Blockhash                                     │
│    │                                                        │
│    └── Instructions: [                                      │
│          { program_id_index, accounts, data },              │
│          { program_id_index, accounts, data },              │
│        ]                                                    │
└─────────────────────────────────────────────────────────────┘

Instruction:
  ├── program_id: 11111111111111111111111111111111  (System Program)
  ├── accounts:
  │     ├── sender    (signer, writable)
  │     └── recipient (not signer, writable)
  └── data: [encoded transfer amount]

import { transactionBuilder } from '@metaplex-foundation/umi'

// All instructions succeed or all fail (atomic)
const builder = transactionBuilder()
  .add(createAccountInstruction)
  .add(initializeMintInstruction)
  .add(mintTokensInstruction)

await builder.sendAndConfirm(umi)

// UMI handles blockhash automatically when sending transactions.
// To fetch it manually:
const { blockhash, lastValidBlockHeight } = await umi.rpc.getLatestBlockhash()

// UMI signs automatically with the identity signer when sending.
// For additional signers, pass them during the build:
const tx = await myBuilder
  .setBlockhash(await umi.rpc.getLatestBlockhash())
  .buildAndSign(umi)

// For partial signing (multi-sig workflows), you can sign
// and serialize the transaction, then pass it to another party:
import { base64 } from '@metaplex-foundation/umi/serializers'

const serialized = umi.transactions.serialize(tx)
const encoded = base64.deserialize(serialized)[0]
// ... send encoded string to another party for additional signing ...

// Send and wait for confirmation (recommended)
const result = await myBuilder.sendAndConfirm(umi)

// Or just send without waiting
const signature = await myBuilder.send(umi)

const result = await myBuilder.sendAndConfirm(umi, {
  send: { skipPreflight: false },
  confirm: { commitment: 'confirmed' },
})

// sendAndConfirm waits for confirmation automatically.
// To check a signature status manually:
const result = await umi.rpc.getSignatureStatuses([signature])

// For most operations, 'confirmed' is the right default
const result = await myBuilder.sendAndConfirm(umi, {
  confirm: { commitment: 'confirmed' },
})

// For financial operations where you need full finality
const result = await myBuilder.sendAndConfirm(umi, {
  confirm: { commitment: 'finalized' },
})

// UMI uses V0 transactions by default
const result = await myBuilder
  .useV0()  // Explicit, but this is already the default
  .sendAndConfirm(umi)

// To use legacy transactions instead
const result = await myBuilder
  .useLegacyVersion()
  .sendAndConfirm(umi)

// With Address Lookup Tables
import { createLut } from '@metaplex-foundation/mpl-toolbox'

const [lutBuilder, lut] = createLut(umi, {
  recentSlot: await umi.rpc.getSlot({ commitment: 'finalized' }),
  addresses: [addressA, addressB, addressC],
})
await lutBuilder.sendAndConfirm(umi)

// Use the lookup table in your transaction
await myBuilder.setAddressLookupTables([lut]).sendAndConfirm(umi)

// Build the transaction without sending
const tx = await myBuilder
  .setBlockhash(await umi.rpc.getLatestBlockhash())
  .buildAndSign(umi)

// Simulate it
const simulation = await umi.rpc.simulateTransaction(tx, {
  commitment: 'confirmed',
})
console.log('Simulation result:', simulation)

solana balance
solana airdrop 1  # On devnet

import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
import { transferSol } from '@metaplex-foundation/mpl-toolbox'
import { signerIdentity, generateSigner, sol, publicKey } from '@metaplex-foundation/umi'
import { base58 } from '@metaplex-foundation/umi/serializers'

// 1. Create UMI instance
const umi = createUmi('https://api.devnet.solana.com')

// 2. Set up signer (your wallet)
const signer = generateSigner(umi)
umi.use(signerIdentity(signer))

// 3. Build and send the transaction
const result = await transferSol(umi, {
  source: umi.identity,
  destination: publicKey('RecipientAddressHere...'),
  amount: sol(1),
}).sendAndConfirm(umi)

// 4. Get the transaction signature
const signature = base58.deserialize(result.signature)[0]
console.log('Transaction confirmed:', signature)
console.log(`Explorer: https://explorer.solana.com/tx/${signature}?cluster=devnet`)