> 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/ar/almrja/precompiles.md).

# مرجع الدوال المُسبقة

كل طريقة في الدوال المُسبقة الخاصة بالتشغيل البيني مع Solana في Rome — العنوان، توقيع Solidity، المحدِّد، وما إذا كانت تقرأ أو تستدعي أو تُحضِّر نداءً عبر عقود فرعية (CPI).

المحددات التي يوجّهها برنامج روما على السلسلة، بواسطة precompile. المعرّف = `keccak256(signature)[:4]`؛ ويُتحقق من كل صف أدناه وفقًا لذلك. واجهات Solidity موجودة في [`rome-solidity/contracts/interface.sol`](https://github.com/rome-protocol/rome-solidity/blob/master/contracts/interface.sol).

**اقرأ عمود التوزيع قبل أي شيء آخر.** يوضح ما الذي يفعله الأسلوب بحالة سولانا:

| التوزيع             | ما الذي يحدث                                                                                                                                                                                                                | استدعاء CPI حقيقي في سولانا | مسموح به في التنفيذ التكراري |
| ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- | ---------------------------- |
| `استدعاء` / `مركّب` | استدعاء واحد أو أكثر من CPIs، موقّعة بصفتها PDA الخاصة بالسلطة الخارجية للمتصل حيث تنطبق البذور. على **المسار القديم** المسار، تُنفَّذ فورًا؛ وعلى **المخزّنة** المسار، تُوضَع في مرحلة مؤقتة ثم تُعتمَد في نهاية المعاملة. | نعم                         | قديم: **لا**. مؤقتة: نعم     |
| `EthCall`           | حساب خالص أو قراءة لحالة روما نفسها                                                                                                                                                                                         | لا                          | نعم                          |
| `CrossStateEthCall` | قراءة لبايتات حساب سولانا آخر، محمّلة مسبقًا عبر المحاكاة. لا CPI، ولا آثار جانبية.                                                                                                                                         | لا                          | نعم                          |
| `مُسبق الترجمة`     | تشفير حتمي (عمليات precompile القياسية في إيثريوم)                                                                                                                                                                          | لا                          | نعم                          |

تستخدم العقدة **مسارًا واحدًا**: إما precompiles القديمة (`0xff…07`, `0xff…08`, `0xff…09`, `0x42…16`) أو المخبأة (`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`). يُرفض خلط الاستدعاءات المُعدِّلة من كلا المسارين في معاملة واحدة أثناء التشغيل. تظل القراءات مسموحة، مع استثناء واحد: بمجرد تنفيذ invoke في المسار المخزَّن مؤقتًا، تُرفض قراءات المسار القديم لباقي المعاملة. انظر [دمج برنامج سولانا](https://docs.rome.builders/ar/adlh-almtw-ryn/integrate-solana-program.md).

**من يدفع.** دافع الرسوم في سولانا يقدّم مقدمًا كل لامبورت ينفقه CPI في المسار القديم (الإيجار، التحويلات، `swap_gas_to_lamports`)؛ ويقيس البرنامج رصيد الدافع حول كل CPI ويحمّل المستخدم صافي الإنفاق كغاز بسعر الغاز، مع ردّ اللامبورات التي يعيدها CPI.

**من يوقّع.** العقد الذي يستدعي precompile يتصرف بصفته هو نفسه: الموقّع هو PDA الخاصة بالسلطة الخارجية للعقد (`["EXTERNAL_AUTHORITY", contract]`). ولا توقّع PDA الخاصة بالمستخدم إلا على معاملة يرسلها المستخدم مباشرةً إلى عنوان precompile. تحت `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 الخاصة بالمتصل الخارجي لدفع إيجار الـ mint، ولا يجوز لها إنشاء mint إلا إذا كانت سلطاته تلك PDA، و `invoke` / `invoke_signed` ترفض السلطة المجردة (`DelegatecallOwnerAuthority`) وتُسمّي PDAs المملّحة بحسب مساحة الأسماء بعنوان العقد الجاري.

كل أسلوب غير قابل للدفع (`msg.value > 0` يُرجِع خطأً مع `TransferProhibited`) باستثناء `withdrawal(bytes32)`. الأساليب المعلَّمة *لحالة واحدة فقط* مرفوضة على سلاسل op-geth-stack. لا يجوز لـ CPI أن يذكر دافع رسوم سولانا (إلا داخل تعليمة System transfer عادية) أو برنامج روما، ولا يجوز له استدعاء برنامج روما.

## SystemCached (`0xff00000000000000000000000000000000000004`)

إنشاء PDA وعمليات برنامج النظام (allocate، assign، lamport transfer)، تُوضَع في overlay. النظير المخزَّن مؤقتًا للمسار القديم `System @ 0xff..07`المحدّدات المعدِّلة الخاصة به (ويحتفظ System القديم بمحددات القراءة الخالصة).

| توقيع Solidity                       | المعرّف      | التوزيع   | الوصف                                                                 |
| ------------------------------------ | ------------ | --------- | --------------------------------------------------------------------- |
| `create_pda()`                       | `0xe0402a8d` | `استدعاء` | أنشئ `external_auth` PDA الخاصة بالمتصل، معفاة من الإيجار، بلا بيانات |
| `create_pda(uint64)`                 | `0x4ceab657` | `استدعاء` | نفس الشيء، مع لامبورات يحددها الممول فوق الإيجار                      |
| `create_pda(uint64,bytes32)`         | `0x48e2bb86` | `استدعاء` | PDA مشتقة من الملح مع لامبورات                                        |
| `create_pda(bytes32,uint64,bytes32)` | `0xcc258bbf` | `استدعاء` | محددة المالك، بحجم N، ومشتقة من الملح                                 |
| `allocate(uint64,bytes32)`           | `0x93225c9f` | `استدعاء` | خصّص N بايت على PDA مشتقة من الملح                                    |
| `assign(bytes32,bytes32)`            | `0x8ac00bdc` | `استدعاء` | عيّن PDA مشتقة من الملح لمالك جديد                                    |
| `transfer(address,uint64)`           | `0x5d359fbd` | `استدعاء` | تحويل لامبورات إلى PDA مشتقة من عنوان EVM                             |
| `transfer(bytes32,uint64)`           | `0xfd54d1ea` | `استدعاء` | تحويل لامبورات إلى pubkey خام في سولانا                               |
| `transfer(bytes32,uint64,bytes32)`   | `0x875abfc0` | `استدعاء` | تحويل لامبورات إلى pubkey خام، والمصدر مشتق من الملح                  |

## SplCached (`0xff00000000000000000000000000000000000005`)

تحويلات SPL Token / Token-2022 + تهيئة ATA + قراءات حساب عبر الحالة، تُوضَع في overlay.

| توقيع Solidity                                  | المعرّف      | التوزيع             | الوصف                                                                                                                                                                                                                                                                                                                                                                          |
| ----------------------------------------------- | ------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `transfer(address,uint256)`                     | `0xa9059cbb` | `استدعاء`           | تحويل SPL حيث يكون المتصل هو المالك إلى ATA الخاصة بـ PDA المشتقة من عنوان EVM، وmint الحالية للـ rollup                                                                                                                                                                                                                                                                       |
| `transfer(bytes32,uint256)`                     | `0x6a467394` | `استدعاء`           | نفس الشيء، مع تحديد المستلِم كـ pubkey خام في سولانا                                                                                                                                                                                                                                                                                                                           |
| `transfer(address,uint256,bytes32)`             | `0x57cfeeee` | `استدعاء`           | نسخة ذات mint صريح، والوجهة بعنوان EVM                                                                                                                                                                                                                                                                                                                                         |
| `transfer(bytes32,uint256,bytes32)`             | `0x7db527f9` | `استدعاء`           | نسخة ذات mint صريح، والوجهة pubkey خام                                                                                                                                                                                                                                                                                                                                         |
| `transferFrom(address,address,uint256,bytes32)` | `0x401e3367` | `استدعاء`           | نسخة مصدر بالتفويض — السلطة = `external_auth(caller)`، مقبول كمالك ATA أو كمفوَّض بمبلغ كافٍ. يُستخدم في `SPL_ERC20_cached.transferFrom` وتدفّقات موجهة بالموجّه                                                                                                                                                                                                               |
| `approve(address,uint256,bytes32)`              | `0x8180f2fc` | `استدعاء`           | اعتماد منفق EVM — المالك = `external_auth(caller)`، المفوَّض = `external_auth(spender_addr)`. يُستخدم في `SPL_ERC20_cached.approve`                                                                                                                                                                                                                                            |
| `mint(address,uint256,bytes32)`                 | `0x1e458bee` | `استدعاء`           | PDA الخاصة بالمتصل توقّع بصفة سلطة mint. يفرض وقت تشغيل SPL أن تكون PDA الخاصة بالمتصل == سلطة mint على السلسلة. يُستخدم في `SPL_ERC20_cached.mint_to` وتسوية الجسر الوارد                                                                                                                                                                                                     |
| `init(bytes32,bytes32,bytes32)`                 | `0x0b0ad508` | `استدعاء`           | `InitializeAccount3` تعليمة (ata, mint, owner)                                                                                                                                                                                                                                                                                                                                 |
| `account(address)`                              | `0x73b9aa91` | `CrossStateEthCall` | اقرأ حالة حساب SPL الخاصة بـ ATA المشتقة من PDA لعنوان EVM (mint الحالية للـ rollup)                                                                                                                                                                                                                                                                                           |
| `account(bytes32)`                              | `0x882358ae` | `CrossStateEthCall` | اقرأ حالة حساب SPL لـ pubkey خام خاص بـ ATA                                                                                                                                                                                                                                                                                                                                    |
| `account(address,bytes32)`                      | `0xf9827227` | `CrossStateEthCall` | نفس الشيء مثل `account(address)` مع mint صريح.                                                                                                                                                                                                                                                                                                                                 |
| `mint_info(bytes32)`                            | `0xe24bf5d4` | `CrossStateEthCall` | معلومات mint، مع مراعاة overlay: برنامج الرمز، الكسور العشرية، **مفعّل** برنامج hook (0 عند عدم وجوده *أو* غير فعّال)، نقاط الأساس للرسوم في الحقبة الحالية، وbitmap لوجود الامتدادات. نفس المعرّف مثل `HelperProgram.mint_info` — قدرة واحدة، وموضعا توزيع اثنان، لأن العقد في المسار المخزَّن مؤقتًا لا يمكنه استخدام القراءة القديمة بعد أن يتم تنفيذ invoke مخزَّن مؤقتًا. |

## ASplCached (`0xff00000000000000000000000000000000000006`)

إنشاء Associated Token Account، بشكل idempotent.

| توقيع Solidity                | المعرّف      | التوزيع   | الوصف                                                                     |
| ----------------------------- | ------------ | --------- | ------------------------------------------------------------------------- |
| `create_ata()`                | `0xb6d336ed` | `استدعاء` | إنشاء ATA بشكل idempotent لـ PDA الخاصة بالمتصل × mint الحالية للـ rollup |
| `create_ata(bytes32)`         | `0x81972e35` | `استدعاء` | إنشاء ATA بشكل idempotent لـ PDA الخاصة بالمتصل × mint صريح               |
| `create_ata(address)`         | `0x5a7c3259` | `استدعاء` | إنشاء ATA بشكل idempotent لـ PDA المشتقة من عنوان EVM × mint الحالية      |
| `create_ata(address,bytes32)` | `0x3de2251a` | `استدعاء` | إنشاء ATA بشكل idempotent لعنوان EVM × mint صريح                          |

## WithdrawCached (`0xff0000000000000000000000000000000000000b`)

مسارات سحب رمز الغاز (الغاز الأصلي → غلاف SPL، الغاز الأصلي → SOL، الغاز الأصلي → PDA الخاصة بالمتصل)، موضوعة في مرحلة مؤقتة. النظير المخزَّن مؤقتًا للمسار القديم `Withdraw @ 0x42..16`.

| توقيع Solidity                | المعرّف      | التوزيع | الوصف                                                                                                                                                                                                                                                                                                                                                                                                         |
| ----------------------------- | ------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32) payable` | `0x4d8b0ea4` | `مركّب` | حرق `msg.value` غاز روما، تحويل إلى مستلِم حساب نظام سولانا                                                                                                                                                                                                                                                                                                                                                   |
| `withdraw_to_pda(uint256)`    | `0x7f3124a0` | `مركّب` | احرق wei، وأودِع lamports في `EXTERNAL_AUTHORITY` PDA الخاصة بالمتصل. لحالة واحدة فقط.                                                                                                                                                                                                                                                                                                                        |
| `withdraw_to_ata(uint256)`    | `0x8059abc0` | `مركّب` | احرق wei، وأودِع غلاف SPL في ATA المملوكة لـ PDA الخاصة بالمتصل. لحالة واحدة فقط. مسار التغليف في جسر غلاف الغاز.                                                                                                                                                                                                                                                                                             |
| `deposit(uint256)`            | `0xb6b55f25` | `مركّب` | عكس `withdrawal` — تحويل SPL من ATA المملوكة لـ PDA الخاصة بالمتصل إلى ATA الخاصة بـ sol\_wallet في السلسلة على جانب سولانا؛ **mint** `wei` الغاز الأصلي للمتصل على جانب EVM. سكّ خالص (من دون خصم مقابل من `Withdraw::ADDRESS` — محفظة SPL الخاصة بالسلسلة هي الغطاء الاقتصادي، وليس عنوان precompile). لحالة واحدة فقط. مسار فك التغليف في جسر غلاف الغاز. يطابق `HelperProgram.deposit_from_ata` الدلالات. |

## System (`0xff00000000000000000000000000000000000007`)

اشتقاق PDA + تحويل base58 + أدوات شبيهة بالهوية. precompile للقراءة الخالصة — كل أسلوب هو `EthCall` (من دون آثار جانبية على سولانا).

| توقيع Solidity                                    | المعرّف      | التوزيع   | الوصف                                                                            |
| ------------------------------------------------- | ------------ | --------- | -------------------------------------------------------------------------------- |
| `find_program_address(bytes32,(bytes)[])`         | `0x27e3edda` | `EthCall` | Solana `find_program_address` عبر syscall — يُرجع `(pda, bump)`                  |
| `create_program_address(bytes32,(bytes)[],uint8)` | `0xb99f29e1` | `EthCall` | اشتقاق PDA بزمن ثابت مع bump معروف                                               |
| `rome_evm_program_id()`                           | `0xb76fd45b` | `EthCall` | يُرجع معرّف برنامج سولانا لهذا البرنامج Rome EVM                                 |
| `program_id()`                                    | `0x77764881` | `EthCall` | يُرجع معرّف برنامج النظام الخاص بروما (هوية هذا precompile)                      |
| `mint_id()`                                       | `0xe132a122` | `EthCall` | يُرجع pubkey الخاص بـ SPL mint لرمز الغاز في السلسلة (`OwnerInfo.chain_mint_id`) |
| `operator()`                                      | `0x570ca735` | `EthCall` | يُرجع الموقّع في سولانا للمعاملة الخارجية في روما                                |
| `bytes32_to_base58(bytes32)`                      | `0xfa2b1a5f` | `EthCall` | بايتات pubkey → سلسلة base58                                                     |
| `base58_to_bytes32(bytes)`                        | `0x5df01b72` | `EthCall` | سلسلة base58 → بايتات pubkey                                                     |

## CpiProgram (`0xff00000000000000000000000000000000000008`)

**precompile مزدوج الغرض.** من بين المحددات السبعة أدناه، **2 تنفّذ 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 — وهي نفسها **ليست CPIs**. انظر جدول إزالة الالتباس في أعلى هذا القسم للحصول على مصفوفة السلوك الكاملة.

| توقيع Solidity                                                 | المعرّف      | التوزيع             | الوصف                                                                                                                                                                                                             |
| -------------------------------------------------------------- | ------------ | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `invoke(bytes32,(bytes32,bool,bool)[],bytes)`                  | `0x7480cb86` | `استدعاء`           | CPI موقّع بصفة `EXTERNAL_AUTHORITY(caller)` عندما يكون ذلك الحساب مدرجًا كموقّع (ويُرفض تحت DELEGATECALL)؛ لا توجد sub-PDAs مملّحة. يمرّر المتصل البرنامج الهدف + metadatas للحسابات + بيانات ix                  |
| `invoke_signed(bytes32,(bytes32,bool,bool)[],bytes,bytes32[])` | `0xb94f3733` | `استدعاء`           | CPI موقّع بصفة `EXTERNAL_AUTHORITY(caller)` في CALL مباشر؛ تُضاف الأملاح إلى كل seed خاص بـ PDA. تحت DELEGATECALL تُرفض سلطة المتصل المجردة وتحمل البذور المملّحة عنوان العقد الجاري — انظر ملاحظة الاشتقاق أدناه |
| `account_info(bytes32)`                                        | `0xc13465d9` | `CrossStateEthCall` | اقرأ الحالة الكاملة لحساب سولانا (lamports/المالك/الأعلام/البيانات)                                                                                                                                               |
| `account_data_at(bytes32,uint16,uint16)`                       | `0x593762e8` | `CrossStateEthCall` | اقرأ مقطعًا من مخزن بيانات أي حساب في سولانا                                                                                                                                                                      |
| `account_u64_at(bytes32,uint16)`                               | `0xb317d4c1` | `CrossStateEthCall` | قراءة u64 LE مهيكلة عند إزاحة معروفة — توفّر رحلة ABI ذهابًا وإيابًا                                                                                                                                              |
| `account_lamports(bytes32)`                                    | `0xde79ed54` | `CrossStateEthCall` | استعلام خاص بالـ lamports فقط — يتجاوز جلب البيانات                                                                                                                                                               |
| `pdas_batch_derive(bytes[][],bytes32)`                         | `0x944336f8` | `CrossStateEthCall` | N من PDAs المستقلة مقابل برنامج واحد في عملية توزيع واحدة                                                                                                                                                         |

## HelperProgram (`0xff00000000000000000000000000000000000009`)

مساعدات روم الموجّهة للمستخدم لإنشاء ATA/PDA، وتحويلات/اعتماد/سكّ SPL موقعة بواسطة `EXTERNAL_AUTHORITY` PDA الخاصة بالمتصل، وتحويل الغاز↔lamports، وإيداع ATA، وقراءات المواجهة لـ SPL\_ERC20 (`user_balance` / `allowance_of`). كل أسلوب هو `غير قابل للدفع`؛ تمرّ التعديلات عبر `استدعاء` (CPI واحد) باستثناء `deposit_from_ata` (`مركّب`، لحالة واحدة فقط)، وثلاثة الاستعلامات للقراءة فقط `pda`/`ata` الاستعلامات (`EthCall`)، والقراءتين عبر الحالة لـ SPL\_ERC20 (`CrossStateEthCall` — جلب حساب واحد من سولانا).

| توقيع Solidity                                                   | المعرّف      | التوزيع             | الوصف                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ---------------------------------------------------------------- | ------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `create_ata(address)`                                            | `0x5a7c3259` | `استدعاء`           | أنشئ ATA لمستخدم EVM تحت mint الغاز الخاصة بالسلسلة                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `create_ata(address,bytes32)`                                    | `0x3de2251a` | `استدعاء`           | أنشئ ATA لمستخدم EVM تحت mint عشوائية                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `create_ata_for_key(bytes32,bytes32)`                            | `0xd258a69d` | `استدعاء`           | إنشاء ATA بشكل idempotent لـ pubkey خام عشوائي في سولانا بوصفه المالك (غير مشتق عبر `external_auth`). المشغّل يدفع الإيجار. يُستخدم في `SPL_ERC20.bridgeOutToSolana` / `ensureRecipientAta` / `create_token_account` تدفّقات مستلِم pubkey الخام                                                                                                                                                                                                                                                                                                                                                        |
| `create_pda(address)`                                            | `0xff3556ca` | `استدعاء`           | أنشئ الخاص بالمستخدم `EXTERNAL_AUTHORITY` PDA (معفى من الإيجار)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `create_pda(address,uint64)`                                     | `0x58e88298` | `استدعاء`           | نفسه، لكن ممول بـ `لامبورتات` فوق حد الإيجار                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `swap_gas_to_lamports(uint64)`                                   | `0x6e3f24e0` | `استدعاء`           | أضف إلى PDA الخاصة بالمتصل `n` لامبورتات من دافع رسوم سولانا في المعاملة؛ يدفع المتصل قيمتها بغاز Rome (يُضاف إنفاق الدافع من اللامبورتات داخل أي CPI قديم إلى رسوم المعاملة)                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `transfer_lamports(address,uint64)`                              | `0x5fe71665` | `استدعاء`           | انقل اللامبورتات من PDA الخاصة بالمتصل إلى PDA الخاصة بمستخدم EVM آخر                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `transfer_spl(address,uint64)`                                   | `0xb12be5ba` | `استدعاء`           | أرسل SPL الخاصة بوقود السلسلة من ATA الخاصة بـ PDA للمتصل إلى ATA الخاصة بالمستخدم الوجهة                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `transfer_spl(bytes32,uint64)`                                   | `0xba3a5eac` | `استدعاء`           | أرسل SPL الخاصة بوقود السلسلة من ATA الخاصة بـ PDA للمتصل إلى ATA صريح                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `transfer_spl(address,uint64,bytes32)`                           | `0x53b505e0` | `استدعاء`           | أرسل SPL ذات mint عشوائي من ATA الخاصة بـ PDA للمتصل إلى ATA الخاصة بالمستخدم الوجهة                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `transfer_spl(bytes32,uint64,bytes32)`                           | `0xb6977879` | `استدعاء`           | أرسل SPL ذات mint عشوائي من ATA الخاصة بـ PDA للمتصل إلى ATA صريح                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `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` | `استدعاء`           | ساق خروج أصلية خاصة بسولانا. ترسل `المبلغ` من `mint` من ATA الخاصة بـ PDA للمتصل إلى **ATA الخاصة بالموقّع الخارجي على سولانا** لتلك الـ mint (محفظة المستخدم الخاصة فقط على مسار سولانا الموقَّع من المحفظة؛ ومن MetaMask أو عبر المرحّل، يكون الموقّع هو دافع الوكيل الخاص بـ Rome؛ لا يوجد تحويل من عنوان EVM). لا حاجة إلى موافقة — الـ PDA الخاصة بالمتصل تمتلك ATA المصدر. اقترنها مع `ActivateAta` (slot 18) لاستخدام EVM من البداية إلى النهاية بمفاتيح سولانا فقط. يصل إلى المحفظة على المسار v1 الحالي وعلى مسار `DoTxUnsigned` القديم (slot 17)، لأن المحفظة توقّع معاملة سولانا على كليهما. |
| `approve_spl(address,uint64,bytes32)`                            | `0xabf6f675` | `استدعاء`           | المتصل-بوصفه-المالك يعيّن `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` لتجاوز قراءة الـ mint من السلسلة (\~توفير 30-50K CU). `spl_program = SPL Token`. يُستخدم في `RomeBridgeWithdraw.approveBurnETH`                                                                                                                                                                                                                                                                                                      |
| `mint_spl(address,uint64,bytes32)`                               | `0xd795522b` | `استدعاء`           | المتصل-بوصفه-سلطة الصك يسكّ إلى ATA الخاصة بالمستخدم الوجهة عبر SPL `mint_to_checked`. يفرض وقت تشغيل SPL تطابق السلطة. تُستخدم بواسطة `SPL_ERC20.mint_to`                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `create_mint_account(bytes32)`                                   | `0xe97d3291` | `استدعاء`           | System CreateAccount ينشئ PDA مشتقة من salt (`external_auth_with_salt(caller, salt)`) بمساحة=82 مملوكة لـ SPL Token. المموِّل = PDA الخاصة بـ external\_auth للمتصل. موقّعان من PDA. تُستخدم بواسطة `ERC20SPLFactory.create_token_mint`                                                                                                                                                                                                                                                                                                                                                                 |
| `init_spl_mint(bytes32,uint8,bytes32,bool,bytes32)`              | `0x4f75e987` | `استدعاء`           | SPL Token `InitializeMint2` ضد mint مخصّصة مسبقًا. لا يوجد موقّع من 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 واحدًا مقابل الاستدعاءات المنفصلة `create_mint_account` + `init_spl_mint` الاستدعاءات                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `deposit_from_ata(uint256)`                                      | `0x4479b709` | `مركّب`             | اسحب SPL من ATA الخاصة بالمتصل إلى الغاز الأصلي لـ Rome. **حالة واحدة فقط** — مرفوض على سلاسل op-geth                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `pda(address)`                                                   | `0x8854a299` | `EthCall`           | استنتج `EXTERNAL_AUTHORITY` PDA الخاصة بالمستخدم — للقراءة فقط                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `pda_with_salt(address,bytes32)`                                 | `0x5c6d04b3` | `EthCall`           | مشتقة من salt `EXTERNAL_AUTHORITY` PDA في عملية إرسال واحدة. يدمج تركيب Solidity ذي الاستدعاءين `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`           | نفسه مع mint صريح — للقراءة فقط                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `user_balance(address,bytes32)`                                  | `0xdd0119c8` | `CrossStateEthCall` | اقرأ ATA الخاصة بالمستخدم `المبلغ` (إزاحة 64 في SPL TokenAccount). تُرجع 0 إذا لم تكن ATA موجودة (فحص سلسلة جديدة). يدمج 3 عمليات إرسال v1. تُستخدم بواسطة `SPL_ERC20.balanceOf`                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `mint_info(bytes32)`                                             | `0xe24bf5d4` | `CrossStateEthCall` | حقائق الـ mint لمتصل على المسار القديم: برنامج الرمز، decimals، **مفعّل** برنامج hook (0 عند عدم وجوده *أو* (خامل)، bps رسوم حقبة الفترة الحالية، خريطة بتات وجود الامتدادات. مُعكوسة على `SplCached` على نفس المحدِّد. `feeBps` هو **مُسند** — يعني أن الرسوم مفعّلة، لكنه ليس مُعامِلًا، لأن الرسوم الفعلية مقيّدة بواسطة `maximum_fee` الذي لا يحمله هذا عمدًا.                                                                                                                                                                                                                                      |
| `allowance_of(address,address,bytes32)`                          | `0xed72dbc8` | `CrossStateEthCall` | اقرأ delegated\_amount في ATA الخاصة بالمالك مع **فحص تطابق المفوَّض** — تُرجع 0 ما لم يكن المفوَّض على السلسلة == `external_auth(spender)`. صحيح دلاليًا وفق ERC-20 (مطلوب إلزامي). تُستخدم بواسطة `SPL_ERC20.allowance`                                                                                                                                                                                                                                                                                                                                                                               |

## سحب (`0x4200000000000000000000000000000000000016`)

سحب الغاز الأصلي من Rome إلى سولانا.

| توقيع Solidity             | المعرّف      | التوزيع                | الوصف                                                                                                       |
| -------------------------- | ------------ | ---------------------- | ----------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32)`      | `0x4d8b0ea4` | `مركّب` (`قابل للدفع`) | حرق `msg.value` غاز Rome؛ سكّ + نقل إلى حساب نظام سولانا `إلى`. الطريقة القابلة للدفع الوحيدة في precompile |
| `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/ar/almrja/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.
