Go SDK

Go SDK 可让你连接、探索并与 Aptos 区块链交互。你可以用它请求数据、发送交易、设置测试环境等。

安装 Go SDK

Aptos 在 aptos-go-sdk GitHub 仓库中提供官方 Go SDK。 该 SDK 需要 Go 1.25+。

go get github.com/aptos-labs/aptos-go-sdk

示例

快速入门 几分钟内在 Devnet 上完成一笔可运行的转账

账户 生成、恢复并为账户注资

获取数据 读取账本、账户和 View 函数数据

提交交易 构建、模拟、签名并提交交易

示例 SDK 仓库中的可运行示例目录

测试 覆盖 SDK 的集成测试和包测试

来自已测试示例套件的 APT 转账

以下片段取自 SDK 仓库中的 examples/transfer_coin。

main.go

131 collapsed lines
// transfer_coin is an example of how to make a coin transfer transaction in the simplest possible way
package main

import (
  "fmt"

  "github.com/aptos-labs/aptos-go-sdk"
  "github.com/aptos-labs/aptos-go-sdk/bcs"
)

const (
  FundAmount     = 1_000_000_000
  TransferAmount = 1_000
)

// example This example shows you how to make an APT transfer transaction in the simplest possible way
func example(networkConfig aptos.NetworkConfig) {
  // Create a client for Aptos
  client, err := aptos.NewClient(networkConfig)
  if err != nil {
    panic("Failed to create client:" + err.Error())
  }

  // Create accounts locally for alice and bob
  alice, err := aptos.NewEd25519Account()
  if err != nil {
    panic("Failed to create alice:" + err.Error())
  }
  bob, err := aptos.NewEd25519Account()
  if err != nil {
    panic("Failed to create bob:" + err.Error())
  }

  fmt.Printf("\n=== Addresses ===\n")
  fmt.Printf("Alice: %s\n", alice.Address.String())
  fmt.Printf("Bob:%s\n", bob.Address.String())

  // Fund the sender with the faucet to create it on-chain
  err = client.Fund(alice.Address, FundAmount)
  if err != nil {
    panic("Failed to fund alice:" + err.Error())
  }

  aliceBalance, err := client.AccountAPTBalance(alice.Address)
  if err != nil {
    panic("Failed to retrieve alice balance:" + err.Error())
  }
  bobBalance, err := client.AccountAPTBalance(bob.Address)
  if err != nil {
    panic("Failed to retrieve bob balance:" + err.Error())
  }
  fmt.Printf("\n=== Initial Balances ===\n")
  fmt.Printf("Alice: %d\n", aliceBalance)
  fmt.Printf("Bob:%d\n", bobBalance)

  // 1. Build transaction
  accountBytes, err := bcs.Serialize(&bob.Address)
  if err != nil {
    panic("Failed to serialize bob's address:" + err.Error())
  }

  amountBytes, err := bcs.SerializeU64(TransferAmount)
  if err != nil {
    panic("Failed to serialize transfer amount:" + err.Error())
  }
  rawTxn, err := client.BuildTransaction(
    alice.AccountAddress(), aptos.TransactionPayload{
      Payload: &aptos.EntryFunction{
        Module: aptos.ModuleId{
          Address: aptos.AccountOne,
          Name:    "aptos_account",
        },
        Function: "transfer",
        ArgTypes: []aptos.TypeTag{},
        Args: [][]byte{
          accountBytes,
          amountBytes,
        },
      },
    },
  )
  if err != nil {
    panic("Failed to build transaction:" + err.Error())
  }

  // 2. Simulate transaction (optional)
  // This is useful for understanding how much the transaction will cost
  // and to ensure that the transaction is valid before sending it to the network
  // This is optional, but recommended
  simulationResult, err := client.SimulateTransaction(rawTxn, alice)
  if err != nil {
    panic("Failed to simulate transaction:" + err.Error())
  }
  fmt.Printf("\n=== Simulation ===\n")
  fmt.Printf("Gas unit price: %d\n", simulationResult[0].GasUnitPrice)
  fmt.Printf("Gas used: %d\n", simulationResult[0].GasUsed)
  fmt.Printf("Total gas fee: %d\n", simulationResult[0].GasUsed*simulationResult[0].GasUnitPrice)
  fmt.Printf("Status: %s\n", simulationResult[0].VmStatus)

  // 3. Sign transaction
  signedTxn, err := rawTxn.SignedTransaction(alice)
  if err != nil {
    panic("Failed to sign transaction:" + err.Error())
  }

  // 4. Submit transaction
  submitResult, err := client.SubmitTransaction(signedTxn)
  if err != nil {
    panic("Failed to submit transaction:" + err.Error())
  }
  txnHash := submitResult.Hash

  // 5. Wait for the transaction to complete
  _, err = client.WaitForTransaction(txnHash)
  if err != nil {
    panic("Failed to wait for transaction:" + err.Error())
  }

  // Check balances
  aliceBalance, err = client.AccountAPTBalance(alice.Address)
  if err != nil {
    panic("Failed to retrieve alice balance:" + err.Error())
  }
  bobBalance, err = client.AccountAPTBalance(bob.Address)
  if err != nil {
    panic("Failed to retrieve bob balance:" + err.Error())
  }
  fmt.Printf("\n=== Intermediate Balances ===\n")
  fmt.Printf("Alice: %d\n", aliceBalance)
  fmt.Printf("Bob:%d\n", bobBalance)

  // Now do it again, but with a different method
  resp, err := client.BuildSignAndSubmitTransaction(
    alice, aptos.TransactionPayload{
      Payload: &aptos.EntryFunction{
        Module: aptos.ModuleId{
          Address: aptos.AccountOne,
          Name:    "aptos_account",
        },
        Function: "transfer",
        ArgTypes: []aptos.TypeTag{},
        Args: [][]byte{
          accountBytes,
          amountBytes,
        },
      },
    },
  )
  if err != nil {
    panic("Failed to sign transaction:" + err.Error())
  }

  _, err = client.WaitForTransaction(resp.Hash)
20 collapsed lines
  if err != nil {
    panic("Failed to wait for transaction:" + err.Error())
  }

  aliceBalance, err = client.AccountAPTBalance(alice.Address)
  if err != nil {
    panic("Failed to retrieve alice balance:" + err.Error())
  }
  bobBalance, err = client.AccountAPTBalance(bob.Address)
  if err != nil {
    panic("Failed to retrieve bob balance:" + err.Error())
  }
  fmt.Printf("\n=== Final Balances ===\n")
  fmt.Printf("Alice: %d\n", aliceBalance)
  fmt.Printf("Bob:%d\n", bobBalance)
}

func main() {
  example(aptos.DevnetConfig)
}