> ## Documentation Index
> Fetch the complete documentation index at: https://docs.raydium.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Cadena de herramientas

> Configuración mínima para leer el estado en cadena de Raydium, construir transacciones y desarrollar contra los programas. Solana CLI, Anchor, SDKs en TypeScript y Python, y consejos para devnet/localnet.

<Info>
  **Esta página fue traducida automáticamente por IA. La versión en inglés es la fuente autorizada.**

  [Ver versión en inglés →](/solana-fundamentals/toolchain)
</Info>

<Info>
  Toda la documentación aquí asume que tienes una cadena de herramientas de desarrollo Solana funcional. Esta página enumera las herramientas, las versiones mínimas conocidas para funcionar con Raydium a partir de abril de 2026, y los problemas específicos de configuración. Comienza aquí antes de ejecutar cualquiera de los ejemplos de código en capítulos posteriores.
</Info>

## Herramientas principales

### Solana CLI

La interfaz de línea de comandos canónica para interactuar con clusters de Solana — gestión de carteras, llamadas RPC, despliegue de programas.

Instalar:

```bash theme={null}
sh -c "$(curl -sSfL https://release.solana.com/v1.18.22/install)"
# O la última estable:
sh -c "$(curl -sSfL https://release.solana.com/stable/install)"
```

Verificar:

```bash theme={null}
solana --version   # → solana-cli 1.18.22 (o posterior)
```

Configurar para mainnet:

```bash theme={null}
solana config set --url https://api.mainnet-beta.solana.com
solana config set --keypair ~/.config/solana/id.json
solana-keygen new                           # crear una cartera si no tienes una
solana address                              # tu clave pública
```

Para pruebas de Raydium, casi siempre querrás una cartera devnet financiada:

```bash theme={null}
solana config set --url https://api.devnet.solana.com
solana airdrop 2                            # 2 SOL para pruebas
```

### SPL Token CLI

La CLI oficial para operaciones SPL Token / Token-2022 — crear mints, acuñar tokens, transferencias.

Instalar (incluido en Solana CLI):

```bash theme={null}
spl-token --version
```

Operaciones comunes:

```bash theme={null}
spl-token create-token                                  # crear un mint de SPL Token
spl-token create-token --program-id TOKEN_2022 ...      # crear un mint de Token-2022
spl-token create-account <MINT>                         # crear una ATA
spl-token mint <MINT> 1000                              # acuñar 1000 tokens en tu ATA
spl-token transfer <MINT> 100 <RECIPIENT>               # transferir 100
spl-token display <ACCOUNT_OR_MINT>                     # inspeccionar
```

### Anchor CLI

Necesario para obtener IDLs de Raydium, construir clientes y verificar programas.

Instalar:

```bash theme={null}
cargo install --git https://github.com/coral-xyz/anchor avm --locked
avm install 0.30.1
avm use 0.30.1
anchor --version
```

Operaciones comunes:

```bash theme={null}
anchor idl fetch <PROGRAM_ID> -o program.idl.json       # obtener el IDL en cadena
anchor idl init -f idl.json <PROGRAM_ID>                # subir un IDL
anchor build                                             # construir un programa desde el código fuente
```

## Configuración de TypeScript

La ruta de integración principal para Raydium.

### Paquetes

```bash theme={null}
npm install \
  @solana/web3.js \
  @solana/spl-token \
  @coral-xyz/anchor \
  @raydium-io/raydium-sdk-v2 \
  bn.js \
  decimal.js
```

Versiones conocidas para funcionar juntas a partir de abril de 2026:

| Paquete                      | Versión       |
| ---------------------------- | ------------- |
| `@solana/web3.js`            | ≥1.95         |
| `@solana/spl-token`          | ≥0.4          |
| `@coral-xyz/anchor`          | ≥0.30         |
| `@raydium-io/raydium-sdk-v2` | ≥0.2.42-alpha |

### Script mínimo

```ts theme={null}
import { Connection, Keypair } from "@solana/web3.js";
import { Raydium } from "@raydium-io/raydium-sdk-v2";

const connection = new Connection("https://api.mainnet-beta.solana.com", "confirmed");
const owner      = Keypair.fromSecretKey(/* tu clave */);

const raydium = await Raydium.load({
  connection,
  owner,
  cluster:      "mainnet",
  disableFeatureCheck: true,
});

const poolInfo = await raydium.api.fetchPoolById({ id: "..." });
console.log(poolInfo);
```

Consulta [`sdk-api/typescript-sdk`](/es/sdk-api/typescript-sdk) para la referencia completa del SDK.

## Configuración de Rust

Para integración de CPI y programas en cadena.

### Cadena de herramientas

```bash theme={null}
rustup install 1.76.0           # o lo que Anchor actualmente requiera
rustup component add rustfmt clippy
solana-install init 1.18.22     # cadena de herramientas BPF incluida
```

### Cargo.toml del programa para una integración de CPI de Raydium

```toml theme={null}
[dependencies]
anchor-lang        = "0.30.1"
anchor-spl         = "0.30.1"
raydium-cp-swap    = { version = "0.2", features = ["cpi"] }
raydium-clmm       = { version = "0.1", features = ["cpi"] }
```

La característica `"cpi"` importa el módulo `cpi` con ayudantes de CPI (así puedes usar `raydium_cp_swap::cpi::swap_base_input(...)`). Consulta [`sdk-api/rust-cpi`](/es/sdk-api/rust-cpi).

## Configuración de Python

Ruta de integración secundaria — común para desarrolladores de bots.

### Paquetes

```bash theme={null}
pip install solders solana-py anchorpy
pip install raydium-py    # SDK de Raydium de la comunidad (no oficial)
```

Versiones:

| Paquete      | Versión |
| ------------ | ------- |
| `solders`    | ≥0.21   |
| `solana-py`  | ≥0.34   |
| `anchorpy`   | ≥0.21   |
| `raydium-py` | ≥0.2.1  |

### Script mínimo

```python theme={null}
from solana.rpc.async_api import AsyncClient
from solders.keypair import Keypair
from anchorpy import Provider, Wallet, Program

async def main():
    conn = AsyncClient("https://api.mainnet-beta.solana.com")
    owner = Keypair()
    wallet = Wallet(owner)
    provider = Provider(conn, wallet)

    # Cargar IDL y programa
    with open("cpmm.idl.json") as f:
        idl = json.load(f)
    program = Program(idl, CPMM_PROGRAM_ID, provider)

    pool = await program.account["PoolState"].fetch(pool_id)
    print(pool)
```

Consulta [`sdk-api/python-integration`](/es/sdk-api/python-integration).

## Puntos finales RPC

El RPC público de mainnet (`api.mainnet-beta.solana.com`) tiene un límite de velocidad muy alto y se acelera bajo cualquier carga. Para uso no trivial, obtén un punto final privado:

| Proveedor          | Notas                                          |
| ------------------ | ---------------------------------------------- |
| Helius             | El más popular; nivel gratuito generoso.       |
| Triton             | Empresa; precios premium, estable.             |
| QuickNode          | Sólido; latencia sub-segundo.                  |
| Tu propio nodo RPC | Cuesta \~\$500/mes en hardware; control total. |

Configurar:

```ts theme={null}
const connection = new Connection("https://mainnet.helius-rpc.com/?api-key=...");
```

Algunas operaciones RPC necesitan capacidades extendidas:

* `getProgramAccounts` — los escaneos sin restricciones son costosos; algunos proveedores los limitan o cobran por escaneo.
* `getPriorityFeeEstimate` — punto final específico de Helius; otros tienen equivalentes.
* `geyser` / transmisión de WebSocket — necesario para bots de baja latencia; no todos los proveedores lo exponen.

## Devnet y localnet

### Devnet

El cluster de prueba público de Solana. Raydium tiene un despliegue parcial en devnet:

* Algunos pools CPMM existen para pruebas.
* AMM v4 tiene pools devnet históricos.
* CLMM tiene algunos pools de demostración.
* Farm v6 está desplegado.

```bash theme={null}
solana config set --url https://api.devnet.solana.com
solana airdrop 2
```

El SDK soporta devnet mediante `cluster: "devnet"`:

```ts theme={null}
const raydium = await Raydium.load({ connection, owner, cluster: "devnet" });
```

**Advertencia**: los pools devnet tienen liquidez escasa y pueden tener estado obsoleto. No confíes en devnet para descubrimiento de precios; úsalo solo para construir y probar flujos de instrucciones.

### Localnet con estado mainnet bifurcado

Para pruebas realistas, bifurca el estado mainnet en un validador local:

```bash theme={null}
solana-test-validator \
  --url https://api.mainnet-beta.solana.com \
  --clone CPMMoo8L3F4NbTegBCKVNunggL7H1Zpdmwpwh8KMoZ0F \
  --clone CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK \
  --clone <SOME_POOL_ID> \
  --clone <SOME_MINT_ID>
```

Esto clona el estado específico del programa/cuenta a localhost, donde puedes transaccionar libremente. Ideal para:

* Pruebas unitarias de tu integración de CPI contra un programa Raydium real.
* Reproducir una transacción con un parámetro modificado para depuración.
* Prueba de estrés con volúmenes sintéticos grandes.

El equipo de Raydium usa localnet bifurcado extensivamente para pruebas de regresión antes del despliegue en mainnet.

## Plantillas de proyecto

### Inicio de integración de TypeScript

```
my-raydium-app/
├── package.json
├── tsconfig.json
├── src/
│   ├── swap.ts           # ejemplo de swap
│   ├── add-liquidity.ts
│   └── read-pool.ts
└── .env                  # URL RPC, ruta de cartera
```

`package.json` mínimo:

```json theme={null}
{
  "name": "my-raydium-app",
  "type": "module",
  "scripts": { "swap": "tsx src/swap.ts" },
  "dependencies": {
    "@raydium-io/raydium-sdk-v2": "^0.2.42-alpha",
    "@solana/web3.js": "^1.95",
    "@solana/spl-token": "^0.4"
  },
  "devDependencies": {
    "@types/node": "^20",
    "tsx": "^4",
    "typescript": "^5"
  }
}
```

### Inicio de programa CPI de Anchor

```
my-raydium-cpi/
├── Anchor.toml
├── Cargo.toml
├── programs/
│   └── my-cpi/
│       ├── Cargo.toml
│       └── src/lib.rs
└── tests/
    └── my-cpi.ts
```

Con Anchor 0.30:

```bash theme={null}
anchor init my-raydium-cpi
cd my-raydium-cpi
# añadir raydium-cp-swap a Cargo.toml con features = ["cpi"]
anchor build
anchor test
```

## Utilidades CLI útiles

### `solana-keygen`

```bash theme={null}
solana-keygen new --outfile ./wallet.json          # generar una clave
solana-keygen pubkey ./wallet.json                 # mostrar clave pública
```

### Leer cualquier cuenta

```bash theme={null}
solana account <ADDRESS> --output json-compact
```

Útil para inspeccionar el estado del pool sin un decodificador.

### Registros del programa

```bash theme={null}
solana logs | grep CPMMoo8                         # seguir registros de tx relacionados con CPMM
```

### Inspección de transacciones

```bash theme={null}
solana confirm <TX_SIGNATURE> -v                   # imprime registros en formato legible
```

O a través del [explorador](https://explorer.solana.com) — pega la firma y mira la pestaña "Program Logs".

## Higiene del entorno

### Carteras separadas por propósito

* **Cartera de desarrollo**: contiene SOL de testnet, se usa para construir.
* **Cartera de producción**: contiene SOL real, se usa solo para despliegues / envíos multifirma.
* **Cartera activa para bots**: saldo pequeño, permisos estrechos.

Las claves nunca deben estar codificadas. Usa variables de entorno o gestores de secretos.

### Patrón `.env`

```
# .env (no confirmado)
SOLANA_RPC_URL=https://mainnet.helius-rpc.com/?api-key=...
WALLET_PATH=/Users/you/.config/solana/id.json
```

```ts theme={null}
import { config } from "dotenv";
config();

const connection = new Connection(process.env.SOLANA_RPC_URL!);
```

### Fijación de versiones

Bloquea todas las dependencias del ecosistema Solana. El ecosistema se mueve rápido; un aumento de versión menor de `@solana/web3.js` ha introducido cambios significativos anteriormente. Usa `package-lock.json` / `Cargo.lock` religiosamente.

## Enlaces relacionados

* [`sdk-api/typescript-sdk`](/es/sdk-api/typescript-sdk) — Referencia del SDK de TypeScript.
* [`sdk-api/rust-cpi`](/es/sdk-api/rust-cpi) — Uso de CPI en Rust.
* [`sdk-api/python-integration`](/es/sdk-api/python-integration) — Configuración de Python.
* [`solana-fundamentals/programs-and-anchor`](/es/solana-fundamentals/programs-and-anchor) — Información de Anchor.

Fuentes:

* [Documentación de instalación de Solana](https://docs.solana.com/cli/install-solana-cli-tools).
* [Anchor book: getting started](https://book.anchor-lang.com/getting_started/installation.html).
* [Raydium SDK v2 repo](https://github.com/raydium-io/raydium-sdk-V2).