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

# 프리컴파일 참조

Rome의 Solana 상호운용 프리컴파일의 모든 메서드 — 주소, Solidity 시그니처, 셀렉터, 그리고 읽기, 호출, 또는 CPI 준비 중 어느 것인지.

Rome의 온체인 프로그램이 프리컴파일별로 디스패치하는 셀렉터. 셀렉터 = `keccak256(signature)[:4]`; 아래의 각 행은 이를 기준으로 검증됩니다. Solidity 인터페이스는 다음에 있습니다 [`rome-solidity/contracts/interface.sol`](https://github.com/rome-protocol/rome-solidity/blob/master/contracts/interface.sol).

**무엇보다 먼저 Dispatch 열을 읽으세요.** 메서드가 Solana 상태에 대해 무엇을 하는지 설명합니다:

| 디스패치                | 무엇이 일어나는가                                                                                                                         | 실제 Solana CPI | 반복 실행에서 허용됨          |
| ------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ------------- | -------------------- |
| `호출` / `구성됨`        | 하나 이상의 CPI이며, 시드가 적용되는 곳에서는 호출자의 external-authority PDA로 서명됩니다. 해당 **레거시** 트랙에서는 즉시 실행되고, 그 **캐시된** 트랙에서는 스테이징되어 트랜잭션 শেষে 커밋됩니다. | 예             | 레거시: **아니요**. 캐시됨: 예 |
| `EthCall`           | 순수 계산 또는 Rome 자체 상태의 읽기                                                                                                           | 아니요           | 예                    |
| `CrossStateEthCall` | 에뮬레이션으로 미리 로드된 다른 Solana 계정의 바이트를 읽습니다. CPI 없음, 부작용 없음.                                                                           | 아니요           | 예                    |
| `프리컴파일됨`            | 결정적 암호화(이더리움 표준 프리컴파일)                                                                                                            | 아니요           | 예                    |

컨트랙트는 사용합니다 **하나의 트랙**: 레거시 프리컴파일(`0xff…07`, `0xff…08`, `0xff…09`, `0x42…16`) 또는 캐시된 것들(`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`). 둘 모두의 변경 호출을 한 트랜잭션에서 섞는 것은 런타임에서 거부됩니다. 읽기는 계속 허용되지만 한 가지 예외가 있습니다. 캐시된 트랙의 invoke가 한 번 발생하면 이후 그 트랜잭션의 나머지 동안 레거시 트랙 읽기는 거부됩니다. 다음을 참조하세요 [Solana 프로그램 통합](https://docs.rome.builders/ko/developer-guides/integrate-solana-program.md).

**누가 지불하는가.** Solana 수수료 지불자는 레거시 트랙 CPI가 지출하는 모든 lamport(렌트, 전송,  `swap_gas_to_lamports`); 프로그램은 각 CPI 전후의 지불자 잔액을 측정하고, 순 지출분을 가스 가격으로 사용자에게 가스 비용으로 청구하며, CPI가 반환한 lamports는 환불합니다.

**누가 서명하는가.** 프리컴파일을 호출하는 컨트랙트는 자기 자신으로 동작합니다. 서명자는 컨트랙트의 external-authority PDA입니다(`["EXTERNAL_AUTHORITY", contract]`). 사용자의 자체 PDA는 사용자가 프리컴파일 주소로 직접 보내는 트랜잭션에서만 서명합니다.  `DELEGATECALL` / `CALLCODE`, 변경 셀렉터는 다음을 제외하고 거부됩니다 `create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint` 그리고 `create_and_init_mint` HelperProgram에서는, `create_ata*` ASplCached에서는, 그리고 `invoke` / `invoke_signed` CpiProgram에서는. 이들은 대상이 호출자에 바인딩되었거나 운영자가 자금을 대기 때문에 면제되는 것이지, 아무것도 서명하지 않기 때문이 아닙니다: `create_and_init_mint` 여전히 외부 호출자의 PDA로 서명하여 민트의 렌트를 지불하며, 권한이 그 PDA인 민트만 생성할 수 있고,  `invoke` / `invoke_signed` bare authority를 거부합니다(`DelegatecallOwnerAuthority`) 그리고 실행 중인 컨트랙트의 주소로 salt가 붙은 PDA의 네임스페이스를 구분합니다.

모든 메서드는 non-payable입니다(`msg.value > 0` 이면 다음으로 revert됩니다 `TransferProhibited`)를 제외하고 `withdrawal(bytes32)`. 다음으로 표시된 메서드는 *단일 상태 전용* 는 op-geth-stack 체인에서 거부됩니다. CPI는 Solana 수수료 지불자(일반 System transfer instruction 내부를 제외) 또는 Rome 프로그램을 지정할 수 없으며, Rome 프로그램을 호출할 수도 없습니다.

## SystemCached (`0xff00000000000000000000000000000000000004`)

PDA 생성 + system-program 연산(allocate, assign, lamport transfer), 오버레이에 스테이징됨. 레거시의 캐시된 대응물 `System @ 0xff..07`의 변경 셀렉터(레거시 System은 순수 읽기 셀렉터를 유지함).

| Solidity 시그니처                        | 셀렉터          | 디스패치 | 설명                                                       |
| ------------------------------------ | ------------ | ---- | -------------------------------------------------------- |
| `create_pda()`                       | `0xe0402a8d` | `호출` | 호출자의 `external_auth` PDA를 생성합니다. rent-exempt이며 데이터는 0입니다 |
| `create_pda(uint64)`                 | `0x4ceab657` | `호출` | 동일하지만, 펀더가 지정한 lamports가 rent를 초과합니다                     |
| `create_pda(uint64,bytes32)`         | `0x48e2bb86` | `호출` | lamports가 있는 salt 파생 PDA                                 |
| `create_pda(bytes32,uint64,bytes32)` | `0xcc258bbf` | `호출` | 소유자가 지정한, 크기 N의 salt 파생                                  |
| `allocate(uint64,bytes32)`           | `0x93225c9f` | `호출` | salt 파생 PDA에 N바이트를 할당                                    |
| `assign(bytes32,bytes32)`            | `0x8ac00bdc` | `호출` | salt 파생 PDA를 새 소유자에게 할당                                  |
| `transfer(address,uint64)`           | `0x5d359fbd` | `호출` | EVM 주소에서 파생된 PDA로 lamport를 전송                            |
| `transfer(bytes32,uint64)`           | `0xfd54d1ea` | `호출` | 원시 Solana 공개키로 lamport를 전송                               |
| `transfer(bytes32,uint64,bytes32)`   | `0x875abfc0` | `호출` | 원시 공개키로 lamport를 전송, 소스는 salt 파생                         |

## SplCached (`0xff00000000000000000000000000000000000005`)

SPL Token / Token-2022 전송 + ATA 초기화 + 크로스-상태 계정 읽기, 오버레이에 스테이징됨.

| Solidity 시그니처                                   | 셀렉터          | 디스패치                | 설명                                                                                                                                                                                                                        |
| ----------------------------------------------- | ------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `transfer(address,uint256)`                     | `0xa9059cbb` | `호출`                | 호출자-소유자 방식의 SPL 전송을 EVM 주소에서 파생된 PDA의 ATA로, 현재 롤업 민트를 기준으로 수행                                                                                                                                                             |
| `transfer(bytes32,uint256)`                     | `0x6a467394` | `호출`                | 동일하며, 수신자는 원시 Solana 공개키로 지정됨                                                                                                                                                                                             |
| `transfer(address,uint256,bytes32)`             | `0x57cfeeee` | `호출`                | 명시적 민트 변형, EVM 주소 대상                                                                                                                                                                                                      |
| `transfer(bytes32,uint256,bytes32)`             | `0x7db527f9` | `호출`                | 명시적 민트 변형, 원시 공개키 대상                                                                                                                                                                                                      |
| `transferFrom(address,address,uint256,bytes32)` | `0x401e3367` | `호출`                | 위임 소스 변형 — 권한 = `external_auth(caller)`, ATA 소유자 또는 충분한 금액의 위임자로 허용됨. 다음에서 사용됨 `SPL_ERC20_cached.transferFrom` 및 라우터 기반 흐름                                                                                                |
| `approve(address,uint256,bytes32)`              | `0x8180f2fc` | `호출`                | EVM spender 승인 — 소유자 = `external_auth(caller)`, 위임자 = `external_auth(spender_addr)`. 다음에서 사용됨 `SPL_ERC20_cached.approve`                                                                                                  |
| `mint(address,uint256,bytes32)`                 | `0x1e458bee` | `호출`                | 호출자 PDA가 민트 권한자로 서명합니다. SPL 런타임은 호출자 PDA == 온체인 민트 권한자를 강제합니다. 다음에서 사용됨 `SPL_ERC20_cached.mint_to` 및 인바운드 브리지 정산                                                                                                          |
| `init(bytes32,bytes32,bytes32)`                 | `0x0b0ad508` | `호출`                | `InitializeAccount3` ix (ata, mint, owner)                                                                                                                                                                                |
| `account(address)`                              | `0x73b9aa91` | `CrossStateEthCall` | EVM 주소의 PDA 파생 ATA에 대한 SPL 계정 상태를 읽음(현재 롤업 민트)                                                                                                                                                                            |
| `account(bytes32)`                              | `0x882358ae` | `CrossStateEthCall` | 원시 ATA 공개키의 SPL 계정 상태를 읽음                                                                                                                                                                                                 |
| `account(address,bytes32)`                      | `0xf9827227` | `CrossStateEthCall` | 다음과 동일 `account(address)` 하지만 민트를 명시함.                                                                                                                                                                                    |
| `mint_info(bytes32)`                            | `0xe24bf5d4` | `CrossStateEthCall` | 민트 정보, 오버레이 인식: 토큰 프로그램, 소수점 자릿수, **장착된** 훅 프로그램(없으면 0 *또는* 비활성), 현재 에포크 수수료 bps, 그리고 확장 존재 비트맵. 다음과 동일한 셀렉터: `HelperProgram.mint_info` — 하나의 기능, 두 개의 디스패치 위치. 캐시된 트랙 컨트랙트는 캐시된 invoke가 한 번 발생하면 레거시 읽기를 사용할 수 없기 때문입니다. |

## ASplCached (`0xff00000000000000000000000000000000000006`)

Associated Token Account 생성, 멱등적.

| Solidity 시그니처                 | 셀렉터          | 디스패치 | 설명                                      |
| ----------------------------- | ------------ | ---- | --------------------------------------- |
| `create_ata()`                | `0xb6d336ed` | `호출` | 호출자 PDA × 현재 롤업 민트에 대한 멱등적 ATA 생성       |
| `create_ata(bytes32)`         | `0x81972e35` | `호출` | 호출자 PDA × 명시적 민트에 대한 멱등적 ATA 생성         |
| `create_ata(address)`         | `0x5a7c3259` | `호출` | EVM 주소에서 파생된 PDA × 현재 민트에 대한 멱등적 ATA 생성 |
| `create_ata(address,bytes32)` | `0x3de2251a` | `호출` | EVM 주소 × 명시적 민트에 대한 멱등적 ATA 생성          |

## WithdrawCached (`0xff0000000000000000000000000000000000000b`)

가스 토큰 출금 경로(native gas → SPL 래퍼, native gas → SOL, native gas → 호출자 PDA), 스테이징됨. 레거시의 캐시된 대응물 `Withdraw @ 0x42..16`.

| Solidity 시그니처                 | 셀렉터          | 디스패치  | 설명                                                                                                                                                                                                                                                                                                  |
| ----------------------------- | ------------ | ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32) payable` | `0x4d8b0ea4` | `구성됨` | 소각 `msg.value` Rome 가스를 소각하고 Solana 시스템 계정 수신자에게 전송                                                                                                                                                                                                                                                 |
| `withdraw_to_pda(uint256)`    | `0x7f3124a0` | `구성됨` | wei를 소각하고 호출자의 `EXTERNAL_AUTHORITY` PDA에 lamports를 입금합니다. 단일 상태 전용.                                                                                                                                                                                                                                 |
| `withdraw_to_ata(uint256)`    | `0x8059abc0` | `구성됨` | wei를 소각하고 호출자의 PDA 소유 ATA에 SPL 래퍼를 입금합니다. 단일 상태 전용. 가스 래퍼 브리지의 래핑 경로입니다.                                                                                                                                                                                                                            |
| `deposit(uint256)`            | `0xb6b55f25` | `구성됨` | 의 반대 `withdrawal` — Solana 측에서 호출자의 PDA 소유 ATA에서 체인의 sol\_wallet ATA로 SPL 전송; **mint** `wei` EVM 측에서 호출자에게 전달되는 네이티브 가스입니다. 순수 민트입니다(다음에 대한 상쇄 차감 없음 `Withdraw::ADDRESS` — 체인의 SPL 지갑이 경제적 담보이며, 프리컴파일 주소가 아닙니다). 단일 상태 전용. 가스 래퍼 브리지의 언래핑 경로입니다. 다음과 일치합니다 `HelperProgram.deposit_from_ata` 의 의미론과 |

## System (`0xff00000000000000000000000000000000000007`)

PDA 파생 + base58 변환 + identity 스타일 유틸리티. 순수 읽기 프리컴파일 — 모든 메서드는 `EthCall` (Solana 측 부작용 없음).

| Solidity 시그니처                                     | 셀렉터          | 디스패치      | 설명                                                              |
| ------------------------------------------------- | ------------ | --------- | --------------------------------------------------------------- |
| `find_program_address(bytes32,(bytes)[])`         | `0x27e3edda` | `EthCall` | Solana `find_program_address` 시스템 호출을 통해 — 다음을 반환 `(pda, bump)` |
| `create_program_address(bytes32,(bytes)[],uint8)` | `0xb99f29e1` | `EthCall` | 알려진 bump를 사용한 상수 시간 PDA 파생                                      |
| `rome_evm_program_id()`                           | `0xb76fd45b` | `EthCall` | 이 Rome EVM 프로그램의 Solana 프로그램 ID를 반환합니다                          |
| `program_id()`                                    | `0x77764881` | `EthCall` | Rome의 System Program ID(이 프리컴파일의 ID)를 반환합니다                     |
| `mint_id()`                                       | `0xe132a122` | `EthCall` | 체인의 가스 토큰 SPL 민트 공개키를 반환합니다(`OwnerInfo.chain_mint_id`)          |
| `operator()`                                      | `0x570ca735` | `EthCall` | 외부 Rome 트랜잭션의 Solana 서명자를 반환합니다                                 |
| `bytes32_to_base58(bytes32)`                      | `0xfa2b1a5f` | `EthCall` | 공개키 바이트 → base58 문자열                                            |
| `base58_to_bytes32(bytes)`                        | `0x5df01b72` | `EthCall` | base58 문자열 → 공개키 바이트                                            |

## CpiProgram (`0xff00000000000000000000000000000000000008`)

**이중 목적 프리컴파일.** 아래 7개 셀렉터 중 **2개는 실제 Solana CPI를 수행하고** (`invoke`, `invoke_signed` — 다음으로 디스패치됩니다 `호출`) 그리고 **5개는 순수 크로스-상태 읽기입니다** (`account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` — 다음으로 디스패치됩니다 `CrossStateEthCall`, 시스템 호출 없음,  `found_cpi` 플래그가 설정됨). 역사적으로 "CPI shortcut selectors"라는 표현은 이전의 CPI 기반 읽기를 대체하는 CU 절약용 읽기 셀렉터를 가리켰으며, 이들 자체는 **CPI가 아닙니다**. 전체 동작 매트릭스는 이 섹션 상단의 구분 표를 참조하세요.

| Solidity 시그니처                                                  | 셀렉터          | 디스패치                | 설명                                                                                                                                                                          |
| -------------------------------------------------------------- | ------------ | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `invoke(bytes32,(bytes32,bool,bool)[],bytes)`                  | `0x7480cb86` | `호출`                | 다음으로 서명된 CPI `EXTERNAL_AUTHORITY(caller)` 해당 계정이 서명자로 나열된 경우( DELEGATECALL에서는 거부됨 ); salt가 붙은 하위 PDA는 없습니다. 호출자는 대상 프로그램 + 계정 메타 + ix 데이터를 전달합니다                            |
| `invoke_signed(bytes32,(bytes32,bool,bool)[],bytes,bytes32[])` | `0xb94f3733` | `호출`                | 다음으로 서명된 CPI `EXTERNAL_AUTHORITY(caller)` 직접 CALL에서; salt는 PDA별 시드에 추가됩니다. DELEGATECALL에서는 bare caller authority가 거부되며 salt가 붙은 시드는 실행 중인 컨트랙트의 주소를 담습니다 — 아래의 파생 설명을 참조하세요 |
| `account_info(bytes32)`                                        | `0xc13465d9` | `CrossStateEthCall` | Solana 계정의 전체 상태(lamports/owner/flags/data)를 읽음                                                                                                                             |
| `account_data_at(bytes32,uint16,uint16)`                       | `0x593762e8` | `CrossStateEthCall` | 임의의 Solana 계정 데이터 버퍼의 일부를 읽음                                                                                                                                                |
| `account_u64_at(bytes32,uint16)`                               | `0xb317d4c1` | `CrossStateEthCall` | 알려진 오프셋에서 타입이 지정된 u64 LE 읽기 — ABI 왕복을 절약함                                                                                                                                   |
| `account_lamports(bytes32)`                                    | `0xde79ed54` | `CrossStateEthCall` | lamports 전용 조회 — 데이터 가져오기를 건너뜀                                                                                                                                              |
| `pdas_batch_derive(bytes[][],bytes32)`                         | `0x944336f8` | `CrossStateEthCall` | 하나의 프로그램에 대해 N개의 독립적인 PDA를 한 번의 디스패치로 파생                                                                                                                                    |

## HelperProgram (`0xff00000000000000000000000000000000000009`)

ATA/PDA 생성, 호출자의 `EXTERNAL_AUTHORITY` PDA로 서명되는 SPL 전송/승인/민트, 가스↔lamports 변환, ATA 입금, 그리고 SPL\_ERC20 대상 읽기(`user_balance` / `allowance_of`). 모든 메서드는 `not_payable`; 변경은 다음을 통해 이루어집니다 `호출` (단일 CPI) except `deposit_from_ata` (`구성됨`, 단일 상태 전용), 세 개의 읽기 전용 `pda`/`ata` 질의(`EthCall`), 그리고 두 개의 크로스-상태 SPL\_ERC20 읽기(`CrossStateEthCall` — Solana 계정 조회 1회).

| Solidity 시그니처                                                    | 셀렉터          | 디스패치                | 설명                                                                                                                                                                                                                                                                                                                                                                       |
| ---------------------------------------------------------------- | ------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `create_ata(address)`                                            | `0x5a7c3259` | `호출`                | 체인의 가스 민트 아래에서 EVM 사용자에 대한 ATA를 생성                                                                                                                                                                                                                                                                                                                                       |
| `create_ata(address,bytes32)`                                    | `0x3de2251a` | `호출`                | 임의의 민트 아래에서 EVM 사용자에 대한 ATA를 생성                                                                                                                                                                                                                                                                                                                                          |
| `create_ata_for_key(bytes32,bytes32)`                            | `0xd258a69d` | `호출`                | 임의의 원시 Solana 공개키를 소유자로 하는 멱등적 ATA 생성( `external_auth`). 운영자가 rent를 지불합니다. 다음에서 사용됨 `SPL_ERC20.bridgeOutToSolana` / `ensureRecipientAta` / `create_token_account` 원시 공개키 수신자 흐름                                                                                                                                                                                          |
| `create_pda(address)`                                            | `0xff3556ca` | `호출`                | 사용자의 `EXTERNAL_AUTHORITY` PDA(렌트 면제)                                                                                                                                                                                                                                                                                                                                     |
| `create_pda(address,uint64)`                                     | `0x58e88298` | `호출`                | 동일하지만, 다음으로 자금이 지원됨 `람포트` 렌트 기준액 초과                                                                                                                                                                                                                                                                                                                                      |
| `swap_gas_to_lamports(uint64)`                                   | `0x6e3f24e0` | `호출`                | 호출자의 PDA에 다음을 적립 `n` 트랜잭션의 Solana 수수료 지불자로부터 lamports를 가져오며; 호출자는 이를 Rome 가스로 지불합니다(어떤 레거시 CPI 내에서든 지불자의 lamport 지출은 트랜잭션 수수료에 추가됨)                                                                                                                                                                                                                                      |
| `transfer_lamports(address,uint64)`                              | `0x5fe71665` | `호출`                | 호출자의 PDA에서 다른 EVM 사용자의 PDA로 lamports를 이동                                                                                                                                                                                                                                                                                                                                 |
| `transfer_spl(address,uint64)`                                   | `0xb12be5ba` | `호출`                | 호출자 PDA의 ATA에서 대상 사용자의 ATA로 체인 가스 SPL을 전송                                                                                                                                                                                                                                                                                                                                |
| `transfer_spl(bytes32,uint64)`                                   | `0xba3a5eac` | `호출`                | 호출자 PDA의 ATA에서 명시적 ATA로 체인 가스 SPL을 전송                                                                                                                                                                                                                                                                                                                                    |
| `transfer_spl(address,uint64,bytes32)`                           | `0x53b505e0` | `호출`                | 호출자 PDA의 ATA에서 대상 사용자의 ATA로 임의 민트 SPL을 전송                                                                                                                                                                                                                                                                                                                                |
| `transfer_spl(bytes32,uint64,bytes32)`                           | `0xb6977879` | `호출`                | 호출자 PDA의 ATA에서 명시적 ATA로 임의 민트 SPL을 전송                                                                                                                                                                                                                                                                                                                                    |
| `transfer_spl(bytes32,bytes32,uint64,bytes32)`                   | `0x766b362a` | `호출`                | 위임 변형 — 호출자가 다음을 제공 `src_ata` (PDA 소유이거나 PDA가 충분한 `delegated_amount`)                                                                                                                                                                                                                                                                                                    |
| `transfer_spl(address,address,uint64,bytes32)`                   | `0xe479df56` | `호출`                | 주소 키 기반 위임 변형 — 두 ATA를 내부적으로 EVM 주소에서 유도합니다. 서명 주체는 `external_auth(caller)`; SPL Token은 PDA를 소유자 또는 위임자로 허용합니다. 다음에서 사용됨 `SPL_ERC20.transferFrom`                                                                                                                                                                                                                        |
| `transfer_spl_to_signer(uint64,bytes32)`                         | `0x46efa679` | `호출`                | Solana 네이티브 종료 단계. 다음을 전송합니다 `amount` of `mint` 호출자 PDA의 ATA에서 다음으로 **외부 Solana 서명자의** 해당 민트의 ATA로(지갑 서명 Solana 레인에서는 사용자의 자체 지갑만; MetaMask에서 또는 릴레이를 통해서는 서명자는 Rome의 프록시 지불자임; EVM 주소 변환 없음). 승인 불필요 — 호출자-PDA가 소스 ATA를 소유함. 다음과 함께 사용: `ActivateAta` (슬롯 18) 최종 단계까지 Solana 키만으로 EVM 사용. 현재 v1 레인과 이전 레거시 `DoTxUnsigned` (슬롯 17) 레인 모두에서 지갑이 Solana 트랜잭션에 서명하므로 도달합니다. |
| `approve_spl(address,uint64,bytes32)`                            | `0xabf6f675` | `호출`                | 호출자-PDA-소유자 설정 `delegate_pda(spender)` 소유자 ATA에서 SPL을 통해 `approve_checked`. 다음에서 사용됨 `SPL_ERC20.approve`                                                                                                                                                                                                                                                                 |
| `approve_spl_raw_delegate(bytes32,bytes32,uint64,bytes32,uint8)` | `0x7881d453` | `호출`                | SPL `approve_checked` 호출자 제공 원시 공개키 위임자 사용(예: Wormhole `authority_signer` PDA, EVM 주소 대응 없음). 호출자는 `decimals` 온체인 민트 조회를 건너뛰어 약 30\~50K CU를 절약합니다. 하드코딩된 `spl_program = SPL Token`. 다음에서 사용됨 `RomeBridgeWithdraw.approveBurnETH`                                                                                                                                         |
| `mint_spl(address,uint64,bytes32)`                               | `0xd795522b` | `호출`                | 호출자-PDA-민트 권한이 SPL을 통해 대상 사용자의 ATA에 민트 `mint_to_checked`. SPL 런타임이 권한 일치를 강제합니다. 다음에서 사용됨 `SPL_ERC20.mint_to`                                                                                                                                                                                                                                                            |
| `create_mint_account(bytes32)`                                   | `0xe97d3291` | `호출`                | SPL Token에 의해 소유된, salt에서 파생된 PDA를 할당하는 System CreateAccount (`external_auth_with_salt(caller, salt)`) 공간=82. 자금 제공자 = 호출자의 external\_auth PDA. PDA 서명자 2개. 다음에서 사용됨 `ERC20SPLFactory.create_token_mint`                                                                                                                                                                 |
| `init_spl_mint(bytes32,uint8,bytes32,bool,bytes32)`              | `0x4f75e987` | `호출`                | SPL Token `InitializeMint2` 사전 할당된 민트를 대상으로 합니다. PDA 서명자 없음(mint\_authority/freeze\_authority는 데이터로 저장되며, 런타임 서명자는 아님). 다음에서 사용됨 `ERC20SPLFactory.init_token_mint`                                                                                                                                                                                                       |
| `create_and_init_mint(uint8,bytes32,bool,bytes32,bytes32)`       | `0x20972d0f` | `구성됨`               | 결합: System CreateAccount + SPL InitializeMint2를 하나의 디스패치로 처리합니다. 별도의 `create_mint_account` + `init_spl_mint` 호출                                                                                                                                                                                                                                                          |
| `deposit_from_ata(uint256)`                                      | `0x4479b709` | `구성됨`               | 호출자의 ATA에서 Rome 네이티브 가스로 SPL을 끌어옵니다. **단일 상태만** — op-geth 체인에서는 거부됨                                                                                                                                                                                                                                                                                                      |
| `pda(address)`                                                   | `0x8854a299` | `EthCall`           | 사용자의 `EXTERNAL_AUTHORITY` PDA — 읽기 전용                                                                                                                                                                                                                                                                                                                                    |
| `pda_with_salt(address,bytes32)`                                 | `0x5c6d04b3` | `EthCall`           | salt에서 파생된 `EXTERNAL_AUTHORITY` PDA를 단일 디스패치로 처리합니다. Solidity 측 2회 호출 `rome_evm_program_id() + find_program_address()` 구성을 하나로 축소합니다. 다음에서 사용됨 `RomeEVMAccount.pda_with_salt`, `RomeBridgeWithdraw.{burnUSDC,burnETH}`                                                                                                                                                   |
| `ata(address)`                                                   | `0x31db4f82` | `EthCall`           | 유도 `getATA(user_pda, chain_mint_id)` — EXT\_AUTH + ATA를 구성 — 읽기 전용                                                                                                                                                                                                                                                                                                       |
| `ata(address,bytes32)`                                           | `0xfeb1c647` | `EthCall`           | 명시적 민트가 있는 동일한 방식 — 읽기 전용                                                                                                                                                                                                                                                                                                                                                |
| `user_balance(address,bytes32)`                                  | `0xdd0119c8` | `CrossStateEthCall` | 사용자 ATA 읽기 `amount` (SPL TokenAccount 오프셋 64). ATA가 없으면 0을 반환합니다(새 체인 프로브). v1 디스패치 3개를 하나로 축소합니다. 다음에서 사용됨 `SPL_ERC20.balanceOf`                                                                                                                                                                                                                                        |
| `mint_info(bytes32)`                                             | `0xe24bf5d4` | `CrossStateEthCall` | 레거시 트랙 호출자를 위한 민트 정보: 토큰 프로그램, decimals, **장착된** 훅 프로그램(없으면 0 *또는* (비활성), 현재 epoch 수수료 bps, 확장 존재 비트맵. 다음에 미러링됨 `SplCached` 동일한 셀렉터에서. `feeBps` 는 **술어** — 수수료가 활성화되었다는 뜻일 뿐이며, 실제 수수료는 다음에 의해 상한이 정해지므로 피연산자가 아닙니다 `maximum_fee` 이 값은 의도적으로 포함하지 않습니다.                                                                                                                  |
| `allowance_of(address,address,bytes32)`                          | `0xed72dbc8` | `CrossStateEthCall` | 소유자 ATA의 delegated\_amount를 다음과 함께 읽기 **delegate 동일성 검사** — 온체인 delegate == `external_auth(spender)`. ERC-20 의미상 올바름(HARD REQ). 다음에서 사용됨 `SPL_ERC20.allowance`                                                                                                                                                                                                           |

## 인출 (`0x4200000000000000000000000000000000000016`)

Rome → Solana 네이티브 가스 인출.

| Solidity 시그니처              | 셀렉터          | 디스패치              | 설명                                                                       |
| -------------------------- | ------------ | ----------------- | ------------------------------------------------------------------------ |
| `withdrawal(bytes32)`      | `0x4d8b0ea4` | `구성됨` (`payable`) | 소각 `msg.value` Rome 가스; Solana 시스템 계정으로 민트+전송 `를`. 유일한 payable 프리컴파일 메서드 |
| `withdraw_to_pda(uint256)` | `0x7f3124a0` | `구성됨`             | 가스 소각; 호출자의 `EXTERNAL_AUTHORITY` PDA에 입금. **단일 상태만**                     |
| `withdraw_to_ata(uint256)` | `0x8059abc0` | `구성됨`             | 가스 소각; 다음에 입금 `getATA(caller_pda, chain_mint_id)`. **단일 상태만**            |


---

# 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/ko/reference/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.
