mirror of
https://github.com/luxfi/node.git
synced 2026-07-27 03:39:39 +00:00
Hanzo AI
6de839a515
Wave 1D of the luxfi/codec final rip: leaf-misc tier under node/.
This batch removes the direct codec/wrappers, codec/linearcodec, and
codec.Manager imports from p2p network protocol, IP/port encoding,
indexer/keystore on-disk storage, warp socket IPC, x/archivedb +
merkledb internals, and the primary-network wallet UTXO loader.
Migration shape:
(a) codec/wrappers.Packer + length constants
→ node/utils/wrappers (same shape, already in tree as the local
canonical home for binary IO helpers). 14 files: indexer/,
network/, utils/ips/, utils/metric/, warp/, x/.
(b) codec.Manager + linearcodec for on-disk container storage
→ hand-rolled big-endian binary marshal/unmarshal. Hard cut;
no codec-version prefix; payload size bounded explicitly:
- indexer/codec.go: marshalContainer/unmarshalContainer
- service/keystore/codec.go: marshalHash/unmarshalHash and
marshalUser/unmarshalUser, 16 MiB blob cap retained.
(c) codec.Manager for cross-chain UTXO parsing (wallet/network/primary)
→ utxo.ParseUTXO via the ZAP wire dispatcher already registered
by node/vms/components/lux. Drops the per-chain codec.Manager
slot from FetchState; AddAllUTXOs no longer takes a codec.
Underscore-import of vms/components/lux ensures the dispatcher
is wired even for callers that don't already pull platformvm.
No snow/snowman/snowball/avalanche/avm/subnet residue introduced.
101 lines
2.1 KiB
Go
101 lines
2.1 KiB
Go
// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved.
|
|
// See the file LICENSE for licensing terms.
|
|
|
|
package ips
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"net"
|
|
"strconv"
|
|
|
|
"github.com/luxfi/node/utils/wrappers"
|
|
)
|
|
|
|
const nullStr = "null"
|
|
|
|
var (
|
|
errMissingQuotes = errors.New("first and last characters should be quotes")
|
|
errBadIP = errors.New("bad ip format")
|
|
)
|
|
|
|
type IPDesc IPPort
|
|
|
|
func (ipDesc IPDesc) String() string {
|
|
return IPPort(ipDesc).String()
|
|
}
|
|
|
|
func (ipDesc IPDesc) MarshalJSON() ([]byte, error) {
|
|
return []byte(`"` + ipDesc.String() + `"`), nil
|
|
}
|
|
|
|
func (ipDesc *IPDesc) UnmarshalJSON(b []byte) error {
|
|
str := string(b)
|
|
if str == nullStr { // If "null", do nothing
|
|
return nil
|
|
} else if len(str) < 2 {
|
|
return errMissingQuotes
|
|
}
|
|
|
|
lastIndex := len(str) - 1
|
|
if str[0] != '"' || str[lastIndex] != '"' {
|
|
return errMissingQuotes
|
|
}
|
|
|
|
ipPort, err := ToIPPort(str[1:lastIndex])
|
|
if err != nil {
|
|
return fmt.Errorf("couldn't decode to IPPort: %w", err)
|
|
}
|
|
*ipDesc = IPDesc(ipPort)
|
|
|
|
return nil
|
|
}
|
|
|
|
// An IP and a port.
|
|
type IPPort struct {
|
|
IP net.IP `json:"ip"`
|
|
Port uint16 `json:"port"`
|
|
}
|
|
|
|
func (ipPort IPPort) Equal(other IPPort) bool {
|
|
return ipPort.Port == other.Port && ipPort.IP.Equal(other.IP)
|
|
}
|
|
|
|
func (ipPort IPPort) String() string {
|
|
return net.JoinHostPort(ipPort.IP.String(), strconv.FormatUint(uint64(ipPort.Port), 10))
|
|
}
|
|
|
|
// IsZero returns if the IP or port is zeroed out
|
|
func (ipPort IPPort) IsZero() bool {
|
|
ip := ipPort.IP
|
|
return ipPort.Port == 0 ||
|
|
len(ip) == 0 ||
|
|
ip.Equal(net.IPv4zero) ||
|
|
ip.Equal(net.IPv6zero)
|
|
}
|
|
|
|
func ToIPPort(str string) (IPPort, error) {
|
|
host, portStr, err := net.SplitHostPort(str)
|
|
if err != nil {
|
|
return IPPort{}, errBadIP
|
|
}
|
|
port, err := strconv.ParseUint(portStr, 10 /*=base*/, 16 /*=size*/)
|
|
if err != nil {
|
|
return IPPort{}, err
|
|
}
|
|
ip := net.ParseIP(host)
|
|
if ip == nil {
|
|
return IPPort{}, errBadIP
|
|
}
|
|
return IPPort{
|
|
IP: ip,
|
|
Port: uint16(port),
|
|
}, nil
|
|
}
|
|
|
|
// PackIP packs an ip port pair to the byte array
|
|
func PackIP(p *wrappers.Packer, ip IPPort) {
|
|
p.PackFixedBytes(ip.IP.To16())
|
|
p.PackShort(ip.Port)
|
|
}
|