> 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 상태에 대해 무엇을 하는지 설명합니다:

| Dispatch            | 무슨 일이 일어나는가                                                                                                            | 실제 Solana CPI | 반복 실행에서 허용됨          |
| ------------------- | ---------------------------------------------------------------------------------------------------------------------- | ------------- | -------------------- |
| `호출` / `구성됨`        | 하나 이상의 CPI로, 시드가 적용되는 경우 호출자의 외부 권한 PDA로 서명됩니다.  **레거시** 트랙에서는 즉시 실행되며; on the **캐시된** 트랙에서는 트랜잭션이 끝날 때 커밋되도록 스테이징됩니다. | 예             | 레거시: **아니요**. 캐시됨: 예 |
| `EthCall`           | 순수 계산 또는 Rome 자신의 상태 읽기                                                                                                | 아니요           | 예                    |
| `CrossStateEthCall` | 에뮬레이션으로 미리 로드된 다른 Solana 계정 바이트의 읽기입니다. CPI도 없고 부작용도 없습니다.                                                             | 아니요           | 예                    |
| `Precompiled`       | 결정론적 암호학(Ethereum 표준 프리컴파일)                                                                                            | 아니요           | 예                    |

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

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

**누가 서명하는가.** 프리컴파일을 호출하는 컨트랙트는 자기 자신으로서 동작합니다: 서명자는 컨트랙트의 외부 권한 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` 단독 권한을 거부하고(`DelegatecallOwnerAuthority`) 실행 중인 컨트랙트의 주소로 salt가 붙은 PDA에 네임스페이스를 부여합니다.

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

## SystemCached (`0xff00000000000000000000000000000000000004`)

PDA 생성 + 시스템 프로그램 작업(allocate, assign, lamport transfer), 오버레이에 스테이징됨. 레거시의 캐시 대응물 `System @ 0xff..07`의 변경 셀렉터(레거시 System은 순수 읽기 셀렉터를 유지합니다).

| Solidity signature                   | 셀렉터          | Dispatch | 설명                                          |
| ------------------------------------ | ------------ | -------- | ------------------------------------------- |
| `create_pda()`                       | `0xe0402a8d` | `호출`     | 호출자의 `external_auth` PDA를 생성, 렌트 면제, 데이터 없음 |
| `create_pda(uint64)`                 | `0x4ceab657` | `호출`     | 동일하되, 렌트보다 많은 lamport를 펀더가 지정               |
| `create_pda(uint64,bytes32)`         | `0x48e2bb86` | `호출`     | lamport를 가진 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 signature                              | 셀렉터          | Dispatch            | 설명                                                                                                                                                                                                                                     |
| ----------------------------------------------- | ------------ | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `transfer(address,uint256)`                     | `0xa9059cbb` | `호출`                | 호출자-소유자 방식의 SPL 전송, EVM 주소 파생 PDA의 ATA로, 현재 롤업 mint                                                                                                                                                                                    |
| `transfer(bytes32,uint256)`                     | `0x6a467394` | `호출`                | 동일하되, 수신자는 원시 Solana 공개키로 지정                                                                                                                                                                                                           |
| `transfer(address,uint256,bytes32)`             | `0x57cfeeee` | `호출`                | 명시적 mint 변형, EVM 주소 목적지                                                                                                                                                                                                                |
| `transfer(bytes32,uint256,bytes32)`             | `0x7db527f9` | `호출`                | 명시적 mint 변형, 원시 공개키 목적지                                                                                                                                                                                                                |
| `transferFrom(address,address,uint256,bytes32)` | `0x401e3367` | `호출`                | 대리 소스 변형 — 권한 = `external_auth(caller)`, ATA 소유자 또는 충분한 금액의 delegate로 인정됨. 다음에 사용됨 `SPL_ERC20_cached.transferFrom` 및 라우터 주도 흐름                                                                                                         |
| `approve(address,uint256,bytes32)`              | `0x8180f2fc` | `호출`                | EVM 지출자 승인 — 소유자 = `external_auth(caller)`, delegate = `external_auth(spender_addr)`. 다음에 사용됨 `SPL_ERC20_cached.approve`                                                                                                               |
| `mint(address,uint256,bytes32)`                 | `0x1e458bee` | `호출`                | 호출자 PDA가 mint 권한자로서 서명합니다. SPL 런타임은 호출자 PDA == 온체인 mint 권한자임을 강제합니다. 다음에 사용됨 `SPL_ERC20_cached.mint_to` 및 inbound bridge 정산                                                                                                            |
| `init(bytes32,bytes32,bytes32)`                 | `0x0b0ad508` | `호출`                | `InitializeAccount3` ix(ata, mint, owner)                                                                                                                                                                                              |
| `account(address)`                              | `0x73b9aa91` | `CrossStateEthCall` | EVM 주소의 PDA 파생 ATA(현재 롤업 mint)에 대한 SPL 계정 상태 읽기                                                                                                                                                                                        |
| `account(bytes32)`                              | `0x882358ae` | `CrossStateEthCall` | 원시 ATA 공개키의 SPL 계정 상태 읽기                                                                                                                                                                                                               |
| `account(address,bytes32)`                      | `0xf9827227` | `CrossStateEthCall` | 다음과 동일 `account(address)` 명시적 mint를 사용.                                                                                                                                                                                                |
| `mint_info(bytes32)`                            | `0xe24bf5d4` | `CrossStateEthCall` | mint 정보, 오버레이 인식: 토큰 프로그램, 소수점 자리수, **활성화된** hook 프로그램(없을 때는 0 *또는* 비활성), 현재 에폭 수수료 bps, 그리고 확장 존재 비트맵. 다음과 같은 셀렉터를 사용함 `HelperProgram.mint_info` — 하나의 기능, 두 개의 디스패치 홈, 왜냐하면 캐시 트랙 컨트랙트는 캐시된 invoke가 한 번 실행되면 레거시 읽기를 사용할 수 없기 때문입니다. |

## ASplCached (`0xff00000000000000000000000000000000000006`)

연관 토큰 계정 생성, 멱등적.

| Solidity signature            | 셀렉터          | Dispatch | 설명                                     |
| ----------------------------- | ------------ | -------- | -------------------------------------- |
| `create_ata()`                | `0xb6d336ed` | `호출`     | 호출자 PDA × 현재 롤업 mint에 대한 멱등적 ATA 생성    |
| `create_ata(bytes32)`         | `0x81972e35` | `호출`     | 호출자 PDA × 명시적 mint에 대한 멱등적 ATA 생성      |
| `create_ata(address)`         | `0x5a7c3259` | `호출`     | EVM 주소 파생 PDA × 현재 mint에 대한 멱등적 ATA 생성 |
| `create_ata(address,bytes32)` | `0x3de2251a` | `호출`     | EVM 주소 × 명시적 mint에 대한 멱등적 ATA 생성       |

## WithdrawCached (`0xff0000000000000000000000000000000000000b`)

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

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

## System (`0xff00000000000000000000000000000000000007`)

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

| Solidity signature                                | 셀렉터          | Dispatch  | 설명                                                             |
| ------------------------------------------------- | ------------ | --------- | -------------------------------------------------------------- |
| `find_program_address(bytes32,(bytes)[])`         | `0x27e3edda` | `EthCall` | 솔라나 `find_program_address` syscall을 통해 — 다음을 반환: `(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를 반환합니다(이 프리컴파일의 정체성)                   |
| `mint_id()`                                       | `0xe132a122` | `EthCall` | 체인의 가스 토큰 SPL mint 공개키를 반환합니다(`OwnerInfo.chain_mint_id`)       |
| `operator()`                                      | `0x570ca735` | `EthCall` | 외부 Rome tx의 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`, syscall도 없고,  `found_cpi` 플래그가 설정됨). 역사적 표현인 "CPI shortcut selectors"는 이전 CPI 기반 읽기를 대체하는 CU 절감용 읽기 셀렉터를 가리켰습니다 — 그 자체는 **CPI가 아닙니다**. 전체 동작 매트릭스는 이 섹션 상단의 구분 표를 참조하세요.

| Solidity signature                                             | 셀렉터          | Dispatch            | 설명                                                                                                                                                                |
| -------------------------------------------------------------- | ------------ | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `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에서는 단독 호출자 권한이 거부되며 salted seed에 실행 중인 컨트랙트의 주소가 포함됩니다 — 아래의 파생 노트를 참조하세요 |
| `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` | lamport 전용 프로브 — 데이터 가져오기를 건너뜁니다                                                                                                                                  |
| `pdas_batch_derive(bytes[][],bytes32)`                         | `0x944336f8` | `CrossStateEthCall` | 하나의 디스패치로 하나의 프로그램에 대한 N개의 독립 PDA                                                                                                                                 |

## HelperProgram (`0xff00000000000000000000000000000000000009`)

Rome의 사용자용 헬퍼로, ATA/PDA 생성, 호출자의 PDA로 서명된 SPL 전송/승인/mint, `EXTERNAL_AUTHORITY` PDA, gas↔lamports 변환, ATA 예치, 그리고 SPL\_ERC20용 읽기(`user_balance` / `allowance_of`). 모든 메서드는 `지불 불가`; 변경은 다음을 통해 이루어집니다 `호출` (단일 CPI) 단, `deposit_from_ata` (`구성됨`, 단일 상태 전용), 세 가지 읽기 전용 `pda`/`ata` 쿼리(`EthCall`), 그리고 두 개의 교차 상태 SPL\_ERC20 읽기(`CrossStateEthCall` — Solana 계정 한 번 조회).

| Solidity signature                                               | 셀렉터          | Dispatch            | 설명                                                                                                                                                                                                                                                         |
| ---------------------------------------------------------------- | ------------ | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `create_ata(address)`                                            | `0x5a7c3259` | `호출`                | 체인의 gas mint 아래에서 EVM 사용자를 위한 ATA를 생성                                                                                                                                                                                                                      |
| `create_ata(address,bytes32)`                                    | `0x3de2251a` | `호출`                | 임의의 mint 아래에서 EVM 사용자를 위한 ATA를 생성                                                                                                                                                                                                                          |
| `create_ata_for_key(bytes32,bytes32)`                            | `0xd258a69d` | `호출`                | 임의의 원시 Solana 공개키를 소유자로 하는 멱등적 ATA 생성(다음을 통해 파생되지 않음 `external_auth`). 운영자가 렌트를 지불합니다. 다음에 사용됨 `SPL_ERC20.bridgeOutToSolana` / `ensureRecipientAta` / `create_token_account` 원시 공개키 수신자 흐름                                                                 |
| `create_pda(address)`                                            | `0xff3556ca` | `호출`                | 사용자의 것을 생성 `EXTERNAL_AUTHORITY` PDA(임대료 면제)                                                                                                                                                                                                                |
| `create_pda(address,uint64)`                                     | `0x58e88298` | `호출`                | 동일하지만 다음으로 자금 조달 `lamport` 임대료 하한 초과                                                                                                                                                                                                                       |
| `swap_gas_to_lamports(uint64)`                                   | `0x6e3f24e0` | `호출`                | 호출자의 PDA에 다음을 입금 `n` 거래의 Solana 수수료 지불자에게서 lamport를 가져옵니다. 호출자는 Rome 가스로 이를 지불합니다(레거시 CPI 내에서 지불자의 lamport 지출은 거래 수수료에 추가됩니다)                                                                                                                              |
| `transfer_lamports(address,uint64)`                              | `0x5fe71665` | `호출`                | 호출자의 PDA에서 다른 EVM 사용자의 PDA로 lamport를 이동                                                                                                                                                                                                                    |
| `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 네이티브 종료 구간. 다음을 전송 `수량` 의 `mint` 호출자 PDA의 ATA에서 **외부 Solana 서명자의** 해당 민트의 ATA로(사용자 자신의 지갑 — EVM 주소 변환 없음). 승인 불필요 — 호출자 PDA가 소스 ATA를 소유합니다. 다음과 함께 사용: `ActivateAta` (슬롯 18) + `DoTxUnsigned` (슬롯 17) — 종단 간 Solana 키 전용 EVM 사용을 위해                 |
| `approve_spl(address,uint64,bytes32)`                            | `0xabf6f675` | `호출`                | 호출자 PDA를 소유자로 하여 다음을 설정 `delegate_pda(spender)` SPL을 통해 소유자 ATA에 `approve_checked`. 다음에 사용됨 `SPL_ERC20.approve`                                                                                                                                            |
| `approve_spl_raw_delegate(bytes32,bytes32,uint64,bytes32,uint8)` | `0x7881d453` | `호출`                | SPL `approve_checked` 호출자가 제공한 raw pubkey 대리자와 함께(예: Wormhole `authority_signer` PDA, EVM 주소에 상응하는 것은 없음). 호출자는 다음을 전달합니다 `소수점 자리수` 온체인 민트 읽기를 건너뛰기 위해(\~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` | `호출`                | 솔트에서 파생된 PDA를 할당하는 System CreateAccount(`external_auth_with_salt(caller, salt)`)이며, space=82이고 SPL Token이 소유합니다. 자금 제공자 = 호출자의 external\_auth PDA. 두 개의 PDA 서명자. 다음에서 사용: `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를 한 번의 디스패치로 처리합니다. 별도의 호출에 비해 Rome DoTx 엔벨로프 1개를 절약합니다 `create_mint_account` + `init_spl_mint` 호출                                                                                                           |
| `deposit_from_ata(uint256)`                                      | `0x4479b709` | `구성됨`               | 호출자의 ATA에서 SPL을 Rome 네이티브 가스로 전환합니다. **단일 상태 전용** — op-geth 체인에서는 거부됨                                                                                                                                                                                      |
| `pda(address)`                                                   | `0x8854a299` | `EthCall`           | 사용자의 `EXTERNAL_AUTHORITY` PDA — 읽기 전용                                                                                                                                                                                                                      |
| `pda_with_salt(address,bytes32)`                                 | `0x5c6d04b3` | `EthCall`           | 솔트에서 파생된 `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 읽기 `수량` SPL TokenAccount 오프셋 64). ATA가 없으면 0을 반환합니다(새 체인 탐지). v1 디스패치 3개를 하나로 합칩니다. 다음에서 사용: `SPL_ERC20.balanceOf`                                                                                                                                 |
| `mint_info(bytes32)`                                             | `0xe24bf5d4` | `CrossStateEthCall` | 레거시 트랙 호출자를 위한 민트 정보: 토큰 프로그램, 소수점 자리수, **활성화된** hook 프로그램(없을 때는 0 *또는* 비활성), 현재 에포크 수수료 bps, 확장 존재 비트맵. 다음에 미러링됨: `SplCached` 동일한 셀렉터에서. `feeBps` 은 **술어** — 수수료가 설정되었음을 나타내지만, 실제 수수료는 다음에 의해 상한이 정해지므로 피연산자는 아닙니다 `maximum_fee` 이 항목에는 의도적으로 포함되지 않습니다. |
| `allowance_of(address,address,bytes32)`                          | `0xed72dbc8` | `CrossStateEthCall` | 소유자 ATA의 delegated\_amount를 다음으로 읽기 **대리자 동일성 검사** — 온체인 대리자가 같지 않으면 0을 반환 `external_auth(spender)`. ERC-20 의미상 올바름(필수 요건). 다음에서 사용: `SPL_ERC20.allowance`                                                                                                 |

## 출금 (`0x4200000000000000000000000000000000000016`)

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

| Solidity signature         | 셀렉터          | Dispatch          | 설명                                                                         |
| -------------------------- | ------------ | ----------------- | -------------------------------------------------------------------------- |
| `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.