> For the complete documentation index, see [llms.txt](https://docs.rome.builders/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rome.builders/es/casos-de-uso/defi-protocols.md).

# Protocolos DeFi

Patrones de integración para DeFi EVM en Rome: préstamos con oráculos de Solana, composición de Jupiter y Kamino desde Solidity, y pools de liquidez compartida.

Rome permite a los protocolos DeFi de EVM componerse atómicamente con el ecosistema DeFi nativo de Solana. Esta página cubre patrones de integración comunes. Varios ya están activos en Rome — Aave v3, Compound v3 (Aerarium), Uniswap V2/V3/V4 y Rome DEX — vea [Apps en Rome](https://docs.rome.builders/es/apps-en-rome/apps.md).

El código a continuación es ilustrativo; los nombres de las interfaces para programas de Solana de terceros son ejemplos, no interfaces de SDK incluidas.

## ¿Por qué DeFi en Rome?

* **Acceso a liquidez de Solana** — Jupiter, Kamino, Drift, Meteora, Raydium, Orca
* **Componibilidad atómica** — operaciones DeFi de varios pasos en una sola transacción
* **Herramientas de Solidity** — ecosistema de desarrollo y auditoría familiar
* **Estado compartido** — los usuarios de EVM y Solana comparten los mismos pools

## Patrón 1: Protocolo de préstamos con oráculos de Solana

La importación a continuación proviene de [`rome-solidity`](https://github.com/rome-protocol/rome-solidity), que se instala desde GitHub, no desde npm: `npm install github:rome-protocol/rome-solidity`, o `forge install rome-protocol/rome-solidity` con la reasignación `@rome-protocol/rome-solidity/=lib/rome-solidity/` (detalles en [Desplegar contratos de Solidity](https://docs.rome.builders/es/guias-para-desarrolladores/deploy-solidity.md#using-the-rome-solidity-sdk)). Pasa la dirección del feed desde el [registro](https://docs.rome.builders/es/productos/oracle-gateway.md#consume-a-feed-in-three-steps) en lugar de codificarla de forma fija.

```solidity
import {IAggregatorV3Interface} from "@rome-protocol/rome-solidity/contracts/oracle/IAggregatorV3Interface.sol";

contract RomeLending {
    IAggregatorV3Interface public priceFeed;

    constructor(address _priceFeed) {
        priceFeed = IAggregatorV3Interface(_priceFeed);
    }

    function getCollateralValue(uint256 amount) public view returns (uint256) {
        (, int256 price,,,) = priceFeed.latestRoundData();
        // Precio de Pyth/Switchboard a través de Oracle Gateway
        // Misma interfaz que Chainlink en Ethereum
        return (amount * uint256(price)) / 1e8;
    }
}
```

## Patrón 2: Agregador DEX mediante CPI

```solidity
contract RomeSwap {
    function swap(
        bytes32 fromMint,
        bytes32 toMint,
        uint256 amount,
        uint256 minOut
    ) external {
        // CPI a Jupiter/Raydium/Meteora
        // Toda la liquidez de los DEX de Solana accesible desde Solidity
        CpiProgram.invoke(JUPITER_PROGRAM, accounts, swapData);
    }
}
```

## Patrón 3: Bóveda de rendimiento

```solidity
contract YieldVault {
    function deposit(uint256 amount) external {
        // Aceptar depósito de USDC
        // CPI → Jupiter: intercambiar por los tokens óptimos
        // CPI → Kamino: aportar como garantía
        // CPI → Drift: abrir cobertura delta neutral
        // Todo atómico — una tx, todo o nada
    }
}
```

## Patrón 4: Arbitraje entre protocolos

Usando `RemusTx` (varias transacciones EVM en diferentes cadenas Rome, atómicas en una sola transacción de Solana):

1. Comprar en el DEX A en una cadena Rome
2. Vender en el DEX B en otra cadena Rome
3. Ambas se ejecutan atómicamente; si alguna falla, ambas se revierten.

## Implementaciones de referencia

Crea una aplicación Rome que funcione en lugar de empezar desde una página en blanco:

* [**rome-dex**](https://github.com/rome-protocol/rome-dex) — AMM de doble carril; lleva una nueva idea y desplégala para usuarios de Solana y EVM sobre un solo pool.
* [**aerarium**](https://github.com/rome-protocol/aerarium) — interfaz de préstamo de Compound v3 de doble carril.
* [**cardo**](https://github.com/rome-protocol/cardo) — portal de distribución de aplicaciones vía CPI (swap / préstamo / perps / composición).
* [**rome-aave-v3-demo**](https://github.com/rome-protocol/rome-aave-v3-demo) — interfaz de préstamo de Aave v3.
* [**compound-on-rome-comet**](https://github.com/rome-protocol/compound-on-rome-comet) — los contratos de mercado monetario Comet.
* [**rome-oracle-gateway**](https://github.com/rome-protocol/rome-oracle-gateway) — una aplicación cross-VM desde cero: lee cuentas de precios de Solana (Pyth, Switchboard), las publica en EVM y las sirve a Solidity a través de Chainlink estándar `AggregatorV3Interface`.

## Relacionado

* [Pasarela de oráculos](https://docs.rome.builders/es/productos/oracle-gateway.md) — feeds de precios compatibles con Chainlink
* [Rome SDK](https://docs.rome.builders/es/productos/rome-sdk.md) — interfaces tipadas para protocolos DeFi


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

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

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.rome.builders/es/casos-de-uso/defi-protocols.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
