Is it possible to terminate a Go channel to a sink goroutine?

I have a goroutine that reads a file in chunks and passes them through a channel to another goroutine that calculates a checksum for the file. The consuming goroutine is kind of a sink for the channel.

Is it possible to have the consumer return the checksum string after all of the bytes have been received from the channel, or must I use a string stream to return the value? For the former, I get a deadlock, but I am not using any waitgroups; Not sure how to apply them in this case.

I'd appreciate your comments and thank you for your help.

// main()
	var done = make(chan bool)
	defer close(done)
	checksum := FileCheckSum(ReadFileToChannel("mydata4.bin", done), done)
	fmt.Println("Final Checksum: ", checksum)

// FileCheckSum()
import (
	"crypto/sha256"
	"encoding/hex"
	"log"
)

func FileCheckSum(cin <-chan []byte, done <-chan bool) string {

	chunkStream := make(chan []byte)
	checksum := func(in <-chan []byte, done <-chan bool) string {
		defer close(chunkStream)
		
		hasher := sha256.New()

		for chunk := range in {
			_, err := hasher.Write(chunk[:len(chunk)])

			if err != nil {
				log.Fatal(err)
			}

			select {
			case <-done:
				return ""
			}
		}

		return hex.EncodeToString(hasher.Sum(nil))
	}(cin, done)
	return checksum
}

Yes, and let me simplify your code - and read comments inside the following code.
Try this:

package main

import (
	"crypto/rand"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"log"
)

func FileCheckSum(cin <-chan []byte) string {
	h := sha256.New()

	for buf := range cin {
		_, err := h.Write(buf)
		if err != nil {
			log.Fatal(err)
		}
	}

	return hex.EncodeToString(h.Sum(nil))
}

func ReadFileToChannel(filename string) chan []byte {
	gen := make(chan []byte)
	go func() { // goroutine
		defer close(gen)          // signal end of reading file
		for i := 0; i < 10; i++ { // e.g. read from file
			b := make([]byte, 16)  // make new slice every time
			_, err := rand.Read(b) // fill it
			if err != nil {
				log.Fatal(err)
			}
			gen <- b // send it
		}
	}()
	return gen
}

func main() {
	ch := ReadFileToChannel("mydata4.bin")
	crc := FileCheckSum(ch)
	fmt.Println("Final Checksum: ", crc)
}

Output:

Final Checksum:  1e0ad2ec11bfe77833af670c6de296f530c2217d18aa1b8e600feddf6998fb95

Note

Your code needs a code review, you may head over here for the code review.