> 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/adlh-almtw-ryn/integrate-solana-program.md).

# دمج برنامج سولانا

دمج برنامج Solana مع Rome EVM — من هو الموقّع في Solana، وكيف تصل القيمة إلى برنامجك وتعود منه، وقاعدة المسار الواحد، والذرّي مقابل التكراري، وتوفير الحسابات.

هذا الدليل موجّه لفريق برنامج على سولانا يريد أن يستخدم مستخدمو Rome EVM برنامجه — برنامج خصوصية أو إقراض أو خزنة ينبغي أن يحتفظ بالقيمة لحسابات EVM. وهو يعتمد على [استدعِ Solana من EVM](https://docs.rome.builders/ar/adlh-almtw-ryn/call-solana-from-evm.md) (آليات الـ precompile) ويجيب عن الأسئلة التي تظهر بمجرد أن يكون هناك برنامج حقيقي على الجهة الأخرى: *من* يوقّع، *كيف* تدخل الرموز وتخرج، و *أيُّ* القيود التي تشكّل التصميم.

التدفق المستخدم طوال الدليل: ينقل حساب EVM عملة USDC إلى برنامجك («shield» أو «deposit»)، ثم يحتفظ بها برنامجك لهذا المستخدم، ثم يطلقها لاحقًا ويعيدها («unshield» أو «withdraw»). استبدل الأفعال بما يناسبك.

## 1. لكل عنوان EVM هوية واحدة على سولانا

يشتق Rome حسابًا على سولانا لكل عنوان EVM — للمستخدمين والعقود على حد سواء — ويُسمّى **السلطة الخارجية**:

```
external_auth(addr) = find_program_address(["EXTERNAL_AUTHORITY", addr_h160], rome_evm_program_id)
```

وهو يملك حسابات الرموز المرتبطة بالعنوان (أي حيث `wUSDC.balanceOf(addr)` يقرأ منها) وهو المفتاح الذي يوقّع استدعاءات CPI التي تُجرى نيابةً عن ذلك العنوان. يرى برنامجك مفتاحًا عامًا على سولانا بطول 32 بايت؛ ولا يرى H160 أبدًا.

**يُحسم من يوقّع بحسب من يستدعي الـ precompile:**

| يُستدعى الـ precompile من                                            | الموقّع على سولانا                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| -------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| تطبيق **العقد**، مع `CALL`                                           | الأسماء **السلطة الخارجية الخاصة بالعقد**  (`external_auth(contract)`)، إضافةً إلى أي PDAs فرعية ذات salt يطلبها العقد                                                                                                                                                                                                                                                                                                                                                                                                                  |
| تطبيق **المستخدم**، في معاملة تُرسل مباشرةً إلى عنوان الـ precompile | الأسماء **السلطة الخارجية الخاصة بالمستخدم** السلطة الخارجية                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| عقد عبر `DELEGATECALL`                                               | تُرفَض السلطة المجردة (`DelegatecallOwnerAuthority`). `invoke` من دون موقّع، و `invoke_signed` مع PDAs فرعية ذات salt، تظل تعمل — لكن تلك الـ PDAs الفرعية تكون ضمن نطاق عنوان العقد الجاري تشغيله (`["EXTERNAL_AUTHORITY", caller, running_contract, salt]`)، لذا فإن `pda_with_salt` لا يشتقّها. ومن HelperProgram لا تمرر سوى محددات الإنشاء والتمويل (`create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint`, `create_and_init_mint`)؛ فهي معفاة لأن هدفها مرتبط بالمتصل أو ممول من المشغّل، لا لأنها لا توقّع شيئًا |

والنتيجة هي قاعدة ERC-20 التي تعرفها بالفعل: **لا يمكن للعقد أن ينقل أصول المستخدم بمفرده.** إنه يتصرف بهويته الخاصة، ويمنحه المستخدم الحقوق أولًا. وبالنسبة إلى الرموز التي يجب أن تنتقل على جانب سولانا، فذلك المنح هو تفويض SPL على حساب الرموز الخاص بالمستخدم؛ أما غلاف ERC-20 `approve` فهو مجرد إذن على جانب EVM تلتزم به عمليات النقل الخاصة بالغلاف نفسه. هكذا تعمل أغلفة رموز Rome نفسها، وهكذا سيعمل الموصل الخاص بك (القسم 3).

PDAs فرعية ذات salt: `invoke_signed` يأخذ قائمة من `bytes32` من الـ salts، ويوقّع Rome باستخدام `["EXTERNAL_AUTHORITY", caller_h160, salt]` لكل واحدة (مع إلحاق bump في النهاية؛ ويكون المتصل هو العقد في الاستدعاء المباشر). `HelperProgram.pda_with_salt(addr, salt)` يعيد العنوان من Solidity. استخدم salt واحدًا لكل مستخدم (مثلًا عنوان المستخدم) عندما يريد برنامجك حساب مالك مميزًا لكل مركز.

التمويل: لا يشترط وجود PDA للسلطة الخارجية لكي يملك ATA (`create_ata` دالة لا حالية التكرار، ودافع الرسوم في سولانا الخاص بالمعاملة يغطي الإيجار). ولا بد أن يكون موجودًا وأن يحتفظ بلامبورتات فقط عندما يمول الحسابات التي ينشئها تعليمتك. `HelperProgram.create_pda(addr)` ينشئه كتعليمة System `CreateAccount`عادية، لذا استدعِها مرة واحدة؛ فهي ليست لا حالية التكرار. `swap_gas_to_lamports(n)` يضيف إلى PDA الخاص بالعنوان `n` لامبورتات من دافع الرسوم في سولانا الخاص بالمعاملة، ويدفعها المستدعي بعملة Rome gas: إذ يُضاف تأثير كل CPI في المسار القديم على رصيد دافع الرسوم إلى رسوم المعاملة ويُحمَّل على المستخدم بسعر الغاز، بالطريقة نفسها التي تُحمَّل بها الإيجارات لحسابات ينشئها CPI. تُوصف خطوة التهيئة الخاصة بمسار سولانا في [استدعِ EVM من Solana](https://docs.rome.builders/ar/adlh-almtw-ryn/call-evm-from-solana.md)؛ ويُجهّز العقد PDA الخاص به في المُنشئ أو أول استدعاء.

## 2. ثلاث طرق للاحتفاظ بمركز المستخدم

**أ. عقد موصل (موصى به لموصل قابل لإعادة الاستخدام).** عقد Solidity واحد يواجه برنامجك. يمنح المستخدم سلطة الموصل تفويضًا SPL على حساب الرموز الخاص به؛ فيسحب الموصل الرموز إلى حساب رموز يملكه، ثم يستدعي برنامجك بصفته هو نفسه، ويُعرّف مركز المستخدم داخل برنامجك عبر PDA فرعي خاص بكل مستخدم أو عبر معرّف يمرره في بيانات التعليمة. وعند الخروج يطلب من برنامجك أن يحررها إلى حساب الرموز الخاص بالمستخدم نفسه. الموصل هو هوية سولانا الوحيدة التي يحتاج برنامجك إلى معرفتها. هذا المنح هو تفويض SPL، وليس تفويض ERC-20 `approve`؛ يشرح القسم 3 السبب وما الذي يكلفه ذلك المستخدم.

**ب. المستخدم باعتباره الموقّع على سولانا.** يرسل الواجهة الأمامية معاملة من حساب EVM الخاص بالمستخدم **مباشرةً إلى precompile الخاص بـ CpiProgram** (`to = 0xff…08`، calldata = القيمة المرمزة وفق ABI لـ `invoke` أو `invoke_signed`)، بحيث توقّع السلطة الخارجية الخاصة بالمستخدم نفسه، ويُعرّف برنامجك المركز بها. لا يوجد عقد موصل ولا تفويض، لكن كل عملية هي معاملة calldata غير قابلة للشفافية في المحفظة، وأي شيء يحتاجه التدفق إلى جانب CPI (ATA، أو تحويل مسبق) يكون معاملة منفصلة. وهو مناسب لمنح لمرة واحدة (مثل `approve_spl` إلى غلاف) وللبرامج البسيطة، لا للتدفقات متعددة الخطوات. [Cardo](https://github.com/rome-protocol/cardo) يستخدم هذا الشكل: إذ ترسل الواجهة الأمامية `invoke` مباشرةً إلى الـ precompile من محفظة المستخدم.

**ج. موجه من دون وصاية.** عقد لا يحتفظ مطلقًا برموز المستخدم. يمنح المستخدم سلطة الموجّه تفويضًا SPL على حساب الرموز الخاص به؛ ثم يجري الموجّه CPI إلى برنامجك باستخدام تلك السلطة كسلطة تحويل، فتنتقل الرموز من حساب الرموز الخاص بالمستخدم إلى حساب برنامجك (أو تعود إلى المستخدم)، ولا يحتفظ الموجّه بأي شيء بين الاستدعاءات. يشتق الموجّه كل حساب على جانب المستخدم من `msg.sender`، لذا لا يمكن أن يُوجَّه منح مستخدم إلى حساب مستخدم آخر، وهو يستدعي برنامجًا ثابتًا واحدًا بأشكال تعليمات ثابتة بدل أن يعمل كـ `invoke` تمرير عام. الـ `RomeDexRouter` في [rome-dex](https://github.com/rome-protocol/rome-dex) مكتوب بهذه الطريقة؛ كما يوفّر مسار EVM في rome-dex أيضًا الاستدعاء المباشر الخام من الشكل B. وهو يحتاج إلى المنح نفسه مثل A، مع كلفة التفويض الواحد نفسها (القسم 3)، ومن دون خطوة سحب. `invoke` من الشكل B. وهو يحتاج إلى المنح نفسه مثل A، مع كلفة التفويض الواحد نفسها (القسم 3)، ومن دون خطوة سحب.

يتبع بقية هذا الدليل الشكل A؛ أما C فيستخدم المنح نفسه وقاعدة التوقيع نفسها.

## 3. الرموز الداخلة، الرموز الخارجة

USDC على Rome هو سكّ واحد من SPL يُرى من جهتين: غلاف ERC-20 على جانب EVM وATA الخاص بالسلطة الخارجية على جانب سولانا. بالنسبة إلى عنوان المستخدم نفسه، فالجانبان يمثلان الرصيد نفسه: `wUSDC` wUSDC.balanceOf(user) `يقرأ ATA الخاص بالمستخدم. لا شيء يتحرك أو يتزامن بين العرضين.` رصيد الغلاف الخاص بالعقد ليس حساب رموز يتحكم به العقد.

**يقوم المصنع بنشر** للسكّ العادي، وHadrian's `SPL_ERC20_cached` واحد منها. ذلك الغلاف لا يستطيع التوقيع لعقد، لذا عندما `wUSDC` غلاف `wUSDC.transferFrom(user, adapter, amount)` أو `transfer` يرسل الرموز إلى عقد، تنتقل رموز SPL إلى **حساب الرموز المخصص للضمان الخاص بالغلاف نفسه** (`escrow_ata()`)، ويسجل الغلاف المبلغ لكل عقد في تخزينه. `wUSDC.balanceOf(adapter)` يعيد ذلك السجل، أي دفتر ضمان، لا رصيد حساب رموز يملكه `external_auth(adapter)`. لا يمكن للموصل أن يسلم تلك الرموز إلى برنامجك عبر CPI؛ فلا يمكنها أن تخرج إلا عبر الغلاف مرة أخرى. لذا فإن الموصل الذي يمول نفسه بـ `transferFrom` لا يملك شيئًا يمكنه إنفاقه على جانب سولانا.

المسار الذي يعمل هو تفويض SPL:

* **المنح.** يرسل المستخدم `approve_spl(adapter, amount, mint)` كمعاملة **مباشرةً إلى HelperProgram** (`to = 0xff…09`)، حيث `mint` هو الخاص بالغلاف `mint_id()`. تُوقَّع السلطة الخاصة بالمستخدم نفسه، ويكون المفوَّض الذي تُسجله على حساب الرموز الخاص بالمستخدم هو السلطة الخارجية الخاصة بالموصل.
* **إلى الداخل.** يُجري الموصل `deposit(amount)` السحب بالتحميل الزائد الخاص بالمفوَّض `HelperProgram.transfer_spl(srcAta, dstAta, amount, mint)`، مع ATA الخاص بالمستخدم كمصدر وATA الخاص بالموصل نفسه (`HelperProgram.ata(address(this), mint)`، يُنشأ مرة واحدة بواسطة `create_ata`) كوجهة. توقّع سلطة الموصل بصفة المفوَّض. أصبحت الرموز الآن في حساب رموز مملوك لـ `external_auth(adapter)`، وهو الحساب الذي يسميه CPI؛ والموقّع والمصدر هما حسابا الموصل نفسه، لذا لا حاجة إلى أي إذن إضافي. وهي لا تظهر في `wUSDC.balanceOf(adapter)`.
* **إلى الخارج.** تعليمة السحب في برنامجك تنقل إلى ATA الخاص بـ **المستخدم** ، `HelperProgram.ata(user, mint)`. لا يحتاج الاستلام إلى أي توقيع من المستخدم، ويظهر الرصيد فورًا على أنه `يقرأ ATA الخاص بالمستخدم. لا شيء يتحرك أو يتزامن بين العرضين.`. إذا كان ATA قد لا يكون موجودًا بعد، فأنشئه أولًا باستخدام `HelperProgram.create_ata(user, mint)` (لا حالية التكرار).

**حساب الرموز له مفوَّض واحد.** المنح أعلاه يستبدل المنح الخاص بالغلاف نفسه على ذلك الحساب. وحتى يمنح المستخدم الغلاف مرة أخرى، فإن كل `wUSDC` `transfer` أو `transferFrom` خارج عنوانهم يُعاد مع الخطأ SPL `0x4`. بعد أي تدفق يستخدم هذا المنح، استدعِ `wUSDC.isEnabled(user)`؛ وعندما يعيد `false`، اطلب من المستخدم إرسال `approve_spl(wrapper, 2^64-1, mint)` مجدّدًا إلى HelperProgram، وهو المنح الأقصى نفسه الذي بُني الغلاف حوله (انظر [مرة واحدة: امنح الغلاف](https://docs.rome.builders/ar/adlh-almtw-ryn/dual-lane-app.md#one-time-grant-the-wrapper)). سيكسر المنح المحدود عمليات `wUSDC` التحويلات العادية للمستخدم مرة أخرى بمجرد أن يقترب من النفاد، و `isEnabled` يبقى `true` ما دام أي جزء منه متبقيًا، لذا لن يعرف التطبيق أن يطلبه مرة أخرى.

للتحقق من الغلاف الذي يخص سكًّا ما، اقرأ `wrapper_kind_by_mint(mint)` المخزن المخبأ في `contracts.json` في [السجل](https://github.com/rome-protocol/rome-registry)). `1` هو الغلاف المخزن الذي يصفه هذا القسم. `2` هو غلاف CPI المباشر الذي ينشره المصنع لسكّ Token-2022 مع hook نقل مسلّح؛ ولا يغطيه هذا الدليل. تحتوي `tokens.json` على عنوان الغلاف والسكّ، لكنها لا تبيّن نوعه.

## 4. مسار واحد لكل عقد، ولكل معاملة

لدى Rome عائلتان من الـ precompile تغيّران حالة سولانا، و **تستخدم المعاملة واحدة منهما فقط** — إذ يرفض النظام أي معاملة تخلط استدعاءات معدِّلة من كليهما، حتى بين العقود.

| المسار        | الاستدعاءات المسبقة                                                                                 | تصل التأثيرات                                                                                  | يعمل في التنفيذ التكراري                                                  |
| ------------- | --------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- |
| **قديم**      | `CpiProgram` `0xff…08` (`invoke`, `invoke_signed`), `HelperProgram` `0xff…09`, `السحب` `0x42…16`    | فورًا، كـ CPI حقيقي داخل خطوة EVM                                                              | **لا** — تفشل CPI قديمة في معاملة تكرارية مع `CpiProhibitedInIterativeTx` |
| **مخزن مؤقت** | `SplCached` `0xff…05`, `ASplCached` `0xff…06`, `SystemCached` `0xff…04`, `WithdrawCached` `0xff…0b` | تُرحَّل داخل طبقة تراكب وتُنفَّذ كـ CPIs في نهاية المعاملة؛ ويؤدي أي revert في EVM إلى إسقاطها | نعم                                                                       |

ما الذي يعنيه هذا بالنسبة إلى تكامل برنامج:

* **استدعاء تعليمات برنامجك نفسه يقتصر على المسار القديم.** المسار المخزن مؤقتًا لا يملك `invoke`عامًا؛ فهو يغطي تحويلات SPL، وإنشاء ATA، وعمليات برنامج النظام، وسحب الغاز.
* لذا يجب أن تكون خطوة تمويل الموصل على المسار القديم أيضًا إذا كانت تُنفَّذ في المعاملة نفسها مع CPI. أما `transferFrom` فهو استدعاء على المسار المخزن مؤقتًا، لذا لا يمكنه مشاركة معاملة مع CPI الخاص بك (وكما يبيّن القسم 3، فلن يضيف إلا إلى دفتر ضمان). اسحب باستخدام `HelperProgram.transfer_spl(userAta, adapterAta, amount, mint)` بدلًا من ذلك، بعد أن يجعل المستخدم الموصل مفوَّض SPL (`approve_spl`، ويُرسل مباشرةً من المستخدم إلى HelperProgram). يكون السحب وCPI كلاهما على المسار القديم، لذا يعملان في معاملة واحدة.
* **أبقِ الغلاف خارج تلك المعاملة.** لا تستدعِ الدوال المعدِّلة الخاصة بالغلاف (`wUSDC.transfer`, `transferFrom`) من الموصل في المعاملة نفسها التي يوجد فيها CPI قديم. تحقّق من `isEnabled(user)` والأرصدة من الواجهة الأمامية باستخدام `eth_call`.
* **كما يجب أن تكون معاملة CPI ذرّية.** هذا هو الحد الذي يقف التصميم تحته.

القراءات خارج هذه القاعدة: `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` و `HelperProgram.user_balance` / `allowance_of` هي قراءات لحسابات محمّلة مسبقًا (من دون CPI)، ويسمح بها على أي من المسارين وفي كلا نمطي التنفيذ. ضع فحوصاتك المسبقة عليها. قاعدة ترتيب واحدة: بمجرد أن يُشغَّل تعديل مخزن مؤقت في معاملة، تُحجب قراءات المسار القديم لباقي المعاملة — اقرأ أولًا، ثم عدّل.

## 5. الذرّية هي الميزانية

المعاملة الذرّية على Rome هي معاملة سولانا واحدة: حوالي **1.4 مليون وحدة حوسبة**، **قائمة حسابات من 64 عنوانًا** و **4 كيلوبايت** من الحجم على السلك (معاملات سولانا v1). يشارك برنامج Rome وCPI الخاص بك تلك الميزانية. يعمل نقل الغلاف بحوالي 170 ألف وحدة حوسبة على Hadrian ويضيف تعليمتك الخاصّة وحداتها؛ قِس باستخدام `computeUnitsConsumed`بدلًا من EVM `gasUsed`.

عندما يقرر المحاكي أن المعاملة لا تتسع، يشغّلها Rome **تكراريًا** عبر عدة معاملات سولانا، ثم تفشل CPI قديمة داخلها. اجعل كلًا من الإيداع والسحب يقتصر على حركة رمزية واحدة مع CPI واحد إلى برنامجك، وابقِ Solidity المحيط بهما صغيرًا. قسّم أي شيء أكبر إلى معاملتين من المستخدم.

عمق CPI: تسمح سولانا بأربعة مستويات ويستخدم Rome واحدًا، لذا تعمل تعليمتك في المستوى 2 مع مستويين تحتها (برنامجك → بقاء SPL Token يترك واحدًا).

## 6. تهيئة الحسابات

لا يتسلم برنامجك حساباته من Solidity وقت التشغيل. الوكيل **يحاكي** كل معاملة قبل إرسالها، ويسجل كل حساب سولانا لامسته CPIs، ويضعها في معاملة سولانا. يسمي موصلُك الحسابات في `invoke_signed` قائمة الحسابات؛ ويُثبت المحاكاة أنها تُحل. وتترتب ثلاثة أمور:

* كل حساب تلمسه تعليمتك يجب أن يكون قابلًا للاشتقاق من المدخلات التي يملكها الموصل (PDA الخاص به وPDAs الفرعية، ومعرّف برنامجك، والسكّات، وعنوان المستخدم). `SystemProgram.find_program_address` و `CpiProgram.pdas_batch_derive` تجريان الاشتقاقات في Solidity.
* أي حساب لا يزال غير موجود (مركز جديد، ATA جديد) يجب أن يُذكر رغم ذلك في قائمة الحسابات؛ وعنوانه هو ما يصل إلى معاملة سولانا.
* كل ما تلمسه المعاملة — بما في ذلك حسابات Rome الخاصة بالمستخدم والموصل والغلاف — يجب أن يبقى تحت 64 عنوانًا. التصميم الذي يلمس عشرة أسواق في استدعاء واحد لن يتسع.

بالنسبة إلى مسار محفظة سولانا، `rome_emulateCallAccounts` يعرض الاكتشاف نفسه للعميل؛ وتستخدمه حزمة SDK.

هناك حسابان لا يجوز لـ CPI تسميتهما مطلقًا: دافع الرسوم في سولانا الذي يقدّم المعاملة (باستثناء داخل تعليمة System transfer عادية) وبرنامج Rome نفسه. يُرفض أي CPI يعود إلى برنامج Rome.

## 7. إيداع وسحب في Solidity

مخطط مبسّط جدًا لموصل على المسار القديم. كان المستخدم قد أرسل بالفعل `approve_spl(adapter, amount, mint)` إلى HelperProgram (القسم 3). `PRIVACY_PROGRAM` هو معرّف برنامجك؛ `encodeDeposit` / `encodeWithdraw` تنشئ بيانات تعليمتك (Borsh، little-endian)؛ وتأتي metas الخاصة بالحسابات وفق تخطيط تعليماتك.

```solidity
import {ICrossProgramInvocation, IHelperProgram}
    from "@rome-protocol/rome-solidity/contracts/interface.sol";

contract PrivacyAdapter {
    ICrossProgramInvocation constant Cpi    = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);
    IHelperProgram          constant Helper = IHelperProgram(0xFF00000000000000000000000000000000000009);
    bytes32 constant SPL_TOKEN = 0x06ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9; // TokenkegQ...

    bytes32 immutable PRIVACY_PROGRAM;
    bytes32 immutable USDC_MINT;

    constructor(bytes32 program, bytes32 mint) {
        PRIVACY_PROGRAM = program; USDC_MINT = mint;
        Helper.create_pda(address(this));                 // الهوية على سولانا الخاصة بالموصل
        Helper.create_ata(address(this), USDC_MINT);      // وحساب USDC يملكه
    }

    function _salt(address user) internal pure returns (bytes32) { return bytes32(uint256(uint160(user))); }

    function deposit(uint64 amount) external {
        bytes32 self       = Helper.pda(address(this));                   // الموقّع: سلطة الموصل
        bytes32 adapterAta = Helper.ata(address(this), USDC_MINT);
        bytes32 position   = Helper.pda_with_salt(address(this), _salt(msg.sender)); // PDA فرعي خاص بكل مستخدم، يوقّع أيضًا

        // اسحب من حساب الرموز الخاص بالمستخدم. توقّع سلطة الموصل بصفة
        // المفوَّض الذي منحه المستخدم؛ هذا استدعاء على المسار القديم، مثل CPI أدناه.
        Helper.transfer_spl(Helper.ata(msg.sender, USDC_MINT), adapterAta, amount, USDC_MINT);

        ICrossProgramInvocation.AccountMeta[] memory accs = new ICrossProgramInvocation.AccountMeta[](5);
        accs[0] = ICrossProgramInvocation.AccountMeta(self,       true,  true);
        accs[1] = ICrossProgramInvocation.AccountMeta(position,   true,  true);
        accs[2] = ICrossProgramInvocation.AccountMeta(adapterAta, false, true);                          // المصدر: مملوك لسلطة الموصل
        accs[3] = ICrossProgramInvocation.AccountMeta(_vaultFor(position), false, true);                 // خزنة برنامجك
        accs[4] = ICrossProgramInvocation.AccountMeta(SPL_TOKEN, false, false);

        bytes32[] memory salts = new bytes32[](1);
        salts[0] = _salt(msg.sender);
        Cpi.invoke_signed(PRIVACY_PROGRAM, accs, encodeDeposit(amount), salts);
    }

    function withdraw(uint64 amount) external {
        bytes32 position = Helper.pda_with_salt(address(this), _salt(msg.sender));
        bytes32 userAta  = Helper.ata(msg.sender, USDC_MINT);            // الوجهة: حساب المستخدم نفسه
        // ... نفس الشكل: ينقل برنامجك `amount` من الخزنة إلى userAta، موقَّعًا بواسطة `position`
        Cpi.invoke_signed(PRIVACY_PROGRAM, accs, encodeWithdraw(amount), salts);
    }
}
```

الموصل لا يستدعي أبدًا `wUSDC` العقد. السحب هو استدعاء إلى HelperProgram ينفق تفويض المستخدم، وتبقى الرموز في حساب رموز يملكه `external_auth(adapter)` ، ولهذا يستطيع CPI إنفاقها.

ملاحظات حول الموقّع. يوقّع Rome لنوعين فقط من الحسابات: السلطة المجردة للعقد المتصل (`Helper.pda(address(this))`)، التي توقّع من دون أن تكون مدرجة في `الـ salts`، وPDA فرعي واحد لكل إدخال في `الـ salts`. يجب أن يظهر كل salt تذكره في قائمة الحسابات بصفته موقّعًا، وإلا فستفشل الدعوة مع `لم يُعثر على حساب الموقّع المحسوب من البذرة المقدمة`. أما أي حساب آخر يُعلَّم بصفته موقّعًا، بما في ذلك السلطة الخاصة بالمستخدم نفسه، فلا يحصل على بذرة من Rome، ويرفض وقت تشغيل سولانا CPI. تأتي حقوق المستخدم على رموزه من التفويض، لا من توقيع الموصل بصفته المستخدم.

تفويض من دون سحب: إذا كان ينبغي لبرنامجك أن ينفق مباشرةً من حساب الرموز الخاص بالمستخدم، يرسل المستخدم `HelperProgram.approve_spl_raw_delegate(userAta, yourProgramPda, amount, mint, decimals)` مباشرةً إلى HelperProgram، ويُسمي PDA الخاص ببرنامجك بوصفه مفوَّض SPL. يستخدم جسر Rome هذا مع Wormhole. تنطبق هنا أيضًا قاعدة المفوَّض الواحد من القسم 3: فالمنح يزيح منح الغلاف.

## 8. الاختبار

* انشر على **هادريان** (testnet، السلسلة 200010) أولًا؛ العناوين وRPC موجودان في [عناوين العقود](https://docs.rome.builders/ar/almrja/contract-addresses.md) و [السجل](https://github.com/rome-protocol/rome-registry).
* `eth_call` و `eth_estimateGas` يشغّل المحاكاة نفسها التي يستخدمها الوكيل للإرسال، لذا فإن CPI الذي يفشل هناك سيفشل على السلسلة لنفس السبب، وتحمل بيانات الإرجاع الخطأ الكامن في سولانا (`خطأ استدعاء غير EVM: …` في سجل برنامج سولانا).
* اقرأ جانب سولانا من معاملة EVM التي وصلت إلى السلسلة باستخدام `rome_solanaTxForEvmTx(hash)`؛ فإيصال سولانا هو المكان الذي تعيش فيه وحدات الحوسبة وسجلات برنامجك.
* CPI يعمل في `eth_call` لكن يُرفض عند إرساله عادةً لأنه اصطدم بحد تبلغه المحاكاة: حد 64 عنوانًا، أو ميزانية وحدات الحوسبة الذرّية (فقدت المعاملة طابعها التكراري)، أو قاعدة المسار.

## 9. مرجع

* [مرجع Precompile](https://docs.rome.builders/ar/almrja/precompiles.md) — كل محدد على كل precompile، مع فئة الإرسال وقاعدة delegatecall.
* [القيود](https://docs.rome.builders/ar/almfahym-alasasyh/constraints.md) — القيود أعلاه في جدول واحد.
* [التوافق البيني للرموز](https://docs.rome.builders/ar/almfahym-alasasyh/token-interop.md) — الأغلفة، والسكّات canonical، والإيداع والسحب.
* تطبيقات مرجعية في المستودعات العامة: [cardo](https://github.com/rome-protocol/cardo) (يستدعي المستخدم precompile الخاص بـ CPI مباشرةً، الشكل B)، [rome-dex](https://github.com/rome-protocol/rome-dex) (مباشر `invoke` إضافةً إلى موجه من دون وصاية، الشكل C)، و [aerarium](https://github.com/rome-protocol/aerarium) (تطبيق إقراض Compound III فوق سوق مشتركة واحدة؛ ولا يستدعي برامج سولانا من Solidity (لا CPI)، لذا ليس مثالًا على موصل).


---

# 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/adlh-almtw-ryn/integrate-solana-program.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.
