# Send transaction in Solana

**Steps to Send a Transaction on Solana**

1. Set up a Solana connection.
2. Create transaction instructions.
3. Fetch the latest blockhash.
4. Create a `TransactionMessage`.
5. Use Address Lookup Tables (ALTs) if available.
6. Compile and create a `VersionedTransaction`.
7. Sign and send the transaction.
8. Return the transaction signature.

***

**Code Example (Without Hooks)**

```ts
import { 
  Connection, PublicKey, TransactionInstruction, TransactionMessage, 
  VersionedTransaction, AddressLookupTableAccount 
} from '@solana/web3.js';

// 1️⃣ Initialize Solana connection
const connection = new Connection('https://api.mainnet-beta.solana.com');

// 2️⃣ Function to create and send a transaction
async function sendSolanaTransaction(wallet, instructionsData, addressLookupTableAccounts) {
  if (!wallet?.publicKey) {
    throw new Error("Wallet is not connected");
  }

  // 3️⃣ Convert instruction data into TransactionInstructions
  const instructions = instructionsData.map((instruction) => new TransactionInstruction({
    keys: instruction.keys.map(key => ({
      pubkey: new PublicKey(key.pubkey),
      isSigner: key.isSigner,
      isWritable: key.isWritable
    })),
    programId: new PublicKey(instruction.programId),
    data: Buffer.from(instruction.data)
  }));

  // 4️⃣ Fetch the latest blockhash
  const { blockhash } = await connection.getLatestBlockhash('confirmed');

  // 5️⃣ Handle Address Lookup Tables (if available)
  const lookupTables = addressLookupTableAccounts?.map(alta => new AddressLookupTableAccount({
    key: new PublicKey(alta.key),
    state: {
      addresses: alta.state.addresses.map(addr => new PublicKey(addr)),
      authority: new PublicKey(alta.state.authority),
      deactivationSlot: BigInt(alta.state.deactivationSlot),
      lastExtendedSlot: alta.state.lastExtendedSlot,
      lastExtendedSlotStartIndex: alta.state.lastExtendedSlotStartIndex
    }
  }));

  // 6️⃣ Create a TransactionMessage
  const messageV0 = new TransactionMessage({
    payerKey: wallet.publicKey,
    recentBlockhash: blockhash,
    instructions: instructions
  });

  // 7️⃣ Compile to VersionedTransaction
  const messageV0Compiled = messageV0.compileToV0Message(lookupTables);
  const transaction = new VersionedTransaction(messageV0Compiled);

  // 8️⃣ Sign and send the transaction
  const signature = await wallet.signAndSendTransaction(transaction);
  
  console.log("Transaction Signature:", signature);
  return signature;
}
```

***

#### **How to Use This Function**

```ts
// Example wallet object (Replace with actual wallet provider)
const wallet = {
  publicKey: new PublicKey("YourWalletPublicKeyHere"),
  signAndSendTransaction: async (tx) => {
    console.log("Signing and sending transaction...");
    return "mock_signature"; // Replace with actual wallet signing logic
  }
};

// Example transaction instructions (Replace with real data)
const transactionInstructions = [
  {
    keys: [{ pubkey: "TargetAddressHere", isSigner: false, isWritable: true }],
    programId: "ProgramIdHere",
    data: "Base64EncodedDataHere"
  }
];

// Example Address Lookup Tables (Replace with real ALTs)
const addressLookupTableAccounts = [];

// Send transaction
sendSolanaTransaction(wallet, transactionInstructions, addressLookupTableAccounts)
  .then(sig => console.log("Transaction sent with signature:", sig))
  .catch(err => console.error("Transaction failed:", err));
```

***

#### **Explanation**

* **Creates a transaction** from provided instructions.
* **Fetches the latest blockhash** to ensure validity.
* **Uses Address Lookup Tables (ALTs)** for optimized transactions.
* **Compiles the transaction** into a `VersionedTransaction`.
* **Signs and sends the transaction** using the connected wallet.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.unizen.io/api-get-started/single-chain-swap/send-transaction-in-solana.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.