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

# Referência de Precompiles

Todos os métodos nas precompilações de interoperabilidade Solana da Rome — endereço, assinatura Solidity, seletor e se ele lê, invoca ou prepara uma CPI.

Os seletores que o programa on-chain da Rome despacha, por pré-compilação. Seletor = `keccak256(signature)[:4]`; cada linha abaixo é verificada em relação a isso. As interfaces Solidity estão em [`rome-solidity/contracts/interface.sol`](https://github.com/rome-protocol/rome-solidity/blob/master/contracts/interface.sol).

**Leia a coluna Dispatch antes de qualquer coisa.** Ela diz o que um método faz ao estado da Solana:

| Despacho               | O que acontece                                                                                                                                                                                                                             | CPI real da Solana | Permitido na execução iterativa |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------ | ------------------------------- |
| `Invocar` / `Composto` | Uma ou mais CPIs, assinadas como a PDA de autoridade externa do chamador onde os seeds se aplicam. Na **legado** trilha, elas são executadas imediatamente; na **cached** trilha, elas são preparadas e confirmadas ao final da transação. | Sim                | Legado: **não**. Em cache: sim  |
| `EthCall`              | Cálculo puro ou leitura do próprio estado da Rome                                                                                                                                                                                          | Não                | Sim                             |
| `CrossStateEthCall`    | Uma leitura dos bytes de outra conta da Solana, pré-carregados pela emulação. Sem CPI, sem efeitos colaterais.                                                                                                                             | Não                | Sim                             |
| `Pré-compilado`        | Criptografia determinística (as pré-compilações padrão do Ethereum)                                                                                                                                                                        | Não                | Sim                             |

Um contrato usa **uma trilha**: ou as pré-compilações legadas (`0xff…07`, `0xff…08`, `0xff…09`, `0x42…16`) ou as em cache (`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`). Misturar chamadas mutativas de ambas em uma transação é recusado em tempo de execução. Leituras continuam permitidas, com uma exceção: quando uma invocação da trilha em cache é disparada, leituras da trilha legada são recusadas pelo restante da transação. Veja [Integrar um programa Solana](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/integrate-solana-program.md).

**Quem paga.** O pagador de taxas da Solana adianta cada lamport que uma CPI da trilha legada gasta (aluguel, transferências, `swap_gas_to_lamports`); o programa mede o saldo do pagador em torno de cada CPI e cobra do usuário o gasto líquido como gás ao preço do gás, reembolsando os lamports que uma CPI devolve.

**Quem assina.** Um contrato que chama uma pré-compilação age como ele mesmo: o signatário é a PDA de autoridade externa do contrato (`["EXTERNAL_AUTHORITY", contract]`). A própria PDA do usuário assina apenas em uma transação que o usuário envia diretamente para o endereço da pré-compilação. Sob `DELEGATECALL` / `CALLCODE`, seletores mutativos são recusados, exceto `create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint` e `create_and_init_mint` em HelperProgram, `create_ata*` em ASplCached, e `invoke` / `invoke_signed` em CpiProgram. Eles são isentos porque seu alvo está vinculado ao chamador ou financiado pelo operador, não porque não assinam nada: `create_and_init_mint` ainda assina com a PDA do chamador externo para pagar o aluguel da mint e só pode criar uma mint cujas autoridades sejam essa PDA, e `invoke` / `invoke_signed` recusam a autoridade nua (`DelegatecallOwnerAuthority`) e nomeiam o namespace das PDAs com salt pelo endereço do contrato em execução.

Todo método é não pagável (`msg.value > 0` reverte com `TransferProhibited`) exceto `withdrawal(bytes32)`. Métodos marcados como *single-state only* são recusados em cadeias op-geth-stack. Uma CPI não pode nomear o pagador de taxas da Solana (exceto dentro de uma instrução de transferência System simples) nem o programa Rome, e não pode chamar o programa Rome.

## SystemCached (`0xff00000000000000000000000000000000000004`)

Criação de PDA + operações do programa system (allocate, assign, transferência de lamports), preparadas na overlay. Contrapartida em cache do legado `System @ 0xff..07`dos seletores mutativos (o System legado mantém os seletores de leitura pura).

| Assinatura Solidity                  | Seletor      | Despacho  | Descrição                                                             |
| ------------------------------------ | ------------ | --------- | --------------------------------------------------------------------- |
| `create_pda()`                       | `0xe0402a8d` | `Invocar` | Criar a `external_auth` PDA do chamador, isenta de aluguel, sem dados |
| `create_pda(uint64)`                 | `0x4ceab657` | `Invocar` | Igual, com lamports especificados pelo financiador acima do aluguel   |
| `create_pda(uint64,bytes32)`         | `0x48e2bb86` | `Invocar` | PDA derivada de salt com lamports                                     |
| `create_pda(bytes32,uint64,bytes32)` | `0xcc258bbf` | `Invocar` | Proprietário especificado, tamanho N, derivada de salt                |
| `allocate(uint64,bytes32)`           | `0x93225c9f` | `Invocar` | Alocar N bytes em uma PDA derivada de salt                            |
| `assign(bytes32,bytes32)`            | `0x8ac00bdc` | `Invocar` | Atribuir uma PDA derivada de salt a um novo proprietário              |
| `transfer(address,uint64)`           | `0x5d359fbd` | `Invocar` | Transferência de lamports para PDA derivada de endereço EVM           |
| `transfer(bytes32,uint64)`           | `0xfd54d1ea` | `Invocar` | Transferência de lamports para pubkey bruta da Solana                 |
| `transfer(bytes32,uint64,bytes32)`   | `0x875abfc0` | `Invocar` | Transferência de lamports para pubkey bruta, fonte derivada de salt   |

## SplCached (`0xff00000000000000000000000000000000000005`)

Transferências de SPL Token / Token-2022 + inicialização de ATA + leituras de contas cross-state, preparadas na overlay.

| Assinatura Solidity                             | Seletor      | Despacho            | Descrição                                                                                                                                                                                                                                                                                                                                                                                                     |
| ----------------------------------------------- | ------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `transfer(address,uint256)`                     | `0xa9059cbb` | `Invocar`           | Transferência SPL com o chamador como proprietário para a ATA da PDA derivada do endereço EVM, mint atual do rollup                                                                                                                                                                                                                                                                                           |
| `transfer(bytes32,uint256)`                     | `0x6a467394` | `Invocar`           | Igual, destinatário dado como pubkey bruta da Solana                                                                                                                                                                                                                                                                                                                                                          |
| `transfer(address,uint256,bytes32)`             | `0x57cfeeee` | `Invocar`           | Variante com mint explícita, destino em endereço EVM                                                                                                                                                                                                                                                                                                                                                          |
| `transfer(bytes32,uint256,bytes32)`             | `0x7db527f9` | `Invocar`           | Variante com mint explícita, destino em pubkey bruta                                                                                                                                                                                                                                                                                                                                                          |
| `transferFrom(address,address,uint256,bytes32)` | `0x401e3367` | `Invocar`           | Variante com fonte delegada — autoridade = `external_auth(caller)`, aceita como proprietário da ATA OU delegado com quantidade suficiente. Usado por `SPL_ERC20_cached.transferFrom` e fluxos conduzidos por roteador                                                                                                                                                                                         |
| `approve(address,uint256,bytes32)`              | `0x8180f2fc` | `Invocar`           | Aprovação de gastador EVM — proprietário = `external_auth(caller)`, delegado = `external_auth(spender_addr)`. Usado por `SPL_ERC20_cached.approve`                                                                                                                                                                                                                                                            |
| `mint(address,uint256,bytes32)`                 | `0x1e458bee` | `Invocar`           | A PDA do chamador assina como autoridade da mint. O runtime do SPL exige que a PDA do chamador == autoridade on-chain da mint. Usado por `SPL_ERC20_cached.mint_to` e liquidação da ponte de entrada                                                                                                                                                                                                          |
| `init(bytes32,bytes32,bytes32)`                 | `0x0b0ad508` | `Invocar`           | `InitializeAccount3` ix (ata, mint, owner)                                                                                                                                                                                                                                                                                                                                                                    |
| `account(address)`                              | `0x73b9aa91` | `CrossStateEthCall` | Ler o estado da conta SPL da ATA derivada de PDA do endereço EVM (mint atual do rollup)                                                                                                                                                                                                                                                                                                                       |
| `account(bytes32)`                              | `0x882358ae` | `CrossStateEthCall` | Ler o estado da conta SPL para uma pubkey de ATA bruta                                                                                                                                                                                                                                                                                                                                                        |
| `account(address,bytes32)`                      | `0xf9827227` | `CrossStateEthCall` | Igual a `account(address)` com uma mint explícita.                                                                                                                                                                                                                                                                                                                                                            |
| `mint_info(bytes32)`                            | `0xe24bf5d4` | `CrossStateEthCall` | Informações da mint, ciente da overlay: programa de token, decimais, **armado** programa hook (0 quando ausente *ou* inerte), bps de taxa do epoch atual e um bitmap de presença de extensões. Mesmo seletor que `HelperProgram.mint_info` — uma capacidade, dois destinos de despacho, porque um contrato da trilha em cache não pode usar a leitura legada depois que uma invocação em cache foi disparada. |

## ASplCached (`0xff00000000000000000000000000000000000006`)

Criação de Associated Token Account, idempotente.

| Assinatura Solidity           | Seletor      | Despacho  | Descrição                                                                 |
| ----------------------------- | ------------ | --------- | ------------------------------------------------------------------------- |
| `create_ata()`                | `0xb6d336ed` | `Invocar` | Criação idempotente de ATA para PDA do chamador × mint atual do rollup    |
| `create_ata(bytes32)`         | `0x81972e35` | `Invocar` | Criação idempotente de ATA para PDA do chamador × mint explícita          |
| `create_ata(address)`         | `0x5a7c3259` | `Invocar` | Criação idempotente de ATA para PDA derivada de endereço EVM × mint atual |
| `create_ata(address,bytes32)` | `0x3de2251a` | `Invocar` | Criação idempotente de ATA para endereço EVM × mint explícita             |

## WithdrawCached (`0xff0000000000000000000000000000000000000b`)

Etapas de retirada do token de gás (gás nativo → wrapper SPL, gás nativo → SOL, gás nativo → PDA do chamador), preparadas. Contrapartida em cache do legado `Withdraw @ 0x42..16`.

| Assinatura Solidity           | Seletor      | Despacho   | Descrição                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| ----------------------------- | ------------ | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32) payable` | `0x4d8b0ea4` | `Composto` | Queimar `msg.value` gás Rome, transferir para o destinatário da conta de sistema da Solana                                                                                                                                                                                                                                                                                                                                                                                |
| `withdraw_to_pda(uint256)`    | `0x7f3124a0` | `Composto` | Queimar wei, depositar lamports na `EXTERNAL_AUTHORITY` PDA do chamador. Apenas single-state.                                                                                                                                                                                                                                                                                                                                                                             |
| `withdraw_to_ata(uint256)`    | `0x8059abc0` | `Composto` | Queimar wei, depositar wrapper SPL na ATA do chamador pertencente à PDA. Apenas single-state. Etapa de wrap da ponte de wrapper de gás.                                                                                                                                                                                                                                                                                                                                   |
| `deposit(uint256)`            | `0xb6b55f25` | `Composto` | Inverso de `withdrawal` — transferência SPL da ATA pertencente à PDA do chamador para a ATA sol\_wallet da cadeia no lado da Solana; **mint** `wei` gás nativo para o chamador no lado EVM. Mint puro (sem débito compensatório contra `Withdraw::ADDRESS` — a carteira SPL da cadeia é o lastro econômico, não o endereço da pré-compilação). Apenas single-state. Etapa de unwrap da ponte de wrapper de gás. Corresponde a `HelperProgram.deposit_from_ata` semântica. |

## System (`0xff00000000000000000000000000000000000007`)

Derivação de PDA + conversão base58 + utilitários de identidade. Pré-compilação de leitura pura — todo método é `EthCall` (sem efeitos colaterais na Solana).

| Assinatura Solidity                               | Seletor      | Despacho  | Descrição                                                                          |
| ------------------------------------------------- | ------------ | --------- | ---------------------------------------------------------------------------------- |
| `find_program_address(bytes32,(bytes)[])`         | `0x27e3edda` | `EthCall` | Solana `find_program_address` via syscall — retorna `(pda, bump)`                  |
| `create_program_address(bytes32,(bytes)[],uint8)` | `0xb99f29e1` | `EthCall` | Derivação de PDA em tempo constante com um bump conhecido                          |
| `rome_evm_program_id()`                           | `0xb76fd45b` | `EthCall` | Retorna o ID de programa Solana deste programa Rome EVM                            |
| `program_id()`                                    | `0x77764881` | `EthCall` | Retorna o ID do System Program da Rome (a identidade desta pré-compilação)         |
| `mint_id()`                                       | `0xe132a122` | `EthCall` | Retorna a pubkey da mint SPL do token de gás da cadeia (`OwnerInfo.chain_mint_id`) |
| `operator()`                                      | `0x570ca735` | `EthCall` | Retorna o signatário da Solana da transação externa da Rome                        |
| `bytes32_to_base58(bytes32)`                      | `0xfa2b1a5f` | `EthCall` | Bytes de pubkey → string base58                                                    |
| `base58_to_bytes32(bytes)`                        | `0x5df01b72` | `EthCall` | string base58 → bytes de pubkey                                                    |

## CpiProgram (`0xff00000000000000000000000000000000000008`)

**Pré-compilação de duplo propósito.** Dos 7 seletores abaixo, **2 realizam CPI real na Solana** (`invoke`, `invoke_signed` — despacham como `Invocar`) e **5 são leituras puras cross-state** (`account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` — despacham como `CrossStateEthCall`, sem syscall, sem `found_cpi` sinalização definida). A expressão histórica "CPI shortcut selectors" se referia aos seletores de leitura como substitutos que economizavam CU para leituras anteriores baseadas em CPI — eles próprios são **não CPIs**. Veja a tabela de desambiguação no topo desta seção para a matriz completa de comportamento.

| Assinatura Solidity                                            | Seletor      | Despacho            | Descrição                                                                                                                                                                                                                                                            |
| -------------------------------------------------------------- | ------------ | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `invoke(bytes32,(bytes32,bool,bool)[],bytes)`                  | `0x7480cb86` | `Invocar`           | CPI assinada como `EXTERNAL_AUTHORITY(caller)` quando essa conta está listada como signatária (recusada em DELEGATECALL); sem sub-PDAs com salt. O chamador passa o programa alvo + metadados de conta + dados da ix                                                 |
| `invoke_signed(bytes32,(bytes32,bool,bool)[],bytes,bytes32[])` | `0xb94f3733` | `Invocar`           | CPI assinada como `EXTERNAL_AUTHORITY(caller)` em um CALL direto; os salts são anexados por seed de cada PDA. Em DELEGATECALL a autoridade nua do chamador é recusada e seeds com salt carregam o endereço do contrato em execução — veja a nota de derivação abaixo |
| `account_info(bytes32)`                                        | `0xc13465d9` | `CrossStateEthCall` | Ler o estado completo de uma conta da Solana (lamports/proprietário/sinalizadores/dados)                                                                                                                                                                             |
| `account_data_at(bytes32,uint16,uint16)`                       | `0x593762e8` | `CrossStateEthCall` | Ler um trecho do buffer de dados de qualquer conta da Solana                                                                                                                                                                                                         |
| `account_u64_at(bytes32,uint16)`                               | `0xb317d4c1` | `CrossStateEthCall` | Leitura tipada u64 LE em um deslocamento conhecido — economiza ida e volta de ABI                                                                                                                                                                                    |
| `account_lamports(bytes32)`                                    | `0xde79ed54` | `CrossStateEthCall` | Consulta apenas de lamports — ignora busca de dados                                                                                                                                                                                                                  |
| `pdas_batch_derive(bytes[][],bytes32)`                         | `0x944336f8` | `CrossStateEthCall` | N PDAs independentes contra um programa em um único despacho                                                                                                                                                                                                         |

## HelperProgram (`0xff00000000000000000000000000000000000009`)

Helpers da Rome voltados ao usuário para criação de ATA/PDA, transferências/aprovação/mint SPL assinadas pela `EXTERNAL_AUTHORITY` PDA do chamador, conversão gás↔lamports, depósito em ATA e leituras voltadas a SPL\_ERC20 (`user_balance` / `allowance_of`). Todo método é `not_payable`; mutação passa por `Invocar` (uma CPI única) exceto `deposit_from_ata` (`Composto`, apenas single-state), as três consultas somente leitura `pda`/`ata` consultas (`EthCall`), e as duas leituras cross-state de SPL\_ERC20 (`CrossStateEthCall` — uma busca de conta da Solana).

| Assinatura Solidity                                              | Seletor      | Despacho            | Descrição                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| ---------------------------------------------------------------- | ------------ | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `create_ata(address)`                                            | `0x5a7c3259` | `Invocar`           | Criar ATA para o usuário EVM sob a mint de gás da cadeia                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `create_ata(address,bytes32)`                                    | `0x3de2251a` | `Invocar`           | Criar ATA para o usuário EVM sob uma mint arbitrária                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `create_ata_for_key(bytes32,bytes32)`                            | `0xd258a69d` | `Invocar`           | Criação idempotente de ATA para uma pubkey bruta arbitrária da Solana como proprietário (não derivada via `external_auth`). O operador paga o aluguel. Usado por `SPL_ERC20.bridgeOutToSolana` / `ensureRecipientAta` / `create_token_account` fluxos de destinatário com pubkey bruta                                                                                                                                                                                                                                                                                                                                                                                           |
| `create_pda(address)`                                            | `0xff3556ca` | `Invocar`           | Crie o do usuário `EXTERNAL_AUTHORITY` PDA (isento de aluguel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `create_pda(address,uint64)`                                     | `0x58e88298` | `Invocar`           | Igual, mas financiado com `lamports` acima do piso de aluguel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `swap_gas_to_lamports(uint64)`                                   | `0x6e3f24e0` | `Invocar`           | Credite o PDA do chamador com `n` lamports do pagador de taxas Solana da transação; o chamador paga por eles em gas Rome (o gasto de lamports do pagador dentro de qualquer CPI legado é somado à taxa da transação)                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `transfer_lamports(address,uint64)`                              | `0x5fe71665` | `Invocar`           | Move lamports do PDA do chamador para o PDA de outro usuário EVM                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `transfer_spl(address,uint64)`                                   | `0xb12be5ba` | `Invocar`           | Envie SPL de chain-gas da ATA do PDA do chamador para a ATA do usuário de destino                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `transfer_spl(bytes32,uint64)`                                   | `0xba3a5eac` | `Invocar`           | Envie SPL de chain-gas da ATA do PDA do chamador para uma ATA explícita                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `transfer_spl(address,uint64,bytes32)`                           | `0x53b505e0` | `Invocar`           | Envie SPL de mint arbitrário da ATA do PDA do chamador para a ATA do usuário de destino                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `transfer_spl(bytes32,uint64,bytes32)`                           | `0xb6977879` | `Invocar`           | Envie SPL de mint arbitrário da ATA do PDA do chamador para uma ATA explícita                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `transfer_spl(bytes32,bytes32,uint64,bytes32)`                   | `0x766b362a` | `Invocar`           | Variante com delegado — o chamador fornece `src_ata` (deve ser de propriedade do PDA OU o PDA deve ser o delegado com quantidade suficiente `delegated_amount`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `transfer_spl(address,address,uint64,bytes32)`                   | `0xe479df56` | `Invocar`           | Variante de delegado indexada por endereço — deriva ambas as ATAs a partir de endereços EVM internamente. Assina como `external_auth(caller)`; o SPL Token aceita o PDA como proprietário OU delegado. Usado por `SPL_ERC20.transferFrom`                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `transfer_spl_to_signer(uint64,bytes32)`                         | `0x46efa679` | `Invocar`           | Perna de saída nativa da Solana. Envia `amount` de `mint` da ATA do PDA do chamador para a **da conta do signatário externo da Solana** para aquela mint (o próprio wallet do usuário apenas na faixa Solana assinada pela carteira; a partir do MetaMask ou via o relé, o signatário é o pagador proxy do Rome; sem conversão de endereço EVM). Não é necessário approve — o PDA do chamador é o proprietário da ATA de origem. Combine com `ActivateAta` (slot 18) para uso EVM ponta a ponta somente com chave Solana. Ele alcança a carteira na faixa v1 atual e na faixa legacy mais antiga `DoTxUnsigned` (slot 17), porque a carteira assina a transação Solana em ambas. |
| `approve_spl(address,uint64,bytes32)`                            | `0xabf6f675` | `Invocar`           | PDA do chamador como proprietário define `delegate_pda(spender)` na ATA do proprietário via SPL `approve_checked`. Usado por `SPL_ERC20.approve`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `approve_spl_raw_delegate(bytes32,bytes32,uint64,bytes32,uint8)` | `0x7881d453` | `Invocar`           | SPL `approve_checked` com delegado de pubkey bruta fornecido pelo chamador (por exemplo, Wormhole `authority_signer` PDA, sem equivalente de endereço EVM). O chamador passa `decimals` para pular a leitura on-chain do mint (\~economia de 30–50 mil CU). Codificado de forma fixa `spl_program = SPL Token`. Usado por `RomeBridgeWithdraw.approveBurnETH`                                                                                                                                                                                                                                                                                                                    |
| `mint_spl(address,uint64,bytes32)`                               | `0xd795522b` | `Invocar`           | PDA do chamador como autoridade de mint cunha para a ATA do usuário de destino via SPL `mint_to_checked`. O runtime do SPL impõe a correspondência de autoridade. Usado por `SPL_ERC20.mint_to`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `create_mint_account(bytes32)`                                   | `0xe97d3291` | `Invocar`           | System CreateAccount alocando um PDA derivado de salt (`external_auth_with_salt(caller, salt)`) com espaço=82 de propriedade do SPL Token. Financiador = PDA external\_auth do chamador. Dois signatários PDA. Usado por `ERC20SPLFactory.create_token_mint`                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `init_spl_mint(bytes32,uint8,bytes32,bool,bytes32)`              | `0x4f75e987` | `Invocar`           | SPL Token `InitializeMint2` contra um mint pré-alocado. Nenhum signatário PDA (mint\_authority/freeze\_authority armazenados como dados, não como signatários em tempo de execução). Usado por `ERC20SPLFactory.init_token_mint`                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `create_and_init_mint(uint8,bytes32,bool,bytes32,bytes32)`       | `0x20972d0f` | `Composto`          | Combinado: System CreateAccount + SPL InitializeMint2 em um único dispatch. Economiza 1 envelope Rome DoTx em comparação com chamadas separadas `create_mint_account` + `init_spl_mint` chamadas                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `deposit_from_ata(uint256)`                                      | `0x4479b709` | `Composto`          | Puxe SPL da ATA do chamador para o gas nativo Rome. **Apenas estado único** — rejeitado em cadeias op-geth                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `pda(address)`                                                   | `0x8854a299` | `EthCall`           | Derive o `EXTERNAL_AUTHORITY` PDA — somente leitura                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `pda_with_salt(address,bytes32)`                                 | `0x5c6d04b3` | `EthCall`           | Derivado de salt `EXTERNAL_AUTHORITY` PDA em um único dispatch. Colapsa a composição de 2 chamadas no lado do Solidity `rome_evm_program_id() + find_program_address()` composição. Usado por `RomeEVMAccount.pda_with_salt`, `RomeBridgeWithdraw.{burnUSDC,burnETH}`                                                                                                                                                                                                                                                                                                                                                                                                            |
| `ata(address)`                                                   | `0x31db4f82` | `EthCall`           | Derive `getATA(user_pda, chain_mint_id)` — compõe EXT\_AUTH + ATA — somente leitura                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `ata(address,bytes32)`                                           | `0xfeb1c647` | `EthCall`           | Igual, com um mint explícito — somente leitura                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `user_balance(address,bytes32)`                                  | `0xdd0119c8` | `CrossStateEthCall` | Leia a ATA do usuário `amount` (deslocamento 64 do SPL TokenAccount). Retorna 0 se a ATA não existir (verificação em cadeia recém-criada). Colapsa 3 dispatches v1. Usado por `SPL_ERC20.balanceOf`                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `mint_info(bytes32)`                                             | `0xe24bf5d4` | `CrossStateEthCall` | Fatos do mint para um chamador da trilha legada: programa do token, decimais, **armado** programa hook (0 quando ausente *ou* inerte), bps da taxa do epoch atual, bitmap de presença de extensões. Espelhado em `SplCached` no mesmo seletor. `feeBps` é um **predicado** — ele indica que uma taxa está armada, não é um operando, já que a taxa real é limitada por `maximum_fee` que isto deliberadamente não carrega.                                                                                                                                                                                                                                                       |
| `allowance_of(address,address,bytes32)`                          | `0xed72dbc8` | `CrossStateEthCall` | Leia delegated\_amount da ATA do proprietário com **verificação de igualdade do delegado** — retorna 0, a menos que o delegado on-chain == `external_auth(spender)`. Semanticamente correto para ERC-20 (REQ. OBRIGATÓRIO). Usado por `SPL_ERC20.allowance`                                                                                                                                                                                                                                                                                                                                                                                                                      |

## Saque (`0x4200000000000000000000000000000000000016`)

Saque de gas nativo Rome → Solana.

| Assinatura Solidity        | Seletor      | Despacho               | Descrição                                                                                                                |
| -------------------------- | ------------ | ---------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `withdrawal(bytes32)`      | `0x4d8b0ea4` | `Composto` (`payable`) | Queimar `msg.value` Gas Rome; cunhe+transfira para uma conta de sistema Solana `a`. O único método de precompile pagável |
| `withdraw_to_pda(uint256)` | `0x7f3124a0` | `Composto`             | Queime gas; deposite no `EXTERNAL_AUTHORITY` PDA. **Apenas estado único**                                                |
| `withdraw_to_ata(uint256)` | `0x8059abc0` | `Composto`             | Queime gas; deposite no `getATA(caller_pda, chain_mint_id)`. **Apenas 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/pt-br/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.
