Tobfilter

common/test_utils.go

@@ -250,12 +250,45 @@ func DisplayEthTxs(txs map[string]ethtypes.Transactions) {
 	for domain, domainTxs := range txs {
 		fmt.Printf("domain: %s\n", domain)
 		for _, tx := range domainTxs {
-			fmt.Printf("tx: %s\n", tx.Hash().Hex())
+			sender, err := ExtractSender(tx)
+			if err != nil {
+				panic(err)
+			}
+			fmt.Printf("sender: %s tx: %s:%d\n", sender, tx.Hash().Hex(), tx.Nonce())
 		}
 	}
 	fmt.Printf("========txs info end=======\n")
 }
 
+func FindTxHash(txLhs *ethtypes.Transaction, txs []*ethtypes.Transaction) bool {
+	if txLhs == nil {
+		panic("txLhs is nil")
+	}
+	lhsHash := txLhs.Hash()
+	for _, tx := range txs {
+		rhsHash := tx.Hash()
+		if lhsHash == rhsHash {
+			return true
+		}
+	}
+	return false
+}
+
+func TxsHashUnorderedMatch(txsLhs []*ethtypes.Transaction, txsRhs []*ethtypes.Transaction) bool {
+	if len(txsLhs) != len(txsRhs) {
+		return false
+	}
+
+	for _, tx := range txsLhs {
+		if !FindTxHash(tx, txsRhs) {
+			fmt.Printf("could not find tx hash " + tx.Hash().Hex())
+			return false
+		}
+	}
+
+	return true
+}
+
 func SyncMapLen(m *sync.Map) int {
 	var length int
 	m.Range(func(_, _ interface{}) bool {

common/types.go

@@ -23,6 +23,7 @@ import (
 
 	"github.com/AnomalyFi/hypersdk/chain"
 	"github.com/AnomalyFi/hypersdk/codec"
+	abls "github.com/AnomalyFi/hypersdk/crypto/bls"
 	"github.com/AnomalyFi/hypersdk/utils"
 	"github.com/AnomalyFi/nodekit-seq/actions"
 	"github.com/ava-labs/avalanchego/ids"
@@ -204,10 +205,12 @@ type ToBChunk struct {
 	txHash2BundleHash map[string]string
 	revertingTxHashes map[string]struct{}
 
+	// refers to whether bundle at idx has been removed
 	removedBitSet *bitset.BitSet
-	domains       map[string]struct{} // chain ids or rollup ids
-	seqTxs        []*chain.Transaction
-	initialized   bool
+
+	domains     map[string]struct{} // chain ids or rollup ids
+	seqTxs      []*chain.Transaction
+	initialized bool
 
 	l sync.RWMutex
 }
@@ -228,6 +231,17 @@ func (tob *ToBChunk) GetBundles() []*CrossRollupBundle {
 	return ret
 }
 
+func (tob *ToBChunk) IsBundleIdxFiltered(idx int) bool {
+	tob.l.RLock()
+	defer tob.l.RUnlock()
+
+	if idx >= len(tob.Bundles) {
+		return false
+	}
+
+	return tob.removedBitSet.Test(uint(idx))
+}
+
 func (tob *ToBChunk) GetTxs() map[string]ethtypes.Transactions {
 	tob.l.RLock()
 	defer tob.l.RUnlock()
@@ -343,10 +357,45 @@ func (tob *ToBChunk) removeBundleContainTx(txHash string) (*CrossRollupBundle, e
 	bundleIdx2remove := slices.IndexFunc(tob.Bundles, func(crb *CrossRollupBundle) bool {
 		return crb.BundleHash == bundleHash
 	})
+
 	// mark as removed
 	tob.removedBitSet = tob.removedBitSet.Set(uint(bundleIdx2remove))
 
 	// re-populate [tob.txs]
+	tob.repopulateToBTxs()
+
+	return tob.Bundles[bundleIdx2remove], nil
+}
+
+func (tob *ToBChunk) FilterBundleWithHash(bundleHash string) (*CrossRollupBundle, error) {
+	tob.l.Lock()
+	defer tob.l.Unlock()
+
+	var foundIdx int
+	var foundBundle *CrossRollupBundle
+
+	for bundleIdx, bundle := range tob.Bundles {
+		if bundle.BundleHash == bundleHash {
+			foundIdx = bundleIdx
+			foundBundle = bundle
+			break
+		}
+	}
+
+	if foundBundle == nil {
+		return nil, fmt.Errorf("filterBundleWithHash found no bundle hash [%s]", bundleHash)
+	}
+
+	// mark as removed
+	tob.removedBitSet = tob.removedBitSet.Set(uint(foundIdx))
+
+	// re-populate [tob.txs]
+	tob.repopulateToBTxs()
+
+	return tob.Bundles[foundIdx], nil
+}
+
+func (tob *ToBChunk) repopulateToBTxs() {
 	tob.txs = make(map[string]ethtypes.Transactions)
 	for bundleIdx, bundle := range tob.Bundles {
 		// continue as this bundle was removed
@@ -359,13 +408,12 @@ func (tob *ToBChunk) removeBundleContainTx(txHash string) (*CrossRollupBundle, e
 			tob.txs[domain] = l
 		}
 	}
+
 	// track domains that contain txs in it
 	tob.domains = make(map[string]struct{})
 	for domain := range tob.txs {
 		tob.domains[domain] = struct{}{}
 	}
-
-	return tob.Bundles[bundleIdx2remove], nil
 }
 
 // LowestBlockNumber return the tracked lowest heights for domains, this prevents the situation that
@@ -526,7 +574,7 @@ type RoBChunk struct {
 	BlockNumber uint64   `json:"block_number"`
 
 	// following fields will be populated after initialization
-	removedBitSet *bitset.BitSet
+	removedBitSet *bitset.BitSet // refers to whether tx within txs at idx has been removed
 	initialized   bool
 	txs           ethtypes.Transactions
 	seqTxs        []*chain.Transaction
@@ -1135,6 +1183,23 @@ type GetBlockPayloadFromArcadia struct {
 	BlockNumber  uint64 `json:"blockNumber"`
 }
 
+func (req *GetBlockPayloadFromArcadia) Payload() ([]byte, error) {
+	return json.Marshal(req)
+}
+
+func (req *GetBlockPayloadFromArcadia) VerifyIssuer(networkID uint32, seqChainID ids.ID, pk *abls.PublicKey, sig *abls.Signature) (bool, error) {
+	payload, err := req.Payload()
+	if err != nil {
+		return false, err
+	}
+	uwm, err := warp.NewUnsignedMessage(networkID, seqChainID, payload)
+	if err != nil {
+		return false, err
+	}
+	uwmBytes := uwm.Bytes()
+	return abls.Verify(uwmBytes, pk, sig), nil
+}
+
 type SEQTxWrapper struct {
 	Tx   *chain.Transaction
 	Size int
@@ -1505,6 +1570,10 @@ func (b *CrossRollupBundle) Domains() []string {
 	return maps.Keys(b.txs)
 }
 
+func (b *CrossRollupBundle) HasTxs() bool {
+	return len(b.txs) > 0
+}
+
 func (b *CrossRollupBundle) ContainTx(txHash string) bool {
 	for _, txs := range b.txs {
 		contain := slices.ContainsFunc(txs, func(t *ethtypes.Transaction) bool {

common/utils.go

@@ -12,6 +12,7 @@ import (
 	"strings"
 	"time"
 
+	abls "github.com/AnomalyFi/hypersdk/crypto/bls"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 
 	"github.com/AnomalyFi/hypersdk/chain"
@@ -221,3 +222,15 @@ func BuildDACert(chunk *ArcadiaChunk, epoch uint64, certificate []byte) *seqtype
 		return robDA
 	}
 }
+
+func HeaderToSEQSignature(sigHeader string) (*abls.Signature, error) {
+	sigBytes, err := hexutil.Decode(sigHeader)
+	if err != nil {
+		return nil, err
+	}
+	return abls.SignatureFromBytes(sigBytes)
+}
+
+func BytesToSEQPubkey(pkBytes []byte) (*abls.PublicKey, error) {
+	return abls.PublicKeyFromBytes(pkBytes)
+}

database/mockdb.go

@@ -29,7 +29,7 @@ type MockDB struct {
 	RoBChunkMap                       map[string]map[uint64]*common.RoBChunkDB
 	RoBChunkAcceptedMap               map[string]*common.RoBChunkAcceptedDB
 	LastFetchedBlockNum               common.LastFetchedBlockNumberDB
-	PayloadResp                       common.PayloadDB
+	PayloadResp                       *common.PayloadDB
 	Epoch                             uint64
 	EpochLowestToBNonce               map[uint64]uint64
 	PayloadTxsToB                     map[string]*common.PayloadTxs
@@ -54,7 +54,6 @@ func NewMockDB() *MockDB {
 		RoBChunkMap:               make(map[string]map[uint64]*common.RoBChunkDB),
 		RoBChunkAcceptedMap:       make(map[string]*common.RoBChunkAcceptedDB),
 		LastFetchedBlockNum:       common.LastFetchedBlockNumberDB{},
-		PayloadResp:               common.PayloadDB{},
 		Epoch:                     0,
 		EpochLowestToBNonce:       make(map[uint64]uint64),
 		PayloadTxsToB:             make(map[string]*common.PayloadTxs),
@@ -247,8 +246,10 @@ func (db *MockDB) RemoveBestAuctionBid(epoch uint64) error {
 func (db *MockDB) GetPayloadResp(chainID string, blockNumber uint64) (*common.PayloadDB, error) {
 	db.l.Lock()
 	defer db.l.Unlock()
-
-	return &db.PayloadResp, nil
+	if db.PayloadResp == nil {
+		return nil, nil
+	}
+	return db.PayloadResp, nil
 }
 
 func (db *MockDB) SetPayloadResp(chainID string, blockNumber uint64, txs *common.GetPayloadResponse) error {
@@ -260,7 +261,7 @@ func (db *MockDB) SetPayloadResp(chainID string, blockNumber uint64, txs *common
 		return err
 	}
 
-	db.PayloadResp = *payloadTxs
+	db.PayloadResp = payloadTxs
 	return nil
 }
 

seq/consts.go

@@ -0,0 +1,4 @@
+package seq
+
+const DefaultProposerLRUSize = 20
+const GetArcadiaBlockSignatureHeader = "X-Arcadia-GetBlock-Sig"