425 lines
11 KiB
Go
425 lines
11 KiB
Go
|
// utility.go
|
||
|
|
package utility
|
||
|
|
|
||
|
|
import (
|
||
|
|
"encoding/binary"
|
||
|
|
"encoding/hex"
|
||
|
|
"encoding/json"
|
||
|
|
"fmt"
|
||
|
|
"io/ioutil"
|
||
|
|
"strconv"
|
||
|
|
|
||
|
|
"bytes"
|
||
|
|
"log"
|
||
|
|
"math"
|
||
|
|
"math/big"
|
||
|
|
"os"
|
||
|
|
"os/exec"
|
||
|
|
"strings"
|
||
|
|
|
||
|
|
"time"
|
||
|
|
|
||
|
|
"github.com/zeromq/goczmq"
|
||
|
|
"go.uber.org/zap"
|
||
|
|
"go.uber.org/zap/zapcore"
|
||
|
|
"gopkg.in/natefinch/lumberjack.v2"
|
||
|
|
)
|
||
|
|
|
||
|
|
const BITCOIND_ZMQ_HASHBLOCK string = "hashblock"
|
||
|
|
|
||
|
|
type CoinConfig struct {
|
||
|
|
Coin string `json:"coin"`
|
||
|
|
}
|
||
|
|
|
||
|
|
type ZmqConfig struct {
|
||
|
|
Pub string `json:"pub"`
|
||
|
|
Sub string `json:"sub"`
|
||
|
|
}
|
||
|
|
|
||
|
|
type RedisConfig struct {
|
||
|
|
Addr string `json:"addr"`
|
||
|
|
Password string `json:"password"`
|
||
|
|
DB int `json:"db"`
|
||
|
|
}
|
||
|
|
|
||
|
|
type LogRotateConfig struct {
|
||
|
|
MaxSize int `json:"maxsize"`
|
||
|
|
MaxBackups int `json:"maxbackups"`
|
||
|
|
MaxAge int `json:"maxage"`
|
||
|
|
Compress bool `json:"compress"`
|
||
|
|
}
|
||
|
|
|
||
|
|
func InitLogg(zaplog *zap.Config, rotate *LogRotateConfig, coinname string, modulename string) (*zap.Logger, *lumberjack.Logger, error) {
|
||
|
|
os.MkdirAll("logs/"+coinname, os.ModePerm)
|
||
|
|
logfile := "./logs/" + coinname + "/" + modulename + ".log"
|
||
|
|
|
||
|
|
logRotate := &lumberjack.Logger{
|
||
|
|
Filename: logfile,
|
||
|
|
MaxSize: rotate.MaxSize,
|
||
|
|
MaxBackups: rotate.MaxBackups,
|
||
|
|
MaxAge: rotate.MaxAge,
|
||
|
|
Compress: rotate.Compress,
|
||
|
|
}
|
||
|
|
|
||
|
|
zaplog.EncoderConfig = zap.NewProductionEncoderConfig()
|
||
|
|
zaplog.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
|
||
|
|
|
||
|
|
opath := []string{"", ""}
|
||
|
|
opath[0] = zaplog.OutputPaths[0]
|
||
|
|
opath[1] = logfile
|
||
|
|
zaplog.OutputPaths = opath
|
||
|
|
|
||
|
|
l, err := zaplog.Build(
|
||
|
|
zap.WrapCore(func(core zapcore.Core) zapcore.Core {
|
||
|
|
return zapcore.NewCore(
|
||
|
|
zapcore.NewJSONEncoder(zaplog.EncoderConfig),
|
||
|
|
zapcore.AddSync(logRotate),
|
||
|
|
zaplog.Level,
|
||
|
|
)
|
||
|
|
}),
|
||
|
|
)
|
||
|
|
if err != nil {
|
||
|
|
log.Fatal("[gbt]", err.Error())
|
||
|
|
return nil, nil, err
|
||
|
|
}
|
||
|
|
return l, logRotate, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func GetCoin(config_file string) string {
|
||
|
|
var config CoinConfig
|
||
|
|
data, err := ioutil.ReadFile(config_file)
|
||
|
|
if err != nil {
|
||
|
|
panic(err.Error())
|
||
|
|
}
|
||
|
|
if err = json.Unmarshal(data, &config); err != nil {
|
||
|
|
panic(err.Error())
|
||
|
|
}
|
||
|
|
|
||
|
|
return config.Coin
|
||
|
|
}
|
||
|
|
|
||
|
|
func confirmXPubSubscriptions(pub *goczmq.Channeler, count int) {
|
||
|
|
for i := 0; i < count; i++ {
|
||
|
|
select {
|
||
|
|
case <-pub.RecvChan:
|
||
|
|
case <-time.After(time.Second * 2):
|
||
|
|
log.Println("confirmXPubSubscriptions, timeout")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func InitZmqPub(pub_host string) *goczmq.Sock {
|
||
|
|
pub_ch, err := goczmq.NewXPub(pub_host)
|
||
|
|
if err != nil {
|
||
|
|
log.Fatal("[server]", zap.String("NewXPub", "zmq pub create failed!"))
|
||
|
|
}
|
||
|
|
//pub_ch.SetMaxmsgsize(1024 * 1024 * 8)
|
||
|
|
return pub_ch
|
||
|
|
}
|
||
|
|
|
||
|
|
func InitZmqSub(sub_to string, topic string) *goczmq.Sock {
|
||
|
|
|
||
|
|
sub_ch, err := goczmq.NewSub(sub_to, topic)
|
||
|
|
if err != nil {
|
||
|
|
log.Fatal("[server]", zap.String("NewSub", "zmq sub connect failed!"))
|
||
|
|
}
|
||
|
|
//sub_ch.SetMaxmsgsize(1024 * 1024 * 8)
|
||
|
|
return sub_ch
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
func InitZmqPush(sub_to string) *goczmq.Sock {
|
||
|
|
push_ch, err := goczmq.NewPush(sub_to)
|
||
|
|
if err != nil {
|
||
|
|
log.Fatal("[server]", zap.String("NewPushChanneler", "zmq push connect failed!"))
|
||
|
|
}
|
||
|
|
//push_ch.Bind(sub_to)
|
||
|
|
//push_ch.SetMaxmsgsize(1024 * 1024 * 8)
|
||
|
|
return push_ch
|
||
|
|
}
|
||
|
|
|
||
|
|
func InitZmqPull(sub_to string) *goczmq.Sock {
|
||
|
|
pull_ch, err := goczmq.NewPull(sub_to)
|
||
|
|
if err != nil {
|
||
|
|
log.Fatal("[server]", zap.String("InitZmqPull", "zmq pull connect failed! "+err.Error()))
|
||
|
|
}
|
||
|
|
//pull_ch.SetMaxmsgsize(1024 * 1024 * 8)
|
||
|
|
return pull_ch
|
||
|
|
}
|
||
|
|
|
||
|
|
func Int32ToString(n uint32) string {
|
||
|
|
buf := [11]byte{}
|
||
|
|
pos := len(buf)
|
||
|
|
i := int64(n)
|
||
|
|
signed := i < 0
|
||
|
|
if signed {
|
||
|
|
i = -i
|
||
|
|
}
|
||
|
|
for {
|
||
|
|
pos--
|
||
|
|
buf[pos], i = '0'+byte(i%10), i/10
|
||
|
|
if i == 0 {
|
||
|
|
if signed {
|
||
|
|
pos--
|
||
|
|
buf[pos] = '-'
|
||
|
|
}
|
||
|
|
return string(buf[pos:])
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func ByteToUint32(bytes []byte) uint32 {
|
||
|
|
return binary.LittleEndian.Uint32(bytes)
|
||
|
|
}
|
||
|
|
|
||
|
|
func Reverse_string(instr string) string {
|
||
|
|
var outstr string = ""
|
||
|
|
for i := 0; i < len(instr)/2; i++ {
|
||
|
|
outstr = outstr + instr[len(instr)-i*2-2:len(instr)-i*2]
|
||
|
|
}
|
||
|
|
return outstr
|
||
|
|
}
|
||
|
|
|
||
|
|
// CompactToBig converts a compact representation of a whole number N to an
|
||
|
|
// unsigned 32-bit number. The representation is similar to IEEE754 floating
|
||
|
|
// point numbers.
|
||
|
|
//
|
||
|
|
// Like IEEE754 floating point, there are three basic components: the sign,
|
||
|
|
// the exponent, and the mantissa. They are broken out as follows:
|
||
|
|
//
|
||
|
|
// - the most significant 8 bits represent the unsigned base 256 exponent
|
||
|
|
// - bit 23 (the 24th bit) represents the sign bit
|
||
|
|
// - the least significant 23 bits represent the mantissa
|
||
|
|
//
|
||
|
|
// -------------------------------------------------
|
||
|
|
// | Exponent | Sign | Mantissa |
|
||
|
|
// -------------------------------------------------
|
||
|
|
// | 8 bits [31-24] | 1 bit [23] | 23 bits [22-00] |
|
||
|
|
// -------------------------------------------------
|
||
|
|
//
|
||
|
|
// The formula to calculate N is:
|
||
|
|
//
|
||
|
|
// N = (-1^sign) * mantissa * 256^(exponent-3)
|
||
|
|
//
|
||
|
|
// This compact form is only used in bitcoin to encode unsigned 256-bit numbers
|
||
|
|
// which represent difficulty targets, thus there really is not a need for a
|
||
|
|
// sign bit, but it is implemented here to stay consistent with bitcoind.
|
||
|
|
func CompactToBig(compact uint32) *big.Int {
|
||
|
|
// Extract the mantissa, sign bit, and exponent.
|
||
|
|
mantissa := compact & 0x007fffff
|
||
|
|
isNegative := compact&0x00800000 != 0
|
||
|
|
exponent := uint(compact >> 24)
|
||
|
|
|
||
|
|
// Since the base for the exponent is 256, the exponent can be treated
|
||
|
|
// as the number of bytes to represent the full 256-bit number. So,
|
||
|
|
// treat the exponent as the number of bytes and shift the mantissa
|
||
|
|
// right or left accordingly. This is equivalent to:
|
||
|
|
// N = mantissa * 256^(exponent-3)
|
||
|
|
var bn *big.Int
|
||
|
|
if exponent <= 3 {
|
||
|
|
mantissa >>= 8 * (3 - exponent)
|
||
|
|
bn = big.NewInt(int64(mantissa))
|
||
|
|
} else {
|
||
|
|
bn = big.NewInt(int64(mantissa))
|
||
|
|
bn.Lsh(bn, 8*(exponent-3))
|
||
|
|
}
|
||
|
|
|
||
|
|
// Make it negative if the sign bit is set.
|
||
|
|
if isNegative {
|
||
|
|
bn = bn.Neg(bn)
|
||
|
|
}
|
||
|
|
|
||
|
|
return bn
|
||
|
|
}
|
||
|
|
|
||
|
|
const truediffone float64 = 26959535291011309493156476344723991336010898738574164086137773096960.0
|
||
|
|
const bits192 float64 = 6277101735386680763835789423207666416102355444464034512896.0
|
||
|
|
const bits128 float64 = 340282366920938463463374607431768211456.0
|
||
|
|
const bits64 float64 = 18446744073709551616.0
|
||
|
|
|
||
|
|
func target2float(target []byte) float64 {
|
||
|
|
var b64 float64 = float64(binary.LittleEndian.Uint64(target[24:32])) * bits192
|
||
|
|
b64 += (float64(binary.LittleEndian.Uint64(target[16:24])) * bits128)
|
||
|
|
b64 += (float64(binary.LittleEndian.Uint64(target[8:16])) * bits64)
|
||
|
|
b64 += (float64(binary.LittleEndian.Uint64(target[0:8])))
|
||
|
|
return b64
|
||
|
|
}
|
||
|
|
|
||
|
|
// convert target to difficulty
|
||
|
|
func Target2Diff(target []byte) float64 {
|
||
|
|
//var f64 float64 = truediffone
|
||
|
|
max, _ := new(big.Int).SetString("00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16) // 2 ^ 256 -1
|
||
|
|
//max, _ := new(big.Int).SetString("00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16)
|
||
|
|
maxf, _ := new(big.Float).SetString(max.String())
|
||
|
|
f64, _ := maxf.Float64()
|
||
|
|
var fcut64 float64 = target2float(target)
|
||
|
|
//log.Println("diff", f64, fcut64, f64/fcut64)
|
||
|
|
return f64 / fcut64
|
||
|
|
}
|
||
|
|
|
||
|
|
func DiffToTarget(diff float64 /*, powLimit *big.Int*/) (*big.Int, error) {
|
||
|
|
if diff <= 0 {
|
||
|
|
return nil, fmt.Errorf("invalid pool difficulty %v (0 or less than "+
|
||
|
|
"zero passed)", diff)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Round down in the case of a non-integer diff since we only support
|
||
|
|
// ints (unless diff < 1 since we don't allow 0)..
|
||
|
|
if diff <= 1 {
|
||
|
|
diff = 1
|
||
|
|
} else {
|
||
|
|
diff = math.Floor(diff)
|
||
|
|
}
|
||
|
|
divisor := new(big.Int).SetInt64(int64(diff))
|
||
|
|
//max, _ := new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16)
|
||
|
|
max, _ := new(big.Int).SetString("00000000FFFF0000000000000000000000000000000000000000000000000000", 16) // BTC -> MAX_TARGET
|
||
|
|
target := new(big.Int)
|
||
|
|
//log.Println("target calc", hex.EncodeToString(max.Bytes()), hex.EncodeToString(divisor.Bytes()))
|
||
|
|
target.Div(max, divisor)
|
||
|
|
|
||
|
|
return target, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func Convert_big_endian(src []byte) []byte {
|
||
|
|
var dst []byte = make([]byte, 32)
|
||
|
|
for i := 0; i < 8; i++ {
|
||
|
|
dst[0+4*i] = src[3+4*i]
|
||
|
|
dst[1+4*i] = src[2+4*i]
|
||
|
|
dst[2+4*i] = src[1+4*i]
|
||
|
|
dst[3+4*i] = src[0+4*i]
|
||
|
|
}
|
||
|
|
return dst
|
||
|
|
}
|
||
|
|
|
||
|
|
func ReverseS(s string) (string, error) {
|
||
|
|
a := strings.Split(s, "")
|
||
|
|
sRev := ""
|
||
|
|
if len(a)%2 != 0 {
|
||
|
|
return "", fmt.Errorf("Incorrect input length")
|
||
|
|
}
|
||
|
|
for i := 0; i < len(a); i += 2 {
|
||
|
|
tmp := []string{a[i], a[i+1], sRev}
|
||
|
|
sRev = strings.Join(tmp, "")
|
||
|
|
}
|
||
|
|
return sRev, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func Reverse(src []byte) []byte {
|
||
|
|
dst := make([]byte, len(src))
|
||
|
|
for i := len(src); i > 0; i-- {
|
||
|
|
dst[len(src)-i] = src[i-1]
|
||
|
|
}
|
||
|
|
return dst
|
||
|
|
}
|
||
|
|
|
||
|
|
func Uint32ToByte(targetu uint32) []byte {
|
||
|
|
bytes := make([]byte, 4)
|
||
|
|
binary.LittleEndian.PutUint32(bytes, targetu)
|
||
|
|
return bytes
|
||
|
|
}
|
||
|
|
|
||
|
|
func Uint32ToByteBig(targetu uint32) []byte {
|
||
|
|
bytes := make([]byte, 4)
|
||
|
|
binary.BigEndian.PutUint32(bytes, targetu)
|
||
|
|
return bytes
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExecShellCmd(s string) (string, error) {
|
||
|
|
cmd := exec.Command("/bin/bash", "-c", s)
|
||
|
|
var out bytes.Buffer
|
||
|
|
cmd.Stdout = &out
|
||
|
|
err := cmd.Run()
|
||
|
|
if err != nil {
|
||
|
|
fmt.Println(err)
|
||
|
|
}
|
||
|
|
//fmt.Println(out.String(), s)
|
||
|
|
return out.String(), err
|
||
|
|
}
|
||
|
|
|
||
|
|
func BytesToHexStr(b []byte) string {
|
||
|
|
hexString := hex.EncodeToString(b)
|
||
|
|
return hexString
|
||
|
|
}
|
||
|
|
|
||
|
|
func NormalStrToHexStr(s string) string {
|
||
|
|
hexStr := fmt.Sprintf("%x", s) // 将字符串转换为16进制字符串
|
||
|
|
return hexStr
|
||
|
|
}
|
||
|
|
|
||
|
|
func HexStrToBytes(s string) []byte {
|
||
|
|
// 将16进制字符串转换为[]byte
|
||
|
|
bytes, err := hex.DecodeString(s)
|
||
|
|
if err != nil {
|
||
|
|
log.Fatal(err)
|
||
|
|
}
|
||
|
|
return bytes
|
||
|
|
}
|
||
|
|
|
||
|
|
func ChainIndexStr(fromGroup uint32, toGroup uint32) string {
|
||
|
|
return fmt.Sprintf("%d -> %d", fromGroup, toGroup)
|
||
|
|
}
|
||
|
|
|
||
|
|
func AlphDiff1Target() *big.Int {
|
||
|
|
// 计算 2^226 - 1
|
||
|
|
result := new(big.Int).Lsh(big.NewInt(1), 226) // 1 << 226
|
||
|
|
result.Sub(result, big.NewInt(1)) // 2^226 - 1
|
||
|
|
return result
|
||
|
|
}
|
||
|
|
|
||
|
|
// fromBuffer: 将字节切片解析为大整数
|
||
|
|
func fromBuffer(buf []byte) *big.Int {
|
||
|
|
return new(big.Int).SetBytes(buf)
|
||
|
|
}
|
||
|
|
|
||
|
|
func AlphShareDiff(hash []byte) float64 {
|
||
|
|
hashBigNum := fromBuffer(hash)
|
||
|
|
diff1Target := AlphDiff1Target()
|
||
|
|
temp := new(big.Int).Mul(diff1Target, big.NewInt(1024))
|
||
|
|
result := new(big.Int).Div(temp, hashBigNum)
|
||
|
|
finalResult := new(big.Float).SetInt(result)
|
||
|
|
finalResult.Quo(finalResult, big.NewFloat(1024.0))
|
||
|
|
diffStr := finalResult.Text('f', 8)
|
||
|
|
diff, err := strconv.ParseFloat(diffStr, 64)
|
||
|
|
if err != nil {
|
||
|
|
log.Fatal(err)
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
return diff
|
||
|
|
}
|
||
|
|
|
||
|
|
func AlphDiffToTarget(diff float64) (*big.Int, error) {
|
||
|
|
if diff <= 0 {
|
||
|
|
return nil, fmt.Errorf("invalid pool difficulty %v (0 or less than "+
|
||
|
|
"zero passed)", diff)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Round down in the case of a non-integer diff since we only support
|
||
|
|
// ints (unless diff < 1 since we don't allow 0)..
|
||
|
|
if diff <= 1 {
|
||
|
|
diff = 1
|
||
|
|
} else {
|
||
|
|
diff = math.Floor(diff)
|
||
|
|
}
|
||
|
|
divisor := new(big.Int).SetInt64(int64(diff))
|
||
|
|
//max, _ := new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16)
|
||
|
|
max, _ := new(big.Int).SetString("000000003FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16) //
|
||
|
|
target := new(big.Int)
|
||
|
|
//log.Println("target calc", hex.EncodeToString(max.Bytes()), hex.EncodeToString(divisor.Bytes()))
|
||
|
|
target.Div(max, divisor)
|
||
|
|
|
||
|
|
return target, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// 结果等同于上面的AlphDiffToTarget方法
|
||
|
|
func AlphDiffToTarget2(diff float64) string {
|
||
|
|
alphTarget1Diff := new(big.Int).Lsh(big.NewInt(1), 226)
|
||
|
|
alphTarget1Diff.Sub(alphTarget1Diff, big.NewInt(1)) // 难度1的 target
|
||
|
|
// 直接在原变量上操作，避免不必要的变量创建
|
||
|
|
alphTarget1Diff.Mul(alphTarget1Diff, big.NewInt(1024))
|
||
|
|
// 计算 difficulty * 1024 并转换为 big.Int
|
||
|
|
ceilDifficultyInt := new(big.Int).SetUint64(uint64(math.Ceil(diff * 1024)))
|
||
|
|
// 计算最终 target
|
||
|
|
target := new(big.Int).Div(alphTarget1Diff, ceilDifficultyInt)
|
||
|
|
return target.Text(16)
|
||
|
|
}
|