Bridge จาก Solana ไป Chiliz Chain

ปรับใช้ OFT Adapter บน Solana และ Native OFT บน Chiliz Chain โดยใช้ LayerZero v2 เพื่อ bridge token จาก Solana ไปยัง Chiliz Chain

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

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

LayerZero V2 OFT Quickstart - LayerZeroLayerZero Documentation

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

การ bridge จาก Solana (Non-EVM) ไปยัง Chiliz Chain (EVM) ต้องใช้การพัฒนาแบบ dual-stack คุณจะต้องตั้งค่าสภาพแวดล้อมและกระเป๋าเงินสำหรับทั้งสองระบบ

ดังนั้นคุณจะต้องมีสภาพแวดล้อมต่อไปนี้:

• สำหรับการใช้งาน Solana: Rustup (smart contract ของ Solana ใช้ภาษา Rust), Solana CLI และ Anchor framework และ LayerZero's Solana SDK

• สำหรับการใช้งาน Chiliz Chain: Node/npx และ Hardhat

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

• mint address ของ SPL Token ที่มีอยู่แล้วซึ่งคุณต้องการ bridge ไปยัง Chiliz Chain

• กระเป๋าเงิน Web3 สำหรับแต่ละ chain:

  • สำหรับ Solana: กระเป๋าเงิน Solflare พร้อม การกำหนดค่า Solana Mainnet นี่คือ คู่มือการตั้งค่า

  • สำหรับ Chiliz Chain: กระเป๋าเงิน MetaMask พร้อม การกำหนดค่า Chiliz Chain RPC

• gas token เพียงพอบนแต่ละ chain เพื่อชำระค่าการปรับใช้ smart contract รวมถึงค่า gas สำหรับการส่งข้อความ

  • บน Solana: token SOL

  • บน Chiliz Chain: token CHZ

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

ความท้าทายเรื่อง "Shared Decimals"

เนื่องจาก Ethereum Virtual Machine (EVM) จัดการคณิตศาสตร์ของ token แตกต่างจาก Solana เราจึงต้องปรับความแม่นยำทศนิยมให้ตรงกันก่อนที่ token จะข้าม bridge:

• Solana (ต้นทาง): Native SPL Token โดยทั่วไปมีทศนิยม 9 หลัก

• Chiliz Chain (ปลายทาง): token ERC-20 มาตรฐาน (และ OFT ปลายทางใหม่ของคุณ) โดยทั่วไปใช้ทศนิยม 18 หลัก

หากคุณส่ง payload ที่มีทศนิยม 9 หลักจาก Solana ไปยัง Chiliz โดยตรงโดยไม่แปลง EVM contract จะตีความจำนวนผิดพลาด ส่งผลให้มีการสร้าง token เพียงเศษเสี้ยวเล็กน้อยบน chain ปลายทาง

เพื่อทำให้คณิตศาสตร์เป็นมาตรฐาน LayerZero ใช้การกำหนดค่า sharedDecimals โดยค่าเริ่มต้น มาตรฐาน LayerZero V2 OFT กำหนด sharedDecimals เป็น 6

• เมื่อผู้ใช้ bridge SPL token 1.00 จาก Solana Solana Adapter จะลดขนาดตัวเลขลงเหลือ 6 ทศนิยม (โดยถือว่า 3 ทศนิยมล่างสุดของ SPL token เป็น "dust" และเก็บไว้ในกระเป๋าเงินของผู้ใช้อย่างปลอดภัย)

• payload ที่มี 6 ทศนิยมจะถูกส่งข้าม bridge

• Chiliz Chain Native OFT รับตัวเลข 6 ทศนิยมและขยายขึ้น เป็น 18 ทศนิยมในเครื่องก่อนสร้าง token ERC-20 ไปยังกระเป๋าเงิน EVM ของผู้ใช้

เรียนรู้เพิ่มเติมได้ที่นี่

การพัฒนา Solana Program

เนื่องจาก token ของคุณมีอยู่แล้วบน Solana คุณไม่จำเป็นต้องสร้าง smart contract token ใหม่ แต่คุณจะปรับใช้ Solana OFT Adapter Program ที่เขียนด้วย Rust โปรแกรมนี้จะทำหน้าที่เป็นตู้เซฟแบบกระจายศูนย์ โดยเก็บ SPL token ของคุณอย่างปลอดภัยเมื่อผู้ใช้ bridge ไปยัง Chiliz Chain และปล่อยคืนเมื่อผู้ใช้ bridge กลับ

LayerZero มี Anchor workspace พร้อม contract ที่สร้างไว้ล่วงหน้าและผ่านการตรวจสอบแล้ว เพื่อไม่ให้คุณต้องเขียน Rust logic ตั้งแต่ต้น

1. โคลน LayerZero Solana SDK

เริ่มต้นด้วยการโคลน repository เครื่องมือสำหรับนักพัฒนาของ LayerZero อย่างเป็นทางการ ซึ่งประกอบด้วยตัวอย่าง Solana OFT Adapter

เปิด terminal และรัน:

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

2. สร้าง Solana Adapter Program

directory นี้คือ Anchor workspace ที่ประกอบด้วยทั้งการใช้งาน Native OFT และ OFT Adapter คุณต้องสร้าง Rust program เพื่อสร้าง Solana Program ID เฉพาะของคุณ

anchor build

หลังจากการสร้างเสร็จสมบูรณ์ ดึง Program ID ใหม่ของคุณโดยรัน:

anchor keys list

คุณต้องอัปเดตไฟล์ Anchor.toml และ macro declare_id! ภายในไฟล์ programs/oft-adapter/src/lib.rs ด้วย Program ID ใหม่ของคุณก่อนปรับใช้

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

ตรวจสอบให้แน่ใจว่า Solana CLI ของคุณกำหนดค่าสำหรับ Mainnet และกระเป๋าเงิน local ของคุณมี $SOL เพียงพอเพื่อครอบคลุมขนาดการปรับใช้และค่าเช่าพื้นที่จัดเก็บ

solana config set --url mainnet-beta
anchor deploy

4. เริ่มต้น OFT Adapter

ต่างจาก Native OFT (ซึ่งต้องสร้าง Mint ใหม่) การเริ่มต้น Adapter เพียงแค่เชื่อมโยง Program ID ที่ปรับใช้ใหม่กับ SPL Token Mint Address ที่มีอยู่ของคุณ

LayerZero SDK มี Hardhat tasks เพื่อจัดการการเริ่มต้นนี้จาก command line ตรวจสอบให้แน่ใจว่า Solana LayerZero Endpoint (30168) ของคุณได้รับการกำหนดค่า จากนั้นรัน:

npx hardhat lz:oft-adapter-solana:init --program-id <YOUR_NEW_PROGRAM_ID> --mint <YOUR_EXISTING_SPL_MINT_ADDRESS_BASE58> --shared-decimals 6

มีพารามิเตอร์สำคัญดังนี้:

• --mint: ต้องเป็น Base58 Mint Address ที่แน่นอนของ SPL token ที่คุณต้องการ bridge Adapter จะสร้างบัญชี escrow โดยเฉพาะสำหรับ token นี้

• --shared-decimals 6: กำหนดวิธีที่ Adapter ปรับขนาด payload ก่อนส่งไปยัง EVM หาก Solana token ของคุณมีทศนิยม 9 หลัก การกำหนด 6 shared decimals ที่นี่จะรับประกันการแปลผ่าน bridge อย่างปลอดภัยโดยไม่เกิดปัญหา overflow

เมื่อธุรกรรมการเริ่มต้นนี้ได้รับการยืนยันบน Solana Adapter ของคุณจะพร้อมใช้งานและพร้อมที่จะล็อค SPL token ของคุณอย่างปลอดภัย!

การพัฒนา Chiliz Contract

เนื่องจาก SPL token ของ Solana ยังไม่มีอยู่บน Chiliz Chain คุณต้องปรับใช้ contract OFT แบบ Native มาตรฐาน contract นี้จะทำหน้าที่เป็นผู้สร้าง เมื่อได้รับข้อความที่ผ่านการยืนยันจาก Solana Adapter จะสร้าง token ERC-20 ที่สอดคล้องกัน เมื่อผู้ใช้ bridge กลับไปยัง Solana จะเผาไหม้พวกมัน

ตามที่เราได้กล่าวถึงใน "ความท้าทายเรื่อง Shared Decimals" Solana Adapter ของคุณปรับขนาด payload ลงเหลือ 6 ทศนิยมก่อนส่ง

การใช้งาน EVM ของ LayerZero เป็นเช่นนั้นที่คุณไม่จำเป็นต้องเขียน logic การปรับขนาดแบบกำหนดเอง โดยค่าเริ่มต้น contract OFT.sol ใช้ 18 ทศนิยมในเครื่องและ 6 shared decimals มันจะตรวจจับ payload 6 ทศนิยมที่มาจาก Solana โดยอัตโนมัติและขยายขึ้นเป็นรูปแบบ 18 ทศนิยมมาตรฐาน () ก่อนสร้าง token ERC-20 ไปยังกระเป๋าเงินของผู้ใช้

การปรับใช้ OFT บน Chiliz Chain

สร้างไฟล์ใหม่ชื่อ ChilizNativeOFT.sol ในโฟลเดอร์ contracts/ ของโปรเจกต์ Hardhat ของคุณ:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.22;

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

contract ChilizNativeOFT is OFT {
    constructor(
        string memory _name,    // The name of the token (Should match your Solana SPL Token)
        string memory _symbol,  // The symbol of the token (Should match your Solana SPL Token)
        address _lzEndpoint,    // The LayerZero V2 Endpoint address on Chiliz
        address _delegate       // The address capable of making configuration changes
    ) OFT(_name, _symbol, _lzEndpoint, _delegate) Ownable(_delegate) {}
}

อย่าปรับใช้ตอนนี้! แต่โปรดจำไว้ว่า:

• ตรวจสอบให้แน่ใจว่าพารามิเตอร์ _name และ _symbol ตรงกับ Solana SPL token เดิมของคุณอย่างแน่นอน เพื่อมอบประสบการณ์ที่เป็นหนึ่งเดียวให้กับผู้ใช้ของคุณ

• เมื่อปรับใช้กับ Chiliz Mainnet คุณจะส่ง Chiliz Endpoint V2 address (0x6F475642a6e85809B1c36Fa62763669b1b48DD5B) เป็น _lzEndpoint

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

เมื่อคุณมี Solana Adapter ที่เริ่มต้นแล้วและ Chiliz Native OFT พร้อมสำหรับการปรับใช้ คุณต้องกำหนดค่าการเชื่อมต่อระหว่างพวกมัน

ความท้าทายหลักที่นี่คือการจัดรูปแบบ address การส่งข้อความข้าม chain ของ LayerZero ต้องการให้ peer address ทั้งหมดอยู่ในรูปแบบ bytes32 LayerZero V2 Hardhat toolbox จัดการสิ่งนี้โดยอัตโนมัติโดยถอดรหัส Base58 Solana Adapter Program ID ของคุณและเติมให้ได้รูปแบบ EVM มาตรฐาน

Simple Config Generator เป็นวิธีที่แนะนำในการสร้างการกำหนดค่าการเชื่อมต่อ เนื่องจากทำให้การเชื่อมต่อสองทิศทางเป็นอัตโนมัติและใช้การกำหนดค่าความปลอดภัยที่แนะนำโดยอัตโนมัติ

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

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 solanaContract: OmniPointHardhat = {
    eid: EndpointId.SOLANA_V2_MAINNET,
    address: 'YourSolanaAdapterProgramIdHereInBase58', 
    // NOTE: Non-EVMs use 'address' instead of 'contractName'
};

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

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

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

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

generator จัดการการแปลง Base58 address ของ Solana เป็นการเติม bytes32 ของ EVM ที่ smart contract ของ Chiliz ต้องการโดยอัตโนมัติ

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

ในขั้นตอนนี้ Solana Adapter ของคุณได้รับการคอมไพล์ ปรับใช้ และเริ่มต้นแล้ว (ตามที่อธิบายไว้ในขั้นตอนที่ 1) ตอนนี้ คุณต้องปรับใช้ฝั่ง EVM ของ bridge ซึ่งก็คือ Native OFT บน Chiliz Chain

คุณจะใช้ Hardhat เพื่อ push contract นี้ไปยัง Chiliz Mainnet

1. Script การปรับใช้ Chiliz Native OFT

ในโปรเจกต์ Hardhat ของคุณ สร้าง deployment script ในไดเรกทอรี deploy/ ชื่อ 01_deploy_chiliz_native_oft.ts script นี้จะเริ่มต้น token ERC-20 ใหม่บน Chiliz

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

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

    // Token Details (Must strictly match your existing Solana SPL Token)
    const TOKEN_NAME = "My Solana Token";
    const TOKEN_SYMBOL = "SOLTKN";

    // The Chiliz Mainnet Endpoint V2 Address
    const CHILIZ_ENDPOINT_V2 = "0x6F475642a6e85809B1c36Fa62763669b1b48DD5B";

    console.log("Deploying Native OFT to Chiliz Mainnet...");

    await deploy('ChilizNativeOFT', {
        from: deployer,
        args: [
            TOKEN_NAME,         // _name
            TOKEN_SYMBOL,       // _symbol
            CHILIZ_ENDPOINT_V2, // _lzEndpoint
            deployer            // _delegate (Owner)
        ],
        log: true,
        waitConfirmations: 2,
    });
};

export default deployOFT;
deployOFT.tags = ['ChilizNativeOFT'];

2. การปรับใช้ Solana Program

เพื่อเตือนความจำ Solana Adapter ของคุณไม่ใช้ Hardhat สำหรับการปรับใช้เริ่มต้น คุณควรได้ดำเนินการต่อไปนี้แล้ว:

1. รัน anchor build และ anchor deploy เพื่อ push Rust program ไปยัง Solana Mainnet

2. รัน task lz:oft-adapter-solana:init เพื่อเชื่อมโยง Adapter กับ SPL Token Mint ที่มีอยู่ของคุณ

3. คัดลอก Base58 Program ID ที่ได้ไปยังไฟล์ layerzero.config.ts ของคุณ

3. ดำเนินการปรับใช้ Chiliz

ตรวจสอบให้แน่ใจว่าไฟล์ hardhat.config.ts ของคุณมี RPC URL และ private key ที่กำหนดค่าอย่างถูกต้องสำหรับ network chiliz

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

npx hardhat deploy --network chiliz --tags ChilizNativeOFT

เมื่อการปรับใช้เสร็จสิ้น Hardhat จะบันทึก Chiliz contract address ที่สร้างใหม่ในโฟลเดอร์ deployments/ ตอนนี้คุณมี contract ที่ใช้งานได้ทั้งบน Solana (SVM) และ Chiliz Chain (EVM) แต่ยังไม่ได้รับอนุญาตให้สื่อสารกัน

ขั้นตอนที่ 4: การเชื่อมต่อและการ Peer

ณ จุดนี้ คุณมี Rust Adapter Program บน Solana และ Native EVM OFT บน Chiliz Chain เพื่อให้พวกมันสื่อสารได้อย่างปลอดภัย คุณต้อง "เชื่อมต่อ" พวกมันเข้าด้วยกันในฐานะ peer ที่เชื่อถือได้

เช่นเดียวกับการ bridge ในทิศทางตรงข้าม เราจัดการกับ Virtual Machine สองแบบที่แตกต่างกันอย่างสิ้นเชิง (SVM และ EVM) ด้วยเหตุนี้ การกำหนดค่า Enforced Options (Gas Limits) อย่างถูกต้องจึงมีความสำคัญอย่างยิ่งเพื่อให้แน่ใจว่าธุรกรรมของคุณไม่ค้างบน chain ปลายทาง

"Enforced Options" สำหรับ Chiliz (EVM)

เมื่อผู้ใช้ bridge SPL token จาก Solana ไปยัง Chiliz LayerZero Executor ต้องการ EVM gas เพื่อเรียกฟังก์ชัน lzReceive บน Chiliz contract ของคุณเพื่อสร้าง token ERC-20

ในทางกลับกัน สำหรับการเดินทางกลับ (Chiliz ไปยัง Solana) Executor จะต้องการ Solana Compute Units และ Lamports เพื่อปลดล็อค SPL token และอาจต้องชำระค่าเช่าสำหรับ Associated Token Account (ATA)

การอัปเดตการกำหนดค่า

เพื่อรับประกันว่า Executor มี gas เพียงพอสำหรับทั้งสองทิศทาง คุณต้องกำหนดขีดจำกัดเหล่านี้ในไฟล์ layerzero.config.ts ของคุณก่อนการเชื่อมต่อ

อัปเดต array connections ในไฟล์ config ของคุณให้รวม enforcedOptions ต่อไปนี้:

import { EndpointId } from '@layerzerolabs/lz-definitions';
import { ExecutorOptionType } from '@layerzerolabs/lz-v2-utilities';

// ... (contracts array from Step 3)

    connections: [
        // Pathway 1: Solana -> Chiliz (The primary route)
        {
            from: 'YourSolanaAdapterProgramIdHereInBase58',
            to: 'ChilizNativeOFT',
            config: {
                enforcedOptions: [
                    {
                        msgType: 1, // Standard OFT Transfer
                        optionType: ExecutorOptionType.LZ_RECEIVE,
                        gas: 200000, // Standard EVM Gas to mint tokens on Chiliz
                        value: 0,    // No native drop needed on Chiliz EVM
                    }
                ]
            },
        },
        // Pathway 2: Chiliz -> Solana (The return trip)
        {
            from: 'ChilizNativeOFT',
            to: 'YourSolanaAdapterProgramIdHereInBase58',
            config: {
                enforcedOptions: [
                    {
                        msgType: 1, 
                        optionType: ExecutorOptionType.LZ_RECEIVE,
                        gas: 200000,    // Solana Compute Units for the unlock
                        value: 2500000, // Lamports (covers the ATA rent fee if needed)
                    }
                ]
            },
        },
    ],
// ...

การดำเนินการ Wire Task

เมื่อบันทึกการกำหนดค่าแล้ว LayerZero V2 toolbox จะทำให้กระบวนการ peering เป็นอัตโนมัติ มันถอดรหัส Base58 Solana address ของคุณ เติมให้ได้รูปแบบ bytes32 ของ EVM ที่ต้องการ และส่งธุรกรรมการกำหนดค่าไปยังทั้ง Solana Mainnet และ Chiliz Mainnet

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

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

CLI จะขอให้คุณยืนยันธุรกรรม มันจะใช้กระเป๋าเงิน Solana ที่กำหนดค่าไว้เพื่อส่งธุรกรรมต้นทาง (ใช้ $SOL) และ Hardhat เพื่อส่งธุรกรรมปลายทาง Chiliz (ใช้ $CHZ)

ในฝั่ง Chiliz LayerZero Hardhat toolbox จะสร้างและดำเนินการธุรกรรมการกำหนดค่าที่จำเป็น 6 รายการโดยอัตโนมัติ:

1. setSendLibrary: กำหนด V2 MessageLib สำหรับการส่งข้อความ

2. setReceiveLibrary: กำหนด MessageLib สำหรับการรับข้อความ

3. setConfig (Send Library): กำหนดค่า DVN และ Executor

4. setConfig (Receive Library): กำหนดค่า DVN สำหรับการยืนยันขาเข้า

5. setEnforcedOptions: รับประกันพารามิเตอร์การดำเนินการที่สอดคล้องกัน (โดยเฉพาะการรับประกันว่ามีการชำระ Solana Compute Units เพียงพอสำหรับการเดินทางกลับ)

6. setPeer: เชื่อมโยง Chiliz EID กับ Base58 Program ID ของ Solana Adapter ของคุณโดยการเข้ารหัส (แปลงเป็น bytes32)

Solana SDK จัดการคำสั่งโปรแกรมที่เทียบเท่าสำหรับฝั่ง SVM โดยอัตโนมัติ

เมื่อธุรกรรมทั้งสองได้รับการยืนยัน bridge จาก Solana ไปยัง Chiliz ของคุณจะพร้อมใช้งานอย่างเป็นทางการและได้รับอนุญาตอย่างปลอดภัย!

ขั้นตอนที่ 5: การดำเนินการและการทดสอบ

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

1) เตรียมกระเป๋าเงิน Solana ของคุณ

ต่างจาก EVM ที่คุณต้องดำเนินการธุรกรรม approve() แยกต่างหากก่อนเพื่อให้ Adapter ได้รับอนุญาต Solana จัดการการอนุมัติ token และการโอนภายในคำสั่งธุรกรรมเดียวกัน

อย่างไรก็ตาม คุณต้องตรวจสอบให้แน่ใจว่ากระเป๋าเงิน Solana local ของคุณ (ที่กำหนดค่าในโปรเจกต์ของคุณ) มียอดคงเหลือของ SPL token ที่คุณต้องการ bridge รวมถึง $SOL เพียงพอเพื่อชำระค่าธุรกรรมต้นทางและค่าธรรมเนียมข้อความข้าม chain ของ LayerZero

2) ส่งข้อความข้าม Chain ไปยัง Chiliz

LayerZero V2 toolbox มี Hardhat task สำหรับส่ง OFT transfer โดยตรงจาก command line แม้ว่า source chain จะเป็น Solana

ต่างจากการโอน Solana-to-Solana ปลายทางของคุณที่นี่คือ EVM hexadecimal wallet address มาตรฐาน (เช่น 0x123...) LayerZero CLI จัดการการเติมและการแปลง byte สำหรับ payload โดยอัตโนมัติ

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

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

สิ่งที่เกิดขึ้นที่นี่?

1. script อ้างค่าธรรมเนียมข้าม chain เป็น $SOL

2. มันสร้างธุรกรรมที่โอน SPL token 10 ชิ้นจากกระเป๋าเงินของคุณไปยังบัญชี escrow ของ Solana Adapter

3. Adapter ปรับขนาดจำนวน SPL token ที่มีทศนิยม 9 หลักลงเหลือ 6 shared decimals

4. LayerZero Endpoint ส่ง packet ไปยัง Chiliz Mainnet

3) ติดตาม Packet บน LayerZero Scan

เนื่องจากการ bridge จาก Solana เกี่ยวข้องกับการแปลระหว่าง consensus mechanism สองแบบที่แตกต่างกันโดยสิ้นเชิงและการสรุปธุรกรรมบน SVM ก่อนดำเนินการบน EVM ความล่าช้าแบบ asynchronous จึงเป็นเรื่องปกติ

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

เรียนรู้เพิ่มเติมเกี่ยวกับเครื่องมือนี้ที่นี่:

LayerZero Scan - LayerZeroLayerZero Documentation

Chiliz Native OFT จะขยาย payload 6 ทศนิยมกลับขึ้นเป็น 18 ทศนิยมมาตรฐาน EVM โดยอัตโนมัติ ดังนั้นคุณจะได้รับ token ครบ 10 ชิ้นพอดี

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

หากธุรกรรมของคุณได้รับการยืนยันบน Solana แต่ไม่สามารถดำเนินการบน Chiliz ได้ สาเหตุที่พบบ่อยที่สุดคือข้อผิดพลาด EVM Out-of-Gas

• หากพารามิเตอร์ gas ใน enforcedOptions ของคุณ (กำหนดค่าในขั้นตอนที่ 5) ถูกตั้งค่าต่ำเกินไปสำหรับ Chiliz network ในการประมวลผลฟังก์ชันการสร้าง lzReceive LayerZero Executor จะไม่สามารถส่งข้อความได้

• วิธีแก้ไข: คุณไม่สูญเสีย token เพียง connect กระเป๋าเงิน EVM ของคุณกับ Chiliz Chain แล้วคลิกปุ่ม "Force Resume" หรือ "Execute" บน block explorer และชำระค่า gas ของ Chiliz เองเพื่อสรุปการสร้าง token คุณสามารถ push ข้อความที่ค้างอยู่ผ่าน LayerZero Scan UI ได้ด้วยตนเอง