> 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 com base nisso. As interfaces Solidity ficam 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 outra coisa.** Ela diz o que um método faz ao estado da Solana: | Dispatch | O que acontece | CPI real da Solana | Permitido em execução iterativa | | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | ------------------------------- | | `Invocar` / `Composto` | Uma ou mais CPIs, assinadas como o PDA de autoridade externa do chamador, quando houver seeds aplicáveis. Na **legada** trilha, elas executam imediatamente; na **cached** trilha, elas são preparadas e confirmadas no fim da transação. | Sim | Legado: **não**. Em cache: sim | | `EthCall` | Computação pura ou leitura do próprio estado da Rome | Não | Sim | | `CrossStateEthCall` | Leitura dos bytes de outra conta da Solana, pré-carregados por emulação. Sem CPI, sem efeitos colaterais. | Não | Sim | | `Pré-compilado` | Criptografia determinística (as pré-compilações padrão 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 mutáveis de ambas em uma única transação é recusado em tempo de execução. Leituras continuam permitidas, com uma exceção: depois que 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](/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 (rent, 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 assinante é o PDA de autoridade externa do contrato (`["EXTERNAL_AUTHORITY", contract]`). O próprio PDA de um usuário assina apenas em uma transação que o usuário envia diretamente ao endereço da pré-compilação. Sob `DELEGATECALL` / `CALLCODE`, os seletores mutáveis são recusados, exceto `create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint` e `create_and_init_mint` no HelperProgram, `create_ata*` no ASplCached, e `invoke` / `invoke_signed` no CpiProgram. Eles são isentos porque seu alvo é vinculado ao chamador ou financiado pelo operador, e não porque não assinam nada: `create_and_init_mint` ainda assina com o PDA do chamador externo para pagar o rent da mint e só pode criar uma mint cujas autoridades sejam esse PDA, e `invoke` / `invoke_signed` recusam a autoridade nua (`DelegatecallOwnerAuthority`) e aplicam namespace aos PDAs com salt pelo endereço do contrato em execução. Todo método é non-payable (`msg.value > 0` faz revert com `TransferProhibited`) exceto `withdrawal(bytes32)`. Métodos marcados como *single-state only* são recusados em chains op-geth-stack. Uma CPI não pode nomear o pagador de taxas da Solana (exceto dentro de uma instrução simples de transferência do System) 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 no overlay. Contraparte em cache do legacy `System @ 0xff..07`os seletores mutáveis do System (o System legado mantém os seletores puros de leitura). | Assinatura Solidity | Seletor | Dispatch | Descrição | | ------------------------------------ | ------------ | --------- | -------------------------------------------------------------------- | | `create_pda()` | `0xe0402a8d` | `Invocar` | Crie o `external_auth` PDA do chamador, isento de rent, sem dados | | `create_pda(uint64)` | `0x4ceab657` | `Invocar` | Igual, com lamports acima do rent especificados pelo financiador | | `create_pda(uint64,bytes32)` | `0x48e2bb86` | `Invocar` | PDA derivado de salt com lamports | | `create_pda(bytes32,uint64,bytes32)` | `0xcc258bbf` | `Invocar` | Especificado pelo proprietário, tamanho N, derivado de salt | | `allocate(uint64,bytes32)` | `0x93225c9f` | `Invocar` | Alocar N bytes em um PDA derivado de salt | | `assign(bytes32,bytes32)` | `0x8ac00bdc` | `Invocar` | Atribuir um PDA derivado de salt a um novo proprietário | | `transfer(address,uint64)` | `0x5d359fbd` | `Invocar` | Transferência de lamports para um PDA derivado de endereço EVM | | `transfer(bytes32,uint64)` | `0xfd54d1ea` | `Invocar` | Transferência de lamports para uma pubkey bruta da Solana | | `transfer(bytes32,uint64,bytes32)` | `0x875abfc0` | `Invocar` | Transferência de lamports para pubkey bruta, origem derivada de salt | ## SplCached (`0xff00000000000000000000000000000000000005`) Transferências de SPL Token / Token-2022 + inicialização de ATA + leituras de contas cross-state, preparadas no overlay. | Assinatura Solidity | Seletor | Dispatch | Descrição | | ----------------------------------------------- | ------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `transfer(address,uint256)` | `0xa9059cbb` | `Invocar` | Transferência SPL com o chamador como proprietário para a ATA do PDA derivado de endereço EVM, mint atual do rollup | | `transfer(bytes32,uint256)` | `0x6a467394` | `Invocar` | Igual, destinatário informado como pubkey bruta da Solana | | `transfer(address,uint256,bytes32)` | `0x57cfeeee` | `Invocar` | Variante com mint explícito, destino por endereço EVM | | `transfer(bytes32,uint256,bytes32)` | `0x7db527f9` | `Invocar` | Variante com mint explícito, destino por pubkey bruta | | `transferFrom(address,address,uint256,bytes32)` | `0x401e3367` | `Invocar` | Variante com origem delegada — autoridade = `external_auth(caller)`, aceito como proprietário da ATA OU delegado com quantidade suficiente. Usado por `SPL_ERC20_cached.transferFrom` e fluxos dirigidos 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` | O PDA do chamador assina como autoridade da mint. O runtime do SPL impõe que o PDA do chamador == autoridade on-chain da mint. Usado por `SPL_ERC20_cached.mint_to` e liquidação de bridge de entrada | | `init(bytes32,bytes32,bytes32)` | `0x0b0ad508` | `Invocar` | `InitializeAccount3` ix (ata, mint, owner) | | `account(address)` | `0x73b9aa91` | `CrossStateEthCall` | Ler o estado da conta SPL para a ATA do PDA derivado de endereço EVM (mint atual do rollup) | | `account(bytes32)` | `0x882358ae` | `CrossStateEthCall` | Ler o estado da conta SPL para uma pubkey bruta de ATA | | `account(address,bytes32)` | `0xf9827227` | `CrossStateEthCall` | Igual a `account(address)` com um mint explícito. | | `mint_info(bytes32)` | `0xe24bf5d4` | `CrossStateEthCall` | Dados da mint, com consciência do overlay: programa de token, decimais, **armado** programa hook (0 quando ausente *ou* inativo), fee bps da época atual e um bitmap de presença de extensões. Mesmo seletor que `HelperProgram.mint_info` — uma capacidade, dois destinos de dispatch, 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 | Dispatch | 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ícito | | `create_ata(address)` | `0x5a7c3259` | `Invocar` | Criação idempotente de ATA para PDA derivado de endereço EVM × mint atual | | `create_ata(address,bytes32)` | `0x3de2251a` | `Invocar` | Criação idempotente de ATA para endereço EVM × mint explícito | ## WithdrawCached (`0xff0000000000000000000000000000000000000b`) Etapas de saque do token de gás (gás nativo → wrapper SPL, gás nativo → SOL, gás nativo → PDA do chamador), preparadas. Contraparte em cache do legacy `Withdraw @ 0x42..16`. | Assinatura Solidity | Seletor | Dispatch | Descrição | | ----------------------------- | ------------ | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `withdrawal(bytes32) payable` | `0x4d8b0ea4` | `Composto` | Queimar `msg.value` gás da Rome, transferir para o destinatário conta de sistema da Solana | | `withdraw_to_pda(uint256)` | `0x7f3124a0` | `Composto` | Queimar wei, depositar lamports no `EXTERNAL_AUTHORITY` PDA do chamador. Somente estado único. | | `withdraw_to_ata(uint256)` | `0x8059abc0` | `Composto` | Queimar wei, depositar wrapper SPL na ATA de propriedade do PDA do chamador. Somente estado único. Etapa de wrap da ponte de wrapper de gás. | | `deposit(uint256)` | `0xb6b55f25` | `Composto` | Inverso de `withdrawal` — transferência SPL da ATA de propriedade do 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 pura (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). Somente estado único. Etapa de unwrap da ponte de wrapper de gás. Corresponde a `HelperProgram.deposit_from_ata` a semântica. | ## System (`0xff00000000000000000000000000000000000007`) Derivação de PDA + conversão base58 + utilitários de estilo identidade. Pré-compilação de leitura pura — todo método é `EthCall` (sem efeitos colaterais na Solana). | Assinatura Solidity | Seletor | Dispatch | 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 da Solana deste programa Rome EVM | | `program_id()` | `0x77764881` | `EthCall` | Retorna o System Program ID 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 signer da Solana da tx Rome externa | | `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 da Solana** (`invoke`, `invoke_signed` — despacham como `Invocar`e **5 são leituras puras de cross-state** (`account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` — despacham como `CrossStateEthCall`, sem syscall, sem `found_cpi` bandeira 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 são CPIs**. Veja a tabela de desambiguação no topo desta seção para a matriz comportamental completa. | Assinatura Solidity | Seletor | Dispatch | Descrição | | -------------------------------------------------------------- | ------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `invoke(bytes32,(bytes32,bool,bool)[],bytes)` | `0x7480cb86` | `Invocar` | CPI assinada como `EXTERNAL_AUTHORITY(caller)` quando essa conta é listada como signatária (recusado sob DELEGATECALL); sem sub-PDAs com salt. O chamador passa o programa alvo + metadados das contas + 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. Sob DELEGATECALL, a autoridade nua do chamador é recusada e os 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/bandeiras/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 de u64 LE em um offset conhecido — economiza ida e volta da ABI | | `account_lamports(bytes32)` | `0xde79ed54` | `CrossStateEthCall` | Consulta somente de lamports — ignora a busca de dados | | `pdas_batch_derive(bytes[][],bytes32)` | `0x944336f8` | `CrossStateEthCall` | N PDAs independentes contra um programa em um único dispatch | ## HelperProgram (`0xff00000000000000000000000000000000000009`) Helpers da Rome voltados ao usuário para criação de ATA/PDA, transferências/aprovação/mint SPL assinadas pelo `EXTERNAL_AUTHORITY` PDA do chamador, conversão gás↔lamports, depósito em ATA e leituras voltadas ao SPL\_ERC20 (`user_balance` / `allowance_of`). Todo método é `not_payable`; mutação passa por `Invocar` (uma única CPI) exceto `deposit_from_ata` (`Composto`, somente estado único), as três consultas somente leitura `pda`/`ata` consultas (`EthCall`), e as duas leituras cross-state do SPL\_ERC20 (`CrossStateEthCall` — uma busca de conta da Solana). | Assinatura Solidity | Seletor | Dispatch | 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 um mint arbitrário | | `create_ata_for_key(bytes32,bytes32)` | `0xd258a69d` | `Invocar` | Criação idempotente de ATA para uma pubkey bruta arbitrária da Solana como proprietária (não derivada via `external_auth`). O operador paga o rent. Usado por `SPL_ERC20.bridgeOutToSolana` / `ensureRecipientAta` / `create_token_account` fluxos com destinatário por pubkey bruta | | `create_pda(address)` | `0xff3556ca` | `Invocar` | Crie o `EXTERNAL_AUTHORITY` PDA do usuário (isento de rent) | | `create_pda(address,uint64)` | `0x58e88298` | `Invocar` | Igual, mas financiado com `lamports` acima do piso de rent | | `swap_gas_to_lamports(uint64)` | `0x6e3f24e0` | `Invocar` | Credita o PDA do chamador com `n` lamports do pagador de taxa Solana da transação; o chamador paga por eles em gás de Rome (o gasto de lamports do pagador dentro de qualquer CPI legada é adicionado à 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` | Envia SPL de gás da cadeia da ATA do PDA do chamador para a ATA do usuário de destino | | `transfer_spl(bytes32,uint64)` | `0xba3a5eac` | `Invocar` | Envia SPL de gás da cadeia da ATA do PDA do chamador para uma ATA explícita | | `transfer_spl(address,uint64,bytes32)` | `0x53b505e0` | `Invocar` | Envia 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` | Envia 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 `delegated_amount`) | | `transfer_spl(address,address,uint64,bytes32)` | `0xe479df56` | `Invocar` | Variante de delegado indexada por endereço — deriva ambas as ATAs de endereços EVM internamente. Assina como `external_auth(caller)`; o SPL Token aceita 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 `quantidade` de `mint` da ATA do PDA do chamador para a **ATA do signatário Solana externo** para esse mint (a própria carteira do usuário — sem conversão de endereço EVM). Não é necessário aprovar — o PDA do chamador é o proprietário da ATA de origem. Emparelhado com `ActivateAta` (slot 18) + `DoTxUnsigned` (slot 17) para uso EVM de ponta a ponta apenas com chave Solana | | `approve_spl(address,uint64,bytes32)` | `0xabf6f675` | `Invocar` | PDA do chamador como proprietário define `delegate_pda(spender)` na owner-ATA 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 chave pública bruta fornecido pelo chamador (por exemplo, o PDA authority\_signer do Wormhole, sem equivalente de endereço EVM). O chamador passa `authority_signer` PDA, sem equivalente de endereço EVM). O chamador passa `decimais` para pular a leitura do mint on-chain (\~30-50K CU de economia). codificado fixamente `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 da 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)`) de espaço=82 pertencente ao 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 mint pré-alocado. Nenhum signatário PDA (mint\_authority/freeze\_authority armazenadas como dados, não como signatários em runtime). 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 `create_mint_account` + `init_spl_mint` chamadas | | `deposit_from_ata(uint256)` | `0x4479b709` | `Composto` | Extrai SPL da ATA do chamador para o gás nativo de Rome. **Somente estado único** — rejeitado em cadeias op-geth | | `pda(address)` | `0x8854a299` | `EthCall` | Derive o `EXTERNAL_AUTHORITY` PDA do usuário — somente leitura | | `pda_with_salt(address,bytes32)` | `0x5c6d04b3` | `EthCall` | Derivado de salt `EXTERNAL_AUTHORITY` PDA em um único dispatch. Reduz a composição de 2 chamadas do lado Solidity `rome_evm_program_id() + find_program_address()` compose. 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, mas com um mint explícito — somente leitura | | `user_balance(address,bytes32)` | `0xdd0119c8` | `CrossStateEthCall` | Lê a ATA do usuário `quantidade` (offset 64 da SPL TokenAccount). Retorna 0 se a ATA não existir (verificação em cadeia nova). Reduz 3 dispatches v1. Usado por `SPL_ERC20.balanceOf` | | `mint_info(bytes32)` | `0xe24bf5d4` | `CrossStateEthCall` | Dados de mint para um chamador do caminho legado: programa do token, decimais, **armado** programa hook (0 quando ausente *ou* inerte), bps de taxa do epoch atual, bitmap de presença de extensões. Espelhado em `SplCached` no mesmo seletor. `feeBps` é um **predicado** — ele diz que uma taxa está ativada, 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` | Lê delegated\_amount da owner-ATA com **verificação de igualdade do delegado** — retorna 0 a menos que o delegate on-chain = `external_auth(spender)`. Semântica de ERC-20 correta (REQUISITO OBRIGATÓRIO). Usado por `SPL_ERC20.allowance` | ## Saque (`0x4200000000000000000000000000000000000016`) saque de gás nativo de Rome → Solana. | Assinatura Solidity | Seletor | Dispatch | Descrição | | -------------------------- | ------------ | ---------------------- | ---------------------------------------------------------------------------------------------------------------------------- | | `withdrawal(bytes32)` | `0x4d8b0ea4` | `Composto` (`pagável`) | Queimar `msg.value` gás de Rome; mint+transfer para uma conta de sistema Solana `em`. O único método de precompilado pagável | | `withdraw_to_pda(uint256)` | `0x7f3124a0` | `Composto` | Queime gás; deposite no PDA do chamador. `EXTERNAL_AUTHORITY` PDA. **Somente estado único** | | `withdraw_to_ata(uint256)` | `0x8059abc0` | `Composto` | Queime gás; deposite em `getATA(caller_pda, chain_mint_id)`. **Somente 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=&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.