Skip to main content

Blockfrost với Go

Dưới đây là các bước để kết nối ví trong Blockchain Cardano bằng cách sử dụng Go với Blockfrost:

1. Nhập các gói cần thiết.#

package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"os"
"strconv"
)

2. Đặt API Blockfrost và khóa API của bạn làm biến môi trường.#

apiEndpoint := os.Getenv("BLOCKFROST_API_ENDPOINT")
apiKey := os.Getenv("BLOCKFROST_API_KEY")

3. Xác định một chức năng để truy xuất các UTxO được liên kết với một địa chỉ nhất định.#

Bạn có thể sử dụng /addresses/{address}/utxos cho việc này.

func getUTxOs(address string) ([]UTxO, error) {
url := fmt.Sprintf("%s/addresses/%s/utxos", apiEndpoint, address)
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return nil, err
}
req.Header.Set("project_id", apiKey)
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
var utxos []UTxO
err = json.Unmarshal(body, &utxos)
if err != nil {
return nil, err
}
return utxos, nil
}
type UTxO struct {
TxHash string `json:"tx_hash"`
OutputIndex int `json:"output_index"`
Amount string `json:"amount"`
Block int `json:"block"`
BlockHash string `json:"block_hash"`
Confirmations int `json:"confirmations"`
Epoch int `json:"epoch"`
Slot int `json:"slot"`
TransactionHeight int `json:"tx_index"`
OutputType string `json:"output_type"`
SpendingProof struct {
Proof string `json:"proof"`
Hash string `json:"hash"`
Index int `json:"index"`
Signature []string `json:"signature"`
} `json:"spending_proof"`
}

4. Định nghĩa một hàm để tính tổng số dư của một địa chỉ nhất định.#

Bạn có thể sử dụng hàm getUTxOs được xác định ở bước 3 để truy xuất các UTxO và sau đó tính tổng các giá trị của chúng.

func getBalance(address string) (int64, error) {
utxos, err := getUTxOs(address)
if err != nil {
return 0, err
}
var balance int64
for _, utxo := range utxos {
amount, err := strconv.ParseInt(utxo.Amount, 10, 64)
if err != nil {
return 0, err
}
balance += amount
}
return balance, nil
}

5. Xác định hàm để xây dựng giao dịch chuyển ADA từ địa chỉ này sang địa chỉ khác.#

Bạn sẽ cần cung cấp địa chỉ nguồn và địa chỉ đích, số tiền cần chuyển và khóa riêng được liên kết với địa chỉ nguồn. Bạn có thể sử dụng /txs/build và /txs/{txHash}/sign cho việc này.

Đây là một ví dụ về chức năng Go xây dựng và ký một giao dịch để chuyển ADA từ địa chỉ này sang địa chỉ khác bằng API Blockfrost:

package main
import (
"bytes"
"encoding/hex"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
const (
blockfrostApiUrl = "https://cardano-mainnet.blockfrost.io/api/v0"
blockfrostApiKey = "YOUR_API_KEY"
)
type BuildTransactionRequest struct {
Inputs []TransactionInput `json:"inputs"`
Outputs []TransactionOutput `json:"outputs"`
}
type TransactionInput struct {
TxHash string `json:"tx_hash"`
TxIndex int `json:"tx_index"`
Amount int64 `json:"amount"`
PrivateKey string `json:"private_key"`
}
type TransactionOutput struct {
Address string `json:"address"`
Amount int64 `json:"amount"`
}
func BuildAndSignTransaction(sourceAddress string, destinationAddress string, amount int64, privateKey string) (string, error) {
// Construct the input object for the transaction
input := TransactionInput{
TxHash: "INPUT_TX_HASH", // replace with the hash of the transaction containing the source UTXO
TxIndex: 0, // replace with the index of the UTXO within the transaction
Amount: amount, // amount of ADA to transfer
PrivateKey: privateKey, // private key for the source address
}
// Construct the output object for the transaction
output := TransactionOutput{
Address: destinationAddress, // destination address
Amount: amount, // amount of ADA to transfer
}
// Build the transaction request
requestBody := BuildTransactionRequest{
Inputs: []TransactionInput{input},
Outputs: []TransactionOutput{output},
}
requestBytes, err := json.Marshal(requestBody)
if err != nil {
return "", err
}
requestReader := bytes.NewReader(requestBytes)
// Send the build transaction request to Blockfrost
buildTransactionUrl := fmt.Sprintf("%s/txs/build", blockfrostApiUrl)
buildTransactionRequest, err := http.NewRequest("POST", buildTransactionUrl, requestReader)
if err != nil {
return "", err
}
buildTransactionRequest.Header.Set("Content-Type", "application/json")
buildTransactionRequest.Header.Set("Project_id", blockfrostApiKey)
buildTransactionResponse, err := http.DefaultClient.Do(buildTransactionRequest)
if err != nil {
return "", err
}
defer buildTransactionResponse.Body.Close()
buildTransactionResponseBody, err := ioutil.ReadAll(buildTransactionResponse.Body)
if err != nil {
return "", err
}
// Sign the transaction
var buildTransactionResponseData map[string]interface{}
err = json.Unmarshal(buildTransactionResponseBody, &buildTransactionResponseData)
if err != nil {
return "", err
}
txHash := buildTransactionResponseData["tx_hash"].(string)
signTransactionUrl := fmt.Sprintf("%s/txs/%s/sign", blockfrostApiUrl, txHash)
signTransactionRequest, err := http.NewRequest("POST", signTransactionUrl, nil)
if err != nil {
return "", err
}
signTransactionRequest.Header.Set("Project_id", blockfrostApiKey)
signTransactionResponse, err := http.DefaultClient.Do(signTransactionRequest)
if err != nil {
return "", err
}
defer signTransactionResponse.Body.Close()
signTransactionResponseBody, err := ioutil.ReadAll(signTransactionResponse.Body)
if err != nil {
return "", err
}
// Return the signed transaction in hex format
var signTransaction

6. Đây là phần tiếp theo của mã Go mẫu để tương tác với API Blockfrost trên Chuỗi khối Cardano.#

Sau khi khởi tạo ứng dụng khách API và đặt ID dự án, bạn có thể sử dụng ứng dụng khách để gọi các phương thức khác nhau do API cung cấp.

Ví dụ: Nhận UTXO của ví#

Để lấy danh sách đầu ra giao dịch chưa sử dụng (UTXO) của ví, bạn có thể sử dụng phương GetAddressUtxosthức của ứng dụng khách Blockfrost API.

func getAddressUtxos(api *blockfrost.ApiClient, address string) ([]blockfrost_models.UtxoAddress, error) {
utxos, _, err := api.AddressesApi.GetAddressUtxos(context.Background(), address, nil)
if err != nil {
return nil, err
}
return utxos, nil
}

Hàm này lấy ứng dụng khách API và địa chỉ ví Cardano làm đầu vào, đồng thời trả về một phần UtxoAddress và một lỗi Nếu có lỗi, nó sẽ trả về nilcho lát và lỗi.

Ví dụ: Gửi ADA từ ví#

Để gửi ADA từ ví, bạn cần tạo một giao dịch và ký tên vào giao dịch đó bằng khóa riêng của ví. Đây là một chức năng ví dụ tạo và ký một giao dịch bằng API Blockfrost.

func sendAda(api *blockfrost.ApiClient, privateKey string, fromAddress string, toAddress string, amount int64) (string, error) {
// Get the current slot
currentSlot, _, err := api.HealthApi.GetCurrentBackendSlot(context.Background())
if err != nil {
return "", err
}
// Create the transaction
tx, _, err := api.TxApi.PostTransactions(context.Background(), blockfrost_models.TxSubmit{
Inputs: []blockfrost_models.TxInput{
blockfrost_models.TxInput{
Address: fromAddress,
},
},
Outputs: []blockfrost_models.TxOutput{
blockfrost_models.TxOutput{
Address: toAddress,
Value: amount,
},
},
ValidityIntervalStart: currentSlot,
})
if err != nil {
return "", err
}
// Sign the transaction
signedTx, err := cardano.SignTransaction(tx, privateKey)
if err != nil {
return "", err
}
// Submit the signed transaction
_, _, err = api.TxApi.PostTransaction(context.Background(), blockfrost_models.TxSubmit{
TxHash: signedTx,
})
if err != nil {
return "", err
}
return signedTx, nil
}

Hàm này lấy ứng dụng khách API, khóa riêng của ví, địa chỉ người gửi và người nhận cũng như lượng ADA cần gửi làm đầu vào. Nó trả về hàm băm giao dịch và một lỗi. Nếu có lỗi, nó sẽ trả về một chuỗi trống cho hàm băm giao dịch và lỗi.

Lưu ý rằng đây chỉ là một ví dụ và bạn có thể cần sửa đổi mã để phù hợp với trường hợp sử dụng cụ thể của mình.

Edit this page