> For the complete documentation index, see [llms.txt](https://docs.chiliz.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.chiliz.com/th/phatthana/sung-khuen/omnichain-tokens/chiliz-to-solana.md).

# Bridge จาก Chiliz Chain ไป Solana

ในการ bridge token ที่มีอยู่แล้วจาก Chiliz Chain ไปยัง Solana คุณต้องเขียนและปรับใช้ smart contract แยกกันสองชุด ได้แก่ OFT Adapter บนเครือข่ายที่ token นั้นมีอยู่แล้ว (Chiliz Chain) และ Native OFT บนเครือข่ายปลายทาง (Solana)

*โปรดทราบว่า LayerZero มี QuickStart สำหรับ OFT contracts ของตัวเองด้วย:*

{% embed url="<https://docs.layerzero.network/v2/developers/evm/oft/quickstart>" %}

## ข้อกำหนดเบื้องต้น

{% hint style="info" %}
การ bridge จาก Chiliz Chain (EVM) ไปยัง Solana (Non-EVM) ต้องใช้การพัฒนาแบบ dual-stack\
คุณจะต้องตั้งค่า environment และ กระเป๋าเงิน สำหรับทั้งสองระบบ

ดังนั้นคุณจะต้องมี environment ดังต่อไปนี้:

* สำหรับการใช้งาน Chiliz Chain: Node/npx และ Hardhat
* สำหรับการใช้งาน Solana: [Rustup](https://rustup.rs/) (Solana smart contract ใช้ภาษาโปรแกรม Rust), [Solana CLI และ Anchor framework](https://solana.com/docs/intro/installation) และ [LayerZero's Solana SDK](https://docs.layerzero.network/v2/tools/sdks/solana-sdk)
  {% endhint %}

คู่มือนี้ต้องการสิ่งต่อไปนี้:

* ที่อยู่ contract ของ token บน Chiliz Chain คุณไม่จำเป็นต้องเป็นเจ้าของ
* กระเป๋าเงิน Web3 สำหรับแต่ละเครือข่าย (MetaMask ไม่รองรับเครือข่าย non-EVM):
  * สำหรับ Chiliz Chain: กระเป๋าเงิน MetaMask พร้อม [การกำหนดค่า RPC ของ Chiliz Chain](/th/phatthana/phuenthan/tho-chiliz-chain/tho-rpc.md)
  * สำหรับ Solana: กระเป๋าเงิน [Solflare](https://www.solflare.com/) พร้อม [การกำหนดค่า Solana Mainnet](https://solana.com/docs/references/clusters) นี่คือ [คู่มือการตั้งค่า](https://www.solflare.com/guides/how-to-set-up-your-first-crypto-wallet-with-solflare-step-by-step/)
* gas token เพียงพอบนแต่ละเครือข่ายเพื่อชำระค่าธรรมเนียมการปรับใช้ contract รวมถึงค่าธรรมเนียม gas สำหรับการส่งข้อความ
  * บน Chiliz Chain: token CHZ
  * บน Solana: token SOL

## ขั้นตอนที่ 1: การพัฒนา Contract

{% hint style="info" %}
**ความท้าทายเรื่อง "Shared Decimals"**

เนื่องจาก Solana จัดการคณิตศาสตร์ของ token แตกต่างจาก Ethereum Virtual Machine (EVM) เราจึงต้องจัดการ decimals อย่างถูกต้อง:

* Chiliz Chain (EVM): token ERC-20 มาตรฐานมักมีความแม่นยำ 18 decimals
* Solana: Native SPL Tokens มักมีความแม่นยำ 9 decimals

หากคุณส่ง $$ $1 \times 10^{18}$ $$ หน่วยจาก Chiliz ไปยัง Solana contract ของ Solana จะตีความจำนวนผิด ส่งผลให้เกิดการ inflation ของ token อย่างมหาศาลบนเครือข่ายปลายทาง

เพื่อทำให้การคำนวณเป็นมาตรฐาน LayerZero ใช้การกำหนดค่า `sharedDecimals` โดยค่าเริ่มต้น LayerZero V2 OFT standard กำหนด `sharedDecimals` ไว้ที่ 6

* เมื่อผู้ใช้ bridge 1.00 token จาก Chiliz Adapter จะตัด 12 decimals ล่างสุดออก (ถือว่าเป็น "dust") เพื่อลดตัวเลขให้เหลือ 6 decimals
* ข้อความถูกส่งข้าม bridge
* โปรแกรม Solana รับตัวเลข 6 decimals แล้วปรับ *ขึ้น* ไปยัง 9 decimals ในระบบของตนก่อนการสร้าง

[เรียนรู้เพิ่มเติมได้ที่นี่](https://docs.layerzero.network/v2/faq#what-is-shareddecimals-can-i-override-default-shareddecimals-in-an-oft-contract)
{% endhint %}

### การเตรียม `OFTAdapter` บน Chiliz Chain

{% hint style="warning" %}
นี่เป็นขั้นตอนการเตรียมความพร้อม อย่าปรับใช้ตอนนี้!\
คุณจะปรับใช้ในขั้นตอนที่ 3
{% endhint %}

contract `OFTAdapter` ทำหน้าที่เป็นกล่องล็อคสำหรับ token ที่มีอยู่ของคุณ เมื่อผู้ใช้ bridge token ออกจาก Chiliz Chain contract นี้จะล็อค token ERC20 ต้นฉบับไว้

{% hint style="info" %}
เนื่องจาก `OFTAdapter` ของ LayerZero กำหนด `sharedDecimals` เป็น 6 โดยค่าเริ่มต้น คุณจึงสามารถใช้การใช้งานมาตรฐานได้ หากคุณต้องการเปลี่ยนค่านี้ (เช่น เป็น 8) คุณจะต้อง override ฟังก์ชัน `sharedDecimals()`
{% endhint %}

สร้างไฟล์ใหม่ชื่อ `ChilizTokenAdapter.sol` ในโฟลเดอร์ contracts ของคุณ:

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

import { OFTAdapter } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oft/OFTAdapter.sol";
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";

contract ChilizSolanaAdapter is OFTAdapter {
    constructor(
        address _token,      // The address of your EXISTING Token on Chiliz Chain (18 decimals)
        address _lzEndpoint, // The LayerZero V2 Endpoint address on Chiliz
        address _delegate    // The address capable of making configuration changes ( (usually your wallet)
    ) OFTAdapter(_token, _lzEndpoint, _delegate) Ownable(_delegate) {}
}
```

{% hint style="info" %}
ดังที่เห็น contract นี้ขยาย [LayerZero OFT Adapter contract](https://github.com/LayerZero-Labs/LayerZero-v2/blob/main/packages/layerzero-v2/evm/oapp/contracts/oft/OFTAdapter.sol) รวมถึง contract `Ownable.sol` มาตรฐานเพื่อให้สิทธิ์ผู้ดูแลระบบ คุณต้องการทั้งสองอย่างเพื่อให้คุณ และเฉพาะคุณเท่านั้น สามารถเชื่อมโยงเครือข่ายทั้งสองได้อย่างปลอดภัย
{% endhint %}

### การเตรียมและปรับใช้ `OFT` บน Solana

ต่างจาก Chiliz Chain ตรงที่ Solana ไม่ได้ใช้ Ethereum Virtual Machine (EVM) หรือภาษา Solidity Smart contract ของ Solana (เรียกว่า "Programs") เขียนด้วย [Rust](https://rust-lang.org/)

ในการ bridge token ของคุณ คุณต้องปรับใช้โปรแกรม OFT บน Solana เมื่อโปรแกรมนี้ได้รับข้อความที่ผ่านการยืนยันจาก OFTAdapter ที่ปรับใช้บน Chiliz มันจะสร้าง SPL token ที่สอดคล้องกันเข้าไปใน กระเป๋าเงิน Solana ของผู้ใช้

{% embed url="<https://docs.layerzero.network/v2/developers/solana/oft/overview>" %}

LayerZero มี [ตัวอย่าง Anchor ที่พร้อมใช้งาน](https://github.com/LayerZero-Labs/devtools/tree/main/examples/oft-solana) ดังนั้นคุณไม่ต้องเขียนลอจิก bridge ด้วย Rust ตั้งแต่ต้น

#### 1. Clone ตัวอย่าง LayerZero OFT Solana:

```bash
git clone https://github.com/LayerZero-Labs/devtools.git
cd devtools/examples/oft-solana
npm install
```

#### 2. Build โปรแกรม Rust

สิ่งนี้จะสร้าง Solana Program ID ที่ไม่ซ้ำกันของคุณด้วย (เทียบเท่ากับ ที่อยู่ contract ใน EVM):

```bash
anchor build
```

หลังจาก build เสร็จสมบูรณ์ Anchor จะสร้าง keypair ใหม่ใน `target/deploy/oft_solana-keypair.json`\
คุณสามารถดึง Program ID ใหม่ของคุณได้โดยรัน:

```bash
anchor keys list
```

#### 3. ปรับใช้บน Solana Mainnet

ตรวจสอบให้แน่ใจว่า Solana CLI ของคุณได้รับการกำหนดค่าสำหรับ Mainnet และ กระเป๋าเงิน ในเครื่องของคุณมี $SOL เพียงพอสำหรับการปรับใช้และ storage rent\
อย่าลืมอัปเดตไฟล์ `Anchor.toml` และ macro `declare_id!` ใน `lib.rs` ด้วย Program ID ใหม่นี้ก่อนปรับใช้

```bash
solana config set --url mainnet-beta
anchor deploy
```

#### 4. Initialize OFT และ SPL Mint

บน Solana ลอจิกของ token และบัญชีแยกประเภทถูกแยกออกจากกัน คุณต้อง initialize Mint Account ใหม่ (SPL Token) และกำหนดโปรแกรม OFT ที่ปรับใช้ใหม่ของคุณเป็น Mint Authority เพื่อให้แน่ใจว่าเฉพาะ bridge ของ LayerZero เท่านั้นที่สามารถสร้าง token ใหม่บน Solana ได้

LayerZero SDK มี task ของ Hardhat/TypeScript เพื่อจัดการการ initialize นี้โดยตรงจาก command line ในโปรเจกต์ `oft-solana` ของคุณ กำหนดค่า LayerZero Endpoint สำหรับ Solana (`30168`) และรัน initialization script:

{% code overflow="wrap" lineNumbers="true" %}

```bash
npx hardhat lz:oft-solana:init --program-id <YOUR_NEW_PROGRAM_ID> --mint-decimals 9 --shared-decimals 6
```

{% endcode %}

{% hint style="info" %}
พารามิเตอร์สำคัญ:

* `--mint-decimals 9`: กำหนดความแม่นยำของ SPL token มาตรฐานบน Solana
* `--shared-decimals 6`: ต้องตรงกับ shared decimals ที่คุณกำหนดค่า (หรือค่าเริ่มต้น) บน `OFTAdapter` ของ Chiliz Chain ซึ่งเป็นสิ่งที่รับประกันว่า 1 token บน Chiliz = 1 token บน Solana
  {% endhint %}

เมื่อธุรกรรม initialization นี้ได้รับการยืนยันบน blockchain ของ Solana โปรแกรม OFT ของคุณก็พร้อมใช้งานและพร้อมที่จะเชื่อมต่อกับ Chiliz OFTAdapter แล้ว!

## ขั้นตอนที่ 2: การกำหนดค่า LayerZero

เมื่อปรับใช้ Chiliz Adapter และ initialize โปรแกรม Solana OFT แล้ว คุณต้องกำหนดค่าการเชื่อมต่อระหว่างกัน นี่คือจุดที่ความแตกต่างระหว่างเครือข่าย EVM และ non-EVM ปรากฏชัดเจนมาก

{% hint style="info" %}
รูปแบบที่อยู่:

* Chiliz Chain (EVM): ใช้ที่อยู่เลขฐานสิบหกขนาด 20 bytes มาตรฐาน (เช่น `0x123...`)
* Solana: ใช้ที่อยู่แบบ Base58 encoded (เช่น `YourProgramId111111111111111111111111111111`)
  {% endhint %}

การส่งข้อความข้ามเครือข่ายของ LayerZero กำหนดให้ [ที่อยู่ peer](https://docs.layerzero.network/v2/concepts/glossary#peer) ทั้งหมดต้องอยู่ในรูปแบบ `bytes32` โชคดีที่ tooling Hardhat ของ LayerZero V2 จัดการการแปลง Base58 เป็น Bytes32 ให้คุณโดยอัตโนมัติ ตราบใดที่คุณกำหนด endpoint อย่างถูกต้องในการกำหนดค่า

[Simple Config Generator](https://docs.layerzero.network/v2/tools/simple-config) เป็นวิธีที่แนะนำในการสร้างการกำหนดค่า wiring เนื่องจากจัดการ bidirectional wiring โดยอัตโนมัติและใช้การกำหนดค่าความปลอดภัยที่แนะนำโดยไม่ต้องตั้งค่าเอง

สร้างหรืออัปเดตไฟล์ `layerzero.config.ts` ในไดเรกทอรีรากของโปรเจกต์ Hardhat ของคุณ:

{% code lineNumbers="true" %}

```typescript
import { ExecutorOptionType } from '@layerzerolabs/lz-v2-utilities';
import { OAppEnforcedOption, OmniPointHardhat } from '@layerzerolabs/toolbox-hardhat';
import { EndpointId } from '@layerzerolabs/lz-definitions';
import { generateConnectionsConfig } from '@layerzerolabs/metadata-tools';

// Define the Contracts
const chilizContract: OmniPointHardhat = {
    eid: EndpointId.CHILIZ_V2_MAINNET,
    contractName: 'ChilizSolanaAdapter', // Your Hardhat deployment name on EVM
};

const solanaContract: OmniPointHardhat = {
    eid: EndpointId.SOLANA_V2_MAINNET,
    address: 'YourSolanaProgramIdHereInBase58', // Base58 address format for Solana
};

// Define Execution Options for Solana (Compute Units & Lamports)
const SOLANA_ENFORCED_OPTIONS: OAppEnforcedOption[] = [
    {
        msgType: 1,
        optionType: ExecutorOptionType.LZ_RECEIVE,
        gas: 200000,    // Solana Compute Units needed for destination execution
        value: 2500000, // Lamports to cover the potential ATA creation rent fee
    },
];

// Define Execution Options for the return trip to Chiliz (EVM Gas)
const EVM_ENFORCED_OPTIONS: OAppEnforcedOption[] = [
    {
        msgType: 1, 
        optionType: ExecutorOptionType.LZ_RECEIVE,
        gas: 200000, // Standard EVM gas units to unlock tokens on Chiliz
        value: 0,
    },
];

// Export the Generated Configuration
export default async function () {
    return {
        contracts: [
            { contract: chilizContract },
            { contract: solanaContract },
        ],
        connections: await generateConnectionsConfig([
            [
                chilizContract, 
                solanaContract,
                [['LayerZero Labs'], []], 
                [1, 1], 
                [SOLANA_ENFORCED_OPTIONS, EVM_ENFORCED_OPTIONS], // Options [To Solana SVM, To Chiliz EVM]
            ],
        ]),
    };
}
```

{% endcode %}

task wire ของ LayerZero จะอ่านสิ่งนี้ ถอดรหัสสตริง Base58 เติมให้ครบ 32 bytes และส่งต่ออย่างปลอดภัยไปยังฟังก์ชัน `setPeer` ของ Chiliz OFTAdapter

## ขั้นตอนที่ 3: ขั้นตอนการปรับใช้

เมื่อเขียน contract และเตรียม `layerzero.config.ts` แล้ว ถึงเวลาปรับใช้ Chiliz OFTAdapter เนื่องจากคุณได้ build และปรับใช้โปรแกรม native OFT ของ Solana โดยใช้ Anchor ในขั้นตอนที่ 1 แล้ว ขั้นตอนนี้จึงมุ่งเน้นที่การปรับใช้ฝั่ง EVM ของ bridge โดยใช้ Hardhat

### **การปรับใช้ contract Chiliz OFTAdapter**

ในโปรเจกต์ Hardhat ของคุณ สร้าง deployment script ในไดเรกทอรี `deploy/` ชื่อ `01_deploy_chiliz_solana_adapter.ts` script นี้ส่ง ที่อยู่ token ที่มีอยู่และ Chiliz Endpoint V2 address (EID) ไปยัง constructor

{% code overflow="wrap" lineNumbers="true" %}

```typescript
import { DeployFunction } from 'hardhat-deploy/types';

const deployAdapter: DeployFunction = async ({ getNamedAccounts, deployments }) => {
    const { deploy } = deployments;
    const { deployer } = await getNamedAccounts();

    // The address of your existing ERC-20 token on Chiliz (18 decimals)
    const TOKEN_ADDRESS = "0xYourTokenAddressHere"; 
    
    // The Chiliz Mainnet Endpoint V2 Address
    const CHILIZ_ENDPOINT_V2 = "0x6F475642a6e85809B1c36Fa62763669b1b48DD5B";

    console.log("Deploying OFTAdapter to Chiliz Mainnet...");

    await deploy('ChilizSolanaAdapter', {
        from: deployer,
        args: [
            TOKEN_ADDRESS,       // _token
            CHILIZ_ENDPOINT_V2,  // _lzEndpoint
            deployer             // _delegate (Owner)
        ],
        log: true,
        waitConfirmations: 2,
    });
};

export default deployAdapter;
deployAdapter.tags = ['ChilizSolanaAdapter'];
```

{% endcode %}

### **การปรับใช้ Chiliz OFTAdapter**

{% hint style="info" %}
ก่อนดำเนินการต่อ ตรวจสอบให้แน่ใจว่า:

* คุณได้คัดลอก Base58 Program ID ที่ได้ไปใส่ในไฟล์ `layerzero.config.ts` ของคุณแล้ว
* `hardhat.config.ts` ของคุณมีการกำหนดค่า RPC URL และ private key อย่างถูกต้องสำหรับ Chiliz Chain Mainnet
  {% endhint %}

รันคำสั่งต่อไปนี้ใน terminal เพื่อปรับใช้ EVM Adapter:

{% code overflow="wrap" lineNumbers="true" %}

```bash
npx hardhat deploy --network chiliz --tags ChilizSolanaAdapter
```

{% endcode %}

เมื่อการปรับใช้เสร็จสมบูรณ์ Hardhat จะบันทึก ที่อยู่ contract ของ Chiliz ไว้ในโฟลเดอร์ `deployments/`

ณ จุดนี้ คุณมี contract ที่ใช้งานอยู่ทั้งบน Chiliz Chain (EVM) และ Solana (SVM) แต่พวกมันยังไม่เชื่อถือกัน ถึงเวลาให้พวกมันรู้จักกัน!

## ขั้นตอนที่ 4: การ Wire และ Peer

เพื่อให้ contract OFTAdapter และโปรแกรม OFT ของคุณสื่อสารกันได้ คุณต้อง "wire" พวกมันเข้าด้วยกันในฐานะ peer ที่เชื่อถือได้

เนื่องจากเราเป็น bridge ข้าม Virtual Machine สองประเภทที่แตกต่างกันโดยสิ้นเชิง (EVM และ SVM) การกำหนดค่าจึงต้องใส่ใจเป็นพิเศษ

{% hint style="info" %}
**EVM gas เทียบกับ Solana compute units**

เมื่อผู้ใช้ bridge token จาก Chiliz Chain ไปยังเครือข่าย EVM อื่น (เช่น Base) LayerZero Executor ต้องใช้ EVM gas เพื่อเรียก `lzReceive`

อย่างไรก็ตาม เมื่อ bridge จาก Chiliz Chain ไปยัง Solana เครือข่ายปลายทางไม่ได้ใช้ EVM gas [มันใช้ Compute Units และ Lamports (เศษส่วนของ $SOL)](https://solana.com/docs/core/fees)\
นอกจากนี้ หากผู้ใช้ bridge token ไปยัง กระเป๋าเงิน Solana ที่ยังไม่ได้ถือ token ของคุณ Executor จะต้องจ่ายค่า "rent exemption" ของ Solana เพื่อสร้าง Associated Token Account (ATA) สำหรับพวกเขา ซึ่งต้องใช้ค่า $SOL จริงๆ บนปลายทาง
{% endhint %}

เพื่อรับประกันว่า Executor มี Compute Units และ Lamports เพียงพอในการสร้าง token และสร้าง ATA บน Solana คุณต้องกำหนดขีดจำกัดเหล่านี้ในไฟล์ `layerzero.config.ts` *ก่อน* การ wire

รันคำสั่ง wire อัตโนมัติใน terminal ของคุณ:

{% code lineNumbers="true" %}

```bash
npx hardhat lz:oapp:wire --oapp-config layerzero.config.ts
```

{% endcode %}

สิ่งนี้จะเตรียมธุรกรรมการกำหนดค่าที่จำเป็น 6 รายการ:

1. `setSendLibrary`: กำหนด MessageLib สำหรับ packet ขาออก
2. `setReceiveLibrary`: กำหนด MessageLib สำหรับ packet ขาเข้า
3. `setConfig`: กำหนดค่า DVN และ Executor
4. `setConfig`: กำหนดค่า DVN สำหรับการยืนยันขาเข้า
5. `setEnforcedOptions`: รับประกันพารามิเตอร์การดำเนินการที่สอดคล้องกัน (สำคัญมากเพื่อให้แน่ใจว่าผู้ใช้ชำระเงินล่วงหน้าเพียงพอเพื่อครอบคลุม Solana Compute Units และ Lamport rent)
6. `setPeer`: เชื่อมโยง Solana EID กับ Base58 Program ID ปลายทางของคุณ

LayerZero V2 toolbox จัดการส่วนที่หนักโดยอัตโนมัติ: มันจะถอดรหัส ที่อยู่ Solana แบบ Base58 เติมให้ครบรูปแบบ `bytes32` ของ EVM และส่งธุรกรรม `setPeer` และ `setEnforcedOptions` ไปยังทั้งสองเครือข่าย

เมื่อธุรกรรม wiring ได้รับการยืนยัน bridge EVM-to-Solana ของคุณก็เปิดใช้งานและได้รับการกำหนดสิทธิ์อย่างปลอดภัยแล้ว

token ของคุณพร้อมข้ามแดน EVM/SVM อย่างเป็นทางการแล้ว!

## ขั้นตอนที่ 5: การใช้งานและการทดสอบ

เมื่อปรับใช้ Chiliz Adapter เริ่มต้น Solana Native OFT และ wire ทั้งสองเข้าด้วยกันอย่างถูกต้องแล้ว token ของคุณก็พร้อมข้ามแดน EVM/SVM อย่างเป็นทางการแล้ว ขั้นตอนสุดท้ายคือการดำเนินการและติดตามการโอน ทดสอบจาก Chiliz Chain ไปยัง Solana

### 1) การส่งข้อความข้ามเครือข่ายไปยัง Solana

LayerZero V2 toolbox มี task ของ Hardhat สำหรับส่งการโอน OFT โดยตรงจาก command line

ต่างจากการโอน EVM-to-EVM ที่ปลายทางเป็นสตริงเลขฐานสิบหกมาตรฐาน ปลายทางของคุณที่นี่คือ ที่อยู่ กระเป๋าเงิน Solana แบบ Base58 LayerZero CLI จัดการการแปลง Base58 เป็น Bytes32 สำหรับ message payload โดยอัตโนมัติ

รันคำสั่งต่อไปนี้ใน terminal ของคุณ:

{% code overflow="wrap" lineNumbers="true" %}

```bash
npx hardhat lz:oft:send --oapp-config layerzero.config.ts --from-eid 30409 --to-eid 30168 --to <YOUR_SOLANA_WALLET_ADDRESS_BASE58> --amount 10
```

{% endcode %}

{% hint style="info" %}
เกิดอะไรขึ้นที่นี่?

1. script จะแสดงค่าธรรมเนียมข้ามเครือข่ายใน $CHZ (ซึ่งครอบคลุม EVM gas ค่าธรรมเนียมเครือข่ายผู้ยืนยัน และค่าธรรมเนียมปลายทาง Solana)
2. มันเรียกฟังก์ชัน `send()` บน Chiliz Adapter ของคุณ
3. Adapter ล็อค 10 token (18 decimals) มันตัด 12 decimals ล่างสุดเป็น "dust" (ทิ้งไว้ใน กระเป๋าเงิน Chiliz ของคุณ) เพื่อปรับ payload ลงเป็น `sharedDecimals` จำนวน 6
4. LayerZero Endpoint ส่ง packet ไปยัง Solana Mainnet
   {% endhint %}

### 2) การติดตาม Packet บน LayerZero Scan

เนื่องจากการ bridge ไปยัง Solana เกี่ยวข้องกับการแปลระหว่างกลไกฉันทามติสองประเภทที่แตกต่างกันโดยสิ้นเชิงและรอ SVM finality ความล่าช้าแบบ asynchronous จึงเป็นเรื่องปกติ

ในการติดตามการเดินทางนี้แบบ real-time ให้คลิกลิงก์ LayerZero Scan ที่ปรากฏใน CLI output

เรียนรู้เพิ่มเติมเกี่ยวกับ tool นี้ได้ที่นี่:

{% embed url="<https://docs.layerzero.network/v2/developers/evm/tooling/layerzeroscan>" %}

{% hint style="info" %}

#### การแปล Decimal

Solana Native OFT จะปรับ payload 6-decimal ที่มาจาก bridge ขึ้นเป็น SPL มาตรฐาน 9 decimals โดยอัตโนมัติ ดังนั้น กระเป๋าเงิน Solana ของคุณจะได้รับ token ครบถ้วนจำนวน 10 token
{% endhint %}

**4) การแก้ไขปัญหาข้อความที่ค้างอยู่**

หากธุรกรรมของคุณถูกทำเครื่องหมายว่ายืนยันแล้วบน Chiliz แต่ไม่ดำเนินการบน Solana สาเหตุที่พบบ่อยที่สุดคือข้อผิดพลาด Insufficient Lamports หรือ Compute Units

* หาก กระเป๋าเงิน Solana ปลายทางยังไม่มี Associated Token Account (ATA) สำหรับ token เฉพาะของคุณ LayerZero Executor จะต้องจ่ายค่า "rent exemption" ของ Solana เพื่อสร้างมัน
* หากพารามิเตอร์ `value` (Lamports) ใน `enforcedOptions` ของคุณถูกตั้งต่ำเกินไปเพื่อครอบคลุม rent นี้ หรือหาก `gas` (Compute Units) ไม่เพียงพอ Executor จะปฏิเสธที่จะจ่ายเอง และข้อความจะหยุดชะงัก
* วิธีแก้ไข: คุณไม่สูญเสีย token คุณสามารถดัน stuck message ผ่าน LayerZero Scan UI ได้ด้วยตัวเอง เชื่อมต่อ กระเป๋าเงิน Solana ของคุณ คลิกปุ่ม "Force Resume" หรือ "Execute" บน block explorer และชำระค่าธรรมเนียมปลายทางในเครื่อง (Compute Units + ATA Rent ใน $SOL) ด้วยตัวเองเพื่อทำให้การสร้างเสร็จสมบูรณ์


---

# 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 dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.chiliz.com/th/phatthana/sung-khuen/omnichain-tokens/chiliz-to-solana.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.