> 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/vi/rome-academy/08-open-your-solana-program-to-evm-users.md).

# 8. Mở chương trình Solana của bạn cho người dùng EVM

Cho phép người dùng MetaMask gọi một chương trình mà bạn đã chạy trên Solana, thông qua một hợp đồng Solidity mỏng và precompile CPI, không cần port và không cần bản sao thứ hai của trạng thái của bạn.

Bạn có một chương trình Solana hoạt động tốt. Người dùng của nó giữ ví Solana. Rome cho phép một nhóm người dùng thứ hai tiếp cận nó, những người giữ ví EVM như MetaMask, mà không cần bạn viết lại chương trình bằng Solidity.

## Bạn sẽ học được gì

* Vì sao bạn sẽ mở một chương trình Solana cho người dùng EVM, và bạn giữ lại những gì.
* Một lời gọi EVM đi tới chương trình của bạn như thế nào: một hợp đồng Solidity mỏng và CPI precompile.
* Chương trình của bạn nhìn thấy gì với vai trò signer và các tài khoản.
* Token của một người dùng EVM đi vào chương trình của bạn và quay trở lại như thế nào.
* Những giới hạn cần thiết kế xung quanh: một track, một giao dịch nguyên tử, giới hạn tài khoản.

## Trường hợp sử dụng

Bài học này phục vụ một trường hợp sử dụng từ [Bạn có thể xây dựng gì](https://docs.rome.builders/vi/rome-academy/02-what-you-can-build.md): một ứng dụng Solana hiện có muốn có thêm người dùng. Một thị trường cho vay, một AMM, một vault, một thị trường dự đoán hoặc một chương trình riêng tư đều phù hợp.

Tệp người dùng EVM rất lớn và đã có sẵn ví, công cụ và thói quen. Nếu bạn chuyển chương trình của mình sang Solidity, bạn sẽ phải duy trì hai codebase và chia tách trạng thái của mình. Trên Rome, bạn giữ một chương trình và một trạng thái. Người dùng EVM tiếp cận nó thông qua một hợp đồng Solidity nhỏ, còn người dùng Solana vẫn gọi nó theo cách gốc. Cả hai cùng giao dịch trên cùng các tài khoản và cùng thanh khoản. [Chọn lõi của bạn](https://docs.rome.builders/vi/cac-khai-niem-cot-loi/choose-your-core.md) gọi hình dạng này là (b), một lõi Solana gốc với một bộ định tuyến CPI mỏng.

[rome-dex](https://github.com/rome-protocol/rome-dex) là tham chiếu: một pool Solana gốc, với một bộ định tuyến EVM ở phía trước.

## Trước khi bạn bắt đầu

* Hoàn thành [7. Mở ứng dụng EVM của bạn cho ví Solana](https://docs.rome.builders/vi/rome-academy/07-open-to-solana-wallets.md), cùng ý tưởng nhưng nhìn từ phía bên kia.
* Biết [5. Gọi Solana từ Solidity](https://docs.rome.builders/vi/rome-academy/05-call-solana-from-solidity.md) và [6. Token ở cả hai phía](https://docs.rome.builders/vi/rome-academy/06-tokens-on-both-sides.md). Bài học này ghép chúng lại.
* Hãy triển khai chương trình của bạn trên Solana devnet. Hadrian quyết toán ở đó, nên chương trình phải tồn tại trên cụm đó. Xem [Hadrian](https://docs.rome.builders/vi/mang/hadrian.md).

## Lộ trình ngắn gọn

### Bước 1: đặt một hợp đồng mỏng phía trước chương trình của bạn

Hợp đồng là một bộ điều hợp. Nó không chứa logic nghiệp vụ. Nó kiểm tra bên gọi, xây dựng instruction của bạn và gọi CPI precompile với `invoke_signed`. Mọi thứ khác vẫn nằm trong chương trình Solana của bạn. Cơ chế gọi nằm trong [Gọi Solana từ EVM](https://docs.rome.builders/vi/huong-dan-cho-nha-phat-trien/call-solana-from-evm.md#calling-custom-solana-programs), và giao diện là `contracts/interface.sol` trong kho [rome-solidity](https://github.com/rome-protocol/rome-solidity) repo.

Bộ điều hợp của bạn có ba cách để giữ vị thế của một người dùng. Hướng dẫn so sánh chúng trong [Ba cách để giữ vị thế của một người dùng](https://docs.rome.builders/pages/9977036da749fab59b01f5cb71897a69a3cf777c#id-2.-three-ways-to-hold-a-users-position):

| Dạng                       | Nó là gì                                                                    | Phù hợp                                                               |
| -------------------------- | --------------------------------------------------------------------------- | --------------------------------------------------------------------- |
| Hợp đồng bộ điều hợp       | Kéo token của người dùng, gọi chương trình của bạn dưới danh nghĩa chính nó | Một lớp giao diện có thể tái sử dụng cho một chương trình có tiền gửi |
| Người dùng gọi precompile  | Chính quyền của người dùng tự ký, không cần hợp đồng                        | Các quyền cấp một lần và những chương trình đơn giản                  |
| Bộ định tuyến không lưu ký | Không bao giờ giữ token, tiêu quyền ủy quyền của người dùng                 | Hoán đổi và các hành động một lần khác                                |

Chọn adapter cho một chương trình vault hoặc lending, và chọn router cho một swap.

### Bước 2: biết chương trình của bạn nhìn thấy ai

Mỗi địa chỉ EVM có một danh tính Solana, tức PDA quyền bên ngoài của nó, được dẫn xuất dưới chương trình Rome. Khi một hợp đồng gọi precompile, Rome ký bằng quyền của hợp đồng đó. Chương trình của bạn thấy một public key 32 byte được đánh dấu là signer. Nó không bao giờ thấy địa chỉ EVM 20 byte và cũng không bao giờ thấy người dùng.

Vì vậy người dùng không phải là signer. Để phân biệt người dùng, adapter truyền một giá trị theo từng người dùng trong dữ liệu instruction, hoặc yêu cầu Rome cũng ký bằng một sub-PDA có muối được dẫn xuất từ địa chỉ của người dùng. Sau đó chương trình của bạn giữ một vị thế cho mỗi sub-PDA. Các quy tắc về signer nằm trong [Mỗi địa chỉ EVM có một danh tính Solana](https://docs.rome.builders/pages/9977036da749fab59b01f5cb71897a69a3cf777c#id-1.-every-evm-address-has-one-solana-identity).

Hãy viết chương trình của bạn để hành động theo bất kỳ quyền nào ký. Khi đó nó phục vụ cả ví Solana lẫn adapter như nhau.

### Bước 3: chuyển token của người dùng

Trên Rome, USDC của một người dùng là một SPL token được nhìn từ hai phía, như bài 6 đã cho thấy. Số dư của người dùng nằm trong một token account do quyền của họ sở hữu. Để cho một adapter được phép tiêu nó, người dùng cấp cho adapter một SPL delegation trước khi nạp tiền. Adapter kéo token vào một token account do nó sở hữu, rồi gọi chương trình của bạn. Khi trả ra, chương trình của bạn thanh toán vào chính token account của người dùng, và người dùng thấy nó ngay lập tức như một số dư ERC-20.

Có hai cạm bẫy ở đây:

* Một ERC-20 `transferFrom` đến một hợp đồng chỉ ghi có vào sổ ký quỹ của wrapper. Hợp đồng không có token account nào của riêng nó để chi tiêu từ đó. Hãy dùng delegation, không dùng wrapper.
* Một token account chỉ có một delegate. Quyền cấp của bạn thay thế quyền cấp của wrapper, và các giao dịch token thông thường của người dùng sẽ dừng lại cho đến khi họ cấp lại cho wrapper. Hãy kiểm tra `isEnabled` sau luồng của bạn.

Trình tự đầy đủ nằm trong [Token vào, token ra](https://docs.rome.builders/pages/9977036da749fab59b01f5cb71897a69a3cf777c#id-3.-tokens-in-tokens-out).

### Bước 4: ở trong giới hạn

* **Một track.** Một lời gọi chương trình tùy chỉnh là một CPI thuộc legacy-track. Một giao dịch không được trộn nó với các lời gọi cached-track, vì vậy hãy để wrapper cached ra khỏi giao dịch đó.
* **Chỉ nguyên tử.** Một CPI thuộc legacy-track không thể chạy trong một giao dịch lặp. Toàn bộ lời gọi phải gói gọn trong một giao dịch Solana, khoảng 1,4 triệu compute unit, 64 địa chỉ và 4 KB. Chương trình của bạn chia sẻ ngân sách compute đó với chương trình Rome.
* **Tài khoản có sẵn từ đầu.** Rome mô phỏng lời gọi và đưa mọi tài khoản nó chạm vào vào giao dịch Solana. Mỗi tài khoản phải có thể suy ra từ các đầu vào mà adapter có. Một tài khoản mới vẫn phải được đặt tên.
* **Độ sâu nông.** Chương trình của bạn chạy thấp hơn Rome một mức. Mỗi chương trình nó gọi sẽ dùng thêm một mức nữa.
* **Tiền rent là của người dùng.** Các tài khoản mà instruction của bạn tạo ra được trả phí thông qua gas của người dùng.

Giữ mỗi hành động ở một lần di chuyển token và một CPI vào chương trình của bạn. Chia bất cứ thứ gì lớn hơn thành hai giao dịch người dùng. Các giới hạn nằm trong một bảng ở [Ràng buộc](https://docs.rome.builders/vi/cac-khai-niem-cot-loi/constraints.md).

## Một ví dụ thực tế

Giả sử chương trình của bạn là một vault. Một người dùng Solana nạp USDC rồi sau đó rút ra. Bạn muốn người dùng MetaMask làm điều tương tự.

1. Bạn triển khai một adapter biết program ID của bạn và mint USDC. Trong constructor, nó tạo danh tính Solana riêng và một token account cho nó.
2. Một người dùng MetaMask gửi một giao dịch cấp cho adapter một SPL delegation trên USDC của họ.
3. Người dùng gọi `nạp`. Adapter kéo USDC vào token account của chính nó, rồi gọi chương trình của bạn với quyền của chính nó và một sub-PDA có muối cho người dùng đó làm signer.
4. Chương trình của bạn chuyển USDC vào vault của nó và ghi nhận vị thế dưới sub-PDA.
5. Quyền cấp của adapter đã thay thế quyền của wrapper, nên ứng dụng của bạn đọc `isEnabled` trên wrapper cho người dùng. Nó trả về `false`, và người dùng gửi `approve_spl` cho wrapper một lần nữa. Lần nạp tiếp theo cần một quyền cấp mới cho adapter.
6. Người dùng gọi `withdraw`. Adapter để chương trình của bạn chi trả trực tiếp từ vault sang token account của người dùng. Số dư hiển thị trong MetaMask như token ERC-20.

Người dùng Solana của bạn không bao giờ chạm tới adapter. Họ gọi trực tiếp vào vault và thấy cùng các tổng số. Bản phác thảo Solidity tương ứng nằm trong [Một lượt nạp và một lượt rút, bằng Solidity](https://docs.rome.builders/pages/9977036da749fab59b01f5cb71897a69a3cf777c#id-7.-a-deposit-and-a-withdraw-in-solidity).

Hãy kiểm thử trên Hadrian trước. `eth_call` và `eth_estimateGas` chạy cùng mô phỏng mà proxy dùng để gửi, nên một CPI thất bại ở đó cũng sẽ thất bại trên chain vì cùng một lý do, và revert sẽ mang lỗi của chương trình bạn. Sau khi gửi, hãy đọc phía Solana của giao dịch bằng `rome_solanaTxForEvmTx`. Xem [Kiểm thử](https://docs.rome.builders/pages/9977036da749fab59b01f5cb71897a69a3cf777c#id-8.-testing).

## Tự kiểm tra

Hãy lấy một chương trình nhỏ của chính bạn, hoặc chương trình trong rome-dex, và ghi lại, không cần code:

1. Signer mà chương trình của bạn nhìn thấy khi một adapter gọi nó.
2. Các tài khoản mà một lần nạp sẽ đặt tên.
3. Số lần di chuyển token và số CPI trong lần nạp đó.

Sau đó triển khai adapter của bạn trên Hadrian, nạp tiền vào token account của người dùng, gửi SPL grant cho adapter và chạy lượt nạp qua `eth_estimateGas` với địa chỉ người dùng làm `từ`. Ước tính phải thành công. Nếu nó thất bại, dữ liệu revert sẽ nêu tên lỗi Solana.

<details>

<summary>1. Một người dùng MetaMask nạp qua adapter của bạn. Ai ký cho chương trình của bạn?</summary>

PDA quyền bên ngoài của adapter, cộng với bất kỳ sub-PDA có muối nào mà adapter liệt kê. Không phải người dùng. Quyền của người dùng đến từ SPL delegation mà họ đã cấp.

</details>

<details>

<summary>2. Tại sao không kéo USDC của người dùng bằng <code>transferFrom</code>?</summary>

Token sẽ rơi vào tài khoản ký quỹ của wrapper và được ghi vào sổ cái của nó. Adapter sẽ không có token account của riêng mình để chuyển cho chương trình của bạn.

</details>

<details>

<summary>3. Lượt nạp của bạn tăng đến mức tạo ra mười CPI và Rome chạy nó theo kiểu lặp. Điều gì xảy ra?</summary>

Nó thất bại. Một CPI thuộc legacy-track sẽ bị từ chối trong một giao dịch lặp. Hãy giảm hành động xuống còn một lần di chuyển token và một CPI, hoặc tách nó thành hai giao dịch.

</details>

## Tiếp theo

[9. Xây dựng một ứng dụng hai làn](https://docs.rome.builders/vi/rome-academy/09-build-a-dual-lane-app.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/vi/rome-academy/08-open-your-solana-program-to-evm-users.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.
