> 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/referencia/precompiles.md).

# Referencia de precompilados

Cada método de los precompilados de interoperabilidad con Solana de Rome: dirección, firma Solidity, selector y si lee, invoca o prepara una CPI.

Los selectores que despacha el programa en cadena de Rome, por precompilado. Selector = `keccak256(signature)[:4]`; cada fila de abajo se verifica contra eso. Las interfaces de Solidity están en [`rome-solidity/contracts/interface.sol`](https://github.com/rome-protocol/rome-solidity/blob/master/contracts/interface.sol).

**Lee la columna Dispatch antes que nada.** Indica qué hace un método al estado de Solana:

| Dispatch                | Qué ocurre                                                                                                                                                                                                                      | CPI real de Solana | Permitido en ejecución iterativa |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | -------------------------------- |
| `Invocar` / `Compuesto` | Uno o más CPI, firmados como el PDA de autoridad externa del llamador donde aplican las semillas. En el **legado** ruta se ejecutan inmediatamente; en la **caché** ruta se preparan y se confirman al final de la transacción. | Sí                 | Legado: **no**. En caché: sí     |
| `EthCall`               | Cálculo puro o una lectura del propio estado de Rome                                                                                                                                                                            | No                 | Sí                               |
| `CrossStateEthCall`     | Una lectura de los bytes de otra cuenta de Solana, precargados por emulación. Sin CPI, sin efectos secundarios.                                                                                                                 | No                 | Sí                               |
| `Precompilado`          | Criptografía determinista (los precompilados estándar de Ethereum)                                                                                                                                                              | No                 | Sí                               |

Un contrato usa **una ruta**: ya sea los precompilados legacy (`0xff…07`, `0xff…08`, `0xff…09`, `0x42…16`) o los de caché (`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`). Mezclar llamadas mutantes de ambas en una transacción se rechaza en tiempo de ejecución. Las lecturas siguen permitidas, con una excepción: una vez que se ha ejecutado una invoke de la ruta en caché, las lecturas de la ruta legacy se rechazan durante el resto de la transacción. Véase [Integra un programa de Solana](https://docs.rome.builders/es/guias-para-desarrolladores/integrate-solana-program.md).

**Quién paga.** El pagador de comisiones de Solana adelanta cada lamport que gasta un CPI de la ruta legacy (renta, transferencias, `swap_gas_to_lamports`); el programa mide el saldo del pagador alrededor de cada CPI y carga al usuario el gasto neto como gas al precio del gas, reembolsando los lamports que devuelve un CPI.

**Quién firma.** Un contrato que llama a un precompile actúa como sí mismo: el firmante es el PDA de autoridad externa del contrato (`["EXTERNAL_AUTHORITY", contract]`). El propio PDA de un usuario firma solo en una transacción que el usuario envía directamente a la dirección del precompile. Bajo `DELEGATECALL` / `CALLCODE`, los selectores mutantes se rechazan excepto `create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint` y `create_and_init_mint` en HelperProgram, `create_ata*` en ASplCached, y `invoke` / `invoke_signed` en CpiProgram. Están exentos porque su destino está ligado al llamador o financiado por el operador, no porque no firmen nada: `create_and_init_mint` todavía firma con el PDA del llamador externo para pagar la renta del mint y solo puede crear un mint cuyas autoridades sean ese PDA, y `invoke` / `invoke_signed` rechazan la autoridad desnuda (`DelegatecallOwnerAuthority`) y asignan un namespace a los PDA con sal en la dirección del contrato en ejecución.

Todos los métodos son no pagables (`msg.value > 0` revierte con `TransferProhibited`) excepto `withdrawal(bytes32)`. Los métodos marcados *solo de un estado* se rechazan en cadenas op-geth-stack. Un CPI no puede nombrar al pagador de comisiones de Solana (excepto dentro de una instrucción simple de transferencia de System) ni al programa Rome, y no puede llamar al programa Rome.

## SystemCached (`0xff00000000000000000000000000000000000004`)

Creación de PDA + operaciones del programa de sistema (allocate, assign, transferencia de lamports), preparadas en la superposición. Contraparte en caché de legacy `System @ 0xff..07`de los selectores mutantes (System legacy conserva los selectores de solo lectura puros).

| Firma de Solidity                    | Selector     | Dispatch  | Descripción                                                                 |
| ------------------------------------ | ------------ | --------- | --------------------------------------------------------------------------- |
| `create_pda()`                       | `0xe0402a8d` | `Invocar` | Crear el `external_auth` PDA del llamador, exento de renta, sin datos       |
| `create_pda(uint64)`                 | `0x4ceab657` | `Invocar` | Igual, con lamports por encima de la renta especificados por el financiador |
| `create_pda(uint64,bytes32)`         | `0x48e2bb86` | `Invocar` | PDA derivado de sal con lamports                                            |
| `create_pda(bytes32,uint64,bytes32)` | `0xcc258bbf` | `Invocar` | Especificado por el propietario, de tamaño N, derivado de sal               |
| `allocate(uint64,bytes32)`           | `0x93225c9f` | `Invocar` | Asigna N bytes en un PDA derivado de sal                                    |
| `assign(bytes32,bytes32)`            | `0x8ac00bdc` | `Invocar` | Asigna un PDA derivado de sal a un nuevo propietario                        |
| `transfer(address,uint64)`           | `0x5d359fbd` | `Invocar` | Transferencia de lamports a un PDA derivado de una dirección EVM            |
| `transfer(bytes32,uint64)`           | `0xfd54d1ea` | `Invocar` | Transferencia de lamports a una pubkey de Solana en bruto                   |
| `transfer(bytes32,uint64,bytes32)`   | `0x875abfc0` | `Invocar` | Transferencia de lamports a pubkey en bruto, origen derivado de sal         |

## SplCached (`0xff00000000000000000000000000000000000005`)

Transferencias de SPL Token / Token-2022 + inicialización de ATA + lecturas de cuentas entre estados, preparadas en la superposición.

| Firma de Solidity                               | Selector     | Dispatch            | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ----------------------------------------------- | ------------ | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `transfer(address,uint256)`                     | `0xa9059cbb` | `Invocar`           | Transferencia SPL donde el llamador es el propietario al ATA del PDA derivado de una dirección EVM, mint actual del rollup                                                                                                                                                                                                                                                                                                                               |
| `transfer(bytes32,uint256)`                     | `0x6a467394` | `Invocar`           | Igual, con el destinatario dado como pubkey de Solana en bruto                                                                                                                                                                                                                                                                                                                                                                                           |
| `transfer(address,uint256,bytes32)`             | `0x57cfeeee` | `Invocar`           | Variante con mint explícito, destino de dirección EVM                                                                                                                                                                                                                                                                                                                                                                                                    |
| `transfer(bytes32,uint256,bytes32)`             | `0x7db527f9` | `Invocar`           | Variante con mint explícito, destino de pubkey en bruto                                                                                                                                                                                                                                                                                                                                                                                                  |
| `transferFrom(address,address,uint256,bytes32)` | `0x401e3367` | `Invocar`           | Variante con fuente delegada — autoridad = `external_auth(caller)`, aceptada como propietaria del ATA O como delegada con cantidad suficiente. Usado por `SPL_ERC20_cached.transferFrom` y flujos impulsados por el router                                                                                                                                                                                                                               |
| `approve(address,uint256,bytes32)`              | `0x8180f2fc` | `Invocar`           | Aprobación de gastador EVM — propietario = `external_auth(caller)`, delegado = `external_auth(spender_addr)`. Usado por `SPL_ERC20_cached.approve`                                                                                                                                                                                                                                                                                                       |
| `mint(address,uint256,bytes32)`                 | `0x1e458bee` | `Invocar`           | El PDA del llamador firma como autoridad del mint. El entorno de ejecución de SPL impone que el PDA del llamador == autoridad del mint en cadena. Usado por `SPL_ERC20_cached.mint_to` y liquidación de puente entrante                                                                                                                                                                                                                                  |
| `init(bytes32,bytes32,bytes32)`                 | `0x0b0ad508` | `Invocar`           | `InitializeAccount3` ix (ata, mint, owner)                                                                                                                                                                                                                                                                                                                                                                                                               |
| `account(address)`                              | `0x73b9aa91` | `CrossStateEthCall` | Leer el estado de la cuenta SPL para el ATA derivado del PDA de la dirección EVM (mint actual del rollup)                                                                                                                                                                                                                                                                                                                                                |
| `account(bytes32)`                              | `0x882358ae` | `CrossStateEthCall` | Leer el estado de la cuenta SPL para una pubkey de ATA en bruto                                                                                                                                                                                                                                                                                                                                                                                          |
| `account(address,bytes32)`                      | `0xf9827227` | `CrossStateEthCall` | Igual que `account(address)` con un mint explícito.                                                                                                                                                                                                                                                                                                                                                                                                      |
| `mint_info(bytes32)`                            | `0xe24bf5d4` | `CrossStateEthCall` | Datos del mint, con conciencia de la superposición: programa de token, decimales, **habilitado** programa hook (0 cuando está ausente *ni* inerte), bps de comisión del epoch actual y un bitmap de presencia de extensiones. Mismo selector que `HelperProgram.mint_info` — una capacidad, dos destinos de despacho, porque un contrato de la ruta en caché no puede usar la lectura legacy una vez que se ha disparado una invoke de la ruta en caché. |

## ASplCached (`0xff00000000000000000000000000000000000006`)

Creación de Associated Token Account, idempotente.

| Firma de Solidity             | Selector     | Dispatch  | Descripción                                                                      |
| ----------------------------- | ------------ | --------- | -------------------------------------------------------------------------------- |
| `create_ata()`                | `0xb6d336ed` | `Invocar` | Creación idempotente de ATA para el PDA del llamador × mint actual del rollup    |
| `create_ata(bytes32)`         | `0x81972e35` | `Invocar` | Creación idempotente de ATA para el PDA del llamador × mint explícito            |
| `create_ata(address)`         | `0x5a7c3259` | `Invocar` | Creación idempotente de ATA para PDA derivado de una dirección EVM × mint actual |
| `create_ata(address,bytes32)` | `0x3de2251a` | `Invocar` | Creación idempotente de ATA para dirección EVM × mint explícito                  |

## WithdrawCached (`0xff0000000000000000000000000000000000000b`)

Fases de retirada del token de gas (gas nativo → envoltorio SPL, gas nativo → SOL, gas nativo → PDA del llamador), preparadas. Contraparte en caché de legacy `Withdraw @ 0x42..16`.

| Firma de Solidity             | Selector     | Dispatch    | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | ------------ | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32) payable` | `0x4d8b0ea4` | `Compuesto` | Quema `msg.value` Gas de Rome, transferir al destinatario de una cuenta de sistema de Solana                                                                                                                                                                                                                                                                                                                                                                                                            |
| `withdraw_to_pda(uint256)`    | `0x7f3124a0` | `Compuesto` | Quemar wei, depositar lamports en el `EXTERNAL_AUTHORITY` PDA del llamador. Solo de un estado.                                                                                                                                                                                                                                                                                                                                                                                                          |
| `withdraw_to_ata(uint256)`    | `0x8059abc0` | `Compuesto` | Quemar wei, depositar el envoltorio SPL en el ATA del llamador propiedad del PDA. Solo de un estado. Fase de envoltura del puente del envoltorio de gas.                                                                                                                                                                                                                                                                                                                                                |
| `deposit(uint256)`            | `0xb6b55f25` | `Compuesto` | Inverso de `withdrawal` — transferencia SPL desde el ATA propiedad del PDA del llamador al ATA sol\_wallet de la cadena en el lado de Solana; **mint** `wei` gas nativo para el llamador en el lado EVM. Emisión pura (sin débito compensatorio contra `Withdraw::ADDRESS` — la billetera SPL de la cadena es el respaldo económico, no la dirección del precompile). Solo de un estado. Fase de desenvuelto del puente del envoltorio de gas. Coincide con `HelperProgram.deposit_from_ata` semántica. |

## System (`0xff00000000000000000000000000000000000007`)

Derivación de PDA + conversión a base58 + utilidades de estilo de identidad. Precompile de solo lectura pura — cada método es `EthCall` (sin efectos secundarios en Solana).

| Firma de Solidity                                 | Selector     | Dispatch  | Descripción                                                                               |
| ------------------------------------------------- | ------------ | --------- | ----------------------------------------------------------------------------------------- |
| `find_program_address(bytes32,(bytes)[])`         | `0x27e3edda` | `EthCall` | Solana `find_program_address` mediante syscall — devuelve `(pda, bump)`                   |
| `create_program_address(bytes32,(bytes)[],uint8)` | `0xb99f29e1` | `EthCall` | Derivación de PDA en tiempo constante con un bump conocido                                |
| `rome_evm_program_id()`                           | `0xb76fd45b` | `EthCall` | Devuelve el ID de programa de Solana de este programa EVM de Rome                         |
| `program_id()`                                    | `0x77764881` | `EthCall` | Devuelve el ID del System Program de Rome (la identidad de este precompile)               |
| `mint_id()`                                       | `0xe132a122` | `EthCall` | Devuelve la pubkey del mint SPL del token de gas de la cadena (`OwnerInfo.chain_mint_id`) |
| `operator()`                                      | `0x570ca735` | `EthCall` | Devuelve el firmante de Solana de la transacción externa de Rome                          |
| `bytes32_to_base58(bytes32)`                      | `0xfa2b1a5f` | `EthCall` | Bytes de pubkey → cadena base58                                                           |
| `base58_to_bytes32(bytes)`                        | `0x5df01b72` | `EthCall` | cadena base58 → bytes de pubkey                                                           |

## CpiProgram (`0xff00000000000000000000000000000000000008`)

**Precompile de doble propósito.** De los 7 selectores de abajo, **2 realizan CPI real de Solana** (`invoke`, `invoke_signed` — se despachan como `Invocar`y **5 son lecturas puras entre estados** (`account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` — se despachan como `CrossStateEthCall`, sin syscall, sin `found_cpi` bandera activada). La frase histórica "CPI shortcut selectors" se refería a los selectores de lectura como reemplazos que ahorran CU de lecturas anteriores basadas en CPI — ellos mismos son **no CPI**. Véase la tabla de desambiguación al principio de esta sección para la matriz de comportamiento completa.

| Firma de Solidity                                              | Selector     | Dispatch            | Descripción                                                                                                                                                                                                                                                                          |
| -------------------------------------------------------------- | ------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `invoke(bytes32,(bytes32,bool,bool)[],bytes)`                  | `0x7480cb86` | `Invocar`           | CPI firmado como `EXTERNAL_AUTHORITY(caller)` cuando esa cuenta figura como firmante (rechazado bajo DELEGATECALL); sin sub-PDA con sal. El llamador pasa el programa destino + account metas + datos ix                                                                             |
| `invoke_signed(bytes32,(bytes32,bool,bool)[],bytes,bytes32[])` | `0xb94f3733` | `Invocar`           | CPI firmado como `EXTERNAL_AUTHORITY(caller)` en un CALL directo; las sales se añaden a cada semilla de PDA. Bajo DELEGATECALL se rechaza la autoridad desnuda del llamador y las semillas con sal llevan la dirección del contrato en ejecución — véase la nota de derivación abajo |
| `account_info(bytes32)`                                        | `0xc13465d9` | `CrossStateEthCall` | Leer el estado completo de una cuenta de Solana (lamports/propietario/banderas/datos)                                                                                                                                                                                                |
| `account_data_at(bytes32,uint16,uint16)`                       | `0x593762e8` | `CrossStateEthCall` | Leer un fragmento del búfer de datos de cualquier cuenta de Solana                                                                                                                                                                                                                   |
| `account_u64_at(bytes32,uint16)`                               | `0xb317d4c1` | `CrossStateEthCall` | Lectura tipada u64 LE en un desplazamiento conocido — ahorra un roundtrip de ABI                                                                                                                                                                                                     |
| `account_lamports(bytes32)`                                    | `0xde79ed54` | `CrossStateEthCall` | Sondeo solo de lamports — omite la obtención de datos                                                                                                                                                                                                                                |
| `pdas_batch_derive(bytes[][],bytes32)`                         | `0x944336f8` | `CrossStateEthCall` | N PDA independientes contra un programa en un solo despacho                                                                                                                                                                                                                          |

## HelperProgram (`0xff00000000000000000000000000000000000009`)

Ayudas de Rome orientadas al usuario para creación de ATA/PDA, transferencias SPL/approve/mint firmadas por el `EXTERNAL_AUTHORITY` PDA del llamador, conversión gas↔lamports, depósito en ATA y lecturas orientadas a SPL\_ERC20 (`user_balance` / `allowance_of`). Cada método es `not_payable`; la mutación pasa por `Invocar` (un solo CPI) excepto `deposit_from_ata` (`Compuesto`, solo de un estado), las tres consultas de solo lectura `pda`/`ata` consultas (`EthCall`), y las dos lecturas entre estados de SPL\_ERC20 (`CrossStateEthCall` — una obtención de cuenta de Solana).

| Firma de Solidity                                                | Selector     | Dispatch            | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| ---------------------------------------------------------------- | ------------ | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `create_ata(address)`                                            | `0x5a7c3259` | `Invocar`           | Crear ATA para el usuario EVM bajo el mint de gas de la cadena                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `create_ata(address,bytes32)`                                    | `0x3de2251a` | `Invocar`           | Crear ATA para el usuario EVM bajo un mint arbitrario                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `create_ata_for_key(bytes32,bytes32)`                            | `0xd258a69d` | `Invocar`           | Creación idempotente de ATA para una pubkey de Solana en bruto arbitraria como propietario (no derivada mediante `external_auth`). El operador paga la renta. Usado por `SPL_ERC20.bridgeOutToSolana` / `ensureRecipientAta` / `create_token_account` flujos con destinatario de pubkey en bruto                                                                                                                                                                                                                                                                                                                                                                                   |
| `create_pda(address)`                                            | `0xff3556ca` | `Invocar`           | Crear la PDA del usuario `EXTERNAL_AUTHORITY` PDA (exento de renta)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `create_pda(address,uint64)`                                     | `0x58e88298` | `Invocar`           | Igual, pero financiado con `lamports` por encima del mínimo de renta                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `swap_gas_to_lamports(uint64)`                                   | `0x6e3f24e0` | `Invocar`           | Acreditar el PDA del llamador con `n` lamports del pagador de comisiones de Solana de la transacción; el llamador los paga en gas de Rome (el gasto de lamports del pagador dentro de cualquier CPI heredada se añade a la comisión de la transacción)                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `transfer_lamports(address,uint64)`                              | `0x5fe71665` | `Invocar`           | Mover lamports del PDA del llamador al PDA de otro usuario de EVM                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `transfer_spl(address,uint64)`                                   | `0xb12be5ba` | `Invocar`           | Enviar SPL de gas de cadena desde la ATA del PDA del llamador a la ATA del usuario de destino                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `transfer_spl(bytes32,uint64)`                                   | `0xba3a5eac` | `Invocar`           | Enviar SPL de gas de cadena desde la ATA del PDA del llamador a una ATA explícita                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `transfer_spl(address,uint64,bytes32)`                           | `0x53b505e0` | `Invocar`           | Enviar SPL de mint arbitrario desde la ATA del PDA del llamador a la ATA del usuario de destino                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `transfer_spl(bytes32,uint64,bytes32)`                           | `0xb6977879` | `Invocar`           | Enviar SPL de mint arbitrario desde la ATA del PDA del llamador a una ATA explícita                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `transfer_spl(bytes32,bytes32,uint64,bytes32)`                   | `0x766b362a` | `Invocar`           | Variante delegada — el llamador proporciona `src_ata` (debe pertenecer al PDA O el PDA debe ser el delegado con suficiente `delegated_amount`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `transfer_spl(address,address,uint64,bytes32)`                   | `0xe479df56` | `Invocar`           | Variante delegada indexada por dirección — deriva ambas ATA a partir de direcciones EVM internamente. Firma como `external_auth(caller)`; SPL Token acepta PDA como propietario O delegado. Usado por `SPL_ERC20.transferFrom`                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `transfer_spl_to_signer(uint64,bytes32)`                         | `0x46efa679` | `Invocar`           | Tramo de salida nativo de Solana. Envía `amount` de `mint` desde la ATA del PDA del llamador a la **del firmante externo de Solana** ATA para ese mint (solo la propia wallet del usuario en la vía de Solana firmada por la wallet; desde MetaMask o a través del relé, el firmante es el pagador proxy de Rome; sin conversión de direcciones EVM). No se necesita aprobación — el PDA del llamador posee la ATA de origen. Combínalo con `ActivateAta` (slot 18) para uso EVM de extremo a extremo solo con clave de Solana. Llega a la wallet en la vía v1 actual y en la antigua heredada `DoTxUnsigned` (slot 17), porque la wallet firma la transacción de Solana en ambas. |
| `approve_spl(address,uint64,bytes32)`                            | `0xabf6f675` | `Invocar`           | El PDA del llamador como propietario establece `delegate_pda(spender)` en la ATA del propietario vía SPL `approve_checked`. Usado por `SPL_ERC20.approve`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `approve_spl_raw_delegate(bytes32,bytes32,uint64,bytes32,uint8)` | `0x7881d453` | `Invocar`           | SPL `approve_checked` con delegado de clave pública cruda proporcionado por el llamador (p. ej., Wormhole `authority_signer` PDA, sin equivalente de dirección EVM). El llamador pasa `decimals` para omitir la lectura del mint en cadena (\~ahorro de 30-50K CU). Codificado de forma fija `spl_program = SPL Token`. Usado por `RomeBridgeWithdraw.approveBurnETH`                                                                                                                                                                                                                                                                                                              |
| `mint_spl(address,uint64,bytes32)`                               | `0xd795522b` | `Invocar`           | El PDA del llamador como autoridad de mint acuña en la ATA del usuario de destino vía SPL `mint_to_checked`. El runtime de SPL impone la coincidencia de autoridad. Usado por `SPL_ERC20.mint_to`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `create_mint_account(bytes32)`                                   | `0xe97d3291` | `Invocar`           | System CreateAccount que asigna un PDA derivado de salt (`external_auth_with_salt(caller, salt)`) de espacio=82 propiedad de SPL Token. Financiador = PDA external\_auth del llamador. Dos firmantes PDA. Usado por `ERC20SPLFactory.create_token_mint`                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `init_spl_mint(bytes32,uint8,bytes32,bool,bytes32)`              | `0x4f75e987` | `Invocar`           | SPL Token `InitializeMint2` sobre un mint preasignado. Sin firmante PDA (mint\_authority/freeze\_authority se almacenan como datos, no como firmantes en tiempo de ejecución). Usado por `ERC20SPLFactory.init_token_mint`                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `create_and_init_mint(uint8,bytes32,bool,bytes32,bytes32)`       | `0x20972d0f` | `Compuesto`         | Combinado: System CreateAccount + SPL InitializeMint2 en un solo despacho. Ahorra 1 sobre Rome DoTx frente a llamadas separadas `create_mint_account` + `init_spl_mint` llamadas                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `deposit_from_ata(uint256)`                                      | `0x4479b709` | `Compuesto`         | Extraer SPL desde la ATA del llamador hacia el gas nativo de Rome. **Solo estado único** — rechazado en cadenas op-geth                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `pda(address)`                                                   | `0x8854a299` | `EthCall`           | Derivar la PDA del usuario `EXTERNAL_AUTHORITY` PDA — solo lectura                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `pda_with_salt(address,bytes32)`                                 | `0x5c6d04b3` | `EthCall`           | Derivado de salt `EXTERNAL_AUTHORITY` PDA en un solo despacho. Colapsa la composición de 2 llamadas del lado de Solidity `rome_evm_program_id() + find_program_address()` composición. Usado por `RomeEVMAccount.pda_with_salt`, `RomeBridgeWithdraw.{burnUSDC,burnETH}`                                                                                                                                                                                                                                                                                                                                                                                                           |
| `ata(address)`                                                   | `0x31db4f82` | `EthCall`           | Derivar `getATA(user_pda, chain_mint_id)` — compone EXT\_AUTH + ATA — solo lectura                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `ata(address,bytes32)`                                           | `0xfeb1c647` | `EthCall`           | Lo mismo con un mint explícito — solo lectura                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `user_balance(address,bytes32)`                                  | `0xdd0119c8` | `CrossStateEthCall` | Leer la ATA del usuario `amount` (desplazamiento 64 de SPL TokenAccount). Devuelve 0 si la ATA no existe (sondeo de cadena fresca). Colapsa 3 despachos v1. Usado por `SPL_ERC20.balanceOf`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `mint_info(bytes32)`                                             | `0xe24bf5d4` | `CrossStateEthCall` | Datos del mint para un llamador de la vía heredada: programa de tokens, decimales, **habilitado** programa hook (0 cuando está ausente *ni* inerte), bps de comisiones del epoch actual, mapa de bits de presencia de extensiones. Reflejado en `SplCached` en el mismo selector. `feeBps` es un **predicado** — indica que una comisión está habilitada; no es un operando, ya que la comisión real está limitada por `maximum_fee` que esto deliberadamente no incluye.                                                                                                                                                                                                          |
| `allowance_of(address,address,bytes32)`                          | `0xed72dbc8` | `CrossStateEthCall` | Leer delegated\_amount de la ATA del propietario con **comprobación de igualdad del delegado** — devuelve 0 a menos que el delegado en cadena == `external_auth(spender)`. Correcto semánticamente para ERC-20 (REQUISITO DURO). Usado por `SPL_ERC20.allowance`                                                                                                                                                                                                                                                                                                                                                                                                                   |

## Retirar (`0x4200000000000000000000000000000000000016`)

Retiro de gas nativo de Rome → Solana.

| Firma de Solidity          | Selector     | Dispatch                 | Descripción                                                                                                                        |
| -------------------------- | ------------ | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32)`      | `0x4d8b0ea4` | `Compuesto` (`pagadero`) | Quema `msg.value` gas de Rome; acuñar + transferir a una cuenta de sistema de Solana `a`. El único método payable del precompilado |
| `withdraw_to_pda(uint256)` | `0x7f3124a0` | `Compuesto`              | Quemar gas; depositar en el `EXTERNAL_AUTHORITY` PDA. **Solo estado único**                                                        |
| `withdraw_to_ata(uint256)` | `0x8059abc0` | `Compuesto`              | Quemar gas; depositar en `getATA(caller_pda, chain_mint_id)`. **Solo estado único**                                                |


---

# 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/referencia/precompiles.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.
