Merge branch 'release' into 'XX-3566_const_time_comparisons'

# Conflicts:
#   cmix/follow.go

.gitlab-ci.yml

@@ -17,6 +17,7 @@ stages:
   - test
   - build
   - trigger_integration
+  - version_check
 
 test:
   stage: test
@@ -72,8 +73,19 @@ tag:
     image: $DOCKER_IMAGE
     script:
         - git remote add origin_tags git@$GITLAB_SERVER:elixxir/client.git || true
-        - git tag $(release/client.linux64 version | grep "Elixxir Client v"| cut -d ' ' -f3) -f
-        - git push origin_tags -f --tags
+        - git tag $(release/client.linux64 version | grep "Elixxir Client v"| cut -d ' ' -f3)
+        - git push origin_tags --tags
+
+version_check:
+    stage: version_check
+    only:
+        - master
+        - release
+    image: $DOCKER_IMAGE
+    script:
+        - GITTAG=$(git describe --tags)
+        - CODEVERS=$(release/client.darwin64 version | grep "Elixxir Client v"| cut -d ' ' -f3) 
+        - if [[ $GITTAG != $CODEVERS ]]; then echo "VERSION NUMBER BAD $GITTAG != $CODEVER"; exit -1; fi
 
 bindings-ios:
   stage: build

README.md

@@ -462,19 +462,19 @@ use the correct versions as listed below.
 
 |                      | Version | Download                                                            | Documentation                                                           |
 |----------------------|--------:|---------------------------------------------------------------------|-------------------------------------------------------------------------|
-| `protoc`             |  3.15.6 | https://github.com/protocolbuffers/protobuf/releases/tag/v3.15.6    | https://developers.google.com/protocol-buffers/docs/gotutorial          |
-| `protoc-gen-go`      |  1.27.1 | https://github.com/protocolbuffers/protobuf-go/releases/tag/v1.27.1 | https://pkg.go.dev/google.golang.org/protobuf@v1.27.1/cmd/protoc-gen-go |
+| `protoc`             |  3.21.9 | https://github.com/protocolbuffers/protobuf/releases/tag/v3.21.9    | https://developers.google.com/protocol-buffers/docs/gotutorial          |
+| `protoc-gen-go`      |  1.28.1 | https://github.com/protocolbuffers/protobuf-go/releases/tag/v1.28.1 | https://pkg.go.dev/google.golang.org/protobuf@v1.28.1/cmd/protoc-gen-go |
 | `protoc-gen-go-grpc` |   1.2.0 | https://github.com/grpc/grpc-go/releases/tag/v1.2.0                 | https://pkg.go.dev/google.golang.org/grpc/cmd/protoc-gen-go-grpc        |
 
 1. Download the correct release of `protoc` from the
    [release page](https://github.com/protocolbuffers/protobuf/releases) or use
    the link from the table above to get the download for your OS.
 
-       wget https://github.com/protocolbuffers/protobuf/releases/download/v3.15.6/protoc-3.15.6-linux-x86_64.zip
+       wget https://github.com/protocolbuffers/protobuf/releases/download/v3.21.9/protoc-3.21.9-linux-x86_64.zip
 
 2. Extract the files to a folder, such as `$HOME/.local`.
 
-       unzip protoc-3.15.6-linux-x86_64.zip -d $HOME/.local
+       unzip protoc-3.21.9-linux-x86_64.zip -d $HOME/.local
 
 3. Add the selected directory to your environment’s `PATH` variable, make sure
    to include it in your `.profile` or `.bashrc` file. Also, include your go bin
@@ -492,18 +492,18 @@ use the correct versions as listed below.
 
    Which prints the current version
 
-       libprotoc 3.15.6
+       libprotoc 3.21.9
 
 5. Next, download `protoc-gen-go` and `protoc-gen-go-grpc` using the version
    found in the table above.
 
-       go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.27
+       go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.28
        go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.2
 
 6. Check that `protoc-gen-go` is installed with the correct version.
 
        protoc-gen-go --version
-       protoc-gen-go v1.27.1
+       protoc-gen-go v1.28.1
 
 7. Check that `protoc-gen-go-grpc` is installed with the correct version.
 

bindings/channels.go

@@ -906,6 +906,9 @@ func (cm *ChannelsManager) SendAdminGeneric(adminPrivateKey,
 	chanMsgId, rnd, ephId, err := cm.api.SendAdminGeneric(rsaPrivKey,
 		chanId, msgTy, message, time.Duration(leaseTimeMS),
 		params.CMIX)
+	if err != nil {
+		return nil, err
+	}
 
 	// Construct send report
 	return constructChannelSendReport(chanMsgId, rnd.ID, ephId)

bindings/fileTransfer.go

@@ -8,7 +8,9 @@
 package bindings
 
 import (
+	"encoding/base64"
 	"encoding/json"
+	"github.com/pkg/errors"
 	jww "github.com/spf13/jwalterweatherman"
 	"time"
 
@@ -23,62 +25,77 @@ import (
 ////////////////////////////////////////////////////////////////////////////////
 
 // FileTransfer object is a bindings-layer struct which wraps a
-// fileTransfer.FileTransfer interface.
+// [fileTransfer.FileTransfer] interface.
 type FileTransfer struct {
 	w *e2e.Wrapper
 }
 
-// ReceivedFile is a public struct that contains the metadata of a new file
-// transfer.
+// ReceivedFile contains the metadata of a new received file transfer. It is
+// received from a sender on a new file transfer. It is returned by
+// [ReceiveFileCallback.Callback].
 //
 // Example JSON:
 //  {
-//    "TransferID":"B4Z9cwU18beRoGbk5xBjbcd5Ryi9ZUFA2UBvi8FOHWo=",
-//    "SenderID":"emV6aW1hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD",
-//    "Preview":"aXQncyBtZSBhIHByZXZpZXc=",
+//    "TransferID": "0U+QY1nMOUzQGxGpqZyxDw8Cd6+qm8t870CzLtVoUM8=",
+//    "SenderID": "UL3+S8XdJHAfUtCUm7iZMxW8orR8Nd5JM9Ky7/5jds8D",
+//    "Preview": "aXQNcyBtZSBhIHByZXZpZXc=",
 //    "Name": "testfile.txt",
 //    "Type": "text file",
 //    "Size": 2048
 //  }
 type ReceivedFile struct {
-	TransferID []byte // ID of the file transfer
-	SenderID   []byte // ID of the file sender
+	TransferID *ftCrypto.TransferID // ID of the file transfer
+	SenderID   *id.ID               // ID of the file sender
 	Preview    []byte               // A preview of the file
 	Name       string               // Name of the file
 	Type       string               // String that indicates type of file
 	Size       int                  // The size of the file, in bytes
 }
 
-// FileSend is a public struct that contains the file contents and its name,
-// type, and preview.
+// FileSend contains the file and its metadata to send. This structure is JSON
+// marshalled and passed as the payload to [FileTransfer.Send].
+//
+// Example JSON:
 //  {
 //    "Name": "testfile.txt",
 //    "Type": "text file",
-//    "Preview":"aXQncyBtZSBhIHByZXZpZXc=",
-//    "Contents":"VGhpcyBpcyB0aGUgZnVsbCBjb250ZW50cyBvZiB0aGUgZmlsZSBpbiBieXRlcw=="
+//    "Preview": "RMlsZSBwCmV2aWV3Lg==",
+//    "Contents": "RMlsZSBjb250ZW50cy4="
 //  }
 type FileSend struct {
-	Name     string // Name of the file
-	Type     string // String that indicates type of file
-	Preview  []byte // A preview of the file
-	Contents []byte // Full contents of the file
+	// Name is the human-readable file name. Get max length from
+	// [FileTransfer.MaxFileNameLen].
+	Name string
+
+	// Type is a shorthand that identifies the type of file. Get max length from
+	// [FileTransfer.MaxFileTypeLen].
+	Type string
+
+	// Preview of the file data (e.g. a thumbnail). Get max length from
+	// [FileTransfer.MaxPreviewSize].
+	Preview []byte
+
+	// Contents is the full file contents. Get max length from
+	// [FileTransfer.MaxFileSize].
+	Contents []byte
 }
 
-// Progress is a public struct that represents the progress of an in-progress
-// file transfer.
+// Progress contains the progress information of a transfer. It is returned by
+// [FileTransferSentProgressCallback.Callback] and
+// [FileTransferReceiveProgressCallback.Callback].
 //
 // Example JSON:
 //  {
+//    "TransferID": "RyJcMqtI3IIM1+YMxRwCcFiOX6AGuIzS+vQaPnqXVT8=",
 //    "Completed": false,
 //    "Transmitted": 128,
-//    "Total":2048,
-//    "Err":null
+//    "Total": 2048
 //  }
 type Progress struct {
+	TransferID  *ftCrypto.TransferID // Transfer ID
 	Completed   bool                 // Status of transfer (true if done)
 	Transmitted int                  // Number of file parts sent/received
 	Total       int                  // Total number of file parts
-	Err         error // Error status (if any)
 }
 
 // ReceiveFileCallback is a bindings-layer interface that contains a callback
@@ -87,33 +104,42 @@ type ReceiveFileCallback interface {
 	// Callback is called when a new file transfer is received.
 	//
 	// Parameters:
-	//  - payload - the JSON marshalled bytes of a ReceivedFile object.
-	//  - err - any errors that occurred during reception
-	Callback(payload []byte, err error)
+	//  - payload - JSON of [ReceivedFile], which contains information about the
+	//    incoming file transfer.
+	Callback(payload []byte)
 }
 
 // FileTransferSentProgressCallback is a bindings-layer interface that contains
 // a callback that is called when the sent progress updates.
 type FileTransferSentProgressCallback interface {
-	// Callback is called when a file part is sent or an error occurs.
+	// Callback is called when a file part is sent or an error occurs. Once a
+	// transfer completes, it should be closed using [FileTransfer.CloseSend].
 	//
 	// Parameters:
-	//  - payload - the JSON marshalled bytes of a Progress object.
-	//  - t - tracker that allows the lookup of the status of any file part
-	//  - err - any errors that occurred during sending
+	//  - payload - JSON of [Progress], which describes the progress of the
+	//    current transfer.
+	//  - t - file part tracker that allows the lookup of the status of
+	//    individual file parts.
+	//  - err - Fatal errors during sending. If an error is returned, the
+	//    transfer has failed and will not resume. It must be cleared using
+	//    [FileTransfer.CloseSend].
 	Callback(payload []byte, t *FilePartTracker, err error)
 }
 
 // FileTransferReceiveProgressCallback is a bindings-layer interface that is
 // called with the progress of a received file.
-//
 type FileTransferReceiveProgressCallback interface {
-	// Callback is called when a file part is sent or an error occurs.
+	// Callback is called when a file part is received or an error occurs. Once
+	// a transfer completes, the file can be received using
+	// [FileTransfer.Receive].
 	//
 	// Parameters:
-	//  - payload - the JSON marshalled bytes of a Progress object.
-	//  - t - tracker that allows the lookup of the status of any file part
-	//  - err - any errors that occurred during sending
+	//  - payload - JSON of [Progress], which describes the progress of the
+	//    current transfer.
+	//  - t - file part tracker that allows the lookup of the status of
+	//    individual file parts.
+	//  - err - Fatal errors during receiving. If an error is returned, the
+	//    transfer has failed and will not resume.
 	Callback(payload []byte, t *FilePartTracker, err error)
 }
 
@@ -124,18 +150,28 @@ type FileTransferReceiveProgressCallback interface {
 // InitFileTransfer creates a bindings-level file transfer manager.
 //
 // Parameters:
-//  - e2eID - e2e object ID in the tracker
-//  - paramsJSON - JSON marshalled fileTransfer.Params
+//  - e2eID - ID of [E2e] object in tracker.
+//  - receiveFileCallback - A callback that is called when a new file transfer
+//    is received.
+//  - e2eFileTransferParamsJson - JSON of
+//    [gitlab.com/elixxir/client/fileTransfer/e2e.Params].
+//  - fileTransferParamsJson - JSON of [fileTransfer.Params].
+//
+// Returns:
+//  - New [FileTransfer] object.
 func InitFileTransfer(e2eID int, receiveFileCallback ReceiveFileCallback,
 	e2eFileTransferParamsJson, fileTransferParamsJson []byte) (*FileTransfer, error) {
-	jww.INFO.Printf("Calling InitFileTransfer()")
+	jww.INFO.Printf("[FT] Calling InitFileTransfer(e2eID:%d params:%s)",
+		e2eID, fileTransferParamsJson)
+
 	// Get user from singleton
 	user, err := e2eTrackerSingleton.get(e2eID)
 	if err != nil {
 		return nil, err
 	}
 
-	e2eFileTransferParams, err := parseE2eFileTransferParams(e2eFileTransferParamsJson)
+	e2eFileTransferParams, err :=
+		parseE2eFileTransferParams(e2eFileTransferParamsJson)
 	if err != nil {
 		return nil, err
 	}
@@ -147,17 +183,26 @@ func InitFileTransfer(e2eID int, receiveFileCallback ReceiveFileCallback,
 
 	// Create file transfer manager
 	m, err := fileTransfer.NewManager(fileTransferParams, user.api)
+	if err != nil {
+		return nil, errors.Errorf(
+			"could not create new file transfer manager: %+v", err)
+	}
 
 	rcb := func(tid *ftCrypto.TransferID, fileName, fileType string,
 		sender *id.ID, size uint32, preview []byte) {
-		receiveFileCallback.Callback(json.Marshal(ReceivedFile{
-			TransferID: tid.Bytes(),
-			SenderID:   sender.Marshal(),
+		data, err := json.Marshal(ReceivedFile{
+			TransferID: tid,
+			SenderID:   sender,
 			Preview:    preview,
 			Name:       fileName,
 			Type:       fileType,
 			Size:       int(size),
-		}))
+		})
+		if err != nil {
+			jww.FATAL.Panicf(
+				"[FT] Failed to JSON marshal ReceivedFile: %+v", err)
+		}
+		receiveFileCallback.Callback(data)
 	}
 
 	w, err := e2e.NewWrapper(rcb, e2eFileTransferParams, m, user.api)
@@ -175,21 +220,31 @@ func InitFileTransfer(e2eID int, receiveFileCallback ReceiveFileCallback,
 	return &FileTransfer{w: w}, nil
 }
 
-// Send is the bindings-level function for sending a file.
+// Send initiates the sending of a file to a recipient and returns a transfer ID
+// that uniquely identifies this file transfer. Progress for the file transfer
+// is reported to that passed in callback.
 //
 // Parameters:
-//  - payload - JSON marshalled FileSend
-//  - recipientID - marshalled recipient id.ID
-//  - retry - number of retries allowed
-//  - callback - callback that reports file sending progress
-//  - period - Duration (in ms) to wait between progress callbacks triggering.
-//    This value should depend on how frequently you want to receive updates,
-//    and should be tuned to your implementation.
+//  - payload - JSON of [FileSend], which contains the file contents and its
+//    metadata.
+//  - recipientID - marshalled bytes of the recipient's [id.ID].
+//  - retry - The number of sending retries allowed on send failure (e.g. a
+//    retry of 2.0 with 6 parts means 12 total possible sends).
+//  - callback - A callback that reports the progress of the file transfer. The
+//    callback is called once on initialization, on every progress update (or
+//    less if restricted by the period), or on fatal error.
+//  - period - The progress callback will be limited from triggering only once
+//    per period. It is a duration in milliseconds. This value should depend on
+//    how frequently you want to receive updates, and should be tuned to your
+//    implementation.
 //
 // Returns:
-//  - []byte - unique file transfer ID
+//  - The bytes of the unique [fileTransfer.TransferID].
 func (f *FileTransfer) Send(payload, recipientID []byte, retry float32,
 	callback FileTransferSentProgressCallback, period int) ([]byte, error) {
+	jww.INFO.Printf("[FT] Sending file transfer to %s.",
+		base64.StdEncoding.EncodeToString(recipientID))
+
 	// Unmarshal recipient ID
 	recipient, err := id.Unmarshal(recipientID)
 	if err != nil {
@@ -201,25 +256,29 @@ func (f *FileTransfer) Send(payload, recipientID []byte, retry float32,
 	// Wrap transfer progress callback to be passed to fileTransfer layer
 	cb := func(completed bool, arrived, total uint16,
 		st fileTransfer.SentTransfer, t fileTransfer.FilePartTracker, err error) {
-		prog := &Progress{
+		progress := &Progress{
+			TransferID:  st.TransferID(),
 			Completed:   completed,
 			Transmitted: int(arrived),
 			Total:       int(total),
-			Err:         err,
 		}
-		pm, err := json.Marshal(prog)
+		pm, err2 := json.Marshal(progress)
+		if err2 != nil {
+			jww.FATAL.Panicf(
+				"[FT] Failed to JSON marshal sent Progress object: %+v", err)
+		}
 		callback.Callback(pm, &FilePartTracker{t}, err)
 	}
 
 	// Unmarshal payload
-	fs := &FileSend{}
-	err = json.Unmarshal(payload, fs)
-	if err != nil {
+	var fs FileSend
+	if err = json.Unmarshal(payload, &fs); err != nil {
 		return nil, err
 	}
 
 	// Send file
-	ftID, err := f.w.Send(recipient, fs.Name, fs.Type, fs.Contents, retry, fs.Preview, cb, p)
+	ftID, err := f.w.Send(
+		recipient, fs.Name, fs.Type, fs.Contents, retry, fs.Preview, cb, p)
 	if err != nil {
 		return nil, err
 	}
@@ -230,28 +289,28 @@ func (f *FileTransfer) Send(payload, recipientID []byte, retry float32,
 
 // Receive returns the full file on the completion of the transfer. It deletes
 // internal references to the data and unregisters any attached progress
-// callbacks. Returns an error if the transfer is not complete, the full file
+// callback. Returns an error if the transfer is not complete, the full file
 // cannot be verified, or if the transfer cannot be found.
 //
-// Receive can only be called once the progress callback returns that the
-// file transfer is complete.
+// Receive can only be called once the progress callback returns that the file
+// transfer is complete.
 //
 // Parameters:
-//  - tidBytes - file transfer ID
+//  - tidBytes - The file transfer's unique [fileTransfer.TransferID].
 func (f *FileTransfer) Receive(tidBytes []byte) ([]byte, error) {
 	tid := ftCrypto.UnmarshalTransferID(tidBytes)
 	return f.w.Receive(&tid)
 }
 
 // CloseSend deletes a file from the internal storage once a transfer has
-// completed or reached the retry limit. Returns an error if the transfer has
-// not run out of retries.
+// completed or reached the retry limit. If neither of those condition are met,
+// an error is returned.
 //
 // This function should be called once a transfer completes or errors out (as
 // reported by the progress callback).
 //
 // Parameters:
-//  - tidBytes - file transfer ID
+//  - tidBytes - the file transfer's unique [fileTransfer.TransferID].
 func (f *FileTransfer) CloseSend(tidBytes []byte) error {
 	tid := ftCrypto.UnmarshalTransferID(tidBytes)
 	return f.w.CloseSend(&tid)
@@ -264,26 +323,39 @@ func (f *FileTransfer) CloseSend(tidBytes []byte) error {
 // RegisterSentProgressCallback allows for the registration of a callback to
 // track the progress of an individual sent file transfer.
 //
-// SentProgressCallback is auto registered on Send; this function should be
-// called when resuming clients or registering extra callbacks.
+// The callback will be called immediately when added to report the current
+// progress of the transfer. It will then call every time a file part
+// arrives, the transfer completes, or a fatal error occurs. It is called at
+// most once every period regardless of the number of progress updates.
+//
+// In the event that the client is closed and resumed, this function must be
+// used to re-register any callbacks previously registered with this
+// function or Send.
 //
 // Parameters:
-//  - tidBytes - file transfer ID
-//  - callback - callback that reports file reception progress
-//  - period - Duration (in ms) to wait between progress callbacks triggering.
-//    This value should depend on how frequently you want to receive updates,
-//    and should be tuned to your implementation.
+//  - tidBytes - The file transfer's unique [fileTransfer.TransferID].
+//  - callback - A callback that reports the progress of the file transfer. The
+//    callback is called once on initialization, on every progress update (or
+//    less if restricted by the period), or on fatal error.
+//  - period - The progress callback will be limited from triggering only once
+//    per period. It is a duration in milliseconds. This value should depend on
+//    how frequently you want to receive updates, and should be tuned to your
+//    implementation.
 func (f *FileTransfer) RegisterSentProgressCallback(tidBytes []byte,
 	callback FileTransferSentProgressCallback, period int) error {
 	cb := func(completed bool, arrived, total uint16,
 		st fileTransfer.SentTransfer, t fileTransfer.FilePartTracker, err error) {
-		prog := &Progress{
+		progress := &Progress{
+			TransferID:  st.TransferID(),
 			Completed:   completed,
 			Transmitted: int(arrived),
 			Total:       int(total),
-			Err:         err,
 		}
-		pm, err := json.Marshal(prog)
+		pm, err2 := json.Marshal(progress)
+		if err2 != nil {
+			jww.FATAL.Panicf(
+				"[FT] Failed to JSON marshal sent Progress object: %+v", err)
+		}
 		callback.Callback(pm, &FilePartTracker{t}, err)
 	}
 	p := time.Millisecond * time.Duration(period)
@@ -295,25 +367,42 @@ func (f *FileTransfer) RegisterSentProgressCallback(tidBytes []byte,
 // RegisterReceivedProgressCallback allows for the registration of a callback to
 // track the progress of an individual received file transfer.
 //
-// This should be done when a new transfer is received on the ReceiveCallback.
+// The callback will be called immediately when added to report the current
+// progress of the transfer. It will then call every time a file part is
+// received, the transfer completes, or a fatal error occurs. It is called at
+// most once every period regardless of the number of progress updates.
+//
+// In the event that the client is closed and resumed, this function must be
+// used to re-register any callbacks previously registered.
+//
+// Once the callback reports that the transfer has completed, the recipient can
+// get the full file by calling Receive.
 //
 // Parameters:
-//  - tidBytes - file transfer ID
-//  - callback - callback that reports file reception progress
-//  - period - Duration (in ms) to wait between progress callbacks triggering.
-//    This value should depend on how frequently you want to receive updates,
-//    and should be tuned to your implementation.
+//  - tidBytes - The file transfer's unique [fileTransfer.TransferID].
+//  - callback - A callback that reports the progress of the file transfer. The
+//    callback is called once on initialization, on every progress update (or
+//    less if restricted by the period), or on fatal error.
+//  - period - The progress callback will be limited from triggering only once
+//    per period. It is a duration in milliseconds. This value should depend on
+//    how frequently you want to receive updates, and should be tuned to your
+//    implementation.
 func (f *FileTransfer) RegisterReceivedProgressCallback(tidBytes []byte,
 	callback FileTransferReceiveProgressCallback, period int) error {
 	cb := func(completed bool, received, total uint16,
-		rt fileTransfer.ReceivedTransfer, t fileTransfer.FilePartTracker, err error) {
-		prog := &Progress{
+		rt fileTransfer.ReceivedTransfer, t fileTransfer.FilePartTracker,
+		err error) {
+		progress := &Progress{
+			TransferID:  rt.TransferID(),
 			Completed:   completed,
 			Transmitted: int(received),
 			Total:       int(total),
-			Err:         err,
 		}
-		pm, err := json.Marshal(prog)
+		pm, err2 := json.Marshal(progress)
+		if err2 != nil {
+			jww.FATAL.Panicf(
+				"[FT] Failed to JSON marshal received Progress object: %+v", err)
+		}
 		callback.Callback(pm, &FilePartTracker{t}, err)
 	}
 	p := time.Millisecond * time.Duration(period)

bindings/fileTransfer_test.go

@@ -9,6 +9,7 @@ package bindings
 
 import (
 	"encoding/json"
+	"fmt"
 	"testing"
 
 	"gitlab.com/elixxir/crypto/fileTransfer"
@@ -16,52 +17,53 @@ import (
 	"gitlab.com/xx_network/primitives/id"
 )
 
+// Creates example JSON outputs used in documentation.
 func TestFileTransfer_inputs(t *testing.T) {
-	fs := &FileSend{
-		Name:     "testfile.txt",
-		Type:     "text file",
-		Preview:  []byte("it's me a preview"),
-		Contents: []byte("This is the full contents of the file in bytes"),
-	}
-	fsm, _ := json.Marshal(fs)
-	t.Log("FileSend example json:")
-	t.Log(string(fsm))
-	t.Log("\n")
-
+	// ReceivedFile
 	tid, _ := fileTransfer.NewTransferID(csprng.NewSystemRNG())
-	sid := id.NewIdFromString("zezima", id.User, t)
+	sid, _ := id.NewRandomID(csprng.NewSystemRNG(), id.User)
 	rf := &ReceivedFile{
-		TransferID: tid.Bytes(),
-		SenderID:   sid.Marshal(),
+		TransferID: &tid,
+		SenderID:   sid,
 		Preview:    []byte("it's me a preview"),
 		Name:       "testfile.txt",
 		Type:       "text file",
 		Size:       2048,
 	}
-	rfm, _ := json.Marshal(rf)
-	t.Log("ReceivedFile example json:")
-	t.Log(string(rfm))
-	t.Log("\n")
+	rfm, _ := json.MarshalIndent(rf, "", "  ")
+	t.Log("ReceivedFile example JSON:")
+	fmt.Printf("%s\n\n", rfm)
+
+	// FileSend
+	fs := &FileSend{
+		Name:     "testFile",
+		Type:     "txt",
+		Preview:  []byte("File preview."),
+		Contents: []byte("File contents."),
+	}
+	fsm, _ := json.MarshalIndent(fs, "", "  ")
+	t.Log("FileSend example JSON:")
+	fmt.Printf("%s\n\n", fsm)
 
+	// Progress
 	p := &Progress{
+		TransferID:  &tid,
 		Completed:   false,
 		Transmitted: 128,
 		Total:       2048,
-		Err:         nil,
 	}
-	pm, _ := json.Marshal(p)
-	t.Log("Progress example json:")
-	t.Log(string(pm))
-	t.Log("\n")
+	pm, _ := json.MarshalIndent(p, "", "  ")
+	t.Log("Progress example JSON:")
+	fmt.Printf("%s\n\n", pm)
 
+	// EventReport
 	er := &EventReport{
 		Priority:  1,
 		Category:  "Test Events",
 		EventType: "Ping",
 		Details:   "This is an example of an event report",
 	}
-	erm, _ := json.Marshal(er)
-	t.Log("EventReport example json:")
-	t.Log(string(erm))
-	t.Log("\n")
+	erm, _ := json.MarshalIndent(er, "", "  ")
+	t.Log("EventReport example JSON:")
+	fmt.Printf("%s\n\n", erm)
 }

bindings/follow.go

@@ -99,15 +99,26 @@ func (c *Cmix) ReadyToSend() bool {
 		jww.FATAL.Panicf("Failed to get node registration status: %+v", err)
 	}
 
-	// FIXME: This is a fix put in place because not all nodes in the NDF are
-	//  online. This should be fixed.
-	total = 340
-
 	return numReg >= total*7/10
 }
 
+// IsReadyInfo contains information on if the network is ready and how close it
+// is to being ready.
+//
+// Example JSON:
+//
+//	{
+//	  "IsReady": true,
+//	  "HowClose": 0.534
+//	}
+type IsReadyInfo struct {
+	IsReady  bool
+	HowClose float64
+}
+
 // NetworkFollowerStatus gets the state of the network follower. It returns a
 // status with the following values:
+//
 //	Stopped  - 0
 //	Running  - 2000
 //	Stopping - 3000
@@ -144,6 +155,44 @@ func (c *Cmix) GetNodeRegistrationStatus() ([]byte, error) {
 	return json.Marshal(nodeRegReport)
 }
 
+// IsReady returns true if at least percentReady of node registrations has
+// completed. If not all have completed, then it returns false and howClose will
+// be a percent (0-1) of node registrations completed.
+//
+// Parameters:
+//   - percentReady - The percentage of nodes required to be registered with to
+//     be ready. This is a number between 0 and 1.
+//
+// Returns:
+//   - JSON of [IsReadyInfo].
+func (c *Cmix) IsReady(percentReady float64) ([]byte, error) {
+	isReady, howClose := c.api.IsReady(percentReady)
+	return json.Marshal(&IsReadyInfo{isReady, howClose})
+}
+
+// PauseNodeRegistrations stops all node registrations and returns a function to
+// resume them.
+//
+// Parameters:
+//   - timeoutMS - The timeout, in milliseconds, to wait when stopping threads
+//     before failing.
+func (c *Cmix) PauseNodeRegistrations(timeoutMS int) error {
+	timeout := time.Duration(timeoutMS) * time.Millisecond
+	return c.api.PauseNodeRegistrations(timeout)
+}
+
+// ChangeNumberOfNodeRegistrations changes the number of parallel node
+// registrations up to the initialized maximum.
+//
+// Parameters:
+//   - toRun - The number of parallel node registrations.
+//   - timeoutMS - The timeout, in milliseconds, to wait when changing node
+//     registrations before failing.
+func (c *Cmix) ChangeNumberOfNodeRegistrations(toRun, timeoutMS int) error {
+	timeout := time.Duration(timeoutMS) * time.Millisecond
+	return c.api.ChangeNumberOfNodeRegistrations(toRun, timeout)
+}
+
 // HasRunningProcessies checks if any background threads are running and returns
 // true if one or more are.
 //
@@ -168,6 +217,7 @@ func (c *Cmix) IsHealthy() bool {
 //   - []byte - A JSON marshalled list of all running processes.
 //
 // JSON Example:
+//
 //	{
 //	  "FileTransfer{BatchBuilderThread, FilePartSendingThread#0, FilePartSendingThread#1, FilePartSendingThread#2, FilePartSendingThread#3}",
 //	  "MessageReception Worker 0"
@@ -220,6 +270,7 @@ func (c *Cmix) RegisterClientErrorCallback(clientError ClientError) {
 //   - err - JSON unmarshalling error
 //
 // Example JSON:
+//
 //	[
 //	  {
 //	    "Id": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD", // bytes of id.ID encoded as base64 string
@@ -246,10 +297,38 @@ type TrackServicesCallback interface {
 	Callback(marshalData []byte, err error)
 }
 
+// TrackServicesWithIdentity will return via a callback the list of services the
+// backend keeps track of for the provided identity. This may be passed into
+// other bindings call which may need context on the available services for this
+// single identity. This will only return services for the given identity.
+//
+// Parameters:
+//   - e2eID - e2e object ID in the tracker.
+//   - cb - A TrackServicesCallback, which will be passed the marshalled
+//     message.ServiceList.
+func (c *Cmix) TrackServicesWithIdentity(e2eId int,
+	cb TrackServicesCallback) error {
+	// Retrieve the user from the tracker
+	user, err := e2eTrackerSingleton.get(e2eId)
+	if err != nil {
+		return err
+	}
+
+	receptionId := user.api.GetReceptionIdentity().ID
+	c.api.GetCmix().TrackServices(func(list message.ServiceList) {
+		res := make(message.ServiceList)
+		res[*receptionId] = list[*receptionId]
+		cb.Callback(json.Marshal(res))
+	})
+
+	return nil
+}
+
 // TrackServices will return via a callback the list of services the
 // backend keeps track of, which is formally referred to as a
 // [message.ServiceList]. This may be passed into other bindings call which
-// may need context on the available services for this client.
+// may need context on the available services for this client. This will
+// provide services for all identities that the client tracks.
 //
 // Parameters:
 //   - cb - A TrackServicesCallback, which will be passed the marshalled

bindings/notifications.go

@@ -17,6 +17,7 @@ import (
 // via GetNotificationsReport as a JSON marshalled byte data.
 //
 // Example JSON:
+//
 //	[
 //	  {
 //	    "ForMe": true,                                           // boolean
@@ -44,6 +45,7 @@ type NotificationReports []NotificationReport
 // this user.
 //
 // Example NotificationReport JSON:
+//
 //	{
 //	  "ForMe": true,
 //	  "Type": "e2e",
@@ -80,33 +82,27 @@ type NotificationReport struct {
 // NotificationReports.
 //
 // Parameters:
-//  - e2eID - e2e object ID in the tracker
 //   - notificationCSV - the notification data received from the
 //     notifications' server.
 //   - marshalledServices - the JSON-marshalled list of services the backend
-//    keeps track of. Refer to Cmix.TrackServices for information about this.
+//     keeps track of. Refer to Cmix.TrackServices or
+//     Cmix.TrackServicesWithIdentity for information about this.
 //
 // Returns:
 //   - []byte - A JSON marshalled NotificationReports. Some NotificationReport's
 //     within in this structure may have their NotificationReport.ForMe
 //     set to false. These may be ignored.
-func GetNotificationsReport(e2eId int, notificationCSV string,
+func GetNotificationsReport(notificationCSV string,
 	marshalledServices []byte) ([]byte, error) {
-	// Retrieve user
-	user, err := e2eTrackerSingleton.get(e2eId)
-	if err != nil {
-		return nil, err
-	}
 
+	// If services are retrieved using TrackServicesWithIdentity, this
+	// should return a single list.
 	serviceList := message.ServiceList{}
-	err = json.Unmarshal(marshalledServices, &serviceList)
+	err := json.Unmarshal(marshalledServices, &serviceList)
 	if err != nil {
 		return nil, err
 	}
 
-	// Retrieve the services for this user
-	services := serviceList[*user.api.GetReceptionIdentity().ID]
-
 	// Decode notifications' server data
 	notificationList, err := notifications.DecodeNotificationsCSV(notificationCSV)
 	if err != nil {
@@ -117,6 +113,7 @@ func GetNotificationsReport(e2eId int, notificationCSV string,
 	reportList := make([]*NotificationReport, len(notificationList))
 
 	// Iterate over data provided by server
+	for _, services := range serviceList {
 		for i := range notificationList {
 			notifData := notificationList[i]
 
@@ -139,6 +136,7 @@ func GetNotificationsReport(e2eId int, notificationCSV string,
 				}
 			}
 		}
+	}
 
 	return json.Marshal(reportList)
 }

broadcast/client.go

@@ -24,6 +24,8 @@ type broadcastClient struct {
 	rng     *fastRNG.StreamGenerator
 }
 
+// NewBroadcastChannelFunc creates a broadcast Channel. Used so that it can be
+// replaced in tests.
 type NewBroadcastChannelFunc func(channel *crypto.Channel, net Client,
 	rng *fastRNG.StreamGenerator) (Channel, error)
 
@@ -52,7 +54,8 @@ func NewBroadcastChannel(channel *crypto.Channel, net Client,
 }
 
 // RegisterListener registers a listener for broadcast messages.
-func (bc *broadcastClient) RegisterListener(listenerCb ListenerFunc, method Method) error {
+func (bc *broadcastClient) RegisterListener(
+	listenerCb ListenerFunc, method Method) error {
 	var tag string
 	switch method {
 	case Symmetric:

broadcast/interface.go

@@ -83,7 +83,7 @@ type Channel interface {
 	Stop()
 }
 
-// Assembler is a function which allows a bre
+// Assembler is a function which allows a bre.
 type Assembler func(rid id.Round) (payload []byte, err error)
 
 // Client contains the methods from [cmix.Client] that are required by
@@ -92,7 +92,8 @@ type Client interface {
 	SendWithAssembler(recipient *id.ID, assembler cmix.MessageAssembler,
 		cmixParams cmix.CMIXParams) (rounds.Round, ephemeral.Id, error)
 	IsHealthy() bool
-	AddIdentityWithHistory(id *id.ID, validUntil, beginning time.Time, persistent bool)
+	AddIdentityWithHistory(
+		id *id.ID, validUntil, beginning time.Time, persistent bool)
 	AddService(clientID *id.ID, newService message.Service,
 		response message.Processor)
 	DeleteClientService(clientID *id.ID)

broadcast/method.go

@@ -7,7 +7,7 @@
 
 package broadcast
 
-// Method enum for broadcast type
+// Method enum for broadcast type.
 type Method uint8
 
 const (

broadcast/processor.go

@@ -21,7 +21,7 @@ const (
 	errDecrypt = "[BCAST] Failed to decrypt payload for broadcast %s (%q): %+v"
 )
 
-// processor struct for message handling
+// processor struct for message handling.
 type processor struct {
 	c      *crypto.Channel
 	cb     ListenerFunc
@@ -36,16 +36,19 @@ func (p *processor) Process(msg format.Message,
 	var err error
 	switch p.method {
 	case RSAToPublic:
-		decodedMessage, decryptErr := p.c.DecryptRSAToPublic(msg.GetContents(), msg.GetMac(), msg.GetKeyFP())
+		decodedMessage, decryptErr := p.c.DecryptRSAToPublic(
+			msg.GetContents(), msg.GetMac(), msg.GetKeyFP())
 		if decryptErr != nil {
 			jww.ERROR.Printf(errDecrypt, p.c.ReceptionID, p.c.Name, decryptErr)
 			return
 		}
-		size := binary.BigEndian.Uint16(decodedMessage[:internalPayloadSizeLength])
+		size := binary.BigEndian.Uint16(
+			decodedMessage[:internalPayloadSizeLength])
 		payload = decodedMessage[internalPayloadSizeLength : size+internalPayloadSizeLength]
 
 	case Symmetric:
-		payload, err = p.c.DecryptSymmetric(msg.GetContents(), msg.GetMac(), msg.GetKeyFP())
+		payload, err = p.c.DecryptSymmetric(
+			msg.GetContents(), msg.GetMac(), msg.GetKeyFP())
 		if err != nil {
 			jww.ERROR.Printf(errDecrypt, p.c.ReceptionID, p.c.Name, err)
 			return
@@ -57,7 +60,8 @@ func (p *processor) Process(msg format.Message,
 	p.cb(payload, receptionID, round)
 }
 
-// String returns a string identifying the symmetricProcessor for debugging purposes.
+// String returns a string identifying the symmetricProcessor for debugging
+// purposes.
 func (p *processor) String() string {
 	return "broadcastChannel-" + p.c.Name
 }

broadcast/rsaToPublic.go

@@ -35,13 +35,10 @@ const (
 // or smaller and the channel [rsa.PrivateKey] must be passed in.
 //
 // The network must be healthy to send.
-func (bc *broadcastClient) BroadcastRSAtoPublic(pk rsa.PrivateKey,
-	payload []byte, cMixParams cmix.CMIXParams) (rounds.Round, ephemeral.Id, error) {
-	// Confirm network health
-
-	assemble := func(rid id.Round) ([]byte, error) {
-		return payload, nil
-	}
+func (bc *broadcastClient) BroadcastRSAtoPublic(
+	pk rsa.PrivateKey, payload []byte, cMixParams cmix.CMIXParams) (
+	rounds.Round, ephemeral.Id, error) {
+	assemble := func(rid id.Round) ([]byte, error) { return payload, nil }
 	return bc.BroadcastRSAToPublicWithAssembler(pk, assemble, cMixParams)
 }
 
@@ -91,7 +88,7 @@ func (bc *broadcastClient) BroadcastRSAToPublicWithAssembler(
 					"asymmetric broadcast message")
 		}
 
-		// Create service using asymmetric broadcast service tag & channel
+		// Create service using asymmetric broadcast service tag and channel
 		// reception ID allows anybody with this info to listen for messages on
 		// this channel
 		service = message.Service{

broadcast/rsaToPublic_test.go

@@ -158,7 +158,8 @@ func Test_asymmetricClient_Smoke(t *testing.T) {
 	}
 
 	// Broadcast payload
-	_, _, err := clients[0].BroadcastRSAtoPublic(pk, payload, cmix.GetDefaultCMIXParams())
+	_, _, err := clients[0].BroadcastRSAtoPublic(
+		pk, payload, cmix.GetDefaultCMIXParams())
 	if err != nil {
 		t.Errorf("Cmix 0 failed to send broadcast: %+v", err)
 	}

broadcast/symmetric.go

@@ -22,7 +22,6 @@ const (
 	// broadcastClient.Broadcast
 	errNetworkHealth = "cannot send broadcast when the network is not healthy"
 	errPayloadSize   = "size of payload %d must be less than %d"
-	errBroadcastMethodType = "cannot call %s broadcast using %s channel"
 )
 
 // Tags.
@@ -50,7 +49,8 @@ func (bc *broadcastClient) Broadcast(payload []byte, cMixParams cmix.CMIXParams)
 // The payload must be of the size [Channel.MaxPayloadSize] or smaller.
 //
 // The network must be healthy to send.
-func (bc *broadcastClient) BroadcastWithAssembler(assembler Assembler, cMixParams cmix.CMIXParams) (
+func (bc *broadcastClient) BroadcastWithAssembler(
+	assembler Assembler, cMixParams cmix.CMIXParams) (
 	rounds.Round, ephemeral.Id, error) {
 	if !bc.net.IsHealthy() {
 		return rounds.Round{}, ephemeral.Id{}, errors.New(errNetworkHealth)
@@ -59,7 +59,7 @@ func (bc *broadcastClient) BroadcastWithAssembler(assembler Assembler, cMixParam
 	assemble := func(rid id.Round) (fp format.Fingerprint,
 		service message.Service, encryptedPayload, mac []byte, err error) {
 
-		//assemble the passed payload
+		// Assemble the passed payload
 		payload, err := assembler(rid)
 		if err != nil {
 			return format.Fingerprint{}, message.Service{}, nil, nil, err
@@ -93,6 +93,6 @@ func (bc *broadcastClient) BroadcastWithAssembler(assembler Assembler, cMixParam
 		return
 	}
 
-	return bc.net.SendWithAssembler(bc.channel.ReceptionID, assemble,
-		cMixParams)
+	return bc.net.SendWithAssembler(
+		bc.channel.ReceptionID, assemble, cMixParams)
 }

channels/readme.md → channels/README.md

-Channels provides a channels implementation on top of broadcast which is capable of handing the user facing features of
-channels, including replies, reactions, and eventually admin commands.
+Channels provide a channels implementation on top of broadcast which is capable
+of handing the user facing features of channels, including replies, reactions,
+and eventually admin commands.
 
 on sending, data propagates as follows:
+```text
 Send function (Example: SendMessage) - > SendGeneric ->
 Broadcast.BroadcastWithAssembler -> cmix.SendWithAssembler
+```
 
 on receiving messages propagate as follows:
+```text
 cmix message pickup (by service)- > broadcast.Processor ->
 userListener ->  events.triggerEvent ->
 messageTypeHandler (example: Text) ->
 eventModel (example: ReceiveMessage)
+```
 
 on sendingAdmin, data propagates as follows:
+```text
 Send function - > SendAdminGeneric ->
 Broadcast.BroadcastAsymmetricWithAssembler -> cmix.SendWithAssembler
+```
 
 on receiving admin messages propagate as follows:
+```text
 cmix message pickup (by service)- > broadcast.Processor -> adminListener ->
 events.triggerAdminEvent -> messageTypeHandler (example: Text) ->
 eventModel (example: ReceiveMessage)
+```

channels/adminListener.go

@@ -26,7 +26,7 @@ type adminListener struct {
 	checkSent messageReceiveFunc
 }
 
-// Listen is called when a message is received for the admin listener
+// Listen is called when a message is received for the admin listener.
 func (al *adminListener) Listen(payload []byte,
 	receptionID receptionID.EphemeralIdentity, round rounds.Round) {
 	// Get the message ID
@@ -40,7 +40,7 @@ func (al *adminListener) Listen(payload []byte,
 		return
 	}
 
-	//check if we sent the message, ignore triggering if we sent
+	// Check if we sent the message, ignore triggering if we sent
 	if al.checkSent(msgID, round) {
 		return
 	}
@@ -49,14 +49,13 @@ func (al *adminListener) Listen(payload []byte,
 
 	// Check the round to ensure that the message is not a replay
 	if id.Round(cm.RoundID) != round.ID {
-		jww.WARN.Printf("The round message %s send on %s referenced "+
-			"(%d) was not the same as the round the message was found on (%d)",
+		jww.WARN.Printf("The round message %s send on %s referenced (%d) was "+
+			"not the same as the round the message was found on (%d)",
 			msgID, al.chID, cm.RoundID, round.ID)
 		return
 	}
 
-	// Replace the timestamp on the message if it is outside of the
-	// allowable range
+	// Replace the timestamp on the message if it is outside the allowable range
 	ts := vetTimestamp(time.Unix(0, cm.LocalTimestamp),
 		round.Timestamps[states.QUEUED], msgID)
 

channels/adminListener_test.go

@@ -33,9 +33,9 @@ type triggerAdminEventDummy struct {
 }
 
 func (taed *triggerAdminEventDummy) triggerAdminEvent(chID *id.ID,
-	cm *ChannelMessage, ts time.Time, messageID cryptoChannel.MessageID,
+	cm *ChannelMessage, _ time.Time, messageID cryptoChannel.MessageID,
 	receptionID receptionID.EphemeralIdentity, round rounds.Round,
-	status SentStatus) (uint64, error) {
+	_ SentStatus) (uint64, error) {
 	taed.gotData = true
 
 	taed.chID = chID
@@ -49,7 +49,6 @@ func (taed *triggerAdminEventDummy) triggerAdminEvent(chID *id.ID,
 
 // Tests the happy path.
 func TestAdminListener_Listen(t *testing.T) {
-
 	// Build inputs
 	chID := &id.ID{}
 	chID[0] = 1
@@ -77,7 +76,9 @@ func TestAdminListener_Listen(t *testing.T) {
 	al := adminListener{
 		chID:    chID,
 		trigger: dummy.triggerAdminEvent,
-		checkSent: func(messageID cryptoChannel.MessageID, r rounds.Round) bool { return false },
+		checkSent: func(cryptoChannel.MessageID, rounds.Round) bool {
+			return false
+		},
 	}
 
 	// Call the listener
@@ -111,8 +112,7 @@ func TestAdminListener_Listen(t *testing.T) {
 // Tests that the message is rejected when the round it came on doesn't match
 // the round in the channel message.
 func TestAdminListener_Listen_BadRound(t *testing.T) {
-
-	// build inputs
+	// Build inputs
 	chID := &id.ID{}
 	chID[0] = 1
 
@@ -138,18 +138,19 @@ func TestAdminListener_Listen_BadRound(t *testing.T) {
 	al := adminListener{
 		chID:    chID,
 		trigger: dummy.triggerAdminEvent,
-		checkSent: func(messageID cryptoChannel.MessageID, r rounds.Round) bool { return false },
+		checkSent: func(cryptoChannel.MessageID, rounds.Round) bool {
+			return false
+		},
 	}
 
 	// Call the listener
 	al.Listen(cmSerial, receptionID.EphemeralIdentity{}, r)
 
-	// check the results
+	// Check the results
 	if dummy.gotData {
-		t.Fatalf("payload handled when it should have failed due to " +
-			"a round issue")
+		t.Fatal(
+			"Payload handled when it should have failed due to a round issue.")
 	}
-
 }
 
 // Tests that the message is rejected when the channel message is malformed.
@@ -170,7 +171,9 @@ func TestAdminListener_Listen_BadChannelMessage(t *testing.T) {
 	al := adminListener{
 		chID:    chID,
 		trigger: dummy.triggerAdminEvent,
-		checkSent: func(messageID cryptoChannel.MessageID, r rounds.Round) bool { return false },
+		checkSent: func(cryptoChannel.MessageID, rounds.Round) bool {
+			return false
+		},
 	}
 
 	// Call the listener
@@ -181,14 +184,12 @@ func TestAdminListener_Listen_BadChannelMessage(t *testing.T) {
 		t.Fatalf("payload handled when it should have failed due to " +
 			"a malformed channel message")
 	}
-
 }
 
 // Tests that the message is rejected when the sized broadcast message is
 // malformed.
 func TestAdminListener_Listen_BadSizedBroadcast(t *testing.T) {
-
-	// build inputs
+	// Build inputs
 	chID := &id.ID{}
 	chID[0] = 1
 
@@ -217,7 +218,9 @@ func TestAdminListener_Listen_BadSizedBroadcast(t *testing.T) {
 	al := adminListener{
 		chID:    chID,
 		trigger: dummy.triggerAdminEvent,
-		checkSent: func(messageID cryptoChannel.MessageID, r rounds.Round) bool { return false },
+		checkSent: func(cryptoChannel.MessageID, rounds.Round) bool {
+			return false
+		},
 	}
 
 	// Call the listener

channels/channelMessages.pb.go

@@ -7,8 +7,8 @@
 
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.27.1
-// 	protoc        v3.15.6
+// 	protoc-gen-go v1.28.1
+// 	protoc        v3.21.9
 // source: channelMessages.proto
 
 package channels
@@ -44,17 +44,17 @@ type ChannelMessage struct {
 	// Payload is the actual message payload. It will be processed differently
 	// based on the PayloadType.
 	Payload []byte `protobuf:"bytes,4,opt,name=Payload,proto3" json:"Payload,omitempty"`
-	// nickname is the name which the user is using for this message
-	// it will not be longer than 24 characters
+	// nickname is the name which the user is using for this message it will not
+	// be longer than 24 characters.
 	Nickname string `protobuf:"bytes,5,opt,name=Nickname,proto3" json:"Nickname,omitempty"`
 	// Nonce is 32 bits of randomness to ensure that two messages in the same
 	// round with that have the same nickname, payload, and lease will not have
 	// the same message ID.
 	Nonce []byte `protobuf:"bytes,6,opt,name=Nonce,proto3" json:"Nonce,omitempty"`
-	// LocalTimestamp is the timestamp when the "send call" is made based upon the
-	// local clock. If this differs by more than 5 seconds +/- from when the round
-	// it sent on is queued, then a random mutation on the queued time (+/- 200ms)
-	// will be used by local clients instead
+	// LocalTimestamp is the timestamp when the "send call" is made based upon
+	// the local clock. If this differs by more than 5 seconds +/- from when the
+	// round it sent on is queued, then a random mutation on the queued time
+	// (+/- 200ms) will be used by local clients instead.
 	LocalTimestamp int64 `protobuf:"varint,7,opt,name=LocalTimestamp,proto3" json:"LocalTimestamp,omitempty"`
 }
 

channels/channelMessages.proto

@@ -28,8 +28,8 @@ message ChannelMessage{
     // based on the PayloadType.
     bytes Payload = 4;
 
-    // nickname is the name which the user is using for this message
-    // it will not be longer than 24 characters
+    // nickname is the name which the user is using for this message it will not
+    // be longer than 24 characters.
     string Nickname = 5;
 
     // Nonce is 32 bits of randomness to ensure that two messages in the same
@@ -37,10 +37,10 @@ message ChannelMessage{
     // the same message ID.
     bytes Nonce = 6;
 
-    // LocalTimestamp is the timestamp when the "send call" is made based upon the
-    // local clock. If this differs by more than 5 seconds +/- from when the round
-    // it sent on is queued, then a random mutation on the queued time (+/- 200ms)
-    // will be used by local clients instead
+    // LocalTimestamp is the timestamp when the "send call" is made based upon
+    // the local clock. If this differs by more than 5 seconds +/- from when the
+    // round it sent on is queued, then a random mutation on the queued time
+    // (+/- 200ms) will be used by local clients instead.
     int64 LocalTimestamp = 7;
 }
 

channels/dummyNameServer.go

@@ -16,8 +16,8 @@ import (
 	"time"
 )
 
-// NewDummyNameService returns a dummy object adhering to the name service
-// This neither produces valid signatures nor validates passed signatures.
+// NewDummyNameService returns a dummy object adhering to the name service. This
+// neither produces valid signatures nor validates passed signatures.
 //
 // THIS IS FOR DEVELOPMENT AND DEBUGGING PURPOSES ONLY.
 func NewDummyNameService(username string, rng io.Reader) (NameService, error) {
@@ -31,23 +31,23 @@ func NewDummyNameService(username string, rng io.Reader) (NameService, error) {
 		lease:    netTime.Now().Add(35 * 24 * time.Hour),
 	}
 
-	//generate the private key
+	// Generate the private key
 	var err error
 	dns.public, dns.private, err = ed25519.GenerateKey(rng)
 	if err != nil {
 		return nil, err
 	}
 
-	//generate a dummy user discover identity to produce a validation signature
-	//just sign with our own key, it wont be evaluated anyhow
+	// Generate a dummy user discover identity to produce a validation signature
+	// just sign with our own key, it will not be evaluated anyhow
 	dns.validationSig = channel.SignChannelLease(dns.public, dns.username,
 		dns.lease, dns.private)
 
 	return dns, nil
 }
 
-// dummyNameService is a dummy NameService implementation. This is NOT meant
-// for use in production
+// dummyNameService is a dummy NameService implementation. This is NOT meant for
+// use in production.
 type dummyNameService struct {
 	private       ed25519.PrivateKey
 	public        ed25519.PublicKey
@@ -94,14 +94,14 @@ func (dns *dummyNameService) SignChannelMessage(message []byte) (
 	return sig, nil
 }
 
-// ValidateChannelMessage will always return true, indicating the the channel
+// ValidateChannelMessage will always return true, indicating that the channel
 // message is valid. This will ignore the passed in arguments. As a result,
 // these values may be dummy or precanned.
 //
 // THIS IS FOR DEVELOPMENT AND DEBUGGING PURPOSES ONLY.
-func (dns *dummyNameService) ValidateChannelMessage(username string, lease time.Time,
-	pubKey ed25519.PublicKey, authorIDSignature []byte) bool {
-	//ignore the authorIDSignature
+func (dns *dummyNameService) ValidateChannelMessage(
+	string, time.Time, ed25519.PublicKey, []byte) bool {
+	// Ignore the authorIDSignature
 	jww.WARN.Printf("ValidateChannelMessage called on Dummy Name Service, " +
 		"no validation done - identity not validated. YOU SHOULD NEVER SEE " +
 		"THIS MESSAGE IN PRODUCTION")