当前位置：首页 > 文章列表 > Golang > Go教程 > Starknet 交易批量处理程序

Starknet 交易批量处理程序

来源：dev.to 2024-12-25 18:55:02 0浏览收藏

你在学习Golang相关的知识吗？本文《Starknet 交易批量处理程序》，主要介绍的内容就涉及到，如果你想提升自己的开发能力，就不要错过这篇文章，大家要知道编程理论基础和实战操作都是不可或缺的哦！

抽象的

本文介绍了 metacube 中使用的交易批处理程序，用于即时发送玩家赚取的 nft。它解释了批处理程序基于参与者的可扩展架构，并提供了 go 中的详细实现。

所有代码片段都可以在关联的 github 存储库中找到。

建筑学

image description

巴彻由两位主要演员组成：

builder 接收交易，将它们批处理成单个多调用交易，并将其发送给 sender actor。
发送者使用适当的字段（随机数、最大费用等）完成交易，对其进行签名，将其发送到 starknet 网络，并监控其状态。

这种参与者分离可以实现可扩展且高效的批处理程序。构建器在发送者发送交易时准备交易，从而实现连续且高效的交易流。

执行

以下实现特定于 go，但这些概念可以轻松适应其他语言，因为功能保持不变。

此外，请注意，此实现特定于从同一合约发送 nft。然而，本文后面提到了一种更通用的方法。

最后，代码基于nethermind开发的starknet.go库。

巴彻

让我们从 batcher 本身开始：

type batcher struct {
    accnt           *account.account
    contractaddress *felt.felt
    maxsize         int
    inchan          <-chan []string
    failchan        chan<- []string
}

账户（accnt）是持有nft的账户，它将用于签署转移nft的交易。这些 nft 是同一合约的一部分，因此有合约地址字段。 maxsize 字段是批次的最大大小，inchan 是将事务发送到 batcher 的通道。 failchan 用于发回发送失败的交易。

请注意，在这个实现中，后面所说的交易数据（[]string）是一个由两个元素组成的数组：接收者地址和 nft id。

batcher 同时运行 builder 和 sender actor：

type txndatapair struct {
    txn  rpc.broadcastinvokev1txn
    data [][]string
}

func (b *batcher) run() {
    txndatapairchan := make(chan txndatapair)

    go b.runbuildactor(txndatapairchan)
    go b.runsendactor(txndatapairchan)
}

定义的通道 txndatapairchan 将交易数据对从 builder 发送到 sender。每个交易数据对都包含批量交易，每个交易的数据都嵌入其中。每笔交易的数据都与批量交易一起发送，以便可以将失败的交易发送回实例化 batcher 的实体。

建设者

让我们分析一下build actor。请注意，为了更好的可读性，代码已被简化（完整代码）：

// 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)
        }
    }
}

runbuildactor 函数是 builder actor 的事件循环。它等待事务发送到批处理程序，并在批处理已满或达到超时时构建批处理事务。然后批量交易被发送到 sender actor。

发件人

现在让我们分析一下sender actor。请注意，为了更好的可读性，代码已被简化（完整代码）：

// actual send actor event loop
func (b *batcher) runsendactor(txndatapairchan <-chan txndatapair) {
    oldnonce := new(felt.felt).setuint64(0)

    for {
        // receive the batch transaction
        txndatapair, ok := <-txndatapairchan
        if !ok {
            ...
        }
        txn := txndatapair.txn
        data := txndatapair.data

        // get the current nonce of the sender account
        nonce, err := b.accnt.nonce(
            context.background(),
            rpc.blockid{tag: "latest"},
            b.accnt.accountaddress,
        )
        if err != nil {
            ...
        }

        // it might happen that the nonce is not directly updated if another transaction was sent just before. therefore, we manually increment it to make sure this new transaction is sent with the correct nonce
        if nonce.cmp(oldnonce) <= 0 {
            nonce.add(oldnonce, new(felt.felt).setuint64(1))
        }

        txn.invoketxnv1.nonce = nonce

        // sign the transaction
        err = b.accnt.signinvoketransaction(
            context.background(),
            &txn.invoketxnv1,
        )
        if err != nil {
            ...
        }

        // send the transaction to the starknet network
        resp, err := b.accnt.addinvoketransaction(
            context.background(),
            &txn,
        )
        if err != nil {
            ...
        }

        // monitor the transaction status
    statusloop:
        for {
            // wait a bit before checking the status
            time.sleep(time.second * 5)

            // get the transaction status
            txstatus, err := b.accnt.gettransactionstatus(
                context.background(),
                resp.transactionhash,
            )
            if err != nil {
                ...
            }

            // check the execution status
            switch txstatus.executionstatus {
            case rpc.txnexecutionstatussucceeded:
                oldnonce = nonce
                break statusloop
            case rpc.txnexecutionstatusreverted:
                // a reverted transaction consumes the nonce
                oldnonce = nonce
                ...
                break statusloop
            default:
            }

            // check the finality status
            switch txstatus.finalitystatus {
            case rpc.txnstatus_received:
                continue
            case rpc.txnstatus_accepted_on_l2, rpc.txnstatus_accepted_on_l1:
                oldnonce = nonce
                break statusloop
            case rpc.txnstatus_rejected:
                ...
            default:
            }

            // loop until the transaction status is determined
        }
    }
}

runsendactor 函数是发送者 actor 的事件循环。它等待 builder 发送批量交易，对它们进行签名，将它们发送到 starknet 网络，并监控它们的状态。

关于费用估算的说明：可以在发送之前估算批量交易的费用成本。交易签名后可添加以下代码：

        fee, err := b.accnt.EstimateFee(
            context.Background(),
            []rpc.BroadcastTxn{txn},
            []rpc.SimulationFlag{},
            rpc.WithBlockTag("latest"),
        )
        if err != nil {
            ...
        }

这可能有助于确保在发送交易之前费用不会太高。如果估计费用高于预期，则可能还需要重新调整交易的最大费用字段。但请注意，当交易发生任何更改时，必须重新签名！

但是请注意，如果交易吞吐量相当高，您在估算费用时可能会遇到一些问题。这是因为当给定的交易刚刚被批准时，更新帐户的随机数会有一点延迟。因此，在估计下一笔交易的费用时，它可能会失败，认为随机数仍然是前一笔交易。因此，如果您仍然想估算费用，那么您可能需要在每笔交易之间提供一些睡眠以避免此类问题。