> 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/almfahym-alasasyh/compute-budget.md).

# ميزانية الحوسبة

تكاليف وحدة الحوسبة (CU) في Solana لعمليات Rome EVM — الميزانيات الذرّية مقابل التكرارية وكيفية تصميم عقود Solidity فعّالة في استخدام CU.

كل معاملة في سولانا لها ميزانية حوسبة تُقاس بوحدات الحوسبة (CU). يساعدك فهم تكاليف CU على تصميم عقود Rome بكفاءة.

## نظرة عامة على الميزانية

| الوضع         | الحد الأقصى لوحدات الحوسبة                                              | ملاحظات                                                                                         |
| ------------- | ----------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
| ذرّي (VmAt)   | \~1,400,000 وحدة حوسبة                                                  | معاملة سولانا واحدة                                                                             |
| تكراري (VmIt) | حتى نحو \~1,400,000 وحدة حوسبة لكل مرحلة؛ بحد أقصى 160 تكرارًا لكل جلسة | كل مرحلة هي معاملة سولانا مستقلة؛ شفرات عمليات/خطوة تكيفية — مُحزَّمة ضمن ميزانية CU لكل معاملة |

لكل معاملة في سولانا ميزانية افتراضية قدرها 200,000 وحدة حوسبة، قابلة للزيادة إلى نحو 1.4 مليون وحدة حوسبة عبر تعليمات ميزانية الحوسبة (تُضاف تلقائيًا بواسطة Rome SDK).

التنفيذ التكراري ليس غير محدود. تنتهي جلسة واحدة بعد 160 تكرارًا، ويخطط مؤلف التكرار في Rust Rome SDK بحد أقصى 128 مرحلة. أما الخطة التي توقّعها المحفظة نفسها فتمر عبر `rome_submitSignedV1Plan`، والتي تقبل بحد أقصى 64 معاملة لكل استدعاء. تحتاج معظم الاستدعاءات إلى عدد أقل بكثير. تُرفض استدعاءات CPI الخاصة بالمسار القديم داخل جلسة تكرارية، لذا يجب أن يندرج الاستدعاء الذي ينفذها ضمن الميزانية الذرّية. انظر [الاستدعاءات المُرحَّلة والاستدعاءات الطويلة](https://docs.rome.builders/ar/adlh-almtw-ryn/call-evm-from-solana.md#relayed-calls-and-long-calls) و [القيود](https://docs.rome.builders/ar/almfahym-alasasyh/constraints.md).

## تقديرات تكلفة CU

### عمليات EVM

| العملية                             | CU التقريبية                 | ملاحظات                                                                               |
| ----------------------------------- | ---------------------------- | ------------------------------------------------------------------------------------- |
| فحص توقيع المعاملة (مسار مفتاح EVM) | \~25,000 وحدة حوسبة          | الأسماء `secp256k1_recover` استدعاء نظام، بنفس تكلفة `ecrecover` الدالة المسبقة أدناه |
| تحويل بسيط                          | \~50,000-100,000 وحدة حوسبة  | تحديثات الرصيد فقط                                                                    |
| تحويل ERC-20                        | \~100,000-150,000 وحدة حوسبة | يتضمن استدعاء الدالة المسبقة الخاصة بـ SPL                                            |
| نشر عقد (صغير)                      | \~200,000-400,000 وحدة حوسبة | يعتمد على حجم الـ bytecode                                                            |
| كتابة إلى التخزين (SSTORE)          | \~5,000-20,000 وحدة حوسبة    | الوصول البارد مقابل الساخن                                                            |

### عمليات الدوال المسبقة

| Precompile      | CU التقريبية                                                 | ملاحظات                                                                                                                                                                                                                                                            |
| --------------- | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| ecrecover       | \~25,700 وحدة حوسبة                                          |                                                                                                                                                                                                                                                                    |
| SHA-256         | \~257 وحدة حوسبة لكل كلمة من 32 بايت تم قياسها               | بالإضافة إلى تكلفة ثابتة صغيرة. يحدد البرنامج سعر SHA-256 وRIPEMD-160 والدالة المسبقة identity باستخدام قيمة واحدة مشتركة لكل كلمة تبلغ نحو 2,200 وحدة حوسبة، مُحَدَّدة على أساس RIPEMD-160، الأكثر كلفة بين الثلاثة، لذا يُحاسَب استدعاء SHA-256 بأكثر مما يستهلك |
| BN254 ecAdd     | قريب من 0 وحدة حوسبة                                         | أرخص من نسخ 32 بايت                                                                                                                                                                                                                                                |
| BN254 ecMul     | \~4,200 وحدة حوسبة                                           |                                                                                                                                                                                                                                                                    |
| BN254 ecPairing | \~22,000 وحدة حوسبة بالإضافة إلى \~12,800 وحدة حوسبة لكل زوج | فحص بأربعة أزواج يستهلك نحو 73,000 وحدة حوسبة، وهو ضمن معاملة ذرّية واحدة بسهولة                                                                                                                                                                                   |

تأتي هذه الأرقام من المعايرة الخاصة بالبرنامج نفسه، والتي استخدمت وحدات الحوسبة المقروءة من عقدة Solana في نشر على شبكة اختبار. لم تُعدّ قياساتها لهذه الصفحة؛ قِس استدعاءك بنفسك باستخدام `computeUnitsConsumed`.

## تقنيات التحسين

### 1. استخدم Yul للمسارات الساخنة

يُنتج محسّن Solidity شيفرة جيدة، لكن Yul (التجميع المضمَّن) يمكن أن يقلل CU بشكل كبير للعمليات الحرجة:

```solidity
// قبل: ~600 ألف وحدة حوسبة
function createPairAccount(bytes32 token0, bytes32 token1) external {
    // عمليات على مستوى Solidity
}

// بعد: ~150 ألف وحدة حوسبة (تحسين Yul)
function createPairAccount(bytes32 token0, bytes32 token1) external {
    assembly {
        // معالجة مباشرة للذاكرة، وتجاوز عبء ترميز ABI
    }
}
```

### 2. خزّن اشتقاقات PDA مؤقتًا

اشتقاق PDA عبر `find_program_address` مكلف. خزّن عناوين PDA المشتقة في تخزين العقد بدلاً من حسابها في كل استدعاء:

```solidity
mapping(address => bytes32) private cachedPdas;

function getPda(address user) internal returns (bytes32) {
    bytes32 cached = cachedPdas[user];
    if (cached != bytes32(0)) return cached;

    bytes32 pda = RomeEVMAccount.pda(user);
    cachedPdas[user] = pda;
    return pda;
}
```

### 3. ثبّت معرّفات البرامج المعروفة صراحة

لا تقم بتحميل معرّفات البرامج من التخزين — استخدم ثوابت:

```solidity
// مكلف: يقرأ من التخزين
bytes32 splTokenProgram = storage_program_id;

// رخيص: ثابت وقت الترجمة
bytes32 constant SPL_TOKEN_PROGRAM = 0x06ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9;
```

### 4. قلّل عدد الحسابات

كل حساب في معاملة سولانا يضيف عبئًا على CU. قلّل عدد الحسابات عبر:

* تجميع العمليات التي تشترك في حسابات
* استخدام عدد أقل من الحسابات الوسيطة
* تجنب فحوصات إنشاء ATA الزائدة

### 5. استخدم إعدادات المحسّن

```typescript
// hardhat.config.ts — فعّل المحسّن في ملف تعريف بناء
solidity: {
  profiles: {
    default: { version: "0.8.28" },
    production: {
      version: "0.8.28",
      settings: { optimizer: { enabled: true, runs: 200 } },
    },
  },
}
```

ابنِ باستخدام `npx hardhat compile --build-profile production`.

## قياس استهلاك CU

`eth_estimateGas` لا يقيس وحدات الحوسبة، لأن وحدة غاز واحدة في Rome تساوي لامبورتًا واحدًا من التكلفة. إنه يحدد حد الغاز لديك. اقرأ الحوسبة من معاملة Solana الموجودة خلف تجزئة EVM: استخرج توقيعاتها باستخدام `rome_solanaTxForEvmTx`، ثم اجلب كل واحدة باستخدام `getTransaction` و `maxSupportedTransactionVersion: 1`، واقرأ `computeUnitsConsumed`، أو افتح الاستدعاء في المستكشف. يحتوي الاستدعاء التكراري على معاملة واحدة لكل مرحلة. لتحديد حد الغاز قبل الإرسال:

```bash
cast estimate --rpc-url https://hadrian.testnet.romeprotocol.xyz/ \
  0xCONTRACT "myFunction(uint256)" 42
```

أو عبر ethers.js:

```javascript
const gas = await contract.myFunction.estimateGas(42);
console.log("الغاز المقدّر:", gas.toString());
```

## ما التالي

* [القيود](https://docs.rome.builders/ar/almfahym-alasasyh/constraints.md) — القائمة الكاملة للحدود والنطاقات


---

# 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/almfahym-alasasyh/compute-budget.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.
