address review feedback

chain/datasource/datasource.go

@@ -278,7 +278,7 @@ func (t *DataSource) MinerLoad(store adt.Store, act *types.Actor) (miner.State,
 	return miner.Load(store, act)
 }
 
-func (t *DataSource) ShouldBrunFn(ctx context.Context, ts *types.TipSet) (lens.ShouldBurnFn, error) {
+func (t *DataSource) ShouldBurnFn(ctx context.Context, ts *types.TipSet) (lens.ShouldBurnFn, error) {
 	return t.node.BurnFundsFn(ctx, ts)
 }
 

lens/interface.go

@@ -91,39 +91,47 @@ type BlockMessages struct {
 	SecpMessages []*types.SignedMessage // SECP messages in block `Block`
 }
 
+// BlockMessageReceipts contains a block its messages and their corresponding receipts.
+// The Receipts are one-to-one with Messages index.
 type BlockMessageReceipts struct {
-	Block                 *types.BlockHeader
-	Message               []types.ChainMsg
-	Receipt               []*types.MessageReceipt
+	Block *types.BlockHeader
+	// Messages contained in Block.
+	Messages []types.ChainMsg
+	// Receipts contained in Block.
+	Receipts []*types.MessageReceipt
+	// MessageExectionIndex contains a mapping of Messages to their execution order in the tipset they were included.
 	MessageExecutionIndex map[types.ChainMsg]int
 }
 
+type MessageReceiptIterator struct {
+	idx      int
+	msgs     []types.ChainMsg
+	receipts []*types.MessageReceipt
+	exeIdx   map[types.ChainMsg]int
+}
+
+// Iterator returns a MessageReceiptIterator to conveniently iterate messages, their execution index, and their respective receipts.
 func (bmr *BlockMessageReceipts) Iterator() (*MessageReceiptIterator, error) {
-	if len(bmr.Message) != len(bmr.Receipt) {
-		return nil, fmt.Errorf("invalid construction, expected equal number receipts (%d) and messages (%d)", len(bmr.Receipt), len(bmr.Message))
+	if len(bmr.Messages) != len(bmr.Receipts) {
+		return nil, fmt.Errorf("invalid construction, expected equal number receipts (%d) and messages (%d)", len(bmr.Receipts), len(bmr.Messages))
 	}
 	return &MessageReceiptIterator{
 		idx:      0,
-		msgs:     bmr.Message,
-		receipts: bmr.Receipt,
+		msgs:     bmr.Messages,
+		receipts: bmr.Receipts,
 		exeIdx:   bmr.MessageExecutionIndex,
 	}, nil
 }
 
-type MessageReceiptIterator struct {
-	idx      int
-	msgs     []types.ChainMsg
-	receipts []*types.MessageReceipt
-	exeIdx   map[types.ChainMsg]int
-}
-
+// HasNext returns `true` while there are messages/receipts to iterate.
 func (mri *MessageReceiptIterator) HasNext() bool {
 	if mri.idx < len(mri.msgs) {
 		return true
 	}
 	return false
 }
 
+// Next returns the next message, its execution index, and receipt in the MessageReceiptIterator.
 func (mri *MessageReceiptIterator) Next() (types.ChainMsg, int, *types.MessageReceipt) {
 	if mri.HasNext() {
 		msg := mri.msgs[mri.idx]
@@ -135,6 +143,7 @@ func (mri *MessageReceiptIterator) Next() (types.ChainMsg, int, *types.MessageRe
 	return nil, -1, nil
 }
 
+// Reset resets the MessageReceiptIterator to the first message/receipt.
 func (mri *MessageReceiptIterator) Reset() {
 	mri.idx = 0
 }

lens/lily/impl.go

@@ -563,6 +563,16 @@ func (m *LilyNodeAPI) MessagesForTipSetBlocks(ctx context.Context, ts *types.Tip
 
 // TipSetMessageReceipts returns the blocks and messages in `pts` and their corresponding receipts from `ts` matching block order in tipset (`pts`).
 func (m *LilyNodeAPI) TipSetMessageReceipts(ctx context.Context, ts, pts *types.TipSet) ([]*lens.BlockMessageReceipts, error) {
+	// sanity check args
+	if ts.Key().IsEmpty() {
+		return nil, fmt.Errorf("tipset cannot be empty")
+	}
+	if pts.Key().IsEmpty() {
+		return nil, fmt.Errorf("parent tipset cannot be empty")
+	}
+	if !types.CidArrsEqual(ts.Parents().Cids(), pts.Cids()) {
+		return nil, fmt.Errorf("mismatching tipset (%s) and parent tipset (%s)", ts.Key().String(), pts.Key().String())
+	}
 	// returned BlockMessages match block order in tipset
 	blkMsgs, err := m.ChainAPI.Chain.BlockMsgsForTipset(ctx, pts)
 	if err != nil {
@@ -597,7 +607,7 @@ func (m *LilyNodeAPI) TipSetMessageReceipts(ctx context.Context, ts, pts *types.
 			return nil, fmt.Errorf("loading message receipts %w", err)
 		}
 	}
-	// so we only load the receipt array one
+	// so we only load the receipt array once
 	getReceipt := func(idx int) (*types.MessageReceipt, error) {
 		var r types.MessageReceipt
 		if found, err := rs.Get(uint64(idx), &r); err != nil {
@@ -622,9 +632,9 @@ func (m *LilyNodeAPI) TipSetMessageReceipts(ctx context.Context, ts, pts *types.
 			// block containing messages
 			Block: pts.Blocks()[blkIdx],
 			// total messages returned equal to sum of bls and secp messages
-			Message: make([]types.ChainMsg, len(msgs.BlsMessages)+len(msgs.SecpkMessages)),
+			Messages: make([]types.ChainMsg, len(msgs.BlsMessages)+len(msgs.SecpkMessages)),
 			// total receipts returned equal to sum of bls and secp messages
-			Receipt: make([]*types.MessageReceipt, len(msgs.BlsMessages)+len(msgs.SecpkMessages)),
+			Receipts: make([]*types.MessageReceipt, len(msgs.BlsMessages)+len(msgs.SecpkMessages)),
 			// index of message indicating execution order.
 			MessageExecutionIndex: make(map[types.ChainMsg]int),
 		}
@@ -634,8 +644,8 @@ func (m *LilyNodeAPI) TipSetMessageReceipts(ctx context.Context, ts, pts *types.
 			if err != nil {
 				return nil, err
 			}
-			out[blkIdx].Message[msgIdx] = msgs.BlsMessages[blsIdx]
-			out[blkIdx].Receipt[receiptIdx] = receipt
+			out[blkIdx].Messages[msgIdx] = msgs.BlsMessages[blsIdx]
+			out[blkIdx].Receipts[receiptIdx] = receipt
 			out[blkIdx].MessageExecutionIndex[msgs.BlsMessages[blsIdx]] = executionIndex
 			msgIdx++
 			receiptIdx++
@@ -647,8 +657,8 @@ func (m *LilyNodeAPI) TipSetMessageReceipts(ctx context.Context, ts, pts *types.
 			if err != nil {
 				return nil, err
 			}
-			out[blkIdx].Message[msgIdx] = msgs.SecpkMessages[secpIdx]
-			out[blkIdx].Receipt[receiptIdx] = receipt
+			out[blkIdx].Messages[msgIdx] = msgs.SecpkMessages[secpIdx]
+			out[blkIdx].Receipts[receiptIdx] = receipt
 			out[blkIdx].MessageExecutionIndex[msgs.SecpkMessages[secpIdx]] = executionIndex
 			msgIdx++
 			receiptIdx++

tasks/api.go

@@ -64,5 +64,5 @@ type DataSource interface {
 
 	MinerLoad(store adt.Store, act *types.Actor) (miner.State, error)
 
-	ShouldBrunFn(ctx context.Context, ts *types.TipSet) (lens.ShouldBurnFn, error)
+	ShouldBurnFn(ctx context.Context, ts *types.TipSet) (lens.ShouldBurnFn, error)
 }

tasks/messages/gasoutput/task.go

@@ -74,7 +74,7 @@ func (t *Task) ProcessTipSets(ctx context.Context, current *types.TipSet, execut
 	var burnFn lens.ShouldBurnFn
 	grp.Go(func() error {
 		var err error
-		burnFn, err = t.node.ShouldBrunFn(grpCtx, executed)
+		burnFn, err = t.node.ShouldBurnFn(grpCtx, executed)
 		if err != nil {
 			return fmt.Errorf("getting should burn function: %w", err)
 		}