quicknode-solana-kit 1.0.2 → 1.0.4

package/README.md

@@ -1,458 +1,1444 @@
 # quicknode-solana-kit
 
-**The unified TypeScript SDK for every QuickNode Solana add-on.**
+Typed Solana SDK for QuickNode endpoints and QuickNode-powered add-ons.
 
-One install. One config. Priority fees, Jito bundles, NFT queries, Jupiter swaps, and live streaming — all typed, all in one place.
+This package gives you one place to work with:
+
+- standard Solana RPC
+- standard Solana WebSocket subscriptions
+- QuickNode custom JSON-RPC methods
+- QuickNode REST add-ons mounted on the same endpoint
+
+If your current Solana setup looks like this:
+
+```ts
+import { Connection } from '@solana/web3.js';
+
+const connection = new Connection(
+  'https://your-endpoint.quiknode.pro/TOKEN/',
+  'confirmed',
+);
+```
+
+then `quicknode-solana-kit` is the layer on top of that.
+
+It still uses a normal Solana `Connection`, but adds typed helper methods for common QuickNode add-ons and transaction workflows.
 
 ```bash
 npm install quicknode-solana-kit
 ```
 
----
+## What This Package Is
+
+This package is a wrapper around three patterns:
+
+1. normal Solana `Connection` calls from `@solana/web3.js`
+2. QuickNode custom RPC methods such as `qn_estimatePriorityFees`
+3. QuickNode REST endpoints such as `/jupiter/v6/quote`
+
+It does not replace Solana RPC. It organizes it.
 
-## What Is This?
+You get:
 
-This is an **npm package for Solana developers**.
+- `kit.connection` for normal Solana calls
+- `kit.someMethod()` for QuickNode helper methods
 
-Every developer building on Solana using QuickNode has to wire up each add-on manually — read separate docs pages, figure out separate API shapes, write hundreds of lines of boilerplate glue code. This SDK replaces all of that.
+Example:
 
-**Without this SDK:**
 ```ts
-// ~200 lines of manual code every time:
-// - call qn_estimatePriorityFees, parse it
-// - figure out which level to pick
-// - build SetComputeUnitLimit instruction
-// - build SetComputeUnitPrice instruction
-// - remove existing compute budget ixs to avoid duplicates
-// - simulate to estimate compute units
-// - handle retry when blockhash expires
-// - confirm and return useful data
+import { QNSolanaKit } from 'quicknode-solana-kit';
+
+const kit = new QNSolanaKit({
+  endpointUrl: 'https://your-endpoint.quiknode.pro/TOKEN/',
+});
+
+const slot = await kit.connection.getSlot();
+console.log(slot);
 ```
 
-**With this SDK:**
+## Install
+
+```bash
+npm install quicknode-solana-kit
+```
+
+Requirements:
+
+- Node.js 18+
+- a QuickNode Solana endpoint
+
+## Quick Start
+
+### 1. Create the kit
+
 ```ts
-const result = await kit.sendSmartTransaction({ transaction, signer });
-// That's it. Everything above is handled.
+import { QNSolanaKit } from 'quicknode-solana-kit';
+
+const kit = new QNSolanaKit({
+  endpointUrl: 'https://your-endpoint.quiknode.pro/TOKEN/',
+  commitment: 'confirmed',
+  timeout: 30_000,
+  addOns: {
+    priorityFees: true,
+    das: true,
+    metis: false,
+    yellowstone: false,
+    liljit: false,
+    pumpfun: false,
+    stablecoinBalance: false,
+    openocean: false,
+    merkle: false,
+    blinklabs: false,
+    iris: false,
+    goldrush: false,
+    titan: false,
+    scorechain: false,
+  },
+});
 ```
 
----
+### 2. Use normal Solana methods
 
-## Requirements
+```ts
+import { PublicKey } from '@solana/web3.js';
 
-- Node.js 18+
-- A QuickNode Solana endpoint → **free at [dashboard.quicknode.com](https://dashboard.quicknode.com)**
+const wallet = new PublicKey('E645TckHQnDcavVv92Etc6xSWQaq8zzPtPRGBheviRAk');
 
----
+const balance = await kit.connection.getBalance(wallet);
+const slot = await kit.connection.getSlot();
+const blockhash = await kit.connection.getLatestBlockhash();
 
-## Quickstart
+console.log(balance, slot, blockhash.blockhash);
+```
 
-### 1. Install
+### 3. Use kit helper methods
 
-```bash
-npm install quicknode-solana-kit
+```ts
+const tokenAccounts = await kit.getTokenAccounts(wallet.toString());
+console.log(tokenAccounts.length);
 ```
 
-### 2. Get a QuickNode endpoint
+### 4. Check which add-ons are live
 
-Go to [dashboard.quicknode.com](https://dashboard.quicknode.com) → Create Endpoint → Solana.
-Copy the endpoint URL. It looks like:
+```ts
+const status = await kit.checkAddOns();
+console.log(status.addOns);
+console.log(status.canUse);
 ```
-https://your-name.solana-mainnet.quiknode.pro/YOUR_TOKEN/
+
+CLI:
+
+```bash
+npm run check
 ```
 
-### 3. (Optional) Enable free add-ons
+## Can You Still Use Built-In Solana `Connection` Methods?
+
+Yes.
 
-In the QuickNode dashboard → your endpoint → Add-ons tab:
-- Enable **Priority Fee API** (free) → unlocks `estimatePriorityFees()` + auto-fees in `sendSmartTransaction()`
-- Enable **Metaplex DAS API** (free) → unlocks all NFT query methods
+This is one of the most important points in the whole package.
 
-### 4. Create the kit
+`kit.connection` is a real `Connection` instance from `@solana/web3.js`.
+
+That means you can still use methods like:
 
 ```ts
-import { QNSolanaKit } from '@quicknode/solana-kit';
+const version = await kit.connection.getVersion();
+const slot = await kit.connection.getSlot();
+const balance = await kit.connection.getBalance(walletPublicKey);
+const blockhash = await kit.connection.getLatestBlockhash();
+const tx = await kit.connection.getTransaction(signature, {
+  maxSupportedTransactionVersion: 0,
+});
+```
 
-const kit = new QNSolanaKit({
-  endpointUrl: 'https://your-name.solana-mainnet.quiknode.pro/TOKEN/',
+So the mental model is:
+
+- `kit.connection` = normal Solana SDK access
+- `kit.someMethod()` = helper wrapper provided by this package
+
+## Add-On Model
+
+Some methods work without add-ons.
+
+Some methods require a specific QuickNode add-on.
+
+This package handles add-ons in two ways:
+
+### 1. Local config guard
+
+You tell the SDK what you believe is enabled:
 
-  // Tell the SDK which add-ons you've enabled.
-  // The SDK works without any — it just shows helpful messages
-  // when you call a method that needs an add-on you haven't enabled.
+```ts
+const kit = new QNSolanaKit({
+  endpointUrl: process.env.QN_ENDPOINT_URL!,
   addOns: {
-    priorityFees: true,   // FREE  — Priority Fee API
-    das:          true,   // FREE  — Metaplex DAS API
-    metis:        false,  // PAID  — Metis (Jupiter Swap)
-    liljit:       false,  // PAID  — Lil' JIT (Jito bundles)
-    yellowstone:  false,  // PAID  — Yellowstone gRPC
+    priorityFees: true,
+    das: true,
+    metis: false,
   },
 });
 ```
 
-### 5. Check what's available
+If you explicitly set an add-on to `false` and call a method that needs it, the SDK throws an `AddOnNotEnabledError`.
 
-```bash
-# Probes your endpoint and shows exactly which add-ons are active
-npm run check
+If a value is left `undefined`, the SDK warns and still attempts the network call.
+
+### 2. Real endpoint probe
+
+`checkAddOns()` performs real test calls to your endpoint and tells you what is actually live.
+
+```ts
+const result = await kit.checkAddOns();
+
+console.log(result.canUse.smartTransactions);
+console.log(result.canUse.nftQueries);
+console.log(result.canUse.swaps);
+console.log(result.canUse.goldRushData);
+console.log(result.canUse.riskAssessment);
 ```
 
-Output:
+## How This SDK Talks To QuickNode
+
+There are three backend styles used in this package.
+
+### 1. Standard Solana RPC
+
+Example:
+
+```ts
+await kit.connection.getBalance(pubkey);
 ```
-@quicknode/solana-kit — Add-on Status
-──────────────────────────────────────────────────────
-Endpoint: https://your-name.solana-mainnet.quiknode.pro...
 
-✓ Priority Fee API [FREE]
-  enabled — Dynamic priority fee estimation for faster tx inclusion
+### 2. QuickNode Custom JSON-RPC
 
-✓ Metaplex DAS API [FREE]
-  enabled — Query NFTs, compressed NFTs, token metadata
+Example:
 
-✗ Metis — Jupiter V6 Swap API [PAID]
-  not enabled — Best-price token swaps via Jupiter aggregator
-  Enable: https://marketplace.quicknode.com/add-ons/metis-jupiter-v6-swap-api
+```ts
+await kit.estimatePriorityFees();
+```
 
-Features Available:
-  ✓  Smart Transactions (auto fees + retry)
-  ✓  NFT / Digital Asset Queries
-  ✗  Jupiter Token Swaps
-  ✗  Yellowstone gRPC Streaming
-  ✗  Jito Bundle (MEV protection)
-  ✓  WebSocket Streaming (slot/account/logs)
+Internally, that becomes a JSON-RPC request similar to:
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "qn_estimatePriorityFees",
+  "params": {
+    "last_n_blocks": 100,
+    "api_version": 2
+  }
+}
 ```
 
----
+### 3. QuickNode REST Add-On Route
+
+Example:
+
+```ts
+await kit.getSwapQuote({
+  inputMint: TOKENS.SOL,
+  outputMint: TOKENS.USDC,
+  amount: BigInt(1_000_000_000),
+});
+```
+
+Internally, that calls a route like:
+
+```txt
+https://your-endpoint.quiknode.pro/TOKEN/jupiter/v6/quote?...
+```
+
+## Full Method Count
+
+The `QNSolanaKit` class currently exposes **33 methods**.
+
+They are:
+
+1. `checkAddOns()`
+2. `sendSmartTransaction()`
+3. `prepareSmartTransaction()`
+4. `estimatePriorityFees()`
+5. `getAssetsByOwner()`
+6. `getAsset()`
+7. `getAssetsByCollection()`
+8. `searchAssets()`
+9. `getAssetProof()`
+10. `getTokenAccounts()`
+11. `watchAccount()`
+12. `watchProgram()`
+13. `watchSlot()`
+14. `getSwapQuote()`
+15. `swap()`
+16. `getPumpFunTokens()`
+17. `getPumpFunToken()`
+18. `getPumpFunTokensByCreator()`
+19. `getPumpFunTokenHolders()`
+20. `getPumpFunTokenTrades()`
+21. `getStablecoinBalance()`
+22. `getOpenOceanQuote()`
+23. `openOceanSwap()`
+24. `sendMerkleProtectedTransaction()`
+25. `sendBlinkLabsTransaction()`
+26. `sendIrisTransaction()`
+27. `getGoldRushBalances()`
+28. `getGoldRushTransactions()`
+29. `getTitanSwapQuote()`
+30. `titanSwap()`
+31. `subscribeTitanQuotes()`
+32. `assessWalletRisk()`
+33. `isWalletSafe()`
+
+Also important:
+
+- `kit.connection` is a property, not a method
+- but it gives you access to normal Solana `Connection` methods
+
+## Add-On Requirements Table
+
+| Method | What it does | Add-on needed? | Add-on name |
+|---|---|---|---|
+| `checkAddOns()` | probes endpoint capabilities | No | none |
+| `sendSmartTransaction()` | sends a tx with fee/compute helpers | No, but better with add-on | `priorityFees` recommended |
+| `prepareSmartTransaction()` | prepares a tx with fee/compute helpers | No, but better with add-on | `priorityFees` recommended |
+| `estimatePriorityFees()` | gets live priority fee estimates | Yes | `priorityFees` |
+| `getAssetsByOwner()` | gets wallet assets | Yes | `das` |
+| `getAsset()` | gets one digital asset | Yes | `das` |
+| `getAssetsByCollection()` | gets assets by collection | Yes | `das` |
+| `searchAssets()` | searches digital assets | Yes | `das` |
+| `getAssetProof()` | gets compressed NFT proof | Yes | `das` |
+| `getTokenAccounts()` | gets SPL token accounts | No | none |
+| `watchAccount()` | watches one account | No | none |
+| `watchProgram()` | watches program logs | No | none |
+| `watchSlot()` | watches slot changes | No | none |
+| `getSwapQuote()` | gets Jupiter quote | Yes | `metis` |
+| `swap()` | performs Jupiter swap | Yes | `metis` |
+| `getPumpFunTokens()` | gets recent pump.fun tokens | Yes | `pumpfun` |
+| `getPumpFunToken()` | gets one pump.fun token | Yes | `pumpfun` |
+| `getPumpFunTokensByCreator()` | gets pump.fun tokens by creator | Yes | `pumpfun` |
+| `getPumpFunTokenHolders()` | gets token holders | Yes | `pumpfun` |
+| `getPumpFunTokenTrades()` | gets recent token trades | Yes | `pumpfun` |
+| `getStablecoinBalance()` | gets stablecoin balances across chains | Yes | `stablecoinBalance` |
+| `getOpenOceanQuote()` | gets OpenOcean quote | Yes | `openocean` |
+| `openOceanSwap()` | performs OpenOcean swap | Yes | `openocean` |
+| `sendMerkleProtectedTransaction()` | sends tx through Merkle | Yes | `merkle` |
+| `sendBlinkLabsTransaction()` | sends tx through Blink Labs | Yes | `blinklabs` |
+| `sendIrisTransaction()` | sends tx through Iris | Yes | `iris` |
+| `getGoldRushBalances()` | gets balances through GoldRush | Yes | `goldrush` |
+| `getGoldRushTransactions()` | gets tx history through GoldRush | Yes | `goldrush` |
+| `getTitanSwapQuote()` | gets Titan quote | Yes | `titan` |
+| `titanSwap()` | performs Titan swap | Yes | `titan` |
+| `subscribeTitanQuotes()` | subscribes to Titan quote stream | Yes | `titan` |
+| `assessWalletRisk()` | gets Scorechain risk report | Yes | `scorechain` |
+| `isWalletSafe()` | returns simple safe/unsafe boolean | Yes | `scorechain` |
+
+## Which Features Need No Add-On?
+
+These work without add-ons:
+
+- `checkAddOns()`
+- `sendSmartTransaction()` with fallback behavior
+- `prepareSmartTransaction()` with fallback behavior
+- `getTokenAccounts()`
+- `watchAccount()`
+- `watchProgram()`
+- `watchSlot()`
+- all built-in `kit.connection.*` methods
+
+## Which Add-On Unlocks What?
+
+### `priorityFees`
+
+Unlocks:
+
+- `estimatePriorityFees()`
+- improved `sendSmartTransaction()`
+- improved `prepareSmartTransaction()`
+
+### `das`
+
+Unlocks:
+
+- `getAssetsByOwner()`
+- `getAsset()`
+- `getAssetsByCollection()`
+- `searchAssets()`
+- `getAssetProof()`
+
+### `metis`
+
+Unlocks:
+
+- `getSwapQuote()`
+- `swap()`
+
+### `pumpfun`
+
+Unlocks:
+
+- `getPumpFunTokens()`
+- `getPumpFunToken()`
+- `getPumpFunTokensByCreator()`
+- `getPumpFunTokenHolders()`
+- `getPumpFunTokenTrades()`
+
+### `stablecoinBalance`
+
+Unlocks:
+
+- `getStablecoinBalance()`
+
+### `openocean`
+
+Unlocks:
+
+- `getOpenOceanQuote()`
+- `openOceanSwap()`
+
+### `merkle`
+
+Unlocks:
 
-## Add-on Tiers
+- `sendMerkleProtectedTransaction()`
 
-| Add-on | Tier | What it unlocks |
-|---|---|---|
-| Priority Fee API | **FREE** | `estimatePriorityFees()`, auto-fees in `sendSmartTransaction()` |
-| Metaplex DAS API | **FREE** | `getAssetsByOwner()`, `getAsset()`, `searchAssets()`, `getAssetProof()` |
-| Metis (Jupiter Swap) | **PAID** | `swap()`, `getSwapQuote()` |
-| Lil' JIT (Jito) | **PAID** | `sendSmartTransaction({ options: { useJito: true } })` |
-| Yellowstone gRPC | **PAID** | `watchAccount()` uses gRPC instead of WebSocket |
+### `blinklabs`
 
-**Everything except swaps and Jito works on free tier.**
-WebSocket streaming (`watchAccount`, `watchProgram`, `watchSlot`) works out of the box with no add-ons.
+Unlocks:
 
----
+- `sendBlinkLabsTransaction()`
+
+### `iris`
+
+Unlocks:
+
+- `sendIrisTransaction()`
+
+### `goldrush`
+
+Unlocks:
+
+- `getGoldRushBalances()`
+- `getGoldRushTransactions()`
+
+### `titan`
+
+Unlocks:
+
+- `getTitanSwapQuote()`
+- `titanSwap()`
+- `subscribeTitanQuotes()`
+
+### `scorechain`
+
+Unlocks:
+
+- `assessWalletRisk()`
+- `isWalletSafe()`
 
 ## API Reference
 
-### `kit.sendSmartTransaction(params)`
+### `checkAddOns()`
+
+Checks which add-ons are actually enabled on your endpoint.
 
-Send a transaction with automatic priority fees, compute unit optimization, and retry.
+Add-on required: none
 
 ```ts
+const result = await kit.checkAddOns();
+
+console.log(result.addOns);
+console.log(result.canUse.smartTransactions);
+console.log(result.canUse.nftQueries);
+console.log(result.canUse.swaps);
+```
+
+How it works:
+
+- performs real probe calls to your endpoint
+- tests both RPC-based and REST-based add-ons
+- returns a structured capability report
+
+### `sendSmartTransaction({ transaction, signer, options })`
+
+Sends a transaction with helper logic for compute units, priority fees, and retry behavior.
+
+Add-on required: none, but `priorityFees` is strongly recommended
+
+```ts
+import bs58 from 'bs58';
+import {
+  Keypair,
+  LAMPORTS_PER_SOL,
+  SystemProgram,
+  Transaction,
+} from '@solana/web3.js';
+
+const signer = Keypair.fromSecretKey(bs58.decode(process.env.WALLET_PRIVATE_KEY!));
+
+const tx = new Transaction().add(
+  SystemProgram.transfer({
+    fromPubkey: signer.publicKey,
+    toPubkey: signer.publicKey,
+    lamports: Math.floor(0.001 * LAMPORTS_PER_SOL),
+  }),
+);
+
 const result = await kit.sendSmartTransaction({
-  transaction: myTx,    // your @solana/web3.js Transaction
-  signer:      keypair, // Keypair that signs + pays fees
+  transaction: tx,
+  signer,
   options: {
-    feeLevel:      'recommended', // 'low'|'medium'|'recommended'|'high'|'extreme'
-    useJito:       false,         // true = Jito bundle (requires liljit add-on)
-    maxRetries:    5,             // retries on blockhash expiry
-    simulateFirst: true,          // simulate to right-size compute units
+    feeLevel: 'recommended',
+    simulateFirst: true,
+    maxRetries: 5,
+    computeUnitBuffer: 10,
+    skipPreflight: false,
   },
 });
 
-console.log(result.signature);               // 'abc123...'
-console.log(result.slot);                    // 320481923
-console.log(result.priorityFeeMicroLamports); // 5000
-console.log(result.computeUnitsUsed);        // 12500
-console.log(result.confirmationMs);          // 843
+console.log(result.signature);
+console.log(result.slot);
+console.log(result.priorityFeeMicroLamports);
+console.log(result.computeUnitsUsed);
+console.log(result.confirmationMs);
 ```
 
----
+What it does internally:
+
+1. optionally simulates the transaction
+2. estimates compute units
+3. tries to fetch priority fee recommendations
+4. injects compute budget instructions
+5. gets a blockhash
+6. signs the transaction
+7. sends raw transaction
+8. confirms it
+9. retries on failure
+
+Important note:
+
+- if fee estimation fails, it falls back to a default compute unit price
+- `useJito` exists in options, but Jito routing is not currently wired into this method
 
-### `kit.prepareSmartTransaction(params)`
+### `prepareSmartTransaction({ transaction, payer, options })`
 
-Same as `sendSmartTransaction` but returns the prepared transaction without sending.
-**Use this with wallet adapters** (Phantom, Backpack, etc.) where you don't hold the key.
+Prepares a transaction but does not send it.
+
+Add-on required: none, but `priorityFees` is strongly recommended
+
+This is useful for wallet-adapter flows.
 
 ```ts
-const { transaction } = await kit.prepareSmartTransaction({
+const prepared = await kit.prepareSmartTransaction({
   transaction: myTx,
-  payer:       wallet.publicKey,
-  options:     { feeLevel: 'high' },
+  payer: wallet.publicKey,
+  options: {
+    feeLevel: 'high',
+    computeUnitBuffer: 10,
+  },
 });
 
-// Pass to wallet adapter:
-const sig = await wallet.sendTransaction(transaction, kit.connection);
+console.log(prepared.priorityFeeMicroLamports);
+console.log(prepared.computeUnits);
+
+const sig = await wallet.sendTransaction(prepared.transaction, kit.connection);
+console.log(sig);
 ```
 
----
+How it works:
+
+- gets priority fee if available
+- adds compute budget instructions
+- fetches a recent blockhash
+- sets the fee payer
+- returns the prepared transaction
+
+### `estimatePriorityFees(options?)`
 
-### `kit.estimatePriorityFees(options?)`
+Gets live priority fee estimates from QuickNode.
 
-Get current priority fees for all levels.
+Add-on required: `priorityFees`
 
 ```ts
 const fees = await kit.estimatePriorityFees({
-  account:      'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4', // optional filter
-  lastNBlocks:  100,
+  lastNBlocks: 100,
 });
 
-fees.low          // 500   µlamports/CU
-fees.medium       // 1200  µlamports/CU
-fees.recommended  // 3000  µlamports/CU
-fees.high         // 8000  µlamports/CU
-fees.extreme      // 25000 µlamports/CU
-fees.networkCongestion // 0.42 (0=quiet, 1=congested)
+console.log(fees.low);
+console.log(fees.medium);
+console.log(fees.recommended);
+console.log(fees.high);
+console.log(fees.extreme);
+console.log(fees.networkCongestion);
+```
+
+With account filter:
+
+```ts
+const fees = await kit.estimatePriorityFees({
+  account: 'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4',
+  lastNBlocks: 50,
+});
 ```
 
----
+How it works:
 
-### `kit.getAssetsByOwner(options)`
+- calls QuickNode custom RPC method `qn_estimatePriorityFees`
+- maps response to fee levels
 
-Get all NFTs, cNFTs, and tokens owned by a wallet.
+### `getAssetsByOwner(options)`
+
+Gets digital assets owned by a wallet.
+
+Add-on required: `das`
 
 ```ts
-const { items, total } = await kit.getAssetsByOwner({
-  ownerAddress: 'WalletAddress',
-  limit:        50,
-  sortBy:       'created',
-  sortDirection: 'desc',
+const assets = await kit.getAssetsByOwner({
+  ownerAddress: 'WALLET_ADDRESS',
+  limit: 10,
+  page: 1,
 });
 
-items.forEach(asset => {
-  console.log(asset.content.metadata.name);
-  console.log(asset.ownership.owner);
-  console.log(asset.compression?.compressed); // true = cNFT
-});
+console.log(assets.total);
+
+for (const item of assets.items) {
+  console.log(item.id);
+  console.log(item.content.metadata.name);
+  console.log(item.ownership.owner);
+  console.log(item.compression?.compressed);
+}
 ```
 
----
+How it works:
+
+- calls DAS RPC method `getAssetsByOwner`
+
+### `getAsset(mintAddress)`
 
-### `kit.getAsset(mintAddress)`
+Gets one digital asset.
 
-Get a single digital asset by mint address.
+Add-on required: `das`
 
 ```ts
-const asset = await kit.getAsset('NFTMintAddress');
+const asset = await kit.getAsset('ASSET_ID_OR_MINT');
+
+console.log(asset.id);
 console.log(asset.content.metadata.name);
+console.log(asset.content.metadata.symbol);
 console.log(asset.content.metadata.image);
-console.log(asset.royalty?.basis_points);
 ```
 
----
+How it works:
+
+- calls DAS RPC method `getAsset`
+
+### `getAssetsByCollection(options)`
 
-### `kit.searchAssets(options)`
+Gets assets by collection.
 
-Search with filters: owner, creator, collection, token type.
+Add-on required: `das`
 
 ```ts
-const { items } = await kit.searchAssets({
-  ownerAddress: 'WalletAddress',
-  tokenType:    'compressedNFT', // only cNFTs
-  limit:        100,
+const collectionAssets = await kit.getAssetsByCollection({
+  collectionMint: 'COLLECTION_MINT',
+  limit: 20,
+  page: 1,
 });
+
+console.log(collectionAssets.total);
 ```
 
----
+How it works:
+
+- calls DAS RPC method `getAssetsByGroup`
+- uses collection grouping
+
+### `searchAssets(options)`
 
-### `kit.getAssetProof(assetId)`
+Searches digital assets with filters.
 
-Get the Merkle proof for a compressed NFT. Required for cNFT transfers via Bubblegum.
+Add-on required: `das`
+
+By owner:
 
 ```ts
-const proof = await kit.getAssetProof('cNFTAssetId');
-// proof.root + proof.proof → use with mpl-bubblegum transfer instruction
+const result = await kit.searchAssets({
+  ownerAddress: 'WALLET_ADDRESS',
+  limit: 25,
+});
+```
+
+By creator:
+
+```ts
+const result = await kit.searchAssets({
+  creatorAddress: 'CREATOR_ADDRESS',
+  limit: 25,
+});
 ```
 
----
+By collection:
 
-### `kit.getTokenAccounts(walletAddress)`
+```ts
+const result = await kit.searchAssets({
+  collection: 'COLLECTION_MINT',
+  limit: 25,
+});
+```
 
-Get all SPL token accounts and balances for a wallet.
+Compressed NFTs only:
 
 ```ts
-const tokens = await kit.getTokenAccounts('WalletAddress');
-tokens
-  .filter(t => t.uiAmount > 0)
-  .forEach(t => console.log(`${t.mint}: ${t.uiAmount}`));
+const result = await kit.searchAssets({
+  tokenType: 'compressedNFT',
+  compressed: true,
+  limit: 25,
+});
 ```
 
----
+How it works:
 
-### `kit.watchAccount(address, callback, options?)`
+- builds a DAS search request
+- calls DAS RPC method `searchAssets`
 
-Watch an account for real-time updates. Auto-uses Yellowstone if enabled, WebSocket otherwise.
+### `getAssetProof(assetId)`
+
+Gets the Merkle proof for a compressed NFT.
+
+Add-on required: `das`
 
 ```ts
-const handle = kit.watchAccount('WalletAddress', (update) => {
-  console.log('SOL balance:', update.lamports / 1e9);
-  console.log('Backend:', update.backend); // 'yellowstone' or 'websocket'
-});
+const proof = await kit.getAssetProof('ASSET_ID');
 
-// Stop watching:
-handle.unsubscribe();
-handle.isConnected(); // boolean
+console.log(proof.root);
+console.log(proof.proof);
+console.log(proof.tree_id);
 ```
 
----
+How it works:
 
-### `kit.watchProgram(programId, callback, options?)`
+- calls DAS RPC method `getAssetProof`
 
-Watch all transactions for a program in real time.
+### `getTokenAccounts(walletAddress)`
+
+Gets SPL token accounts and balances for a wallet.
+
+Add-on required: none
 
 ```ts
-const JUPITER = 'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4';
+const tokens = await kit.getTokenAccounts('WALLET_ADDRESS');
+
+for (const token of tokens) {
+  if (token.uiAmount > 0) {
+    console.log(token.mint, token.uiAmount);
+  }
+}
+```
+
+How it works:
 
-const handle = kit.watchProgram(JUPITER, (tx) => {
-  if (!tx.err) console.log('Swap:', tx.signature);
+- calls normal Solana RPC method `getTokenAccountsByOwner`
+- uses `jsonParsed` encoding
+
+### `watchAccount(address, onUpdate, options?)`
+
+Watches an account in real time.
+
+Add-on required: none
+
+```ts
+const handle = kit.watchAccount('WALLET_ADDRESS', (update) => {
+  console.log(update.pubkey);
+  console.log(update.lamports);
+  console.log(update.owner);
+  console.log(update.slot);
+  console.log(update.backend);
 });
+
+setTimeout(() => {
+  console.log(handle.isConnected());
+  handle.unsubscribe();
+}, 15000);
 ```
 
----
+How it works:
 
-### `kit.watchSlot(callback)`
+- uses Solana websocket subscriptions through `Connection`
+- if `yellowstone` is set, the code prefers that route
+- current implementation falls back to standard websocket behavior
 
-Subscribe to slot updates (~every 400ms). Free tier, no add-ons needed.
+### `watchProgram(programId, onTx, options?)`
+
+Watches program logs in real time.
+
+Add-on required: none
+
+```ts
+const handle = kit.watchProgram(
+  'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4',
+  (tx) => {
+    console.log(tx.signature);
+    console.log(tx.logs);
+    console.log(tx.err);
+  },
+);
+```
+
+How it works:
+
+- uses `connection.onLogs(...)`
+
+### `watchSlot(onSlot)`
+
+Watches slot changes.
+
+Add-on required: none
 
 ```ts
 const handle = kit.watchSlot((slot) => {
-  process.stdout.write(`\r Slot: ${slot.toLocaleString()}`);
+  console.log(slot);
 });
+
+setTimeout(() => handle.unsubscribe(), 10000);
 ```
 
----
+How it works:
+
+- uses `connection.onSlotChange(...)`
 
-### `kit.getSwapQuote(options)` — PAID (Metis)
+### `getSwapQuote(options)`
 
-Get a Jupiter swap quote without executing.
+Gets a Jupiter quote through the Metis add-on.
+
+Add-on required: `metis`
 
 ```ts
-import { TOKENS } from '@quicknode/solana-kit';
+import { TOKENS } from 'quicknode-solana-kit';
 
 const quote = await kit.getSwapQuote({
-  inputMint:  TOKENS.SOL,
+  inputMint: TOKENS.SOL,
   outputMint: TOKENS.USDC,
-  amount:     BigInt(1_000_000_000), // 1 SOL
+  amount: BigInt(1_000_000_000),
+  slippageBps: 50,
 });
 
-console.log(`1 SOL → ${Number(quote.outAmount) / 1e6} USDC`);
-console.log(`Price impact: ${quote.priceImpactPct}%`);
+console.log(quote.inAmount);
+console.log(quote.outAmount);
+console.log(quote.priceImpactPct);
+console.log(quote.routePlan);
 ```
 
----
+How it works:
+
+- calls REST route `/jupiter/v6/quote`
 
-### `kit.swap(options)` — PAID (Metis)
+### `swap(options)`
 
-Execute a token swap in one call.
+Performs a Jupiter swap through Metis.
+
+Add-on required: `metis`
 
 ```ts
+import bs58 from 'bs58';
+import { Keypair } from '@solana/web3.js';
+import { TOKENS } from 'quicknode-solana-kit';
+
+const signer = Keypair.fromSecretKey(bs58.decode(process.env.WALLET_PRIVATE_KEY!));
+
 const result = await kit.swap({
-  inputMint:     TOKENS.SOL,
-  outputMint:    TOKENS.USDC,
-  amount:        BigInt(100_000_000), // 0.1 SOL
-  userPublicKey: keypair.publicKey.toString(),
-  signer:        keypair,
-  slippageBps:   50,   // 0.5%
-  feeLevel:      'recommended',
+  inputMint: TOKENS.SOL,
+  outputMint: TOKENS.USDC,
+  amount: BigInt(10_000_000),
+  userPublicKey: signer.publicKey.toString(),
+  signer,
+  slippageBps: 100,
+  feeLevel: 'recommended',
 });
 
-console.log('Swapped!', result.signature);
+console.log(result.signature);
+console.log(result.inputAmount);
+console.log(result.outputAmount);
+console.log(result.priceImpactPct);
 ```
 
-Token shortcuts: `TOKENS.SOL`, `TOKENS.USDC`, `TOKENS.USDT`, `TOKENS.BONK`, `TOKENS.JUP`, `TOKENS.RAY`, `TOKENS.WIF`
+How it works:
+
+1. gets a quote
+2. requests a serialized swap transaction
+3. deserializes the base64 transaction
+4. signs locally
+5. sends with normal Solana connection
+6. confirms the result
 
----
+### `getPumpFunTokens(options?)`
 
-### `kit.checkAddOns()`
+Gets recent pump.fun tokens.
 
-Probe your endpoint to see which add-ons are live.
+Add-on required: `pumpfun`
 
 ```ts
-const status = await kit.checkAddOns();
-console.log(status.canUse.smartTransactions); // true/false
-console.log(status.canUse.nftQueries);        // true/false
-console.log(status.addOns);                   // per-add-on detail
+const tokens = await kit.getPumpFunTokens({
+  limit: 10,
+  offset: 0,
+  includeNsfw: false,
+});
+
+for (const token of tokens) {
+  console.log(token.mint, token.symbol, token.marketCapSol);
+}
+```
+
+How it works:
+
+- calls REST route `/pump-fun/coins`
+
+### `getPumpFunToken(mint)`
+
+Gets a single pump.fun token by mint.
+
+Add-on required: `pumpfun`
+
+```ts
+const token = await kit.getPumpFunToken('TOKEN_MINT');
+
+console.log(token.name);
+console.log(token.symbol);
+console.log(token.creator);
+console.log(token.price);
+```
+
+How it works:
+
+- calls REST route `/pump-fun/coins/:mint`
+
+### `getPumpFunTokensByCreator(options)`
+
+Gets pump.fun tokens by creator wallet.
+
+Add-on required: `pumpfun`
+
+```ts
+const created = await kit.getPumpFunTokensByCreator({
+  creator: 'CREATOR_WALLET',
+  limit: 20,
+  offset: 0,
+});
+```
+
+How it works:
+
+- calls `/pump-fun/coins?creator=...`
+
+### `getPumpFunTokenHolders(mint)`
+
+Gets holder distribution for a token.
+
+Add-on required: `pumpfun`
+
+```ts
+const holders = await kit.getPumpFunTokenHolders('TOKEN_MINT');
+
+for (const holder of holders.slice(0, 10)) {
+  console.log(holder.address, holder.balance, holder.percentage);
+}
+```
+
+How it works:
+
+- calls REST route `/pump-fun/coins/:mint/holders`
+
+### `getPumpFunTokenTrades(mint, options?)`
+
+Gets recent trades for a token.
+
+Add-on required: `pumpfun`
+
+```ts
+const trades = await kit.getPumpFunTokenTrades('TOKEN_MINT', {
+  limit: 25,
+  offset: 0,
+});
+
+for (const trade of trades) {
+  console.log(trade.signature, trade.isBuy, trade.solAmount, trade.tokenAmount);
+}
 ```
 
----
+How it works:
+
+- calls REST route `/pump-fun/trades/all`
+
+### `getStablecoinBalance(options)`
+
+Gets stablecoin balances across multiple chains.
+
+Add-on required: `stablecoinBalance`
+
+```ts
+const balances = await kit.getStablecoinBalance({
+  walletAddress: 'WALLET_ADDRESS',
+  chains: ['solana', 'ethereum', 'base'],
+});
+
+console.log(balances.totalUsdValue);
+
+for (const balance of balances.balances) {
+  console.log(balance.chain, balance.symbol, balance.balance, balance.usdValue);
+}
+```
+
+How it works:
+
+- calls custom RPC method `qn_getWalletStablecoinBalances`
+
+### `getOpenOceanQuote(options)`
+
+Gets a swap quote from OpenOcean.
+
+Add-on required: `openocean`
+
+```ts
+const quote = await kit.getOpenOceanQuote({
+  inTokenAddress: 'So11111111111111111111111111111111111111112',
+  outTokenAddress: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+  amount: '1000000000',
+  slippage: 1,
+});
+
+console.log(quote.inAmount);
+console.log(quote.outAmount);
+console.log(quote.minOutAmount);
+console.log(quote.priceImpact);
+```
+
+How it works:
+
+- calls REST route `/openocean/v4/solana/quote`
+
+### `openOceanSwap(options)`
+
+Performs a swap through OpenOcean.
+
+Add-on required: `openocean`
+
+```ts
+import bs58 from 'bs58';
+import { Keypair } from '@solana/web3.js';
+
+const signer = Keypair.fromSecretKey(bs58.decode(process.env.WALLET_PRIVATE_KEY!));
+
+const result = await kit.openOceanSwap({
+  inTokenAddress: 'So11111111111111111111111111111111111111112',
+  outTokenAddress: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+  amount: '10000000',
+  slippage: 1,
+  userAddress: signer.publicKey.toString(),
+  signer,
+});
+
+console.log(result.signature);
+console.log(result.inAmount);
+console.log(result.outAmount);
+```
+
+How it works:
+
+1. requests serialized transaction from add-on
+2. decodes base64 transaction
+3. signs locally
+4. sends using normal Solana connection
+5. confirms it
+
+### `sendMerkleProtectedTransaction(options)`
+
+Sends a signed transaction through Merkle for MEV protection.
+
+Add-on required: `merkle`
+
+```ts
+const result = await kit.sendMerkleProtectedTransaction({
+  serializedTransaction: signedTxBase64,
+  tipLamports: 10_000,
+});
+
+console.log(result.signature);
+console.log(result.provider);
+```
+
+How it works:
+
+- calls custom RPC method `mev_sendTransaction`
+- confirms with normal Solana connection
+
+### `sendBlinkLabsTransaction(options)`
+
+Sends a signed transaction through Blink Labs.
+
+Add-on required: `blinklabs`
+
+```ts
+const result = await kit.sendBlinkLabsTransaction({
+  serializedTransaction: signedTxBase64,
+  tipLamports: 5_000,
+});
+
+console.log(result.signature);
+console.log(result.provider);
+```
+
+How it works:
+
+- calls custom RPC method `blinklabs_sendTransaction`
+- confirms with normal Solana connection
+
+### `sendIrisTransaction(options)`
+
+Sends a signed transaction through the Iris add-on.
+
+Add-on required: `iris`
+
+```ts
+const result = await kit.sendIrisTransaction({
+  serializedTransaction: signedTxBase64,
+  skipPreflight: false,
+  maxRetries: 3,
+});
+
+console.log(result.signature);
+console.log(result.slot);
+console.log(result.confirmationMs);
+```
+
+How it works:
+
+- calls custom RPC method `iris_sendTransaction`
+- confirms with normal Solana RPC
+
+### `getGoldRushBalances(options)`
+
+Gets multichain balances through GoldRush.
+
+Add-on required: `goldrush`
+
+```ts
+const balances = await kit.getGoldRushBalances({
+  walletAddress: 'WALLET_ADDRESS',
+  chain: 'solana-mainnet',
+  noSpam: true,
+  quoteCurrency: 'USD',
+});
+
+console.log(balances.chain);
+console.log(balances.address);
+
+for (const item of balances.items) {
+  console.log(item.symbol, item.balance, item.usdBalance);
+}
+```
+
+How it works:
+
+- calls REST route under `/goldrush/v1/`
+
+### `getGoldRushTransactions(options)`
+
+Gets multichain transaction history through GoldRush.
+
+Add-on required: `goldrush`
+
+```ts
+const txs = await kit.getGoldRushTransactions({
+  walletAddress: 'WALLET_ADDRESS',
+  chain: 'solana-mainnet',
+  pageSize: 25,
+  pageNumber: 0,
+});
+
+for (const tx of txs.items) {
+  console.log(tx.txHash, tx.successful, tx.value);
+}
+```
+
+How it works:
+
+- calls REST route under `/goldrush/v1/`
+
+### `getTitanSwapQuote(options)`
+
+Gets a swap quote from Titan.
+
+Add-on required: `titan`
+
+```ts
+const quote = await kit.getTitanSwapQuote({
+  inputMint: 'So11111111111111111111111111111111111111112',
+  outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+  amount: '1000000000',
+  slippageBps: 50,
+});
+
+console.log(quote.inAmount);
+console.log(quote.outAmount);
+console.log(quote.routes);
+```
+
+How it works:
+
+- calls REST route `/titan/v1/quote`
+
+### `titanSwap(options)`
+
+Performs a swap through Titan.
+
+Add-on required: `titan`
+
+```ts
+const result = await kit.titanSwap({
+  inputMint: 'So11111111111111111111111111111111111111112',
+  outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+  amount: '10000000',
+  slippageBps: 50,
+  userPublicKey: 'WALLET_PUBLIC_KEY',
+});
+
+console.log(result.signature);
+console.log(result.inAmount);
+console.log(result.outAmount);
+```
+
+How it works:
+
+1. gets a Titan quote
+2. requests a serialized transaction
+3. deserializes it
+4. sends it through normal Solana connection
+5. confirms it
+
+### `subscribeTitanQuotes(options, onQuote, onError?)`
+
+Subscribes to live quote updates from Titan over WebSocket.
+
+Add-on required: `titan`
+
+```ts
+const unsubscribe = kit.subscribeTitanQuotes(
+  {
+    inputMint: 'So11111111111111111111111111111111111111112',
+    outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+    amount: '1000000000',
+    slippageBps: 50,
+  },
+  (quote) => {
+    console.log('quote', quote.outAmount);
+  },
+  (err) => {
+    console.error(err);
+  },
+);
+
+setTimeout(() => unsubscribe(), 15000);
+```
+
+How it works:
+
+- opens a WebSocket to the Titan stream route on your endpoint
+
+### `assessWalletRisk(options)`
+
+Gets Scorechain risk information for a wallet.
+
+Add-on required: `scorechain`
+
+```ts
+const assessment = await kit.assessWalletRisk({
+  address: 'WALLET_ADDRESS',
+  network: 'solana',
+});
+
+console.log(assessment.address);
+console.log(assessment.riskScore);
+console.log(assessment.riskLevel);
+console.log(assessment.amlStatus);
+console.log(assessment.flags);
+```
+
+How it works:
+
+- calls REST route `/scorechain/v1/risk`
+
+### `isWalletSafe(address)`
+
+Returns a simple safe/unsafe boolean using Scorechain.
+
+Add-on required: `scorechain`
+
+This returns `true` only when:
+
+- `amlStatus === 'clean'`
+- `riskLevel === 'low'`
+
+```ts
+const safe = await kit.isWalletSafe('WALLET_ADDRESS');
+console.log(safe);
+```
+
+How it works:
+
+- first calls `assessWalletRisk()`
+- then applies a simple clean + low-risk check
+
+## Token Constants
+
+### `TOKENS`
+
+Useful for Jupiter / Metis examples.
+
+```ts
+import { TOKENS } from 'quicknode-solana-kit';
+
+console.log(TOKENS.SOL);
+console.log(TOKENS.USDC);
+console.log(TOKENS.USDT);
+console.log(TOKENS.BONK);
+console.log(TOKENS.JUP);
+console.log(TOKENS.RAY);
+console.log(TOKENS.WIF);
+```
+
+### `OO_TOKENS`
+
+Useful for OpenOcean examples.
+
+```ts
+import { OO_TOKENS } from 'quicknode-solana-kit';
+
+console.log(OO_TOKENS.SOL);
+console.log(OO_TOKENS.USDC);
+console.log(OO_TOKENS.USDT);
+console.log(OO_TOKENS.BONK);
+```
 
 ## Error Handling
 
-Every error is typed and tells you exactly what went wrong and how to fix it.
+The package exports custom errors:
+
+- `AddOnNotEnabledError`
+- `TransactionFailedError`
+- `TransactionTimeoutError`
+- `MaxRetriesExceededError`
+- `InvalidEndpointError`
+- `RPCError`
+
+Example:
 
 ```ts
 import {
   AddOnNotEnabledError,
+  RPCError,
   TransactionFailedError,
-  TransactionTimeoutError,
   MaxRetriesExceededError,
-  RPCError,
-} from '@quicknode/solana-kit';
+} from 'quicknode-solana-kit';
 
 try {
   await kit.sendSmartTransaction({ transaction, signer });
 } catch (err) {
   if (err instanceof AddOnNotEnabledError) {
-    // Clear message with link to enable the add-on in the dashboard
-    console.error(err.message);
+    console.error('Enable the missing add-on in QuickNode and update kit config.');
   } else if (err instanceof TransactionFailedError) {
-    // On-chain failure — check logs
-    console.error('Failed on-chain:', err.reason);
-    console.error('Explorer:', `https://explorer.solana.com/tx/${err.signature}`);
-  } else if (err instanceof TransactionTimeoutError) {
-    console.error('Timed out. Try a higher feeLevel.');
+    console.error('On-chain failure:', err.signature, err.reason);
   } else if (err instanceof MaxRetriesExceededError) {
-    console.error(`Failed after ${err.maxRetries} retries.`);
+    console.error('Retries exhausted:', err.maxRetries);
   } else if (err instanceof RPCError) {
-    console.error(`RPC ${err.statusCode}:`, err.message);
+    console.error('RPC error:', err.statusCode, err.message);
+  } else {
+    console.error(err);
   }
 }
 ```
 
----
+## Included Example Scripts
 
-## Tree-Shaking
+```bash
+npm run example:tx
+npm run example:nft
+npm run example:stream
+npm run example:swap
+npm run example:all
+```
 
-Import only what you need for smaller bundles:
+Suggested `.env` values:
 
-```ts
-// Individual function imports (fully tree-shakeable)
-import { estimatePriorityFees }  from '@quicknode/solana-kit';
-import { getAssetsByOwner }      from '@quicknode/solana-kit';
-import { watchAccount }          from '@quicknode/solana-kit';
-import { swap, TOKENS }          from '@quicknode/solana-kit';
+```bash
+QN_ENDPOINT_URL=
+WALLET_PRIVATE_KEY=
+WALLET_ADDRESS=
+ADDON_PRIORITY_FEES=true
+ADDON_DAS=true
+ADDON_METIS=true
+EXECUTE_SWAP=false
 ```
 
----
+## Recommended Learning Order
 
-## Running the Examples
+If you are new to Solana or QuickNode, this order works well:
 
-```bash
-# Clone and install
-git clone https://github.com/quiknode-labs/qn-solana-kit
-cd qn-solana-kit
-npm install
+1. create `kit`
+2. use `kit.connection.getBalance()`
+3. use `kit.getTokenAccounts()`
+4. run `kit.checkAddOns()`
+5. if `priorityFees` is enabled, try `kit.estimatePriorityFees()`
+6. if `das` is enabled, try `kit.getAssetsByOwner()`
+7. if `metis` is enabled, try `kit.getSwapQuote()`
 
-# Setup environment
-cp .env.example .env
-# Fill in QN_ENDPOINT_URL (required)
-# Fill in WALLET_ADDRESS and WALLET_PRIVATE_KEY for tx/swap examples
+## Starter Example
 
-# Check which add-ons are active on your endpoint
-npm run check
+```ts
+import { PublicKey } from '@solana/web3.js';
+import { QNSolanaKit } from 'quicknode-solana-kit';
+
+const kit = new QNSolanaKit({
+  endpointUrl: process.env.QN_ENDPOINT_URL!,
+  addOns: {
+    priorityFees: true,
+    das: true,
+  },
+});
 
-# Run individual examples
-npm run example:tx      # Smart transaction (needs Priority Fee API add-on)
-npm run example:nft     # NFT queries (needs DAS API add-on)
-npm run example:stream  # Live streaming (works on free tier)
-npm run example:swap    # Jupiter swap quote (needs Metis add-on)
+async function main() {
+  const wallet = new PublicKey('E645TckHQnDcavVv92Etc6xSWQaq8zzPtPRGBheviRAk');
 
-# Run all
-npm run example:all
+  const balance = await kit.connection.getBalance(wallet);
+  console.log('SOL balance:', balance / 1e9);
+
+  const tokenAccounts = await kit.getTokenAccounts(wallet.toString());
+  console.log('Token accounts:', tokenAccounts.length);
+
+  const fees = await kit.estimatePriorityFees();
+  console.log('Recommended priority fee:', fees.recommended);
+
+  const assets = await kit.getAssetsByOwner({
+    ownerAddress: wallet.toString(),
+    limit: 5,
+  });
+  console.log('Assets:', assets.items.length);
+}
+
+main().catch(console.error);
 ```
 
+## Current Limitations
+
+- `yellowstone` is exposed in config and add-on checks, but account streaming currently falls back to standard Solana WebSockets
+- `liljit` is probed by `checkAddOns()`, but `sendSmartTransaction()` does not currently route through Jito bundles
+- `sendSmartTransaction()` works without `priorityFees`, but falls back to a default compute unit price
+- several swap integrations return a serialized transaction that the SDK then signs and sends locally
+
+## Beginner Guide
+
+If you want a more beginner-first walkthrough, see:
 
-## Links
+- [readmetounderstand.md](/home/rachit/Videos/QuickNode-Starter-Kit/qn-solana-kit-v2/readmetounderstand.md)
 
-- QuickNode Dashboard: https://dashboard.quicknode.com
-- Add-ons Marketplace: https://marketplace.quicknode.com
-- Priority Fee API: https://www.quicknode.com/docs/solana/qn_estimatePriorityFees
-- Metaplex DAS API: https://www.quicknode.com/docs/solana/getAsset
-- Metis (Jupiter): https://marketplace.quicknode.com/add-ons/metis-jupiter-v6-swap-api
-- Yellowstone gRPC: https://marketplace.quicknode.com/add-ons/yellowstone-grpc
+## License
 
----
+MIT