diff --git a/api.go b/api.go index 4060496..d4c5f2e 100644 --- a/api.go +++ b/api.go @@ -5,7 +5,6 @@ import ( "git.gammaspectra.live/P2Pool/consensus/v3/monero/randomx" "git.gammaspectra.live/P2Pool/consensus/v3/p2pool/p2p" "git.gammaspectra.live/P2Pool/consensus/v3/p2pool/sidechain" - p2pooltypes "git.gammaspectra.live/P2Pool/consensus/v3/p2pool/types" "git.gammaspectra.live/P2Pool/consensus/v3/types" "git.gammaspectra.live/P2Pool/consensus/v3/utils" "github.com/gorilla/mux" @@ -18,6 +17,15 @@ import ( "time" ) +func addPoolBlockMetadata(writer http.ResponseWriter, b *sidechain.PoolBlock) { + + writer.Header().Add("X-Block-Metadata-Local-Time", b.Metadata.LocalTime.Format(time.RFC3339Nano)) + writer.Header().Add("X-Block-Metadata-Address-Port", b.Metadata.AddressPort.String()) + writer.Header().Add("X-Block-Metadata-Peer-Id", strconv.FormatUint(b.Metadata.PeerId, 10)) + writer.Header().Add("X-Block-Metadata-Software-Id", strconv.FormatUint(uint64(b.Metadata.SoftwareId), 10)) + writer.Header().Add("X-Block-Metadata-Software-Version", strconv.FormatUint(uint64(b.Metadata.SoftwareVersion), 10)) +} + func getServerMux(instance *P2Pool) *mux.Router { serveMux := mux.NewRouter() @@ -27,12 +35,12 @@ func getServerMux(instance *P2Pool) *mux.Router { // ================================= Peering section ================================= serveMux.HandleFunc("/server/peers", func(writer http.ResponseWriter, request *http.Request) { clients := instance.Server().Clients() - result := make([]p2pooltypes.P2PoolServerPeerResult, 0, len(clients)) + result := make([]P2PoolServerPeerResult, 0, len(clients)) for _, c := range clients { if !c.IsGood() { continue } - result = append(result, p2pooltypes.P2PoolServerPeerResult{ + result = append(result, P2PoolServerPeerResult{ Incoming: c.IsIncomingConnection, Address: c.AddressPort.Addr().String(), SoftwareId: c.VersionInformation.SoftwareId.String(), @@ -116,7 +124,7 @@ func getServerMux(instance *P2Pool) *mux.Router { banError = banEntry.Error.Error() } - info := p2pooltypes.P2PoolConnectionCheckInformation[*sidechain.PoolBlock]{ + info := P2PoolConnectionCheckInformation[*sidechain.PoolBlock]{ Address: client.AddressPort.Addr().Unmap().String(), Port: client.AddressPort.Port(), ListenPort: uint16(client.ListenPort.Load()), @@ -160,7 +168,7 @@ func getServerMux(instance *P2Pool) *mux.Router { }) serveMux.HandleFunc("/server/status", func(writer http.ResponseWriter, request *http.Request) { - result := p2pooltypes.P2PoolServerStatusResult{ + result := P2PoolServerStatusResult{ PeerId: instance.Server().PeerId(), SoftwareId: instance.Server().VersionInformation().SoftwareId.String(), SoftwareVersion: instance.Server().VersionInformation().SoftwareVersion.String(), @@ -248,6 +256,58 @@ func getServerMux(instance *P2Pool) *mux.Router { _ = EncodeJson(request, writer, result) } }) + // ================================= Transactions section ================================= + /*serveMux.HandleFunc("/tx/get_mempool_parameters", func(writer http.ResponseWriter, request *http.Request) { + if buf, err := io.ReadAll(request.Body); err != nil { + return + } else { + var txidToLookup []types.Hash + if err = utils.UnmarshalJSON(buf, &txidToLookup); err != nil { + writer.Header().Set("Content-Type", "application/json; charset=utf-8") + writer.WriteHeader(http.StatusInternalServerError) + _, _ = writer.Write([]byte("{}")) + return + } + + mempoolData := make(mempool.Mempool, 0, len(txidToLookup)) + for range + + if result, err := instance.ClientRPC().GetOuts(indicesToLookup...); err != nil { + writer.Header().Set("Content-Type", "application/json; charset=utf-8") + writer.WriteHeader(http.StatusInternalServerError) + _, _ = writer.Write([]byte("{}")) + return + } else { + writer.Header().Set("Content-Type", "application/json; charset=utf-8") + writer.WriteHeader(http.StatusOK) + _ = EncodeJson(request, writer, result) + } + } + })*/ + serveMux.HandleFunc("/tx/get_outs", func(writer http.ResponseWriter, request *http.Request) { + if buf, err := io.ReadAll(request.Body); err != nil { + return + } else { + var indicesToLookup []uint64 + if err = utils.UnmarshalJSON(buf, &indicesToLookup); err != nil { + writer.Header().Set("Content-Type", "application/json; charset=utf-8") + writer.WriteHeader(http.StatusInternalServerError) + _, _ = writer.Write([]byte("{}")) + return + } + + if result, err := instance.ClientRPC().GetOuts(indicesToLookup...); err != nil { + writer.Header().Set("Content-Type", "application/json; charset=utf-8") + writer.WriteHeader(http.StatusInternalServerError) + _, _ = writer.Write([]byte("{}")) + return + } else { + writer.Header().Set("Content-Type", "application/json; charset=utf-8") + writer.WriteHeader(http.StatusOK) + _ = EncodeJson(request, writer, result) + } + } + }) // ================================= SideChain section ================================= serveMux.HandleFunc("/sidechain/consensus", func(writer http.ResponseWriter, request *http.Request) { @@ -258,18 +318,20 @@ func getServerMux(instance *P2Pool) *mux.Router { serveMux.HandleFunc("/sidechain/blocks_by_height/{height:[0-9]+}", func(writer http.ResponseWriter, request *http.Request) { if height, err := strconv.ParseUint(mux.Vars(request)["height"], 10, 0); err == nil { - result := make([]p2pooltypes.P2PoolBinaryBlockResult, 0, 1) + result := make([]P2PoolBinaryBlockResult, 0, 1) for _, b := range instance.SideChain().GetPoolBlocksByHeight(height) { if blob, err := b.AppendBinaryFlags(make([]byte, 0, b.BufferLength()), false, false); err != nil { - result = append(result, p2pooltypes.P2PoolBinaryBlockResult{ + result = append(result, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Error: err.Error(), }) } else { - result = append(result, p2pooltypes.P2PoolBinaryBlockResult{ + result = append(result, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Blob: blob, }) + + addPoolBlockMetadata(writer, b) } } writer.Header().Set("Content-Type", "application/json; charset=utf-8") @@ -283,15 +345,18 @@ func getServerMux(instance *P2Pool) *mux.Router { }) serveMux.HandleFunc("/sidechain/block_by_template_id/{id:[0-9a-f]+}", func(writer http.ResponseWriter, request *http.Request) { if templateId, err := types.HashFromString(mux.Vars(request)["id"]); err == nil { - var result p2pooltypes.P2PoolBinaryBlockResult + var result P2PoolBinaryBlockResult if b := instance.SideChain().GetPoolBlockByTemplateId(templateId); b != nil { result.Version = int(b.ShareVersion()) if blob, err := b.AppendBinaryFlags(make([]byte, 0, b.BufferLength()), false, false); err != nil { result.Error = err.Error() } else { result.Blob = blob + + addPoolBlockMetadata(writer, b) } } + writer.Header().Set("Content-Type", "application/json; charset=utf-8") writer.WriteHeader(http.StatusOK) _ = EncodeJson(request, writer, result) @@ -306,20 +371,20 @@ func getServerMux(instance *P2Pool) *mux.Router { if tip != nil { tipId := instance.SideChain().GetChainTip().SideTemplateId(instance.Consensus()) chain, uncles := instance.SideChain().GetPoolBlocksFromTip(tipId) - result := p2pooltypes.P2PoolSideChainStateResult{ + result := P2PoolSideChainStateResult{ TipHeight: tip.Side.Height, TipId: tipId, - Chain: make([]p2pooltypes.P2PoolBinaryBlockResult, 0, len(chain)), - Uncles: make([]p2pooltypes.P2PoolBinaryBlockResult, 0, len(uncles)), + Chain: make([]P2PoolBinaryBlockResult, 0, len(chain)), + Uncles: make([]P2PoolBinaryBlockResult, 0, len(uncles)), } for _, b := range chain { if blob, err := b.AppendBinaryFlags(make([]byte, 0, b.BufferLength()), false, false); err != nil { - result.Chain = append(result.Chain, p2pooltypes.P2PoolBinaryBlockResult{ + result.Chain = append(result.Chain, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Error: err.Error(), }) } else { - result.Chain = append(result.Chain, p2pooltypes.P2PoolBinaryBlockResult{ + result.Chain = append(result.Chain, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Blob: blob, }) @@ -327,12 +392,12 @@ func getServerMux(instance *P2Pool) *mux.Router { } for _, b := range uncles { if blob, err := b.AppendBinaryFlags(make([]byte, 0, b.BufferLength()), false, false); err != nil { - result.Uncles = append(result.Uncles, p2pooltypes.P2PoolBinaryBlockResult{ + result.Uncles = append(result.Uncles, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Error: err.Error(), }) } else { - result.Uncles = append(result.Uncles, p2pooltypes.P2PoolBinaryBlockResult{ + result.Uncles = append(result.Uncles, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Blob: blob, }) @@ -352,20 +417,20 @@ func getServerMux(instance *P2Pool) *mux.Router { if tip != nil { tipId := instance.SideChain().GetChainTip().SideTemplateId(instance.Consensus()) chain, uncles := instance.SideChain().GetPoolBlocksFromTip(tipId) - result := p2pooltypes.P2PoolSideChainStateResult{ + result := P2PoolSideChainStateResult{ TipHeight: tip.Side.Height, TipId: tipId, - Chain: make([]p2pooltypes.P2PoolBinaryBlockResult, 0, len(chain)), - Uncles: make([]p2pooltypes.P2PoolBinaryBlockResult, 0, len(uncles)), + Chain: make([]P2PoolBinaryBlockResult, 0, len(chain)), + Uncles: make([]P2PoolBinaryBlockResult, 0, len(uncles)), } for _, b := range chain { if blob, err := b.AppendBinaryFlags(make([]byte, 0, b.BufferLength()), false, false); err != nil { - result.Chain = append(result.Chain, p2pooltypes.P2PoolBinaryBlockResult{ + result.Chain = append(result.Chain, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Error: err.Error(), }) } else { - result.Chain = append(result.Chain, p2pooltypes.P2PoolBinaryBlockResult{ + result.Chain = append(result.Chain, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Blob: blob, }) @@ -373,17 +438,18 @@ func getServerMux(instance *P2Pool) *mux.Router { } for _, b := range uncles { if blob, err := b.AppendBinaryFlags(make([]byte, 0, b.BufferLength()), false, false); err != nil { - result.Uncles = append(result.Uncles, p2pooltypes.P2PoolBinaryBlockResult{ + result.Uncles = append(result.Uncles, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Error: err.Error(), }) } else { - result.Uncles = append(result.Uncles, p2pooltypes.P2PoolBinaryBlockResult{ + result.Uncles = append(result.Uncles, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Blob: blob, }) } } + writer.Header().Set("Content-Type", "application/json; charset=utf-8") writer.WriteHeader(http.StatusOK) _ = EncodeJson(request, writer, result) @@ -399,20 +465,20 @@ func getServerMux(instance *P2Pool) *mux.Router { if tip != nil { tipId := tip.SideTemplateId(instance.Consensus()) chain, uncles := instance.SideChain().GetPoolBlocksFromTip(tipId) - result := p2pooltypes.P2PoolSideChainStateResult{ + result := P2PoolSideChainStateResult{ TipHeight: tip.Side.Height, TipId: tipId, - Chain: make([]p2pooltypes.P2PoolBinaryBlockResult, 0, len(chain)), - Uncles: make([]p2pooltypes.P2PoolBinaryBlockResult, 0, len(uncles)), + Chain: make([]P2PoolBinaryBlockResult, 0, len(chain)), + Uncles: make([]P2PoolBinaryBlockResult, 0, len(uncles)), } for _, b := range chain { if blob, err := b.AppendBinaryFlags(make([]byte, 0, b.BufferLength()), false, false); err != nil { - result.Chain = append(result.Chain, p2pooltypes.P2PoolBinaryBlockResult{ + result.Chain = append(result.Chain, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Error: err.Error(), }) } else { - result.Chain = append(result.Chain, p2pooltypes.P2PoolBinaryBlockResult{ + result.Chain = append(result.Chain, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Blob: blob, }) @@ -420,17 +486,20 @@ func getServerMux(instance *P2Pool) *mux.Router { } for _, b := range uncles { if blob, err := b.AppendBinaryFlags(make([]byte, 0, b.BufferLength()), false, false); err != nil { - result.Uncles = append(result.Uncles, p2pooltypes.P2PoolBinaryBlockResult{ + result.Uncles = append(result.Uncles, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Error: err.Error(), }) } else { - result.Uncles = append(result.Uncles, p2pooltypes.P2PoolBinaryBlockResult{ + result.Uncles = append(result.Uncles, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Blob: blob, }) } } + + addPoolBlockMetadata(writer, tip) + writer.Header().Set("Content-Type", "application/json; charset=utf-8") writer.WriteHeader(http.StatusOK) _ = EncodeJson(request, writer, result) @@ -446,21 +515,24 @@ func getServerMux(instance *P2Pool) *mux.Router { } }) serveMux.HandleFunc("/sidechain/tip", func(writer http.ResponseWriter, request *http.Request) { - var result p2pooltypes.P2PoolBinaryBlockResult + var result P2PoolBinaryBlockResult if b := instance.SideChain().GetChainTip(); b != nil { result.Version = int(b.ShareVersion()) if blob, err := b.AppendBinaryFlags(make([]byte, 0, b.BufferLength()), false, false); err != nil { result.Error = err.Error() } else { result.Blob = blob + + addPoolBlockMetadata(writer, b) } } + writer.Header().Set("Content-Type", "application/json; charset=utf-8") writer.WriteHeader(http.StatusOK) _ = EncodeJson(request, writer, result) }) serveMux.HandleFunc("/sidechain/status", func(writer http.ResponseWriter, request *http.Request) { - result := p2pooltypes.P2PoolSideChainStatusResult{ + result := P2PoolSideChainStatusResult{ Synchronized: instance.SideChain().PreCalcFinished(), Blocks: instance.SideChain().GetPoolBlockCount(), } @@ -528,11 +600,11 @@ func getServerMux(instance *P2Pool) *mux.Router { defer preAllocatedSharesPool.Put(preAllocatedShares) if _, err = tip.PreProcessBlock(instance.Consensus(), instance.SideChain().DerivationCache(), preAllocatedShares, instance.GetDifficultyByHeight, getByTemplateId); err == nil { - result := p2pooltypes.P2PoolSideChainStateResult{ + result := P2PoolSideChainStateResult{ TipHeight: tip.Side.Height, TipId: tip.SideTemplateId(instance.Consensus()), - Chain: make([]p2pooltypes.P2PoolBinaryBlockResult, 0, expectedBlocks), - Uncles: make([]p2pooltypes.P2PoolBinaryBlockResult, 0, expectedBlocks/5), + Chain: make([]P2PoolBinaryBlockResult, 0, expectedBlocks), + Uncles: make([]P2PoolBinaryBlockResult, 0, expectedBlocks/5), } var topError error @@ -540,18 +612,18 @@ func getServerMux(instance *P2Pool) *mux.Router { topError = sidechain.IterateBlocksInPPLNSWindow(tip, instance.Consensus(), instance.GetDifficultyByHeight, getByTemplateId, nil, func(e sidechain.PoolBlockWindowSlot) { if _, err = e.Block.PreProcessBlock(instance.Consensus(), instance.SideChain().DerivationCache(), preAllocatedShares, instance.GetDifficultyByHeight, getByTemplateId); err != nil { topError = err - result.Chain = append(result.Chain, p2pooltypes.P2PoolBinaryBlockResult{ + result.Chain = append(result.Chain, P2PoolBinaryBlockResult{ Version: int(e.Block.ShareVersion()), Error: err.Error(), }) } else if blob, err := e.Block.AppendBinaryFlags(make([]byte, 0, e.Block.BufferLength()), false, false); err != nil { topError = err - result.Chain = append(result.Chain, p2pooltypes.P2PoolBinaryBlockResult{ + result.Chain = append(result.Chain, P2PoolBinaryBlockResult{ Version: int(e.Block.ShareVersion()), Error: err.Error(), }) } else { - result.Chain = append(result.Chain, p2pooltypes.P2PoolBinaryBlockResult{ + result.Chain = append(result.Chain, P2PoolBinaryBlockResult{ Version: int(e.Block.ShareVersion()), Blob: blob, }) @@ -560,18 +632,18 @@ func getServerMux(instance *P2Pool) *mux.Router { for _, u := range e.Uncles { if _, err = u.PreProcessBlock(instance.Consensus(), instance.SideChain().DerivationCache(), preAllocatedShares, instance.GetDifficultyByHeight, getByTemplateId); err != nil { topError = err - result.Uncles = append(result.Uncles, p2pooltypes.P2PoolBinaryBlockResult{ + result.Uncles = append(result.Uncles, P2PoolBinaryBlockResult{ Version: int(u.ShareVersion()), Error: err.Error(), }) } else if blob, err := u.AppendBinaryFlags(make([]byte, 0, u.BufferLength()), false, false); err != nil { topError = err - result.Uncles = append(result.Uncles, p2pooltypes.P2PoolBinaryBlockResult{ + result.Uncles = append(result.Uncles, P2PoolBinaryBlockResult{ Version: int(u.ShareVersion()), Error: err.Error(), }) } else { - result.Uncles = append(result.Uncles, p2pooltypes.P2PoolBinaryBlockResult{ + result.Uncles = append(result.Uncles, P2PoolBinaryBlockResult{ Version: int(u.ShareVersion()), Blob: blob, }) @@ -659,20 +731,23 @@ func getServerMux(instance *P2Pool) *mux.Router { }) serveMux.HandleFunc("/archive/blocks_by_template_id/{id:[0-9a-f]+}", func(writer http.ResponseWriter, request *http.Request) { if templateId, err := types.HashFromString(mux.Vars(request)["id"]); err == nil { - result := make([]p2pooltypes.P2PoolBinaryBlockResult, 0, 1) + result := make([]P2PoolBinaryBlockResult, 0, 1) for _, b := range archiveCache.LoadByTemplateId(templateId) { if err := archiveCache.ProcessBlock(b); err != nil { - result = append(result, p2pooltypes.P2PoolBinaryBlockResult{ + result = append(result, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Error: err.Error(), }) } else if blob, err := b.AppendBinaryFlags(make([]byte, 0, b.BufferLength()), false, false); err != nil { - result = append(result, p2pooltypes.P2PoolBinaryBlockResult{ + result = append(result, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Error: err.Error(), }) } else { - result = append(result, p2pooltypes.P2PoolBinaryBlockResult{ + + addPoolBlockMetadata(writer, b) + + result = append(result, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Blob: blob, }) @@ -689,20 +764,23 @@ func getServerMux(instance *P2Pool) *mux.Router { }) serveMux.HandleFunc("/archive/blocks_by_side_height/{height:[0-9]+}", func(writer http.ResponseWriter, request *http.Request) { if height, err := strconv.ParseUint(mux.Vars(request)["height"], 10, 0); err == nil { - result := make([]p2pooltypes.P2PoolBinaryBlockResult, 0, 1) + result := make([]P2PoolBinaryBlockResult, 0, 1) for _, b := range archiveCache.LoadBySideChainHeight(height) { if err := archiveCache.ProcessBlock(b); err != nil { - result = append(result, p2pooltypes.P2PoolBinaryBlockResult{ + result = append(result, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Error: err.Error(), }) } else if blob, err := b.AppendBinaryFlags(make([]byte, 0, b.BufferLength()), false, false); err != nil { - result = append(result, p2pooltypes.P2PoolBinaryBlockResult{ + result = append(result, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Error: err.Error(), }) } else { - result = append(result, p2pooltypes.P2PoolBinaryBlockResult{ + + addPoolBlockMetadata(writer, b) + + result = append(result, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Blob: blob, }) @@ -721,12 +799,18 @@ func getServerMux(instance *P2Pool) *mux.Router { serveMux.HandleFunc("/archive/light_blocks_by_main_height/{height:[0-9]+}", func(writer http.ResponseWriter, request *http.Request) { if height, err := strconv.ParseUint(mux.Vars(request)["height"], 10, 0); err == nil { if blocks := archiveCache.LoadByMainChainHeight(height); len(blocks) > 0 { + + for _, b := range blocks { + addPoolBlockMetadata(writer, b) + } + writer.Header().Set("Content-Type", "application/json; charset=utf-8") writer.WriteHeader(http.StatusOK) _ = EncodeJson(request, writer, blocks) } else { writer.Header().Set("Content-Type", "application/json; charset=utf-8") writer.WriteHeader(http.StatusNotFound) + if blocks == nil { blocks = make(sidechain.UniquePoolBlockSlice, 0) } @@ -742,6 +826,11 @@ func getServerMux(instance *P2Pool) *mux.Router { serveMux.HandleFunc("/archive/light_blocks_by_side_height/{height:[0-9]+}", func(writer http.ResponseWriter, request *http.Request) { if height, err := strconv.ParseUint(mux.Vars(request)["height"], 10, 0); err == nil { if blocks := archiveCache.LoadBySideChainHeight(height); len(blocks) > 0 { + + for _, b := range blocks { + addPoolBlockMetadata(writer, b) + } + writer.Header().Set("Content-Type", "application/json; charset=utf-8") writer.WriteHeader(http.StatusOK) _ = EncodeJson(request, writer, blocks) @@ -763,6 +852,11 @@ func getServerMux(instance *P2Pool) *mux.Router { serveMux.HandleFunc("/archive/light_blocks_by_template_id/{id:[0-9a-f]+}", func(writer http.ResponseWriter, request *http.Request) { if mainId, err := types.HashFromString(mux.Vars(request)["id"]); err == nil { if blocks := archiveCache.LoadByTemplateId(mainId); len(blocks) > 0 { + + for _, b := range blocks { + addPoolBlockMetadata(writer, b) + } + writer.Header().Set("Content-Type", "application/json; charset=utf-8") writer.WriteHeader(http.StatusOK) _ = EncodeJson(request, writer, blocks) @@ -806,6 +900,8 @@ func getServerMux(instance *P2Pool) *mux.Router { } if b != nil { + addPoolBlockMetadata(writer, b) + writer.Header().Set("Content-Type", "application/json; charset=utf-8") writer.WriteHeader(http.StatusOK) _ = EncodeJson(request, writer, b) @@ -832,7 +928,7 @@ func getServerMux(instance *P2Pool) *mux.Router { } if mainId, err := types.HashFromString(mux.Vars(request)["id"]); err == nil { - var result p2pooltypes.P2PoolBinaryBlockResult + var result P2PoolBinaryBlockResult var b *sidechain.PoolBlock if templateIdHint != types.ZeroHash { // Fast lookup on sidechain @@ -855,6 +951,8 @@ func getServerMux(instance *P2Pool) *mux.Router { result.Error = err.Error() } else { result.Blob = blob + + addPoolBlockMetadata(writer, b) } } } @@ -869,23 +967,24 @@ func getServerMux(instance *P2Pool) *mux.Router { }) serveMux.HandleFunc("/archive/blocks_by_main_height/{height:[0-9]+}", func(writer http.ResponseWriter, request *http.Request) { if height, err := strconv.ParseUint(mux.Vars(request)["height"], 10, 0); err == nil { - result := make([]p2pooltypes.P2PoolBinaryBlockResult, 0, 1) + result := make([]P2PoolBinaryBlockResult, 0, 1) for _, b := range archiveCache.LoadByMainChainHeight(height) { if err := archiveCache.ProcessBlock(b); err != nil { - result = append(result, p2pooltypes.P2PoolBinaryBlockResult{ + result = append(result, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Error: err.Error(), }) } else if blob, err := b.AppendBinaryFlags(make([]byte, 0, b.BufferLength()), false, false); err != nil { - result = append(result, p2pooltypes.P2PoolBinaryBlockResult{ + result = append(result, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Error: err.Error(), }) } else { - result = append(result, p2pooltypes.P2PoolBinaryBlockResult{ + result = append(result, P2PoolBinaryBlockResult{ Version: int(b.ShareVersion()), Blob: blob, }) + addPoolBlockMetadata(writer, b) } } writer.Header().Set("Content-Type", "application/json; charset=utf-8") diff --git a/go.mod b/go.mod index ea7c74c..546f8fe 100644 --- a/go.mod +++ b/go.mod @@ -3,23 +3,22 @@ module git.gammaspectra.live/P2Pool/go-p2pool/v3 go 1.22 require ( - git.gammaspectra.live/P2Pool/consensus/v3 v3.5.0 - git.gammaspectra.live/P2Pool/observer-cache-archive v0.0.0-20240410025539-c7b42267c7e4 + git.gammaspectra.live/P2Pool/consensus/v3 v3.6.3 + git.gammaspectra.live/P2Pool/observer-cache-archive v0.0.0-20240413050335-08f79500c0c1 github.com/gorilla/mux v1.8.1 ) require ( git.gammaspectra.live/P2Pool/edwards25519 v0.0.0-20240405085108-e2f706cb5c00 // indirect - git.gammaspectra.live/P2Pool/go-randomx/v2 v2.0.0 // indirect + git.gammaspectra.live/P2Pool/go-randomx/v2 v2.1.0 // indirect git.gammaspectra.live/P2Pool/monero-base58 v1.0.0 // indirect git.gammaspectra.live/P2Pool/randomx-go-bindings v1.0.0 // indirect git.gammaspectra.live/P2Pool/sha3 v0.17.0 // indirect - github.com/bahlo/generic-list-go v0.2.0 // indirect github.com/dolthub/maphash v0.1.0 // indirect github.com/dolthub/swiss v0.2.2-0.20240312182618-f4b2babd2bc1 // indirect - github.com/floatdrop/lru v1.3.0 // indirect github.com/go-zeromq/zmq4 v0.16.1-0.20240124085909-e75c615ba1b3 // indirect github.com/goccy/go-json v0.10.2 // indirect + github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc // indirect go.etcd.io/bbolt v1.3.9 // indirect golang.org/x/crypto v0.22.0 // indirect diff --git a/go.sum b/go.sum index 2191c84..435a59c 100644 --- a/go.sum +++ b/go.sum @@ -1,13 +1,13 @@ -git.gammaspectra.live/P2Pool/consensus/v3 v3.5.0 h1:PEJSUFVHCSdazKQ6qVRH1ssSFzjbCb7VaGIUsdVe7Ho= -git.gammaspectra.live/P2Pool/consensus/v3 v3.5.0/go.mod h1:Fs4fDVLBjmb7C0J44DiRkRm8/XUwqpgP78u0GGNidXE= +git.gammaspectra.live/P2Pool/consensus/v3 v3.6.3 h1:bDCJzl5Rm2VfSrRY7gLVzK43Y8JxznTTgZvpHcFmDnE= +git.gammaspectra.live/P2Pool/consensus/v3 v3.6.3/go.mod h1:3mjTaEx2Hm9VUs0rZIjCAFV6fToNxnVDj616NEc9Y0I= git.gammaspectra.live/P2Pool/edwards25519 v0.0.0-20240405085108-e2f706cb5c00 h1:mDQY337iKB+kle5RYWL5CoAz+3DmnkAh/B2XD8B+PFk= git.gammaspectra.live/P2Pool/edwards25519 v0.0.0-20240405085108-e2f706cb5c00/go.mod h1:FZsrMWGucMP3SZamzrd7m562geIs5zp1O/9MGoiAKH0= -git.gammaspectra.live/P2Pool/go-randomx/v2 v2.0.0 h1:lHi2z8Nz3H1Xpu1p53TYccz072BDhbJGNHquiX9orCM= -git.gammaspectra.live/P2Pool/go-randomx/v2 v2.0.0/go.mod h1:vNmHlEIRAcU/bA85mxbUKEiBYtrtS4MVwozf29KmoHM= +git.gammaspectra.live/P2Pool/go-randomx/v2 v2.1.0 h1:L1fV2XBYFmpFU+JKP/7fsgDm2Lfh9yFlS+800v+3OsM= +git.gammaspectra.live/P2Pool/go-randomx/v2 v2.1.0/go.mod h1:vNmHlEIRAcU/bA85mxbUKEiBYtrtS4MVwozf29KmoHM= git.gammaspectra.live/P2Pool/monero-base58 v1.0.0 h1:s8LZxVNc93YEs2NCCNWZ7CKr8RbEb031y6Wkvhn+TS4= git.gammaspectra.live/P2Pool/monero-base58 v1.0.0/go.mod h1:WWEJy/AdWKxKAruvlKI82brw+DtVlePy0ct3ZiBlc68= -git.gammaspectra.live/P2Pool/observer-cache-archive v0.0.0-20240410025539-c7b42267c7e4 h1:zTe7EUZ9yqtwLhZZ1liOM/1uDWhWHQkncAYid8BPMJ4= -git.gammaspectra.live/P2Pool/observer-cache-archive v0.0.0-20240410025539-c7b42267c7e4/go.mod h1:+yi64YRM+zRsgCxgg4SCCfpwTytwG/bix0Erigke0kA= +git.gammaspectra.live/P2Pool/observer-cache-archive v0.0.0-20240413050335-08f79500c0c1 h1:yWgIcGlYLq2N0WjuudNYh/jZYlcHOJhAXUZW+3HB2DI= +git.gammaspectra.live/P2Pool/observer-cache-archive v0.0.0-20240413050335-08f79500c0c1/go.mod h1:cddKgXQGmnRa/2wO4k9oenReuKSYAiWLxH4WA3OD/QY= git.gammaspectra.live/P2Pool/randomx-go-bindings v1.0.0 h1:tajr4QFSPrb8NtHmU14JaXdhr+z+0RbOBLIgUDI5Tow= git.gammaspectra.live/P2Pool/randomx-go-bindings v1.0.0/go.mod h1:S17NNidG5hxqaVLsSykKqDBg/hTPSzP0KcSwXfH8WIA= git.gammaspectra.live/P2Pool/sha3 v0.17.0 h1:CZpB466LPbNVQrUNjQTtQScGDc30xSMkZ6Bmw0W9VuM= @@ -16,18 +16,16 @@ git.gammaspectra.live/P2Pool/zmq4 v0.16.1-0.20240407153747-7f7d531f586e h1:U6zpC git.gammaspectra.live/P2Pool/zmq4 v0.16.1-0.20240407153747-7f7d531f586e/go.mod h1:AOWpIfDC+phUiEeiZRXf5oth8YLsfLtflF+6BJNagi4= github.com/WeebDataHoarder/go-json v0.0.0-20230730135821-d8f6463bb887 h1:P01nqSM+0b6zlPasOFYsqnQSP2dTRVZkanAnY9q/Bcc= github.com/WeebDataHoarder/go-json v0.0.0-20230730135821-d8f6463bb887/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= -github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk= -github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dolthub/maphash v0.1.0 h1:bsQ7JsF4FkkWyrP3oCnFJgrCUAFbFf3kOl4L/QxPDyQ= github.com/dolthub/maphash v0.1.0/go.mod h1:gkg4Ch4CdCDu5h6PMriVLawB7koZ+5ijb9puGMV50a4= github.com/dolthub/swiss v0.2.2-0.20240312182618-f4b2babd2bc1 h1:F7u1ZVCidajlPuJJzdL5REPHfLO/O6xLQRUw/YMxrkM= github.com/dolthub/swiss v0.2.2-0.20240312182618-f4b2babd2bc1/go.mod h1:8AhKZZ1HK7g18j7v7k6c5cYIGEZJcPn0ARsai8cUrh0= -github.com/floatdrop/lru v1.3.0 h1:83abtaKjXcWrPmtzTAk2Ggq8DUKqI29YzrTrB8+vu0c= -github.com/floatdrop/lru v1.3.0/go.mod h1:83zlXKA06Bm32JImNINCiTr0ldadvdAjUe5jSwIaw0s= github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= +github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= +github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= diff --git a/main.go b/main.go index 8c6d2a5..bc7a2fb 100644 --- a/main.go +++ b/main.go @@ -182,7 +182,9 @@ func main() { if *stratumListen != "" { stratumServer := stratum.NewServer(instance.SideChain(), func(block *sidechain.PoolBlock) error { block.WantBroadcast.Store(true) - block.LocalTimestamp = uint64(time.Now().Unix()) + block.Metadata = sidechain.PoolBlockReceptionMetadata{ + LocalTime: time.Now().UTC(), + } if _, err, _ := instance.SideChain().AddPoolBlockExternal(block); err != nil { log.Printf("[Stratum] ERROR: Submitted block template id = %s, side height = %d, main height = %d, main_id = %s, nonce = %d, extra_nonce = %d add_pool_block_external error: %s", block.SideTemplateId(instance.Consensus()), block.Side.Height, block.Main.Coinbase.GenHeight, block.MainId(), block.Main.Nonce, block.ExtraNonce(), err) return err diff --git a/types.go b/types.go new file mode 100644 index 0000000..72bb376 --- /dev/null +++ b/types.go @@ -0,0 +1,77 @@ +package main + +import ( + "git.gammaspectra.live/P2Pool/consensus/v3/types" +) + +type P2PoolSideChainStateResult struct { + TipHeight uint64 `json:"tip_height"` + TipId types.Hash `json:"tip_id"` + Chain []P2PoolBinaryBlockResult `json:"chain"` + Uncles []P2PoolBinaryBlockResult `json:"uncles"` +} + +type P2PoolBinaryBlockResult struct { + Version int `json:"version"` + Blob types.Bytes `json:"blob"` + Error string `json:"error,omitempty"` +} + +type P2PoolSpecialBinaryBlockResult struct { + Version int `json:"version"` + Blob types.Bytes `json:"blob"` + Error string `json:"error,omitempty"` +} + +type P2PoolSideChainStatusResult struct { + Synchronized bool `json:"synchronized"` + Height uint64 `json:"tip_height"` + Id types.Hash `json:"tip_id"` + Difficulty types.Difficulty `json:"difficulty"` + CumulativeDifficulty types.Difficulty `json:"cumulative_difficulty"` + Blocks int `json:"blocks"` +} + +type P2PoolServerStatusResult struct { + PeerId uint64 `json:"peer_id"` + SoftwareId string `json:"software_id"` + SoftwareVersion string `json:"software_version"` + ProtocolVersion string `json:"protocol_version"` + ListenPort uint16 `json:"listen_port"` +} + +type P2PoolServerPeerResult struct { + PeerId uint64 `json:"peer_id"` + Incoming bool `json:"incoming"` + Address string `json:"address"` + SoftwareId string `json:"software_id"` + SoftwareVersion string `json:"software_version"` + ProtocolVersion string `json:"protocol_version"` + ConnectionTime uint64 `json:"connection_time"` + ListenPort uint32 `json:"listen_port"` + Latency uint64 `json:"latency"` +} + +type P2PoolConnectionCheckInformation[TipType any] struct { + Address string `json:"address"` + Port uint16 `json:"port"` + ListenPort uint16 `json:"listen_port"` + PeerId uint64 `json:"peer_id"` + SoftwareId string `json:"software_id"` + SoftwareVersion string `json:"software_version"` + ProtocolVersion string `json:"protocol_version"` + ConnectionTime uint64 `json:"connection_time"` + Latency uint64 `json:"latency"` + LastActive uint64 `json:"last_active"` + Incoming bool `json:"incoming"` + BroadcastTime uint64 `json:"broadcast_time"` + BroadcastHeight uint64 `json:"broadcast_height"` + // Tip is a sidechain.PoolBlock + Tip TipType `json:"tip,omitempty"` + Closed bool `json:"closed"` + AlreadyConnected bool `json:"already_connected"` + HandshakeComplete bool `json:"handshake_complete"` + Banned bool `json:"banned"` + Error string `json:"error,omitempty"` + BanError string `json:"ban_error,omitempty"` +}