New API functions #1:

/blockchain/self/header
/blockchain/self/append
/blockchain/self/read
/blockchain/self/add/file

The local blockchain now works, files metadata can be added and blocks read and decoded successfully.

API.go

@@ -11,8 +11,10 @@ import (
 	"crypto/tls"
 	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"log"
 	"net/http"
+	"strconv"
 	"time"
 
 	"github.com/PeernetOfficial/core"
@@ -36,6 +38,10 @@ func startAPI() {
 	router.HandleFunc("/status", apiStatus).Methods("GET")
 	router.HandleFunc("/peer/self", apiPeerSelf).Methods("GET")
 	router.HandleFunc("/console", apiConsole).Methods("GET")
+	router.HandleFunc("/blockchain/self/header", apiBlockchainSelfHeader).Methods("GET")
+	router.HandleFunc("/blockchain/self/append", apiBlockchainSelfAppend).Methods("POST")
+	router.HandleFunc("/blockchain/self/read", apiBlockchainSelfRead).Methods("GET")
+	router.HandleFunc("/blockchain/self/add/file", apiBlockchainSelfAddFile).Methods("POST")
 
 	for _, listen := range config.APIListen {
 		go startWebServer(listen, config.APIUseSSL, config.APICertificateFile, config.APICertificateKey, router, "API", parseDuration(config.APITimeoutRead), parseDuration(config.APITimeoutWrite))
@@ -85,6 +91,23 @@ func apiEncodeJSON(w http.ResponseWriter, r *http.Request, data interface{}) (er
 	return err
 }
 
+// apiDecodeJSON decodes input JSON data server side sent either via GET or POST. It does not limit the maximum amount to read.
+// In case of error it will automatically send an error to the client.
+func apiDecodeJSON(w http.ResponseWriter, r *http.Request, data interface{}) (err error) {
+	if r.Body == nil {
+		http.Error(w, "", http.StatusBadRequest)
+		return errors.New("no data")
+	}
+
+	err = json.NewDecoder(r.Body).Decode(data)
+	if err != nil {
+		http.Error(w, "", http.StatusBadRequest)
+		return err
+	}
+
+	return nil
+}
+
 func apiTest(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusOK)
 	w.Write([]byte("ok"))
@@ -94,6 +117,9 @@ type apiResponseStatus struct {
 	Status        int  `json:"status"`        // Status code: 0 = Ok.
 	IsConnected   bool `json:"isconnected"`   // Whether connected to Peernet.
 	CountPeerList int  `json:"countpeerlist"` // Count of peers in the peer list. Note that this contains peers that are considered inactive, but have not yet been removed from the list.
+	CountNetwork  int  `json:"countnetwork"`  // Count of total peers in the network.
+	// This is usually a higher number than CountPeerList, which just represents the current number of connected peers.
+	// The CountNetwork number is going to be queried from root peers which may or may not have a limited view.
 }
 
 /* apiStatus returns the current connectivity status to the network
@@ -102,6 +128,7 @@ Result:     200 with JSON structure Status
 */
 func apiStatus(w http.ResponseWriter, r *http.Request) {
 	status := apiResponseStatus{Status: 0, CountPeerList: core.PeerlistCount()}
+	status.CountNetwork = status.CountPeerList // For now always same as CountPeerList, until native Statistics message to root peers is available.
 
 	// Connected: If at leat 2 peers.
 	// This metric needs to be improved in the future, as root peers never disconnect.
@@ -188,3 +215,156 @@ func apiConsole(w http.ResponseWriter, r *http.Request) {
 		bufferR.Write(message)
 	}
 }
+
+type apiBlockchainHeader struct {
+	PeerID  string `json:"peerid"`  // Peer ID hex encoded.
+	Version uint64 `json:"version"` // Current version number of the blockchain.
+	Height  uint64 `json:"height"`  // Height of the blockchain (number of blocks). If 0, no data exists.
+}
+
+/*
+apiBlockchainSelfHeader returns the current blockchain header information
+
+Request:    GET /blockchain/self/header
+Result:     200 with JSON structure apiResponsePeerSelf
+*/
+func apiBlockchainSelfHeader(w http.ResponseWriter, r *http.Request) {
+	publicKey, height, version := core.UserBlockchainHeader()
+
+	apiEncodeJSON(w, r, apiBlockchainHeader{Version: version, Height: height, PeerID: hex.EncodeToString(publicKey.SerializeCompressed())})
+}
+
+type apiBlockRecordRaw struct {
+	Type uint8  `json:"type"` // Record Type. See core.RecordTypeX.
+	Data []byte `json:"data"` // Data according to the type.
+}
+
+// apiBlockchainBlockRaw contains a raw block of the blockchain via API
+type apiBlockchainBlockRaw struct {
+	Records []apiBlockRecordRaw `json:"records"` // Block records in encoded raw format.
+}
+
+type apiBlockchainBlockStatus struct {
+	Status int    `json:"status"` // Status: 0 = Success, 1 = Error invalid data
+	Height uint64 `json:"height"` // New height of the blockchain (number of blocks).
+}
+
+/*
+apiBlockchainSelfAppend appends a block to the blockchain. This is a low-level function for already encoded blocks.
+Do not use this function. Adding invalid data to the blockchain may corrupt it which might result in blacklisting by other peers.
+
+Request:    POST /blockchain/self/append with JSON structure apiBlockchainBlockRaw
+Response:   200 with JSON structure apiBlockchainBlockStatus
+*/
+func apiBlockchainSelfAppend(w http.ResponseWriter, r *http.Request) {
+	var input apiBlockchainBlockRaw
+	if err := apiDecodeJSON(w, r, &input); err != nil {
+		return
+	}
+
+	var records []core.BlockRecordRaw
+
+	for _, record := range input.Records {
+		records = append(records, core.BlockRecordRaw{Type: record.Type, Data: record.Data})
+	}
+
+	newHeight, status := core.UserBlockchainAppend(records)
+
+	apiEncodeJSON(w, r, apiBlockchainBlockStatus{Status: status, Height: newHeight})
+}
+
+type apiBlockchainBlock struct {
+	Status            int                 `json:"status"`            // Status: 0 = Success, 1 = Error block not found, 2 = Error block encoding (indicates that the blockchain is corrupt)
+	PeerID            string              `json:"peerid"`            // Peer ID hex encoded.
+	LastBlockHash     []byte              `json:"lastblockhash"`     // Hash of the last block. Blake3.
+	BlockchainVersion uint64              `json:"blockchainversion"` // Blockchain version
+	Number            uint64              `json:"blocknumber"`       // Block number
+	RecordsRaw        []apiBlockRecordRaw `json:"recordsraw"`        // Block records raw. Successfully decoded records are parsed into the below fields.
+	Decoded           struct {
+		User  apiBlockRecordUser   `json:"user"`  // User details
+		Files []apiBlockRecordFile `json:"files"` // Files
+	} `json:"decoded"`
+}
+
+// apiBlockRecordUser specifies user information
+type apiBlockRecordUser struct {
+	NameValid     bool   `json:"namevalid"`     // Whether the name is supplied in this structure.
+	Name          string `json:"name"`          // Arbitrary name of the user.
+	NameSanitized string `json:"namesanitized"` // Sanitized version of the name.
+}
+
+// apiBlockRecordFile is the metadata of a file published on the blockchain
+type apiBlockRecordFile struct {
+	Hash      []byte `json:"hash"`      // Blake3 hash of the file data
+	Type      uint8  `json:"type"`      // Type (low-level)
+	Format    uint16 `json:"format"`    // Format (high-level)
+	Size      uint64 `json:"size"`      // Size of the file
+	Directory string `json:"directory"` // Directory
+	Name      string `json:"name"`      // File name
+}
+
+/*
+apiBlockchainSelfRead reads a block and returns the decoded information.
+
+Request:    GET /blockchain/self/read?block=[number]
+Result:     200 with JSON structure apiBlockchainBlock
+*/
+func apiBlockchainSelfRead(w http.ResponseWriter, r *http.Request) {
+	r.ParseForm()
+	blockN, err := strconv.Atoi(r.Form.Get("block"))
+	if err != nil || blockN < 0 {
+		http.Error(w, "", http.StatusBadRequest)
+		return
+	}
+
+	block, status := core.UserBlockchainRead(uint64(blockN))
+	result := apiBlockchainBlock{Status: status}
+
+	if status == 0 {
+		for _, record := range block.RecordsRaw {
+			result.RecordsRaw = append(result.RecordsRaw, apiBlockRecordRaw{Type: record.Type, Data: record.Data})
+		}
+
+		result.PeerID = hex.EncodeToString(block.OwnerPublicKey.SerializeCompressed())
+
+		if block.User.Valid {
+			result.Decoded.User.NameValid = true
+			result.Decoded.User.Name = block.User.Name
+			result.Decoded.User.NameSanitized = block.User.NameS
+		}
+
+		for _, file := range block.Files {
+			result.Decoded.Files = append(result.Decoded.Files, apiBlockRecordFile{Hash: file.Hash, Type: file.Type, Format: file.Format, Size: file.Size, Directory: file.Directory, Name: file.Name})
+		}
+	}
+
+	apiEncodeJSON(w, r, result)
+}
+
+// apiBlockAddFiles contains the file metadata to add to the blockchain
+type apiBlockAddFiles struct {
+	Files []apiBlockRecordFile `json:"files"`
+}
+
+/*
+apiBlockchainSelfAddFile adds a file with the provided information to the blockchain.
+
+Request:    POST /blockchain/self/add/file with JSON structure apiBlockAddFiles
+Response:   200 with JSON structure apiBlockchainBlockStatus
+*/
+func apiBlockchainSelfAddFile(w http.ResponseWriter, r *http.Request) {
+	var input apiBlockAddFiles
+	if err := apiDecodeJSON(w, r, &input); err != nil {
+		return
+	}
+
+	var files []core.BlockRecordFile
+
+	for _, file := range input.Files {
+		files = append(files, core.BlockRecordFile{Hash: file.Hash, Type: file.Type, Format: file.Format, Size: file.Size, Directory: file.Directory, Name: file.Name})
+	}
+
+	newHeight, status := core.UserBlockchainAddFiles(files)
+
+	apiEncodeJSON(w, r, apiBlockchainBlockStatus{Status: status, Height: newHeight})
+}