Pengumpul transaksi Starknet

Abstrak

Artikel ini memaparkan kumpulan urus niaga yang digunakan dalam Metacube untuk menghantar NFT yang diperoleh oleh pemain serta-merta. Ia menerangkan seni bina berasaskan pelakon berskala kumpulan dan menyediakan pelaksanaan terperinci dalam Go.

Semua coretan kod tersedia dalam repositori GitHub yang berkaitan.

Seni bina

The Batcher terdiri daripada dua pelakon utama:

• Pembina menerima urus niaga, menyusunnya ke dalam satu transaksi berbilang panggilan dan menghantarnya kepada pelakon Penghantar.
• Penghantar memuktamadkan urus niaga dengan medan yang sesuai (nonce, yuran maksimum, dll.), menandatanganinya, menghantarnya ke rangkaian Starknet dan memantau statusnya.

Pemisahan pelakon ini membolehkan kumpulan berskala dan cekap. Pembina menyediakan urus niaga semasa pengirim menghantarnya, membolehkan aliran urus niaga yang berterusan dan cekap.

Perlaksanaan

Pelaksanaan berikut adalah khusus untuk Go, tetapi konsepnya boleh disesuaikan dengan mudah kepada bahasa lain, kerana fungsinya tetap sama.

Selain itu, ambil perhatian bahawa pelaksanaan ini khusus untuk menghantar NFT daripada kontrak yang sama. Walau bagaimanapun, pendekatan yang lebih generik disebut kemudian dalam artikel.

Akhir sekali, kod itu berdasarkan pustaka starknet.go yang dibangunkan oleh Nethermind.

Bacher

Mari kita mulakan dengan Batcher itu sendiri:

type Batcher struct {
    accnt           *account.Account
    contractAddress *felt.Felt
    maxSize         int
    inChan          <-chan []string
    failChan        chan<- []string
}

Akaun (acnt) ialah akaun yang memegang NFT, ia akan digunakan untuk menandatangani transaksi yang memindahkannya. NFT ini adalah sebahagian daripada kontrak yang sama, oleh itu medan contractAddress. Medan maxSize ialah saiz maksimum kumpulan, dan inChan ialah saluran di mana transaksi dihantar kepada Batcher. FailChan digunakan untuk menghantar semula transaksi yang gagal dihantar.

Perhatikan bahawa, dalam pelaksanaan ini, data transaksi yang dipanggil kemudian ([]rentetan) ialah tatasusunan dua elemen: alamat penerima dan ID NFT.

Batcher menjalankan kedua-dua pelakon Builder dan Pengirim secara serentak:

type TxnDataPair struct {
    Txn  rpc.BroadcastInvokev1Txn
    Data [][]string
}

func (b *Batcher) Run() {
    txnDataPairChan := make(chan TxnDataPair)

    go b.runBuildActor(txnDataPairChan)
    go b.runSendActor(txnDataPairChan)
}

Saluran yang ditentukan txnDataPairChan menghantar pasangan data transaksi daripada Pembina kepada Pengirim. Setiap pasangan data transaksi terdiri daripada urus niaga kelompok, dan data untuk setiap transaksi dibenamkan di dalamnya. Data untuk setiap urus niaga dihantar bersama urus niaga kelompok supaya urus niaga yang gagal boleh dihantar semula kepada entiti yang membuat instantiate Batcher.

pembina

Mari kita analisa pelakon Build. Ambil perhatian bahawa kod dipermudahkan untuk kebolehbacaan yang lebih baik (kod penuh):

type Batcher struct {
    accnt           *account.Account
    contractAddress *felt.Felt
    maxSize         int
    inChan          <-chan []string
    failChan        chan<- []string
}

Fungsi runBuildActor ialah gelung acara pelakon Builder. Ia menunggu urus niaga dihantar kepada Batcher dan membina transaksi kelompok apabila kumpulan penuh atau tamat masa dicapai. Transaksi kelompok kemudiannya dihantar kepada pelakon Pengirim.

penghantar

Mari kita menganalisis pelakon Pengirim. Ambil perhatian bahawa kod dipermudahkan untuk kebolehbacaan yang lebih baik (kod penuh):

type TxnDataPair struct {
    Txn  rpc.BroadcastInvokev1Txn
    Data [][]string
}

func (b *Batcher) Run() {
    txnDataPairChan := make(chan TxnDataPair)

    go b.runBuildActor(txnDataPairChan)
    go b.runSendActor(txnDataPairChan)
}

Fungsi runSendActor ialah gelung acara pelakon penghantar. Ia menunggu untuk Builder menghantar transaksi kelompok, menandatanganinya, menghantarnya ke rangkaian Starknet dan memantau status mereka.

Nota tentang anggaran yuran: seseorang boleh menganggarkan kos yuran transaksi kelompok sebelum menghantarnya. Kod berikut boleh ditambah selepas menandatangani transaksi:

// This function builds a function call from the transaction data.
func (b *Batcher) buildFunctionCall(data []string) (*rpc.FunctionCall, error) {
    // Parse the recipient address
    toAddressInFelt, err := utils.HexToFelt(data[0])
    if err != nil {
        ...
    }

    // Parse the NFT ID
    nftID, err := strconv.Atoi(data[1])
    if err != nil {
        ...
    }

    // The entry point is a standard ERC721 function
    // https://docs.openzeppelin.com/contracts-cairo/0.20.0/erc721
    return &rpc.FunctionCall{
        ContractAddress: b.contractAddress,
        EntryPointSelector: utils.GetSelectorFromNameFelt(
            "safe_transfer_from",
        ),
        Calldata: []*felt.Felt{
            b.accnt.AccountAddress, // from
            toAddressInFelt, // to
            new(felt.Felt).SetUint64(uint64(nftID)), // NFT ID
            new(felt.Felt).SetUint64(0), // data -> None
            new(felt.Felt).SetUint64(0), // extra data -> None
        },
    }, nil
}

// This function builds the batch transaction from the function calls.
func (b *Batcher) buildBatchTransaction(functionCalls []rpc.FunctionCall) (rpc.BroadcastInvokev1Txn, error) {
    // Format the calldata (i.e., the function calls)
    calldata, err := b.accnt.FmtCalldata(functionCalls)
    if err != nil {
        ...
    }

    return rpc.BroadcastInvokev1Txn{
        InvokeTxnV1: rpc.InvokeTxnV1{
            MaxFee:        new(felt.Felt).SetUint64(MAX_FEE),
            Version:       rpc.TransactionV1,
            Nonce:         new(felt.Felt).SetUint64(0), // Will be set by the send actor
            Type:          rpc.TransactionType_Invoke,
            SenderAddress: b.accnt.AccountAddress,
            Calldata:      calldata,
        },
    }, nil
}

// Actual Build actor event loop
func (b *Batcher) runBuildActor(txnDataPairChan chan<- TxnDataPair) {
    size := 0
    functionCalls := make([]rpc.FunctionCall, 0, b.maxSize)
    currentData := make([][]string, 0, b.maxSize)

    for {
        // Boolean to trigger the batch building
        trigger := false

        select {
        // Receive new transaction data
        case data, ok := <-b.inChan:
            if !ok {
                ...
            }

            functionCall, err := b.buildFunctionCall(data)
            if err != nil {
                ...
            }

            functionCalls = append(functionCalls, *functionCall)
            size++
            currentData = append(currentData, data)

            if size >= b.maxSize {
                // The batch is full, trigger the building
                trigger = true
            }

        // We don't want a smaller batch to wait indefinitely to be full, so we set a timeout to trigger the building even if the batch is not full
        case <-time.After(WAITING_TIME):
            if size > 0 {
                trigger = true
            }
        }

        if trigger {
            builtTxn, err := b.buildBatchTransaction(functionCalls)
            if err != nil {
                ...
            } else {
                // Send the batch transaction to the Sender
                txnDataPairChan <- TxnDataPair{
                    Txn:  builtTxn,
                    Data: currentData,
                }
            }

            // Reset variables
            size = 0
            functionCalls = make([]rpc.FunctionCall, 0, b.maxSize)
            currentData = make([][]string, 0, b.maxSize)
        }
    }
}

Ini mungkin berguna untuk memastikan bayaran tidak terlalu tinggi sebelum menghantar transaksi. Jika anggaran yuran lebih tinggi daripada jangkaan, seseorang juga mungkin perlu melaraskan semula medan yuran maks transaksi jika anggaran yuran lebih tinggi daripada jangkaan. Tetapi ambil perhatian bahawa apabila sebarang perubahan dibuat pada transaksi, ia mesti ditandatangani semula!

Walau bagaimanapun, ambil perhatian bahawa anda mungkin mendapat beberapa isu semasa menganggarkan yuran jika pemprosesan urus niaga agak tinggi. Ini kerana apabila transaksi tertentu baru diluluskan, terdapat sedikit kelewatan dalam mengemas kini nonce akaun. Oleh itu, apabila menganggarkan yuran untuk transaksi seterusnya, ia mungkin gagal, memikirkan bahawa nonce masih yang sebelumnya. Jadi, jika anda masih mahu menganggarkan yuran, maka anda mungkin perlu menyediakan sedikit masa antara setiap transaksi untuk mengelakkan masalah sedemikian.

Ke arah kumpulan generik

Batcher yang dibentangkan adalah khusus untuk menghantar NFT daripada kontrak yang sama. Walau bagaimanapun, seni bina boleh disesuaikan dengan mudah untuk menghantar sebarang jenis transaksi.

Pertama, data transaksi yang dihantar kepada Batcher mestilah lebih generik dan, oleh itu, mengandungi lebih banyak maklumat. Ia mesti mengandungi alamat kontrak, pemilih titik masuk dan data panggilan. Fungsi buildFunctionCall kemudiannya mesti disesuaikan untuk menghuraikan maklumat ini.

Seseorang juga boleh melangkah lebih jauh dengan menjadikan akaun pengirim generik. Ini memerlukan lebih banyak pemfaktoran semula, kerana urus niaga mesti dikumpulkan bagi setiap akaun penghantar. Walau bagaimanapun, ia boleh dilaksanakan dan membolehkan kumpulan yang lebih serba boleh.

Walau bagaimanapun, ingat bahawa pengoptimuman pramatang adalah punca segala kejahatan. Oleh itu, jika anda hanya perlu menghantar NFT atau token tertentu seperti ETH atau STRK, kumpulan yang dibentangkan adalah lebih daripada mencukupi.

alat CLI

Kod repositori boleh digunakan sebagai alat CLI untuk menghantar sekumpulan NFT mengikut kelompok. Alat ini mudah digunakan, dan anda sepatutnya dapat menyesuaikannya dengan keperluan anda selepas membaca artikel ini. Sila rujuk README untuk maklumat lanjut.

Kesimpulan

Saya harap artikel ini membantu anda untuk lebih memahami cara Metacube menghantar NFT kepada pemainnya. Bacher adalah komponen infrastruktur utama, dan kami gembira untuk berkongsi dengan komuniti. Jika anda mempunyai sebarang soalan atau maklum balas, sila komen atau hubungi saya. Terima kasih kerana membaca!

Atas ialah kandungan terperinci Pengumpul transaksi Starknet. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!