work on wasm watchers

pkg/super_node/btc/filterer.go

@@ -72,10 +72,10 @@ func (s *ResponseFilterer) filterHeaders(headerFilter HeaderFilter, response *IP
 		if err != nil {
 			return err
 		}
-		response.Headers = append(response.Headers, ipfs.BlockModel{
+		response.Header = ipfs.BlockModel{
 			Data: data,
 			CID:  cid.String(),
-		})
+		}
 	}
 	return nil
 }

pkg/super_node/btc/ipld_fetcher.go

@@ -60,7 +60,7 @@ func (f *IPLDFetcher) Fetch(cids shared.CIDsForFetching) (shared.IPLDs, error) {
 	iplds := IPLDs{}
 	iplds.BlockNumber = cidWrapper.BlockNumber
 	var err error
-	iplds.Headers, err = f.FetchHeaders(cidWrapper.Headers)
+	iplds.Header, err = f.FetchHeader(cidWrapper.Header)
 	if err != nil {
 		return nil, err
 	}
@@ -72,30 +72,21 @@ func (f *IPLDFetcher) Fetch(cids shared.CIDsForFetching) (shared.IPLDs, error) {
 }
 
 // FetchHeaders fetches headers
-// It uses the f.fetchBatch method
-func (f *IPLDFetcher) FetchHeaders(cids []HeaderModel) ([]ipfs.BlockModel, error) {
-	log.Debug("fetching header iplds")
-	headerCids := make([]cid.Cid, len(cids))
-	for i, c := range cids {
-		dc, err := cid.Decode(c.CID)
-		if err != nil {
-			return nil, err
-		}
-		headerCids[i] = dc
+// It uses the f.fetch method
+func (f *IPLDFetcher) FetchHeader(c HeaderModel) (ipfs.BlockModel, error) {
+	log.Debug("fetching header ipld")
+	dc, err := cid.Decode(c.CID)
+	if err != nil {
+		return ipfs.BlockModel{}, err
 	}
-	headers := f.fetchBatch(headerCids)
-	headerIPLDs := make([]ipfs.BlockModel, len(headers))
-	for i, header := range headers {
-		headerIPLDs[i] = ipfs.BlockModel{
-			Data: header.RawData(),
-			CID:  header.Cid().String(),
-		}
+	header, err := f.fetch(dc)
+	if err != nil {
+		return ipfs.BlockModel{}, err
 	}
-	if len(headerIPLDs) != len(headerCids) {
-		log.Errorf("ipfs fetcher: number of header blocks returned (%d) does not match number expected (%d)", len(headers), len(headerCids))
-		return headerIPLDs, errUnexpectedNumberOfIPLDs
-	}
-	return headerIPLDs, nil
+	return ipfs.BlockModel{
+		Data: header.RawData(),
+		CID:  header.Cid().String(),
+	}, nil
 }
 
 // FetchTrxs fetches transactions

pkg/super_node/btc/retriever.go

@@ -57,7 +57,7 @@ func (ecr *CIDRetriever) RetrieveLastBlockNumber() (int64, error) {
 }
 
 // Retrieve is used to retrieve all of the CIDs which conform to the passed StreamFilters
-func (ecr *CIDRetriever) Retrieve(filter shared.SubscriptionSettings, blockNumber int64) (shared.CIDsForFetching, bool, error) {
+func (ecr *CIDRetriever) Retrieve(filter shared.SubscriptionSettings, blockNumber int64) ([]shared.CIDsForFetching, bool, error) {
 	streamFilter, ok := filter.(*SubscriptionSettings)
 	if !ok {
 		return nil, true, fmt.Errorf("btc retriever expected filter type %T got %T", &SubscriptionSettings{}, filter)
@@ -68,38 +68,42 @@ func (ecr *CIDRetriever) Retrieve(filter shared.SubscriptionSettings, blockNumbe
 		return nil, true, err
 	}
 
-	cw := new(CIDWrapper)
-	cw.BlockNumber = big.NewInt(blockNumber)
 	// Retrieve cached header CIDs
-	if !streamFilter.HeaderFilter.Off {
-		cw.Headers, err = ecr.RetrieveHeaderCIDs(tx, blockNumber)
-		if err != nil {
-			if err := tx.Rollback(); err != nil {
-				log.Error(err)
-			}
-			log.Error("header cid retrieval error")
-			return nil, true, err
+	headers, err := ecr.RetrieveHeaderCIDs(tx, blockNumber)
+	if err != nil {
+		if err := tx.Rollback(); err != nil {
+			log.Error(err)
 		}
+		log.Error("header cid retrieval error")
+		return nil, true, err
 	}
-	// Retrieve cached trx CIDs
-	if !streamFilter.TxFilter.Off {
-		cw.Transactions, err = ecr.RetrieveTxCIDs(tx, streamFilter.TxFilter, blockNumber)
-		if err != nil {
-			if err := tx.Rollback(); err != nil {
-				log.Error(err)
-			}
-			log.Error("transaction cid retrieval error")
-			return nil, true, err
+	cws := make([]shared.CIDsForFetching, len(headers))
+	empty := true
+	for i, header := range headers {
+		cw := new(CIDWrapper)
+		cw.BlockNumber = big.NewInt(blockNumber)
+		if !streamFilter.HeaderFilter.Off {
+			cw.Header = header
+			empty = false
 		}
+		// Retrieve cached trx CIDs
+		if !streamFilter.TxFilter.Off {
+			cw.Transactions, err = ecr.RetrieveTxCIDs(tx, streamFilter.TxFilter, header.ID)
+			if err != nil {
+				if err := tx.Rollback(); err != nil {
+					log.Error(err)
+				}
+				log.Error("transaction cid retrieval error")
+				return nil, true, err
+			}
+			if len(cw.Transactions) > 0 {
+				empty = false
+			}
+		}
+		cws[i] = cw
 	}
-	return cw, empty(cw), tx.Commit()
-}
 
-func empty(cidWrapper *CIDWrapper) bool {
-	if len(cidWrapper.Transactions) > 0 || len(cidWrapper.Headers) > 0 {
-		return false
-	}
-	return true
+	return cws, empty, tx.Commit()
 }
 
 // RetrieveHeaderCIDs retrieves and returns all of the header cids at the provided blockheight
@@ -111,32 +115,10 @@ func (ecr *CIDRetriever) RetrieveHeaderCIDs(tx *sqlx.Tx, blockNumber int64) ([]H
 	return headers, tx.Select(&headers, pgStr, blockNumber)
 }
 
-/*
-type TxModel struct {
-	ID          int64  `db:"id"`
-	HeaderID    int64  `db:"header_id"`
-	Index       int64  `db:"index"`
-	TxHash      string `db:"tx_hash"`
-	CID         string `db:"cid"`
-	SegWit      bool   `db:"segwit"`
-	WitnessHash string `db:"witness_hash"`
-}
-// TxFilter contains filter settings for txs
-type TxFilter struct {
-	Off bool
-	Index         int64    // allow filtering by index so that we can filter for only coinbase transactions (index 0) if we want to
-	Segwit        bool     // allow filtering for segwit trxs
-	WitnessHashes []string // allow filtering for specific witness hashes
-	PkScriptClass uint8 // allow filtering for txs that have at least one tx output with the specified pkscript class
-	MultiSig bool  // allow filtering for txs that have at least one tx output that requires more than one signature
-	Addresses []string // allow filtering for txs that have at least one tx output with at least one of the provided addresses
-}
-*/
-
 // RetrieveTxCIDs retrieves and returns all of the trx cids at the provided blockheight that conform to the provided filter parameters
 // also returns the ids for the returned transaction cids
-func (ecr *CIDRetriever) RetrieveTxCIDs(tx *sqlx.Tx, txFilter TxFilter, blockNumber int64) ([]TxModel, error) {
-	log.Debug("retrieving transaction cids for block ", blockNumber)
+func (ecr *CIDRetriever) RetrieveTxCIDs(tx *sqlx.Tx, txFilter TxFilter, headerID int64) ([]TxModel, error) {
+	log.Debug("retrieving transaction cids for header id ", headerID)
 	args := make([]interface{}, 0, 3)
 	results := make([]TxModel, 0)
 	id := 1
@@ -147,8 +129,8 @@ func (ecr *CIDRetriever) RetrieveTxCIDs(tx *sqlx.Tx, txFilter TxFilter, blockNum
 			WHERE transaction_cids.header_id = header_cids.id
 			AND tx_inputs.tx_id = transaction_cids.id
 			AND tx_outputs.tx_id = transaction_cids.id
-			AND header_cids.block_number = $%d`, id)
-	args = append(args, blockNumber)
+			AND header_cids.id = $%d`, id)
+	args = append(args, headerID)
 	id++
 	if txFilter.Segwit {
 		pgStr += ` AND transaction_cids.segwit = true`

pkg/super_node/btc/types.go

@@ -58,7 +58,7 @@ type CIDPayload struct {
 // Passed to IPLDFetcher
 type CIDWrapper struct {
 	BlockNumber  *big.Int
-	Headers      []HeaderModel
+	Header       HeaderModel
 	Transactions []TxModel
 }
 
@@ -66,7 +66,7 @@ type CIDWrapper struct {
 // Returned by IPLDFetcher and ResponseFilterer
 type IPLDs struct {
 	BlockNumber  *big.Int
-	Headers      []ipfs.BlockModel
+	Header       ipfs.BlockModel
 	Transactions []ipfs.BlockModel
 }