Requested Go examples

[LINCKODE]

No description provided.

[LINCKODE]

Transaction creation and broadcasting:

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"github.com/pkg/errors"
	"github.com/qubic/go-node-connector/types"
	"github.com/qubic/go-schnorrq"
	"io"
	"net/http"
	"time"
)

// Create simple transaction and broadcast it to the network

const ApiURL = "https://testapi.qubic.org"

const SenderSeed = ""
const SenderID = ""
const TransactionAmount = 5
const DestinationID = ""

func CreateAndBroadcastTransaction() error {

	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
	defer cancel()

	subSeed, err := types.GetSubSeed(SenderSeed)
	if err != nil {
		return errors.Wrap(err, "getting sub-seed from seed")
	}

	latestTick, err := GetLatestTick(ctx, ApiURL)
	if err != nil {
		return errors.Wrap(err, "getting latest tick")
	}

	targetTick := latestTick + 10

	transaction, err := CreateTransaction(SenderID, DestinationID, TransactionAmount, targetTick, subSeed)
	if err != nil {
		return errors.Wrap(err, "creating transaction")
	}

	err = BroadCastTransaction(ctx, transaction, ApiURL)
	if err != nil {
		return errors.Wrap(err, "broadcasting transaction")
	}

	return nil
}

func CreateTransaction(sourceID, destinationID string, amount int64, targetTick uint32, subSeed [32]byte) (*types.Transaction, error) {
	transaction, err := types.NewSimpleTransferTransaction(sourceID, destinationID, amount, targetTick)
	if err != nil {
		return nil, errors.Wrap(err, "creating transaction")
	}

	unsignedDigest, err := transaction.GetUnsignedDigest()
	if err != nil {
		return nil, errors.Wrap(err, "getting transaction unsigned digest")
	}

	signature, err := schnorrq.Sign(subSeed, transaction.SourcePublicKey, unsignedDigest)
	if err != nil {
		return nil, errors.Wrap(err, "failed to sign transaction")
	}
	transaction.Signature = signature

	return &transaction, nil

}

func GetLatestTick(ctx context.Context, apiUrl string) (uint32, error) {

	request, err := http.NewRequestWithContext(ctx, http.MethodGet, apiUrl+"/v1/latestTick", nil)
	if err != nil {
		return 0, errors.Wrap(err, "creating latest tick request")
	}

	response, err := http.DefaultClient.Do(request)
	if err != nil {
		return 0, errors.Wrap(err, "performing latest tick request")
	}
	defer response.Body.Close()

	data, err := io.ReadAll(response.Body)
	if err != nil {
		return 0, errors.Wrap(err, "reading latest tick response")
	}

	if response.StatusCode != http.StatusOK {
		return 0, errors.New(fmt.Sprintf("Status not 200! Info: %s", data))
	}

	type LatestTickStruct struct {
		LatestTick uint32 `json:"latestTick"`
	}

	var latestTick LatestTickStruct
	err = json.Unmarshal(data, &latestTick)
	if err != nil {
		return 0, errors.Wrap(err, "un-marshalling latest tick response")
	}

	return latestTick.LatestTick, nil
}

func BroadCastTransaction(ctx context.Context, transaction *types.Transaction, apiUrl string) error {

	transactionID, err := transaction.ID()
	if err != nil {
		return errors.Wrap(err, "getting transaction ID")
	}

	finalUrl := apiUrl + "/v1/broadcast-transaction"

	// Encode transaction
	encodedTransaction, err := transaction.EncodeToBase64()
	if err != nil {
		return errors.Wrap(err, "encoding transaction")
	}

	// Create request payload from encoded transaction
	requestPayload := struct {
		EncodedTransaction string `json:"encodedTransaction"`
	}{
		EncodedTransaction: encodedTransaction,
	}
	buffer := new(bytes.Buffer)

	err = json.NewEncoder(buffer).Encode(requestPayload)
	if err != nil {
		return errors.Wrap(err, "encoding request payload")
	}

	//Create and send request
	request, err := http.NewRequestWithContext(ctx, http.MethodPost, finalUrl, buffer)
	if err != nil {
		return errors.Wrap(err, "creating broadcast request")
	}

	response, err := http.DefaultClient.Do(request)
	if err != nil {
		return errors.Wrap(err, "performing broadcast request")
	}
	defer response.Body.Close()

	data, err := io.ReadAll(response.Body)
	if err != nil {
		return errors.Wrap(err, "reading broadcast response")
	}

	if response.StatusCode != http.StatusOK {
		fmt.Printf("DEBUG: %s\n", finalUrl)
		return errors.New(fmt.Sprintf("Status not 200! Info: %s", data))
	}

	type ResponseInfo struct {
		PeersBroadcasted   uint32 `json:"peersBroadcasted"`
		EncodedTransaction string `json:"encodedTransaction"`
	}

	var info ResponseInfo
	err = json.Unmarshal(data, &info)
	if err != nil {
		return errors.Wrap(err, "un-marshalling broadcast response")
	}

	fmt.Printf("Broadcasted to %d peers.\n", info.PeersBroadcasted)
	fmt.Printf("Transaction ID: %s\n", transactionID)
	fmt.Printf("Target tick: %d\n", transaction.Tick)

	return nil
}

[LINCKODE]

Query last tick and it's transactions

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/pkg/errors"
	"io"
	"net/http"
	"time"
)

// Query the last network tick and the transactions in it

const archiverHTTPAddress = "https://testapi.qubic.org"

func RunHTTPExample() error {

	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
	defer cancel()

	httpClient := http.DefaultClient

	// Get Status
	status, err := FetchStatusHTTP(ctx, httpClient, archiverHTTPAddress)
	if err != nil {
		return errors.Wrap(err, "fetching archiver status")
	}

	fmt.Printf("Last processed tick: %d\n", status.LastProcessedTick.TickNumber)
	fmt.Printf("Current epoch: %d\n", status.LastProcessedTick.Epoch)

	// Get transactions in the latest tick

	transactions, err := GetTickTransactionsHTTP(ctx, httpClient, archiverHTTPAddress, status.LastProcessedTick.TickNumber)
	if err != nil {
		return errors.Wrap(err, "fetching tick transactions")
	}

	fmt.Printf("Found %d transactions\n", len(transactions.Transactions))

	for _, transaction := range transactions.Transactions {
		fmt.Printf("  Transaction ID: %s\n", transaction.Transaction.TxId)
		fmt.Printf("  Transfered amount: %s\n", transaction.Transaction.Amount)
		fmt.Printf("  From: %s\n", transaction.Transaction.SourceId)
		fmt.Printf("  To: %s\n", transaction.Transaction.DestId)
		println("-------------------------------")

	}

	return nil

}

func FetchStatusHTTP(ctx context.Context, httpClient *http.Client, baseURL string) (*Status, error) {

	statusRequest, err := http.NewRequestWithContext(ctx, "GET", baseURL+"/v1/status", nil)
	if err != nil {
		return nil, errors.Wrap(err, "creating status request")
	}

	response, err := httpClient.Do(statusRequest)
	if err != nil {
		return nil, errors.Wrap(err, "performing status request")
	}
	defer response.Body.Close()

	data, err := io.ReadAll(response.Body)
	if err != nil {
		return nil, errors.Wrap(err, "reading status response")
	}

	if response.StatusCode != http.StatusOK {
		return nil, errors.New(fmt.Sprintf("Status not 200! Info: %s", data))
	}

	var status Status

	err = json.Unmarshal(data, &status)
	if err != nil {
		return nil, errors.Wrap(err, "un-marshalling status response")
	}

	return &status, nil
}

func GetTickTransactionsHTTP(ctx context.Context, httpClient *http.Client, baseURL string, tickNumber uint32) (*TickTransactions, error) {

	finalURL := fmt.Sprintf(baseURL+"/v2/ticks/%d/transactions?transfers=true", tickNumber)

	tickTransactionsRequest, err := http.NewRequestWithContext(ctx, "GET", finalURL, nil)
	if err != nil {
		return nil, errors.Wrap(err, "creating tick transactions request")
	}

	response, err := httpClient.Do(tickTransactionsRequest)
	if err != nil {
		return nil, errors.Wrap(err, "performing tick transactions request")
	}
	defer response.Body.Close()

	data, err := io.ReadAll(response.Body)
	if err != nil {
		return nil, errors.Wrap(err, "reading tick transactions response")
	}

	if response.StatusCode != http.StatusOK {
		return nil, errors.New(fmt.Sprintf("Status not 200! Info: %s", data))
	}

	var transactions TickTransactions

	err = json.Unmarshal(data, &transactions)
	if err != nil {
		return nil, errors.Wrap(err, "un-marshalling tick transactions response")
	}

	return &transactions, nil

}

type Status struct {
	LastProcessedTick struct {
		TickNumber uint32 `json:"tickNumber"`
		Epoch      uint32 `json:"epoch"`
	} `json:"lastProcessedTick"`
	LastProcessedTicksPerEpoch map[string]uint32 `json:"lastProcessedTicksPerEpoch"`
	SkippedTicks               []struct {
		StartTick uint32 `json:"startTick"`
		EndTick   uint32 `json:"endTick"`
	} `json:"skippedTicks"`
	ProcessedTickIntervalsPerEpoch []struct {
		Epoch     uint32 `json:"epoch"`
		Intervals []struct {
			InitialProcessedTick uint32 `json:"initialProcessedTick"`
			LastProcessedTick    uint32 `json:"lastProcessedTick"`
		} `json:"intervals"`
	}
	EmptyTicksPerEpoch map[string]uint32 `json:"emptyTicksPerEpoch"`
}

type TickTransactions struct {
	Transactions []struct {
		Transaction struct {
			SourceId     string `json:"sourceId"`
			DestId       string `json:"destId"`
			Amount       string `json:"amount"`
			TickNumber   uint32 `json:"tickNumber"`
			InputType    uint32 `json:"inputType"`
			InputSize    uint32 `json:"inputSize"`
			InputHex     string `json:"inputHex"`
			SignatureHex string `json:"signatureHex"`
			TxId         string `json:"txId"`
		} `json:"transaction"`
		Timestamp string `json:"timestamp"`
		MoneyFlew bool   `json:"moneyFlew"`
	} `json:"transactions"`
}

[LINCKODE]

GRPC version of above example

const archiverGRPCAddress = "213.170.135.5:8003"

func RunGRPCExample() error {

	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
	defer cancel()

	// GRPC client creation
	connection, err := grpc.NewClient(archiverGRPCAddress, grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		return errors.Wrap(err, "creating grpc connection")
	}
	defer connection.Close()

	archiverClient := protobuff.NewArchiveServiceClient(connection)

	// Get status
	status, err := FetchStatusGRPC(ctx, archiverClient)
	if err != nil {
		return errors.Wrap(err, "fetching status")
	}

	fmt.Printf("Last processed tick: %d\n", status.LastProcessedTick.TickNumber)
	fmt.Printf("Current epoch: %d\n", status.LastProcessedTick.Epoch)

	// Get transactions in the latest tick

	transactions, err := GetTickTransactionsGRPC(ctx, archiverClient, status.LastProcessedTick.TickNumber, true)
	if err != nil {
		return errors.Wrap(err, "fetching tick transactions")
	}

	fmt.Printf("Found %d transactions\n", len(transactions.Transactions))

	for _, transaction := range transactions.Transactions {
		fmt.Printf("  Transaction ID: %s\n", transaction.Transaction.TxId)
		fmt.Printf("  Transfered amount: %d\n", transaction.Transaction.Amount)
		fmt.Printf("  From: %s\n", transaction.Transaction.SourceId)
		fmt.Printf("  To: %s\n", transaction.Transaction.DestId)
		println("-------------------------------")

	}

	return nil
}

func FetchStatusGRPC(ctx context.Context, archiverClient protobuff.ArchiveServiceClient) (*protobuff.GetStatusResponse, error) {

	result, err := archiverClient.GetStatus(ctx, nil)
	if err != nil {
		return nil, errors.Wrap(err, "performing request")
	}

	return result, nil
}

func GetTickTransactionsGRPC(ctx context.Context, archiverClient protobuff.ArchiveServiceClient, tickNumber uint32, transfersOnly bool) (*protobuff.GetTickTransactionsResponseV2, error) {

	request := protobuff.GetTickTransactionsRequestV2{
		TickNumber: tickNumber,
		// Do not filter, we want to see all transactions
		Approved:  false,
		Transfers: transfersOnly,
	}

	result, err := archiverClient.GetTickTransactionsV2(ctx, &request)
	if err != nil {
		return nil, errors.Wrap(err, "performing request")
	}

	return result, nil

}