feat: add fractal support for runes (#52)

* feat: add fractal support for runes

* chore: remove common.HalvingInterval

* fix: update starting block height

* refactor: move network-genesis-rune definition to constants

* fix: use logger.Panic() instead of panic()

* fix: golangci-lint

* fix: missing return

common/bitcoin.go

@@ -1,4 +0,0 @@
-package common
-
-// HalvingInterval is the number of blocks between each halving event.
-const HalvingInterval = 210_000

common/network.go

@@ -1,6 +1,9 @@
 package common
 
-import "github.com/btcsuite/btcd/chaincfg"
+import (
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/gaze-network/indexer-network/pkg/logger"
+)
 
 type Network string
 
@@ -37,3 +40,15 @@ func (n Network) ChainParams() *chaincfg.Params {
 func (n Network) String() string {
 	return string(n)
 }
+
+func (n Network) HalvingInterval() uint64 {
+	switch n {
+	case NetworkMainnet, NetworkTestnet:
+		return 210_000
+	case NetworkFractalMainnet, NetworkFractalTestnet:
+		return 2_100_000
+	default:
+		logger.Panic("invalid network")
+		return 0
+	}
+}

modules/runes/constants/constants.go

@@ -1,10 +1,13 @@
 package constants
 
 import (
+	"fmt"
+
 	"github.com/Cleverse/go-utilities/utils"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/gaze-network/indexer-network/common"
 	"github.com/gaze-network/indexer-network/core/types"
+	"github.com/gaze-network/indexer-network/pkg/logger"
 )
 
 const (
@@ -17,11 +20,29 @@ var StartingBlockHeader = map[common.Network]types.BlockHeader{
 	common.NetworkMainnet: {
 		Height: 839999,
 		Hash:   *utils.Must(chainhash.NewHashFromStr("0000000000000000000172014ba58d66455762add0512355ad651207918494ab")),
-		PrevBlock: *utils.Must(chainhash.NewHashFromStr("00000000000000000001dcce6ce7c8a45872cafd1fb04732b447a14a91832591")),
 	},
 	common.NetworkTestnet: {
-		Height:    2583200,
-		Hash:      *utils.Must(chainhash.NewHashFromStr("000000000006c5f0dfcd9e0e81f27f97a87aef82087ffe69cd3c390325bb6541")),
-		PrevBlock: *utils.Must(chainhash.NewHashFromStr("00000000000668f3bafac992f53424774515440cb47e1cb9e73af3f496139e28")),
+		Height: 2519999,
+		Hash:   *utils.Must(chainhash.NewHashFromStr("000000000006f45c16402f05d9075db49d3571cf5273cf4cbeaa2aa295f7c833")),
+	},
+	common.NetworkFractalMainnet: {
+		Height: 83999,
+		Hash:   *utils.Must(chainhash.NewHashFromStr("0000000000000000000000000000000000000000000000000000000000000000")), // TODO: Update this to match real hash
+	},
+	common.NetworkFractalTestnet: {
+		Height: 83999,
+		Hash:   *utils.Must(chainhash.NewHashFromStr("00000000000000613ddfbdd1778b17cea3818febcbbf82762eafaa9461038343")),
 	},
 }
+
+func NetworkHasGenesisRune(network common.Network) bool {
+	switch network {
+	case common.NetworkMainnet, common.NetworkFractalMainnet, common.NetworkFractalTestnet:
+		return true
+	case common.NetworkTestnet:
+		return false
+	default:
+		logger.Panic(fmt.Sprintf("unsupported network: %s", network))
+		return false
+	}
+}

modules/runes/processor.go

@@ -69,8 +69,8 @@ func (p *Processor) VerifyStates(ctx context.Context) error {
 	if err := p.ensureValidState(ctx); err != nil {
 		return errors.Wrap(err, "error during ensureValidState")
 	}
-	if p.network == common.NetworkMainnet {
-		if err := p.ensureGenesisRune(ctx); err != nil {
+	if constants.NetworkHasGenesisRune(p.network) {
+		if err := p.ensureGenesisRune(ctx, p.network); err != nil {
 			return errors.Wrap(err, "error during ensureGenesisRune")
 		}
 	}
@@ -122,7 +122,7 @@ func (p *Processor) ensureValidState(ctx context.Context) error {
 
 var genesisRuneId = runes.RuneId{BlockHeight: 1, TxIndex: 0}
 
-func (p *Processor) ensureGenesisRune(ctx context.Context) error {
+func (p *Processor) ensureGenesisRune(ctx context.Context, network common.Network) error {
 	_, err := p.runesDg.GetRuneEntryByRuneId(ctx, genesisRuneId)
 	if err != nil && !errors.Is(err, errs.NotFound) {
 		return errors.Wrap(err, "failed to get genesis rune entry")
@@ -138,8 +138,8 @@ func (p *Processor) ensureGenesisRune(ctx context.Context) error {
 			Terms: &runes.Terms{
 				Amount:      lo.ToPtr(uint128.From64(1)),
 				Cap:         &uint128.Max,
-				HeightStart: lo.ToPtr(uint64(common.HalvingInterval * 4)),
-				HeightEnd:   lo.ToPtr(uint64(common.HalvingInterval * 5)),
+				HeightStart: lo.ToPtr(network.HalvingInterval() * 4),
+				HeightEnd:   lo.ToPtr(network.HalvingInterval() * 5),
 				OffsetStart: nil,
 				OffsetEnd:   nil,
 			},

modules/runes/runes/flag.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
+	"github.com/gaze-network/indexer-network/pkg/logger"
 	"github.com/gaze-network/uint128"
 )
 
@@ -58,7 +59,8 @@ func ParseFlags(input interface{}) (Flags, error) {
 		}
 		return Flags(u128), nil
 	default:
-		panic("invalid flags input type")
+		logger.Panic("invalid flags input type")
+		return Flags{}, nil
 	}
 }
 

modules/runes/runes/rune.go

@@ -1,11 +1,13 @@
 package runes
 
 import (
+	"fmt"
 	"slices"
 
 	"github.com/Cleverse/go-utilities/utils"
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common"
+	"github.com/gaze-network/indexer-network/pkg/logger"
 	"github.com/gaze-network/uint128"
 )
 
@@ -119,24 +121,25 @@ func (r Rune) Cmp(other Rune) int {
 func FirstRuneHeight(network common.Network) uint64 {
 	switch network {
 	case common.NetworkMainnet:
-		return common.HalvingInterval * 4
+		return 840_000
 	case common.NetworkTestnet:
-		return common.HalvingInterval * 12
+		return 2_520_000
 	case common.NetworkFractalMainnet:
-		return 84000
+		return 84_000
 	case common.NetworkFractalTestnet:
-		return 84000
+		return 84_000
 	}
-	panic("invalid network")
+	logger.Panic(fmt.Sprintf("invalid network: %s", network))
+	return 0
 }
 
 func MinimumRuneAtHeight(network common.Network, height uint64) Rune {
 	offset := height + 1
-	interval := common.HalvingInterval / 12
+	interval := network.HalvingInterval() / 12
 
 	// runes are gradually unlocked from rune activation height until the next halving
 	start := FirstRuneHeight(network)
-	end := start + common.HalvingInterval
+	end := start + network.HalvingInterval()
 
 	if offset < start {
 		return (Rune)(unlockSteps[12])

modules/runes/runes/rune_test.go

@@ -92,8 +92,8 @@ func TestMinimumRuneAtHeightMainnet(t *testing.T) {
 	}
 
 	start := FirstRuneHeight(common.NetworkMainnet)
-	end := start + common.HalvingInterval
-	interval := uint64(common.HalvingInterval / 12)
+	end := start + common.NetworkMainnet.HalvingInterval()
+	interval := uint64(common.NetworkMainnet.HalvingInterval() / 12)
 
 	test(0, "AAAAAAAAAAAAA")
 	test(start/2, "AAAAAAAAAAAAA")

modules/runes/runes/tag.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
+	"github.com/gaze-network/indexer-network/pkg/logger"
 	"github.com/gaze-network/uint128"
 )
 
@@ -102,6 +103,7 @@ func ParseTag(input interface{}) (Tag, error) {
 		}
 		return Tag(u128), nil
 	default:
-		panic("invalid tag input type")
+		logger.Panic("invalid tag input type")
+		return Tag{}, nil
 	}
 }