initial commit

pow/pow.go

@@ -0,0 +1,141 @@
+package pow
+
+/*
+#cgo CXXFLAGS: -std=c++17 -O3 -mavx2 -pthread
+#cgo LDFLAGS: -lstdc++ -pthread
+
+#include <stdlib.h>
+#include "pow.h"
+*/
+import "C"
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"unsafe"
+)
+
+var (
+	// ErrNotFound indicates that no nonce satisfies the challenge difficulty.
+	ErrNotFound = errors.New("PoW solution not found")
+	// ErrInvalidArgument indicates malformed or unsupported solver input.
+	ErrInvalidArgument = errors.New("invalid PoW argument")
+	// ErrInternalCppError indicates an exception in the native solver.
+	ErrInternalCppError = errors.New("internal C++ solver error")
+)
+
+// Challenge contains the inputs required to solve a DeepSeekHashV1 challenge.
+type Challenge struct {
+	Algorithm  string `json:"algorithm"`
+	Challenge  string `json:"challenge"`
+	Salt       string `json:"salt"`
+	Difficulty uint64 `json:"difficulty"`
+	ExpireAt   uint64 `json:"expire_at"`
+	Signature  string `json:"signature"`
+	TargetPath string `json:"target_path"`
+}
+
+// Solve validates and solves c, returning a nonce smaller than Difficulty.
+func (c Challenge) Solve() (uint64, error) {
+	if c.Algorithm != "" && c.Algorithm != "DeepSeekHashV1" {
+		return 0, fmt.Errorf(
+			"unsupported PoW algorithm %q",
+			c.Algorithm,
+		)
+	}
+
+	if len(c.Challenge) != 64 {
+		return 0, fmt.Errorf(
+			"%w: challenge must contain 64 hexadecimal characters",
+			ErrInvalidArgument,
+		)
+	}
+
+	if c.Salt == "" {
+		return 0, fmt.Errorf(
+			"%w: salt is empty",
+			ErrInvalidArgument,
+		)
+	}
+
+	if c.Difficulty <= 0 {
+		return 0, fmt.Errorf(
+			"%w: difficulty must be positive",
+			ErrInvalidArgument,
+		)
+	}
+
+	base := c.Salt +
+		"_" +
+		strconv.FormatUint(c.ExpireAt, 10) +
+		"_"
+
+	return Solve(base, c.Challenge, c.Difficulty)
+}
+
+// Solve searches the range [0, difficulty) for a nonce whose DeepSeekHashV1
+// digest equals challengeHex.
+func Solve(
+	base string,
+	challengeHex string,
+	difficulty uint64,
+) (uint64, error) {
+	if base == "" {
+		return 0, fmt.Errorf(
+			"%w: base is empty",
+			ErrInvalidArgument,
+		)
+	}
+
+	if len(challengeHex) != 64 {
+		return 0, fmt.Errorf(
+			"%w: challenge must contain 64 hexadecimal characters",
+			ErrInvalidArgument,
+		)
+	}
+
+	if difficulty <= 0 {
+		return 0, fmt.Errorf(
+			"%w: difficulty must be positive",
+			ErrInvalidArgument,
+		)
+	}
+
+	baseBytes := []byte(base)
+	challengeBytes := []byte(challengeHex)
+
+	result := C.deepseek_pow_solve(
+		(*C.char)(unsafe.Pointer(&baseBytes[0])),
+		C.size_t(len(baseBytes)),
+		(*C.char)(unsafe.Pointer(&challengeBytes[0])),
+		C.size_t(len(challengeBytes)),
+		C.int64_t(difficulty),
+	)
+
+	switch {
+	case result >= 0:
+		return uint64(result), nil
+
+	case result == -1:
+		return 0, ErrNotFound
+
+	case result == -2:
+		return 0, fmt.Errorf(
+			"%w: null pointer passed to C++",
+			ErrInvalidArgument,
+		)
+
+	case result == -3:
+		return 0, ErrInvalidArgument
+
+	case result == -4:
+		return 0, ErrInternalCppError
+
+	default:
+		return 0, fmt.Errorf(
+			"unexpected C++ solver result: %d",
+			int64(result),
+		)
+	}
+}