> 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 el programa en cadena de Rome despacha, por precompile. Selector = `keccak256(signature)[:4]`; cada fila 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: | Despacho | Qué sucede | CPI real de Solana | Permitido en ejecución iterativa | | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | -------------------------------- | | `Invocar` / `Compuesto` | Una o más CPI, firmadas como el PDA de autoridad externa del llamador cuando aplican semillas. En la **legacy** vía se ejecutan de inmediato; en la **cacheada** vía se preparan y se confirman al final de la transacción. | Sí | Legacy: **no**. Cached: sí | | `EthCall` | Cálculo puro o 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 (las precompilaciones estándar de Ethereum) | No | Sí | Un contrato usa **una vía**: o bien las precompilaciones legacy (`0xff…07`, `0xff…08`, `0xff…09`, `0x42…16`) o las almacenadas en caché (`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`). Mezclar llamadas que mutan de ambas en una sola transacción se rechaza en tiempo de ejecución. Las lecturas siguen permitidas, con una excepción: una vez que se ha activado un invoke de la vía cached, las lecturas de la vía legacy se rechazan durante el resto de la transacción. Véase [Integrar un programa de Solana](/es/guias-para-desarrolladores/integrate-solana-program.md). **Quién paga.** El pagador de comisiones de Solana adelanta cada lamport que gasta una CPI de la vía legacy (renta, transferencias, `swap_gas_to_lamports`); el programa mide el saldo del pagador alrededor de cada CPI y factura al usuario el gasto neto como gas al precio del gas, reembolsando los lamports que una CPI devuelve. **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 que mutan 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á vinculado al llamador o financiado por el operador, no porque no firmen nada: `create_and_init_mint` sigue firmando 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 separan los PDAs con sal por espacio de nombres usando la dirección del contrato en ejecución. Cada método es no payable (`msg.value > 0` revierte con `TransferProhibited`) excepto `withdrawal(bytes32)`. Los métodos marcados *solo de un único estado* se rechazan en cadenas op-geth-stack. Una CPI no puede nombrar al pagador de comisiones de Solana (salvo dentro de una instrucción simple de transferencia System) ni al programa de Rome, y no puede llamar al programa de Rome. ## SystemCached (`0xff00000000000000000000000000000000000004`) Creación de PDA + operaciones del programa del sistema (allocate, assign, transferencia de lamports), preparadas en la overlay. Contraparte cached de legacy `System @ 0xff..07`los selectores que mutan de System (legacy System conserva los selectores de lectura pura). | Firma de Solidity | Selector | Despacho | 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 especificados por el financiador por encima de la renta | | `create_pda(uint64,bytes32)` | `0x48e2bb86` | `Invocar` | PDA derivado de sal con lamports | | `create_pda(bytes32,uint64,bytes32)` | `0xcc258bbf` | `Invocar` | Propietario especificado, tamaño N, derivado de sal | | `allocate(uint64,bytes32)` | `0x93225c9f` | `Invocar` | Asignar N bytes en un PDA derivado de sal | | `assign(bytes32,bytes32)` | `0x8ac00bdc` | `Invocar` | Asignar 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 sin procesar | | `transfer(bytes32,uint64,bytes32)` | `0x875abfc0` | `Invocar` | Transferencia de lamports a pubkey sin procesar, origen derivado de sal | ## SplCached (`0xff00000000000000000000000000000000000005`) Transferencias SPL Token / Token-2022 + inicialización de ATA + lecturas de cuentas entre estados, preparadas en la overlay. | Firma de Solidity | Selector | Despacho | Descripción | | ----------------------------------------------- | ------------ | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `transfer(address,uint256)` | `0xa9059cbb` | `Invocar` | Transferencia SPL con el llamador como propietario a la ATA del PDA derivado de una dirección EVM, mint actual del rollup | | `transfer(bytes32,uint256)` | `0x6a467394` | `Invocar` | Igual, el destinatario se da como pubkey de Solana sin procesar | | `transfer(address,uint256,bytes32)` | `0x57cfeeee` | `Invocar` | Variante con mint explícito, destino en dirección EVM | | `transfer(bytes32,uint256,bytes32)` | `0x7db527f9` | `Invocar` | Variante con mint explícito, destino en pubkey sin procesar | | `transferFrom(address,address,uint256,bytes32)` | `0x401e3367` | `Invocar` | Variante de origen delegado — autoridad = `external_auth(caller)`, aceptado como propietario de la ATA O como delegado con cantidad suficiente. Usado por `SPL_ERC20_cached.transferFrom` y flujos impulsados por 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. En tiempo de ejecución SPL impone que 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 la ATA derivada del PDA de una dirección EVM (mint actual del rollup) | | `account(bytes32)` | `0x882358ae` | `CrossStateEthCall` | Leer el estado de la cuenta SPL para una pubkey de ATA sin procesar | | `account(address,bytes32)` | `0xf9827227` | `CrossStateEthCall` | Igual que `account(address)` con un mint explícito. | | `mint_info(bytes32)` | `0xe24bf5d4` | `CrossStateEthCall` | Datos del mint, con conocimiento de overlay: programa de token, decimales, **armado** programa hook (0 cuando está ausente *o* inactivo), bps de comisión del epoch actual y un mapa de bits de presencia de extensiones. Mismo selector que `HelperProgram.mint_info` — una capacidad, dos destinos de despacho, porque un contrato de la vía cached no puede usar la lectura legacy una vez que se ha activado un invoke cached. | ## ASplCached (`0xff00000000000000000000000000000000000006`) Creación idempotente de Associated Token Account. | Firma de Solidity | Selector | Despacho | Descripción | | ----------------------------- | ------------ | --------- | ---------------------------------------------------------------------------- | | `create_ata()` | `0xb6d336ed` | `Invocar` | Creación idempotente de ATA para PDA del llamador × mint actual del rollup | | `create_ata(bytes32)` | `0x81972e35` | `Invocar` | Creación idempotente de ATA para PDA del llamador × mint explícito | | `create_ata(address)` | `0x5a7c3259` | `Invocar` | Creación idempotente de ATA para PDA derivado de 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`) Tramos de retiro del token de gas (gas nativo → wrapper SPL, gas nativo → SOL, gas nativo → PDA del llamador), preparados. Contraparte cached de legacy `Retiro @ 0x42..16`. | Firma de Solidity | Selector | Despacho | Descripción | | ----------------------------- | ------------ | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `withdrawal(bytes32) payable` | `0x4d8b0ea4` | `Compuesto` | Quemar `msg.value` Gas de Rome, transferir al destinatario de cuenta del sistema de Solana | | `withdraw_to_pda(uint256)` | `0x7f3124a0` | `Compuesto` | Quemar wei, depositar lamports en el `EXTERNAL_AUTHORITY` PDA. Solo de un único estado. | | `withdraw_to_ata(uint256)` | `0x8059abc0` | `Compuesto` | Quemar wei, depositar wrapper SPL en la ATA del llamador propiedad del PDA. Solo de un único estado. Tramo de envoltura del puente gas-wrapper. | | `deposit(uint256)` | `0xb6b55f25` | `Compuesto` | Inverso de `withdrawal` — transferencia SPL desde la ATA del llamador propiedad del PDA a la ATA sol\_wallet de la cadena en el lado de Solana; **mint** `wei` gas nativo al llamador en el lado EVM. Mint puro (sin débito compensatorio contra `Withdraw::ADDRESS` — la wallet SPL de la cadena es el respaldo económico, no la dirección del precompile). Solo de un único estado. Tramo de desenvuelto del puente gas-wrapper. Coincide con `HelperProgram.deposit_from_ata` semántica. | ## System (`0xff00000000000000000000000000000000000007`) Derivación de PDA + conversión base58 + utilidades de estilo identidad. Precompile de solo lectura: cada método es `EthCall` (sin efectos secundarios en Solana). | Firma de Solidity | Selector | Despacho | Descripción | | ------------------------------------------------- | ------------ | --------- | ----------------------------------------------------------------------------------------- | | `find_program_address(bytes32,(bytes)[])` | `0x27e3edda` | `EthCall` | Solana `find_program_address` vía 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 de programa System 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 tx 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 siguientes, **2 realizan CPI reales de Solana** (`invoke`, `invoke_signed` — despacho como `Invocar`) y **5 son lecturas puras entre estados** (`account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` — despacho como `CrossStateEthCall`, sin syscall, sin `found_cpi` bandera establecida). La frase histórica "CPI shortcut selectors" se refería a los selectores de lectura como reemplazos que ahorran CU para lecturas anteriores basadas en CPI — ellos mismos son **no CPI**. Véase la tabla de desambiguación al inicio de esta sección para la matriz de comportamiento completa. | Firma de Solidity | Selector | Despacho | Descripción | | -------------------------------------------------------------- | ------------ | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `invoke(bytes32,(bytes32,bool,bool)[],bytes)` | `0x7480cb86` | `Invocar` | CPI firmada como `EXTERNAL_AUTHORITY(caller)` cuando esa cuenta figura como firmante (rechazado bajo DELEGATECALL); sin sub-PDA con sal. El llamador pasa programa destino + metadatos de cuenta + datos de ix | | `invoke_signed(bytes32,(bytes32,bool,bool)[],bytes,bytes32[])` | `0xb94f3733` | `Invocar` | CPI firmada como `EXTERNAL_AUTHORITY(caller)` en un CALL directo; las sales se añaden por semilla de cada 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/owner/flags/data) | | `account_data_at(bytes32,uint16,uint16)` | `0x593762e8` | `CrossStateEthCall` | Leer un fragmento del buffer de datos de cualquier cuenta de Solana | | `account_u64_at(bytes32,uint16)` | `0xb317d4c1` | `CrossStateEthCall` | Lectura tipada u64 LE en un desplazamiento conocido — ahorra un ida y vuelta ABI | | `account_lamports(bytes32)` | `0xde79ed54` | `CrossStateEthCall` | Comprobación solo de lamports — omite la obtención de datos | | `pdas_batch_derive(bytes[][],bytes32)` | `0x944336f8` | `CrossStateEthCall` | N PDAs independientes contra un programa en un solo despacho | ## HelperProgram (`0xff00000000000000000000000000000000000009`) Utilidades 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 `no_payable`; la mutación pasa por `Invocar` (una sola CPI) excepto `deposit_from_ata` (`Compuesto`, solo de un único estado), las tres consultas de solo lectura `pda`/`ata` consultas (`EthCall`), y las dos lecturas SPL\_ERC20 entre estados (`CrossStateEthCall` — una obtención de cuenta de Solana. | Firma de Solidity | Selector | Despacho | 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 sin procesar 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 sin procesar | | `create_pda(address)` | `0xff3556ca` | `Invocar` | Crear la del usuario `EXTERNAL_AUTHORITY` PDA (exenta de alquiler) | | `create_pda(address,uint64)` | `0x58e88298` | `Invocar` | Igual, pero financiado con `lamports` por encima del mínimo de alquiler | | `swap_gas_to_lamports(uint64)` | `0x6e3f24e0` | `Invocar` | Acreditar la PDA del llamante con `n` lamports de la entidad que paga las comisiones de Solana de la transacción; el llamante 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 de la PDA del llamante a la PDA de otro usuario de EVM | | `transfer_spl(address,uint64)` | `0xb12be5ba` | `Invocar` | Enviar SPL de gas en cadena desde la ATA de la PDA del llamante a la ATA del usuario de destino | | `transfer_spl(bytes32,uint64)` | `0xba3a5eac` | `Invocar` | Enviar SPL de gas en cadena desde la ATA de la PDA del llamante a una ATA explícita | | `transfer_spl(address,uint64,bytes32)` | `0x53b505e0` | `Invocar` | Enviar SPL de acuñación arbitraria desde la ATA de la PDA del llamante a la ATA del usuario de destino | | `transfer_spl(bytes32,uint64,bytes32)` | `0xb6977879` | `Invocar` | Enviar SPL de acuñación arbitraria desde la ATA de la PDA del llamante a una ATA explícita | | `transfer_spl(bytes32,bytes32,uint64,bytes32)` | `0x766b362a` | `Invocar` | Variante con delegado — el llamante proporciona `src_ata` (debe ser propiedad de la PDA O la PDA debe ser el delegado con suficiente `delegated_amount`) | | `transfer_spl(address,address,uint64,bytes32)` | `0xe479df56` | `Invocar` | Variante de delegado indexada por dirección — deriva ambas ATA a partir de direcciones EVM internamente. Firma como `external_auth(caller)`; SPL Token acepta la PDA como propietaria O como delegada. 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 de la PDA del llamante a la **ATA del firmante externo de Solana** ATA para esa acuñación (la propia cartera del usuario — sin conversión de direcciones EVM). No se necesita aprobación — la PDA del llamante posee la ATA de origen. Emparejado con `ActivateAta` (slot 18) + `DoTxUnsigned` (slot 17) para uso EVM de extremo a extremo solo con clave de Solana | | `approve_spl(address,uint64,bytes32)` | `0xabf6f675` | `Invocar` | La PDA del llamante como propietaria establece `delegate_pda(spender)` en la ATA del propietario mediante 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 llamante (p. ej., Wormhole `authority_signer` PDA, sin equivalente de dirección EVM). El llamante pasa `decimals` para omitir la lectura de la acuñación 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` | La PDA del llamante como autoridad de acuñación acuña en la ATA del usuario de destino mediante 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 asignando una PDA derivada de una sal (`external_auth_with_salt(caller, salt)`) con espacio=82 propiedad de SPL Token. Financiador = la PDA external\_auth del llamante. Dos firmantes PDA. Usado por `ERC20SPLFactory.create_token_mint` | | `init_spl_mint(bytes32,uint8,bytes32,bool,bytes32)` | `0x4f75e987` | `Invocar` | SPL Token `InitializeMint2` contra una acuñación preasignada. Sin firmante PDA (mint\_authority/freeze\_authority almacenadas 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 envoltorio 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 llamante hacia el gas nativo de Rome. **Solo estado único** — rechazado en cadenas op-geth | | `pda(address)` | `0x8854a299` | `EthCall` | Derivar la `EXTERNAL_AUTHORITY` PDA del usuario — solo lectura | | `pda_with_salt(address,bytes32)` | `0x5c6d04b3` | `EthCall` | Derivada de sal `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 una acuñación explícita — solo lectura | | `user_balance(address,bytes32)` | `0xdd0119c8` | `CrossStateEthCall` | Leer ATA del usuario `amount` (desplazamiento 64 de SPL TokenAccount). Devuelve 0 si la ATA no existe (sondeo de cadena nueva). Colapsa 3 despachos v1. Usado por `SPL_ERC20.balanceOf` | | `mint_info(bytes32)` | `0xe24bf5d4` | `CrossStateEthCall` | Datos de la acuñación para un llamante de la vía heredada: programa de token, decimales, **armado** programa hook (0 cuando está ausente *o* inerte), bps de comisión del epoch actual, mapa de bits de presencia de extensiones. Espejado en `SplCached` con el mismo selector. `feeBps` es un **predicado** — indica que una comisión está activada; 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 sea == `external_auth(spender)`. Correcto semánticamente para ERC-20 (REQUERIMIENTO OBLIGATORIO). Usado por `SPL_ERC20.allowance` | ## Retirar (`0x4200000000000000000000000000000000000016`) retiro de gas nativo de Rome → Solana. | Firma de Solidity | Selector | Despacho | Descripción | | -------------------------- | ------------ | ----------------------- | ----------------------------------------------------------------------------------------------------------------------------- | | `withdrawal(bytes32)` | `0x4d8b0ea4` | `Compuesto` (`payable`) | Quemar `msg.value` Gas de Rome; acuñar+transferir a una cuenta de sistema de Solana `a`. El único método precompilado payable | | `withdraw_to_pda(uint256)` | `0x7f3124a0` | `Compuesto` | Quemar gas; depositar en la `EXTERNAL_AUTHORITY` PDA del llamante. **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=&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.