bindings

func (*AuthenticatedConnection) IsAuthenticated ¶

func (_ *AuthenticatedConnection) IsAuthenticated() bool

func (*Backup) AddJson ¶

func (b *Backup) AddJson(json string)

AddJson stores the argument within the Backup structure.

Params

• json - JSON string

func (*Backup) IsBackupRunning ¶

func (b *Backup) IsBackupRunning() bool

IsBackupRunning returns true if the backup has been initialized and is running. Returns false if it has been stopped.

func (*Backup) StopBackup ¶

func (b *Backup) StopBackup() error

StopBackup stops the backup processes and deletes the user's password from storage. To enable backups again, call InitializeBackup.

func (ChFilePartTracker) GetNumParts ¶ added in v4.6.3

func (fpt ChFilePartTracker) GetNumParts() int

GetNumParts returns the total number of file parts in the transfer.

func (ChFilePartTracker) GetPartStatus ¶ added in v4.6.3

func (fpt ChFilePartTracker) GetPartStatus(partNum int) int

GetPartStatus returns the status of the file part with the given part number.

The possible values for the status are:

• 0 < Part does not exist
• 0 = unsent
• 1 = arrived (sender has sent a part, and it has arrived)
• 2 = received (receiver has received a part)

func (*ChannelsFileTransfer) CloseSend ¶ added in v4.6.3

func (cft *ChannelsFileTransfer) CloseSend(fileIDBytes []byte) error

CloseSend deletes a file from the internal storage once a transfer has 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:

• fileIDBytes - Marshalled bytes of the file's fileTransfer.ID.

func (*ChannelsFileTransfer) Download ¶ added in v4.6.3

func (cft *ChannelsFileTransfer) Download(fileInfoJSON []byte,
	progressCB FtReceivedProgressCallback, periodMS int) ([]byte, error)

Download begins the download of the file described in the marshalled [channelsFileTransfer.FileInfo]. The progress of the download is reported on the FtReceivedProgressCallback.

Once the download completes, the file will be stored in the event model with the given file ID and with the status channels.ReceptionProcessingComplete.

The FtReceivedProgressCallback only indicates the progress of the file download, not the status of the file in the event model. You must rely on updates from the event model to know when it can be retrieved.

Parameters:

• fileInfoJSON - The JSON of [channelsFileTransfer.FileInfo] received on a channel.
• progressCB - A callback that reports the progress of the file download. The callback is called once on initialization, on every progress update (or less if restricted by the period), or on fatal error.
• periodMS - A progress callback will be limited from triggering only once per period, in milliseconds.

Returns:

• Marshalled bytes of fileTransfer.ID that uniquely identifies the file.

func (*ChannelsFileTransfer) GetExtensionBuilderID ¶ added in v4.6.3

func (cft *ChannelsFileTransfer) GetExtensionBuilderID() int

GetExtensionBuilderID returns the ID of the extension builder in the tracker. Pass this ID into the channel manager creator to use file transfer manager in conjunction with channels.

func (*ChannelsFileTransfer) MaxFileNameLen ¶ added in v4.6.3

func (cft *ChannelsFileTransfer) MaxFileNameLen() int

MaxFileNameLen returns the max number of bytes allowed for a file name.

func (*ChannelsFileTransfer) MaxFileSize ¶ added in v4.6.3

func (cft *ChannelsFileTransfer) MaxFileSize() int

MaxFileSize returns the max number of bytes allowed for a file.

func (*ChannelsFileTransfer) MaxFileTypeLen ¶ added in v4.6.3

func (cft *ChannelsFileTransfer) MaxFileTypeLen() int

MaxFileTypeLen returns the max number of bytes allowed for a file type.

func (*ChannelsFileTransfer) MaxPreviewSize ¶ added in v4.6.3

func (cft *ChannelsFileTransfer) MaxPreviewSize() int

MaxPreviewSize returns the max number of bytes allowed for a file preview.

func (*ChannelsFileTransfer) RegisterReceivedProgressCallback ¶ added in v4.6.3

func (cft *ChannelsFileTransfer) RegisterReceivedProgressCallback(
	fileIDBytes []byte, progressCB FtReceivedProgressCallback,
	periodMS int) error

RegisterReceivedProgressCallback allows for the registration of a callback to track the progress of an individual file download.

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 download completes, the file will be stored in the event model with the given file ID and with the status [channelsFileTransfer.Complete].

The FtReceivedProgressCallback only indicates the progress of the file download, not the status of the file in the event model. You must rely on updates from the event model to know when it can be retrieved.

Parameters:

• fileIDBytes - Marshalled bytes of the file's fileTransfer.ID.
• progressCB - A callback that reports the progress of the file upload. The callback is called once on initialization, on every progress update (or less if restricted by the period), or on fatal error.
• periodMS - A progress callback will be limited from triggering only once per period, in milliseconds.

func (*ChannelsFileTransfer) RegisterSentProgressCallback ¶ added in v4.6.3

func (cft *ChannelsFileTransfer) RegisterSentProgressCallback(fileIDBytes []byte,
	progressCB FtSentProgressCallback, periodMS int) error

RegisterSentProgressCallback allows for the registration of a callback to track the progress of an individual file upload. A FtSentProgressCallback is auto-registered on ChannelsFileTransfer.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 ChannelsFileTransfer.Send.

The FtSentProgressCallback only indicates the progress of the file upload, not the status of the file in the event model. You must rely on updates from the event model to know when it can be retrieved.

Parameters:

• fileIDBytes - Marshalled bytes of the file's fileTransfer.ID.
• progressCB - A callback that reports the progress of the file upload. The callback is called once on initialization, on every progress update (or less if restricted by the period), or on fatal error.
• periodMS - A progress callback will be limited from triggering only once per period, in milliseconds.

func (*ChannelsFileTransfer) RetryUpload ¶ added in v4.6.3

func (cft *ChannelsFileTransfer) RetryUpload(fileIDBytes []byte,
	progressCB FtSentProgressCallback, periodMS int) error

RetryUpload retries uploading a failed file upload. Returns an error if the transfer has not failed.

This function should be called once a transfer errors out (as reported by the progress callback).

A new progress callback must be registered on retry. Any previously registered callbacks are defunct when the upload fails.

Parameters:

• fileIDBytes - Marshalled bytes of the file's fileTransfer.ID.
• progressCB - A callback that reports the progress of the file upload. The callback is called once on initialization, on every progress update (or less if restricted by the period), or on fatal error.
• periodMS - A progress callback will be limited from triggering only once per period, in milliseconds.

func (*ChannelsFileTransfer) Send ¶ added in v4.6.3

func (cft *ChannelsFileTransfer) Send(channelIdBytes, fileLinkJSON []byte,
	fileName, fileType string, preview []byte,
	validUntilMS int, cmixParamsJSON []byte, pingsJSON []byte) ([]byte, error)

Send sends the specified file info to the channel. Once a file is uploaded via ChannelsFileTransfer.Upload, its file info (found in the event model) can be sent to any channel.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID to send the file to.
• fileLinkJSON - JSON of [channelsFileTransfer.Link] stored in the event model.
• fileName - Human-readable file name. Max length defined by [MaxFileNameLen].
• fileType - Shorthand that identifies the type of file. Max length defined by [MaxFileTypeLen].
• preview - A preview of the file data (e.g. a thumbnail). Max size defined by [MaxPreviewSize].
• validUntilMS - The duration, in milliseconds, that the file is available in the channel. For the maximum amount of time, use ValidForever.
• cmixParamsJSON - JSON of xxdk.CMIXParams. If left empty, GetDefaultCMixParams will be used internally.
• pingsJSON - JSON of a list of Ed25519 public keys that will receive notifications for this message. They must be in the channel and have notifications enabled.

Example pingsJSON:

[
  "FgJMvgSsY4rrKkS/jSe+vFOJOs5qSSyOUSW7UtF9/KU=",
  "fPqcHtrJ398PAC35QyWXEU9PHzz8Z4BKQTCxSvpSygw=",
  "JnjCgh7g/+hNiI9VPKW01aRSxGOFmNulNCymy3ImXAo="
]

Returns:

• JSON of ChannelSendReport.

func (*ChannelsFileTransfer) Upload ¶ added in v4.6.3

func (cft *ChannelsFileTransfer) Upload(fileData []byte, retry float32,
	progressCB FtSentProgressCallback, periodMS int) ([]byte, error)

Upload starts uploading the file to a new ID that can be sent to the specified channel when complete. To get progress information about the upload, a FtSentProgressCallback must be registered. All errors returned on the callback are fatal and the user must take action to either ChannelsFileTransfer.RetryUpload or ChannelsFileTransfer.CloseSend.

The file is added to the event model at the returned file ID with the status [channelsFileTransfer.Uploading]. Once the upload is complete, the file link is added to the event model with the status [channelsFileTransfer.Complete].

The FtSentProgressCallback only indicates the progress of the file upload, not the status of the file in the event model. You must rely on updates from the event model to know when it can be retrieved.

Parameters:

• fileData - File contents. Max size defined by ChannelsFileTransfer.MaxFileSize.
• 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).
• progressCB - A callback that reports the progress of the file upload. The callback is called once on initialization, on every progress update (or less if restricted by the period), or on fatal error.
• periodMS - A progress callback will be limited from triggering only once per period, in milliseconds.

Returns:

• Marshalled bytes of fileTransfer.ID that uniquely identifies the file.

func (*ChannelsManager) AreDMsEnabled ¶ added in v4.5.0

func (cm *ChannelsManager) AreDMsEnabled(channelIdBytes []byte) (bool, error)

AreDMsEnabled returns the status of DMs for a given channel

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.

Returns:

• DM status (bool) - true if DMs are enabled for passed in channel

func (*ChannelsManager) DeleteChannelAdminKey ¶ added in v4.4.4

func (cm *ChannelsManager) DeleteChannelAdminKey(channelIdBytes []byte) error

DeleteChannelAdminKey deletes the private key for the given channel.

CAUTION: This will remove admin access. This cannot be undone. If the private key is deleted, it cannot be recovered and the channel can never have another admin.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.

func (*ChannelsManager) DeleteMessage ¶ added in v4.4.4

func (cm *ChannelsManager) DeleteMessage(channelIdBytes,
	targetMessageIdBytes, cmixParamsJSON []byte) ([]byte, error)

DeleteMessage deletes the targeted message from user's view. Users may delete their own messages but only the channel admin can delete other user's messages. If the user is not an admin of the channel or if they are not the sender of the targetMessage, then the error channels.NotAnAdminErr is returned.

If undoAction is true, then the targeted message is un-deleted.

Clients will drop the deletion if they do not recognize the target message.

Parameters:

• channelIdBytes - Marshalled bytes of channel id.ID.
• targetMessageIdBytes - The marshalled channel.MessageID of the message you want to delete.
• cmixParamsJSON - JSON of xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.

Returns:

• []byte - JSON of ChannelSendReport.

func (*ChannelsManager) DeleteNickname ¶

func (cm *ChannelsManager) DeleteNickname(channelIDBytes []byte) error

DeleteNickname removes the nickname for a given channel. The name will revert back to the codename for this channel instead.

Parameters:

• channelIDBytes - The marshalled bytes of the channel's id.ID.

func (*ChannelsManager) DisableDirectMessages ¶ added in v4.5.0

func (cm *ChannelsManager) DisableDirectMessages(channelIdBytes []byte) error

DisableDirectMessages removes the token for direct messaging for a given channel.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.

func (*ChannelsManager) EnableDirectMessages ¶ added in v4.5.0

func (cm *ChannelsManager) EnableDirectMessages(channelIdBytes []byte) error

EnableDirectMessages enables the token for direct messaging for this channel.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.

func (*ChannelsManager) ExportChannelAdminKey ¶ added in v4.4.4

func (cm *ChannelsManager) ExportChannelAdminKey(
	channelIDBytes []byte, encryptionPassword string) ([]byte, error)

ExportChannelAdminKey gets the private key for the given channel ID, encrypts it with the provided encryptionPassword, and exports it into a portable format. Returns an error if the user is not an admin of the channel.

This key can be provided to other users in a channel to grant them admin access using ChannelsManager.ImportChannelAdminKey.

The private key is encrypted using a key generated from the password using Argon2. Each call to ExportChannelAdminKey produces a different encrypted packet regardless if the same password is used for the same channel. It cannot be determined which channel the payload is for nor that two payloads are for the same channel.

The passwords between each call are not related. They can be the same or different with no adverse impact on the security properties.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.
• encryptionPassword - The password used to encrypt the private key. The passwords between each call are not related. They can be the same or different with no adverse impact on the security properties.

Returns:

• Portable string of the channel private key encrypted with the password.

func (*ChannelsManager) ExportPrivateIdentity ¶

func (cm *ChannelsManager) ExportPrivateIdentity(password string) ([]byte, error)

ExportPrivateIdentity encrypts the private identity using the password and exports it to a portable string.

Parameters:

• password - The password used to encrypt the private identity.

Returns:

• []byte - Encrypted portable private identity.

func (*ChannelsManager) GenerateChannel ¶ added in v4.4.4

func (cm *ChannelsManager) GenerateChannel(
	name, description string, privacyLevel int) (string, error)

GenerateChannel creates a new channel with the user as the admin and returns the broadcast.Channel object. This function only create a channel and does not join it.

The private key is saved to storage and can be accessed with ExportChannelAdminKey.

Parameters:

• name - The name of the new channel. The name must be between 3 and 24 characters inclusive. It can only include upper and lowercase Unicode letters, digits 0 through 9, and underscores (_). It cannot be changed once a channel is created.
• description - The description of a channel. The description is optional but cannot be longer than 144 characters and can include all Unicode characters. It cannot be changed once a channel is created.
• privacyLevel - The [broadcast.PrivacyLevel] of the channel. 0 = public, 1 = private, and 2 = secret. Refer to the comment below for more information.

Returns:

• string - The pretty print of the channel.

The [broadcast.PrivacyLevel] of a channel indicates the level of channel information revealed when sharing it via URL. For any channel besides public channels, the secret information is encrypted and a password is required to share and join a channel.

• A privacy level of [broadcast.Public] reveals all the information including the name, description, privacy level, public key and salt.
• A privacy level of [broadcast.Private] reveals only the name and description.
• A privacy level of [broadcast.Secret] reveals nothing.

func (*ChannelsManager) GetChannels ¶

func (cm *ChannelsManager) GetChannels() ([]byte, error)

GetChannels returns the IDs of all channels that have been joined.

Returns:

• []byte - A JSON marshalled array of id.ID.

JSON Example:

{
  "U4x/lrFkvxuXu59LtHLon1sUhPJSCcnZND6SugndnVID",
  "15tNdkKbYXoMn58NO6VbDMDWFEyIhTWEGsvgcJsHWAgD"
}

func (*ChannelsManager) GetID ¶

func (cm *ChannelsManager) GetID() int

GetID returns the unique tracking ID for the ChannelsManager object.

func (*ChannelsManager) GetIdentity ¶

func (cm *ChannelsManager) GetIdentity() ([]byte, error)

GetIdentity returns the public identity (channel.Identity) of the user associated with this channel manager.

Returns:

• []byte - JSON of channel.Identity.

func (*ChannelsManager) GetMutedUsers ¶ added in v4.4.4

func (cm *ChannelsManager) GetMutedUsers(channelIDBytes []byte) ([]byte, error)

GetMutedUsers returns the list of the public keys for each muted user in the channel. If there are no muted user or if the channel does not exist, an empty list is returned.

Parameters:

• channelIDBytes - The marshalled bytes of the channel's id.ID.

Returns:

• []byte - JSON of an array of ed25519.PublicKey. Look below for an example.

Example return:

["k2IrybDXjJtqxjS6Tx/6m3bXvT/4zFYOJnACNWTvESE=","ocELv7KyeCskLz4cm0klLWhmFLYvQL2FMDco79GTXYw=","mmxoDgoTEYwaRyEzq5Npa24IIs+3B5LXhll/8K5yCv0="]

func (*ChannelsManager) GetNickname ¶

func (cm *ChannelsManager) GetNickname(channelIDBytes []byte) (string, error)

GetNickname returns the nickname set for a given channel.

Parameters:

• channelIDBytes - The marshalled bytes of the channel's id.ID.

Returns:

• string - The nickname for the channel.

func (*ChannelsManager) GetNotificationLevel ¶ added in v4.7.1

func (cm *ChannelsManager) GetNotificationLevel(
	channelIDBytes []byte) (int, error)

GetNotificationLevel returns the channels.NotificationLevel for the given channel.

Parameters:

• channelIDBytes - The marshalled bytes of the channel's id.ID.

Returns:

• int - The channels.NotificationLevel for the channel.

func (*ChannelsManager) GetNotificationStatus ¶ added in v4.7.1

func (cm *ChannelsManager) GetNotificationStatus(
	channelIDBytes []byte) (int, error)

GetNotificationStatus returns the notification status for the given channel.

Parameters:

• channelIDBytes - The marshalled bytes of the channel's id.ID.

Returns:

• int - The [notifications.NotificationState] for the channel.

func (*ChannelsManager) GetShareURL ¶

func (cm *ChannelsManager) GetShareURL(cmixID int, host string, maxUses int,
	channelIdBytes []byte) ([]byte, error)

GetShareURL generates a URL that can be used to share this channel with others on the given host.

A URL comes in one of three forms based on the privacy level set when generating the channel. Each privacy level hides more information than the last with the lowest level revealing everything and the highest level revealing nothing. For any level above the lowest, a password is returned, which will be required when decoding the URL.

The maxUses is the maximum number of times this URL can be used to join a channel. If it is set to 0, then it can be shared unlimited times. The max uses is set as a URL parameter using the key [broadcast.MaxUsesKey]. Note that this number is also encoded in the secret data for private and secret URLs, so if the number is changed in the URL, it will be verified when calling DecodePublicURL and DecodePrivateURL. There is no enforcement for public URLs.

Parameters:

• cmixID - ID of Cmix object in tracker.
• host - The URL to append the channel info to.
• maxUses - The maximum number of uses the link can be used (0 for unlimited).
• channelIdBytes - Marshalled bytes of the channel (id.ID).

Returns:

• JSON of ShareURL.

func (*ChannelsManager) GetStorageTag ¶

func (cm *ChannelsManager) GetStorageTag() string

GetStorageTag returns the tag where this manager is stored. To be used when loading the manager. The storage tag is derived from the public key.

func (*ChannelsManager) ImportChannelAdminKey ¶ added in v4.4.4

func (cm *ChannelsManager) ImportChannelAdminKey(channelIdBytes []byte,
	encryptionPassword string, encryptedPrivKey []byte) error

ImportChannelAdminKey decrypts and imports the given encrypted private key and grants the user admin access to the channel the private key belongs to. Returns an error if the private key cannot be decrypted or if the private key is for the wrong channel.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.
• encryptionPassword - The password used to encrypt the private key.
• encryptedPrivKey - The encrypted channel private key packet.

Returns:

• Returns the error channels.WrongPasswordErr for an invalid password.
• Returns the error channels.ChannelDoesNotExistsErr if the channel has not already been joined.
• Returns the error channels.WrongPrivateKeyErr if the private key does not belong to the channel.

func (*ChannelsManager) IsChannelAdmin ¶ added in v4.4.4

func (cm *ChannelsManager) IsChannelAdmin(channelIDBytes []byte) (bool, error)

IsChannelAdmin returns true if the user is an admin of the channel.

Parameters:

• channelIDBytes - The marshalled bytes of the channel's id.ID.

Returns:

• bool - True if the user is an admin in the channel and false otherwise.

func (*ChannelsManager) JoinChannel ¶

func (cm *ChannelsManager) JoinChannel(channelPretty string) ([]byte, error)

JoinChannel joins the given channel. It will return the error channels.ChannelAlreadyExistsErr if the channel has already been joined.

Parameters:

• channelPretty - A portable channel string. Should be received from another user or generated via ChannelsManager.GenerateChannel.

The pretty print will be of the format:

<Speakeasy-v3:Test_Channel|description:Channel description.|level:Public|created:1666718081766741100|secrets:+oHcqDbJPZaT3xD5NcdLY8OjOMtSQNKdKgLPmr7ugdU=|rCI0wr01dHFStjSFMvsBzFZClvDIrHLL5xbCOPaUOJ0=|493|1|7cBhJxVfQxWo+DypOISRpeWdQBhuQpAZtUbQHjBm8NQ=>

Returns:

• []byte - JSON of ChannelInfo, which describes all relevant channel info.

func (*ChannelsManager) LeaveChannel ¶

func (cm *ChannelsManager) LeaveChannel(channelIdBytes []byte) error

LeaveChannel leaves the given channel. It will return the error channels.ChannelDoesNotExistsErr if the channel was not previously joined.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.

func (*ChannelsManager) MuteUser ¶ added in v4.4.4

func (cm *ChannelsManager) MuteUser(channelIdBytes, mutedUserPubKeyBytes []byte,
	undoAction bool, validUntilMS int, cmixParamsJSON []byte) ([]byte, error)

MuteUser is used to mute a user in a channel. Muting a user will cause all future messages from the user being dropped on reception. Muted users are also unable to send messages. Only the channel admin can mute a user; if the user is not an admin of the channel, then the error channels.NotAnAdminErr is returned.

If undoAction is true, then the targeted user will be unmuted.

Parameters:

• channelIdBytes - Marshalled bytes of channel id.ID.
• mutedUserPubKeyBytes - The ed25519.PublicKey of the user you want to mute.
• undoAction - Set to true to unmute the user.
• validUntilMS - The time, in milliseconds, that the user should be muted. To remain muted indefinitely, use ValidForever.
• cmixParamsJSON - JSON of xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.

Returns:

• []byte - JSON of ChannelSendReport.

func (*ChannelsManager) Muted ¶ added in v4.4.4

func (cm *ChannelsManager) Muted(channelIDBytes []byte) (bool, error)

Muted returns true if the user is currently muted in the given channel.

Parameters:

• channelIDBytes - The marshalled bytes of the channel's id.ID.

Returns:

• bool - True if the user is muted in the channel and false otherwise.

func (*ChannelsManager) PinMessage ¶ added in v4.4.4

func (cm *ChannelsManager) PinMessage(channelIdBytes,
	targetMessageIdBytes []byte, undoAction bool, validUntilMS int,
	cmixParamsJSON []byte) ([]byte, error)

PinMessage pins the target message to the top of a channel view for all users in the specified channel. Only the channel admin can pin user messages; if the user is not an admin of the channel, then the error channels.NotAnAdminErr is returned.

If undoAction is true, then the targeted message is unpinned.

Clients will drop the pin if they do not recognize the target message.

Parameters:

• channelIdBytes - Marshalled bytes of channel id.ID.
• targetMessageIdBytes - The marshalled channel.MessageID of the message you want to pin.
• undoAction - Set to true to unpin the message.
• validUntilMS - The time, in milliseconds, that the message should be pinned. To remain pinned indefinitely, use ValidForever.
• cmixParamsJSON - JSON of xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.

Returns:

• []byte - JSON of ChannelSendReport.

func (*ChannelsManager) RegisterReceiveHandler ¶

func (cm *ChannelsManager) RegisterReceiveHandler(messageType int,
	listenerCb ChannelMessageReceptionCallback, name string, userSpace,
	adminSpace, mutedSpace bool) error

RegisterReceiveHandler registers a listener for non-default message types so that they can be processed by modules. It is important that such modules collective up with the event model implementation.

There can only be one handler per channels.MessageType; the error channels.MessageTypeAlreadyRegistered will be returned on multiple registrations of the same type.

Parameters:

• messageType - The channels.MessageType that the listener listens for.
• listenerCb - The callback which will be executed when a channel message of messageType is received.
• name - A name describing what type of messages the listener picks up. This is used for debugging and logging.
• userSpace - Set to true if this listener can receive messages from normal users.
• adminSpace - Set to true if this listener can receive messages from admins.
• mutedSpace - Set to true if this listener can receive messages from muted users.

func (*ChannelsManager) ReplayChannel ¶

func (cm *ChannelsManager) ReplayChannel(channelIdBytes []byte) error

ReplayChannel replays all messages from the channel within the network's memory (~3 weeks) over the event model.

Returns the error channels.ChannelDoesNotExistsErr if the channel was not previously joined.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.

func (*ChannelsManager) SendAdminGeneric ¶

func (cm *ChannelsManager) SendAdminGeneric(channelIdBytes []byte,
	messageType int, message []byte, validUntilMS int64, tracked bool,
	cmixParamsJSON []byte) ([]byte, error)

SendAdminGeneric is used to send a raw message over a channel encrypted with admin keys, identifying it as sent by the admin. In general, it should be wrapped in a function that defines the wire protocol.

If the final message, before being sent over the wire, is too long, this will return an error. The message must be at most 510 bytes long.

If the user is not an admin of the channel (i.e. does not have a private key for the channel saved to storage), then the error channels.NotAnAdminErr is returned.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.
• messageType - The message type of the message. This will be a valid channels.MessageType.
• message - The contents of the message. The message should be at most 510 bytes. This need not be of data type string, as the message could be a specified format that the channel may recognize.
• validUntilMS - The lease of the message. This will be how long the message is available from the network, in milliseconds. As per the channels.Manager documentation, this has different meanings depending on the use case. These use cases may be generic enough that they will not be enumerated here. Use channels.ValidForever to last the max message life.
• tracked - Set tracked to true if the message should be tracked in the sendTracker, which allows messages to be shown locally before they are received on the network. In general, all messages that will be displayed to the user should be tracked while all actions should not be.
• cmixParamsJSON - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.

Returns:

• []byte - JSON of ChannelSendReport.

func (*ChannelsManager) SendGeneric ¶

func (cm *ChannelsManager) SendGeneric(channelIdBytes []byte, messageType int,
	message []byte, validUntilMS int64, tracked bool, cmixParamsJSON []byte,
	pingsMapJSON []byte) ([]byte, error)

SendGeneric is used to send a raw message over a channel. In general, it should be wrapped in a function that defines the wire protocol.

If the final message, before being sent over the wire, is too long, this will return an error. Due to the underlying encoding using compression, it is not possible to define the largest payload that can be sent, but it will always be possible to send a payload of 802 bytes at minimum.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.
• messageType - The message type of the message. This will be a valid channels.MessageType.
• message - The contents of the message. This need not be of data type string, as the message could be a specified format that the channel may recognize.
• validUntilMS - The lease of the message. This will be how long the message is available from the network, in milliseconds. As per the channels.Manager documentation, this has different meanings depending on the use case. These use cases may be generic enough that they will not be enumerated here. Use channels.ValidForever to last the max message life.
• tracked - Set tracked to true if the message should be tracked in the sendTracker, which allows messages to be shown locally before they are received on the network. In general, all messages that will be displayed to the user should be tracked while all actions should not be.
• cmixParamsJSON - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.
• pingsMapJSON - JSON of a map of slices of ed25519.PublicKey of users that should receive mobile notifications for the message. Each slice keys on a channels.PingType that describes the type of notification it is.

Example pingsMapJSON:

{
  "usrMention": [
    "CLdKxbe8D2WVOpx1mT63TZ5CP/nesmxHLT5DUUalpe0=",
    "S2c6NXjNqgR11SCOaiQUughWaLpWBKNufPt6cbTVHMA="
  ],
  "usrReply": [
    "aaMzSeA6Cu2Aix2MlOwzrAI+NnpKshzvZRT02PZPVec="
  ]
}

Returns:

• []byte - JSON of ChannelSendReport.

func (*ChannelsManager) SendInvite ¶ added in v4.7.1

func (cm *ChannelsManager) SendInvite(channelIdBytes,
	inviteToJson []byte, message string, host string,
	validUntilMS int64, cmixParamsJSON []byte, pingsJSON []byte) (
	[]byte, error)

SendInvite is used to send to a channel (invited) an invitation to another channel (invitee).

If the channel ID for the invitee channel is not recognized by the Manager, then an error will be returned.

The reception of an invitation will be handled by [EventModel.ReceiveMessage], passing in a channels.MessageType of value channels.Invitation. The message will be JSON encoded. Example invite JSON:

{
   "text": "Check this channel out!",
   "inviteLink": "https://internet.speakeasy.tech/?0Name=name&1Description=description&2Level=Public&3Created=1687359213751145652&e=gnnLqhgsNJE7uFTLRsv1q%2FzgHBesVsezln4mg4mQZ70%3D&k=aOULKJDhSkNOou7CwsybaNTrdfrUS55%2Ffv%2FuHjX2Mc4%3D&l=928&m=0&p=1&s=cN2iHg6b5FdViS4q46QMolQUF0BZt98NEiO6NKrL1d0%3D&v=1",
   "password": "secret"
}

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID This is invited channel.
• inviteToChannelJSON - A JSON marshalled channel. This should be the data of the invitee channel. This can be retrieved from GetChannelJSON.
• message - The contents of the message. The message should be at most 510 bytes. This is expected to be Unicode, and thus a string data type is expected.
• host - The URL to append the channel info to.
• validUntilMS - The lease of the message. This will be how long the message is available from the network, in milliseconds. As per the channels.Manager documentation, this has different meanings depending on the use case. These use cases may be generic enough that they will not be enumerated here. Use channels.ValidForever to last the max message life.
• cmixParamsJSON - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.
• pingsJSON - JSON of a slice of public keys of users that should receive mobile notifications for the message.

Example pingsJSON:

[
  "FgJMvgSsY4rrKkS/jSe+vFOJOs5qSSyOUSW7UtF9/KU=",
  "fPqcHtrJ398PAC35QyWXEU9PHzz8Z4BKQTCxSvpSygw=",
  "JnjCgh7g/+hNiI9VPKW01aRSxGOFmNulNCymy3ImXAo="
]

Returns:

• []byte - JSON of ChannelSendReport.

func (*ChannelsManager) SendMessage ¶

func (cm *ChannelsManager) SendMessage(channelIdBytes []byte, message string,
	validUntilMS int64, cmixParamsJSON []byte, pingsJSON []byte) ([]byte, error)

SendMessage is used to send a formatted message over a channel.

Due to the underlying encoding using compression, it isn't possible to define the largest payload that can be sent, but it will always be possible to send a payload of 798 bytes at minimum.

The message will auto delete validUntil after the round it is sent in, lasting forever if channels.ValidForever is used.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.
• message - The contents of the message. The message should be at most 510 bytes. This is expected to be Unicode, and thus a string data type is expected
• validUntilMS - The lease of the message. This will be how long the message is available from the network, in milliseconds. As per the channels.Manager documentation, this has different meanings depending on the use case. These use cases may be generic enough that they will not be enumerated here. Use channels.ValidForever to last the max message life.
• cmixParamsJSON - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.
• pingsJSON - JSON of a slice of public keys of users that should receive mobile notifications for the message.

Example pingsJSON:

[
  "FgJMvgSsY4rrKkS/jSe+vFOJOs5qSSyOUSW7UtF9/KU=",
  "fPqcHtrJ398PAC35QyWXEU9PHzz8Z4BKQTCxSvpSygw=",
  "JnjCgh7g/+hNiI9VPKW01aRSxGOFmNulNCymy3ImXAo="
]

Returns:

• []byte - JSON of ChannelSendReport.

func (*ChannelsManager) SendReaction ¶

func (cm *ChannelsManager) SendReaction(channelIdBytes []byte, reaction string,
	messageToReactTo []byte, validUntilMS int64, cmixParamsJSON []byte) (
	[]byte, error)

SendReaction is used to send a reaction to a message over a channel. The reaction must be a single emoji with no other characters, and will be rejected otherwise.

Clients will drop the reaction if they do not recognize the reactTo message.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.
• reaction - The user's reaction. This should be a single emoji with no other characters. As such, a Unicode string is expected.
• messageToReactTo - The marshalled channel.MessageID of the message you wish to reply to. This may be found in the ChannelSendReport if replying to your own. Alternatively, if reacting to another user's message, you may retrieve it via the ChannelMessageReceptionCallback registered using RegisterReceiveHandler.
• validUntilMS - The lease of the message. This will be how long the message is available from the network, in milliseconds. As per the channels.Manager documentation, this has different meanings depending on the use case. These use cases may be generic enough that they will not be enumerated here. Use channels.ValidForever to last the max message life.
• cmixParamsJSON - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.

Returns:

• []byte - JSON of ChannelSendReport.

func (*ChannelsManager) SendReply ¶

func (cm *ChannelsManager) SendReply(channelIdBytes []byte, message string,
	messageToReactTo []byte, validUntilMS int64, cmixParamsJSON []byte,
	pingsJSON []byte) ([]byte, error)

SendReply is used to send a formatted message over a channel.

Due to the underlying encoding using compression, it is not possible to define the largest payload that can be sent, but it will always be possible to send a payload of 766 bytes at minimum.

If the message ID that the reply is sent to does not exist, then the other side will post the message as a normal message and not as a reply.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.
• message - The contents of the message. The message should be at most 510 bytes. This is expected to be Unicode, and thus a string data type is expected.
• messageToReactTo - The marshalled channel.MessageID of the message you wish to reply to. This may be found in the ChannelSendReport if replying to your own. Alternatively, if reacting to another user's message, you may retrieve it via the ChannelMessageReceptionCallback registered using [RegisterReceiveHandler].
• validUntilMS - The lease of the message. This will be how long the message is available from the network, in milliseconds. As per the channels.Manager documentation, this has different meanings depending on the use case. These use cases may be generic enough that they will not be enumerated here. Use channels.ValidForever to last the max message life.
• cmixParamsJSON - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.
• pingsJSON - JSON of a slice of public keys of users that should receive mobile notifications for the message.

Example pingsJSON:

[
  "FgJMvgSsY4rrKkS/jSe+vFOJOs5qSSyOUSW7UtF9/KU=",
  "fPqcHtrJ398PAC35QyWXEU9PHzz8Z4BKQTCxSvpSygw=",
  "JnjCgh7g/+hNiI9VPKW01aRSxGOFmNulNCymy3ImXAo="
]

Returns:

• []byte - JSON of ChannelSendReport.

func (*ChannelsManager) SendSilent ¶ added in v4.7.1

func (cm *ChannelsManager) SendSilent(channelIdBytes []byte, validUntilMS int64,
	cmixParamsJSON []byte) ([]byte, error)

SendSilent is used to send to a channel a message with no notifications. Its primary purpose is to communicate new nicknames without calling [SendMessage].

It takes no payload intentionally as the message should be very lightweight.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.
• validUntilMS - The lease of the message. This will be how long the message is available from the network, in milliseconds. As per the channels.Manager documentation, this has different meanings depending on the use case. These use cases may be generic enough that they will not be enumerated here. Use channels.ValidForever to last the max message life.
• cmixParamsJSON - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.

Returns:

• []byte - JSON of ChannelSendReport.

func (*ChannelsManager) SetMobileNotificationsLevel ¶ added in v4.7.1

func (cm *ChannelsManager) SetMobileNotificationsLevel(
	channelIDBytes []byte, level, status int) error

SetMobileNotificationsLevel sets the notification level for the given channel. The channels.NotificationLevel dictates the type of notifications received and the status controls weather the notification is push or in-app. If muted, both the level and status must be set to mute.

To use push notifications, a token must be registered with the notification manager. Note, when enabling push notifications, information may be shared with third parties (i.e., Firebase and Google's Palantir) and may represent a security risk to the user.

Parameters:

• channelIDBytes - The marshaled bytes of the channel's id.ID.
• level - The channels.NotificationLevel to set for the channel.
• status - The [notifications.NotificationState] to set for the channel.

func (*ChannelsManager) SetNickname ¶

func (cm *ChannelsManager) SetNickname(
	nickname string, channelIDBytes []byte) error

SetNickname sets the nickname for a given channel. The nickname must be valid according to IsNicknameValid.

Parameters:

• nickname - The new nickname.
• channelIDBytes - The marshalled bytes of the channel's id.ID.

func (*ChannelsManager) VerifyChannelAdminKey ¶ added in v4.4.4

func (cm *ChannelsManager) VerifyChannelAdminKey(
	channelIdBytes []byte, encryptionPassword string, encryptedPrivKey []byte) (
	bool, error)

VerifyChannelAdminKey verifies that the encrypted private key can be decrypted and that it matches the expected channel. Returns false if private key does not belong to the given channel.

Parameters:

• channelIdBytes - Marshalled bytes of the channel's id.ID.
• encryptionPassword - The password used to encrypt the private key.
• encryptedPrivKey - The encrypted channel private key packet.

Returns:

• bool - True if the private key belongs to the channel and false otherwise.
• Returns the error channels.WrongPasswordErr for an invalid password.
• Returns the error channels.ChannelDoesNotExistsErr if the channel has not already been joined.

func (*Cmix) AddHealthCallback ¶

func (c *Cmix) AddHealthCallback(nhc NetworkHealthCallback) int64

AddHealthCallback adds a callback that gets called whenever the network health changes. Returns a registration ID that can be used to unregister.

func (*Cmix) ChangeNumberOfNodeRegistrations ¶

func (c *Cmix) ChangeNumberOfNodeRegistrations(toRun, timeoutMS int) error

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 (*Cmix) Connect ¶

func (c *Cmix) Connect(e2eId int, recipientContact, e2eParamsJSON []byte) (
	*Connection, error)

Connect performs auth key negotiation with the given recipient and returns a Connection object for the newly created partner.Manager.

This function is to be used sender-side and will block until the partner.Manager is confirmed.

Parameters:

• e2eId - ID of the E2E object in the e2e tracker
• recipientContact - marshalled contact.Contact object
• e2eParamsJSON - JSON marshalled byte of xxdk.E2EParams object

func (*Cmix) ConnectWithAuthentication ¶

func (c *Cmix) ConnectWithAuthentication(e2eId int, recipientContact,
	e2eParamsJSON []byte) (*AuthenticatedConnection, error)

ConnectWithAuthentication is called by the client (i.e., the one establishing connection with the server). Once a connect.Connection has been established with the server, it then authenticates their identity to the server.

func (*Cmix) EKVGet ¶ added in v4.6.3

func (c *Cmix) EKVGet(key string) ([]byte, error)

EKVGet allows access to a value inside secure encrypted key value store

func (*Cmix) EKVSet ¶ added in v4.6.3

func (c *Cmix) EKVSet(key string, value []byte) error

EKVSet allows user to set a value inside secure encrypted key value store

func (*Cmix) GetID ¶

func (c *Cmix) GetID() int

GetID returns the ID for this Cmix in the cmixTracker.

func (*Cmix) GetNodeRegistrationStatus ¶

func (c *Cmix) GetNodeRegistrationStatus() ([]byte, error)

GetNodeRegistrationStatus returns the current state of node registration.

Returns:

• []byte - A marshalled NodeRegistrationReport containing the number of nodes the user is registered with and the number of nodes present in the NDF.
• An error if it cannot get the node registration status. The most likely cause is that the network is unhealthy.

func (*Cmix) GetReceptionID ¶ added in v4.6.3

func (c *Cmix) GetReceptionID() []byte

GetReceptionID returns the Default Reception Identity for this cMix Instance

func (*Cmix) GetReceptionRegistrationValidationSignature ¶

func (c *Cmix) GetReceptionRegistrationValidationSignature() []byte

GetReceptionRegistrationValidationSignature returns the signature provided by the xx network.

func (*Cmix) GetRemoteKV ¶ added in v4.7.1

func (c *Cmix) GetRemoteKV() *RemoteKV

GetRemoteKV returns the underlying RemoteKV storage so it can be interacted with directly. TODO: force this into a synchronized prefix?

func (*Cmix) GetRunningProcesses ¶

func (c *Cmix) GetRunningProcesses() ([]byte, error)

GetRunningProcesses returns the names of all running processes at the time of this call. Note that this list may change and is subject to race conditions if multiple threads are in the process of starting or stopping.

Returns:

• []byte - A JSON marshalled list of all running processes.

JSON Example:

{
  "FileTransfer{BatchBuilderThread, FilePartSendingThread#0, FilePartSendingThread#1, FilePartSendingThread#2, FilePartSendingThread#3}",
  "MessageReception Worker 0"
}

func (*Cmix) HasRunningProcessies ¶

func (c *Cmix) HasRunningProcessies() bool

HasRunningProcessies checks if any background threads are running and returns true if one or more are.

This is meant to be used when NetworkFollowerStatus returns xxdk.Stopping. Due to the handling of comms on iOS, where the OS can block indefinitely, it may not enter the stopped state appropriately. This can be used instead.

func (*Cmix) IsHealthy ¶

func (c *Cmix) IsHealthy() bool

IsHealthy returns true if the network is read to be in a healthy state where messages can be sent.

func (*Cmix) IsReady ¶

func (c *Cmix) IsReady(percentReady float64) ([]byte, error)

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 (*Cmix) MakeLegacyReceptionIdentity ¶

func (c *Cmix) MakeLegacyReceptionIdentity() ([]byte, error)

MakeLegacyReceptionIdentity generates the legacy identity for receiving messages. As with all legacy calls, this should primarily be used for the xx messenger team.

func (*Cmix) MakeReceptionIdentity ¶

func (c *Cmix) MakeReceptionIdentity() ([]byte, error)

MakeReceptionIdentity generates a new cryptographic identity for receiving messages.

func (*Cmix) NetworkFollowerStatus ¶

func (c *Cmix) NetworkFollowerStatus() int

NetworkFollowerStatus gets the state of the network follower. It returns a status with the following values:

Stopped  - 0
Running  - 2000
Stopping - 3000

func (*Cmix) PauseNodeRegistrations ¶

func (c *Cmix) PauseNodeRegistrations(timeoutMS int) error

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 (*Cmix) ReadyToSend ¶

func (c *Cmix) ReadyToSend() bool

ReadyToSend determines if the network is ready to send messages on. It returns true if the network is healthy and if the client has registered with at least 70% of the nodes. Returns false otherwise.

func (*Cmix) RegisterClientErrorCallback ¶

func (c *Cmix) RegisterClientErrorCallback(clientError ClientError)

RegisterClientErrorCallback registers the callback to handle errors from the long-running threads controlled by StartNetworkFollower and StopNetworkFollower.

func (*Cmix) RemoveHealthCallback ¶

func (c *Cmix) RemoveHealthCallback(funcID int64)

RemoveHealthCallback removes a health callback using its registration ID.

func (*Cmix) SetTrackNetworkPeriod ¶ added in v4.4.4

func (c *Cmix) SetTrackNetworkPeriod(periodMS int)

SetTrackNetworkPeriod allows changing the frequency that follower threads are started.

Note that the frequency of the follower threads affect the power usage of the device following the network.

• Low period -> Higher frequency of polling -> Higher battery usage
• High period -> Lower frequency of polling -> Lower battery usage

This may be used to enable a low power (or battery optimization) mode for the end user.

Suggested values are provided, however there are no guarantees that these values will perfectly fit what the end user's device would require to match the user's expectations:

• Low Power Usage: 5000 milliseconds
• High Power Usage: 1000 milliseconds (default, see cmix.DefaultFollowPeriod

Parameters:

• periodMS - The duration of the period, in milliseconds.

func (*Cmix) StartNetworkFollower ¶

func (c *Cmix) StartNetworkFollower(timeoutMS int) error

StartNetworkFollower kicks off the tracking of the network. It starts long- running network threads and returns an object for checking state and stopping those threads.

Call this when returning from sleep and close when going back to sleep.

These threads may become a significant drain on battery when offline, ensure they are stopped if there is no internet access.

Threads Started:

• Network Follower (/network/follow.go) tracks the network events and hands them off to workers for handling.
• Historical Round Retrieval (/network/rounds/historical.go) retrieves data about rounds that are too old to be stored by the client.
• Message Retrieval Worker Group (/network/rounds/retrieve.go) requests all messages in a given round from the gateway of the last nodes.
• Message Handling Worker Group (/network/message/handle.go) decrypts and partitions messages when signals via the Switchboard.
• Health Tracker (/network/health), via the network instance, tracks the state of the network.
• Garbled Messages (/network/message/garbled.go) can be signaled to check all recent messages that could be decoded. It uses a message store on disk for persistence.
• Critical Messages (/network/message/critical.go) ensures all protocol layer mandatory messages are sent. It uses a message store on disk for persistence.
• KeyExchange Trigger (/keyExchange/trigger.go) responds to sent rekeys and executes them.
• KeyExchange Confirm (/keyExchange/confirm.go) responds to confirmations of successful rekey operations.
• Auth Callback (/auth/callback.go) handles both auth confirm and requests.

func (*Cmix) StopNetworkFollower ¶

func (c *Cmix) StopNetworkFollower() error

StopNetworkFollower stops the network follower if it is running. It returns an error if the follower is in the wrong state to stop or if it fails to stop it.

If the network follower is running and this fails, the Cmix object will most likely be in an unrecoverable state and need to be trashed.

func (*Cmix) TrackServices ¶

func (c *Cmix) TrackServices(cb TrackServicesCallback)

TrackServices will return, via a callback, the list of services that the backend keeps track of, which is formally referred to as a [message.ServiceList]. This may be passed into other bindings calls that 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 JSON of [message.ServiceList].

func (*Cmix) TrackServicesWithIdentity ¶

func (c *Cmix) TrackServicesWithIdentity(e2eId int, cb TrackServicesCallback,
	compressedCb TrackCompressedServicesCallback) error

TrackServicesWithIdentity will return, via a callback, the list of services that the backend keeps track of for the provided identity. This may be passed into other bindings calls that may need context on the available services for this single identity. This will only return services for the given identity.

Parameters:

• e2eID - ID of E2e object in tracker.
• cb - A TrackServicesCallback, which will be passed the JSON of [message.ServiceList].
• compressedCb - A TrackCompressedServicesCallback, which will be passed the JSON of [message.CompressedServiceList].

func (*Cmix) WaitForNetwork ¶

func (c *Cmix) WaitForNetwork(timeoutMS int) bool

WaitForNetwork will block until either the network is healthy or the passed timeout is reached. It will return true if the network is healthy.

func (*Cmix) WaitForRoundResult ¶

func (c *Cmix) WaitForRoundResult(
	roundList []byte, mdc MessageDeliveryCallback, timeoutMS int) error

WaitForRoundResult allows the caller to get notified if the rounds a message was sent in successfully completed. Under the hood, this uses an API that uses the internal round data, network historical round lookup, and waiting on network events to determine what has (or will) occur.

This function takes the marshaled send report to ensure a memory leak does not occur as a result of both sides of the bindings holding a reference to the same pointer.

Parameters:

• roundList - JSON marshalled bytes of RoundsList or JSON of any send report that inherits a bindings.RoundsList object
• mdc - callback that adheres to the MessageDeliveryCallback interface
• timeoutMS - timeout when the callback will return if no state update occurs, in milliseconds

func (*Connection) Close ¶

func (c *Connection) Close() error

Close deletes this Connection's partner.Manager and releases resources.

func (*Connection) GetId ¶

func (c *Connection) GetId() int

GetId returns the Connection ID.

func (*Connection) GetPartner ¶

func (c *Connection) GetPartner() []byte

GetPartner returns the partner.Manager for this Connection.

func (*Connection) RegisterListener ¶

func (c *Connection) RegisterListener(messageType int, newListener Listener) error

RegisterListener is used for E2E reception and allows for reading data sent from the partner.Manager.

func (*Connection) SendE2E ¶

func (c *Connection) SendE2E(mt int, payload []byte) ([]byte, error)

SendE2E is a wrapper for sending specifically to the Connection's partner.Manager.

Returns:

• []byte - the JSON marshalled bytes of the E2ESendReport object, which can be passed into Cmix.WaitForRoundResult to see if the send succeeded.

func (*DMClient) BlockPartner ¶ added in v4.7.1

func (dmc *DMClient) BlockPartner(partnerPubKey []byte)

BlockPartner prevents receiving messages and notifications from the partner.

Parameters:

• partnerPubKey - The partner's Ed25519 public key to block.

func (*DMClient) DeleteMessage ¶ added in v4.7.1

func (dmc *DMClient) DeleteMessage(partnerPubKeyBytes []byte, partnerToken int32,
	targetMessageIdBytes []byte, cmixParamsJSON []byte) ([]byte, error)

DeleteMessage sends a message to the partner to delete a message this user sent. Also deletes it from the local database.

Parameters:

• partnerPubKeyBytes - The bytes of the public key of the partner's ED25519 signing key.
• partnerToken - The token used to derive the reception ID for the partner.
• targetMessageIdBytes - The bytes of the [message.ID] of the message to delete. This may be found in the ChannelSendReport.
• cmixParamsJSON - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.

func (*DMClient) ExportPrivateIdentity ¶ added in v4.4.4

func (dmc *DMClient) ExportPrivateIdentity(password string) ([]byte, error)

ExportPrivateIdentity encrypts and exports the private identity to a portable string.

func (*DMClient) GetBlockedPartners ¶ added in v4.7.1

func (dmc *DMClient) GetBlockedPartners() []byte

GetBlockedPartners returns all partners who are blocked by this user.

Returns:

• []byte - JSON of of an array of ed25519.PublicKey.

Example return:

[
  "TYWuCfyGBjNWDtl/Roa6f/o206yYPpuB6sX2kJZTe98=",
  "4JLRzgtW1SZ9c5pE+v0WwrGPj1t19AuU6Gg5IND5ymA=",
  "CWDqF1bnhulW2pko+zgmbDZNaKkmNtFdUgY4bTm2DhA="
]

func (*DMClient) GetID ¶ added in v4.4.4

func (dmc *DMClient) GetID() int

GetID returns the tracker ID for the DMClient object.

func (*DMClient) GetIdentity ¶ added in v4.4.4

func (dmc *DMClient) GetIdentity() []byte

GetIdentity returns the public identity associated with this client.

func (*DMClient) GetNickname ¶ added in v4.4.4

func (dmc *DMClient) GetNickname() (string, error)

GetNickname gets the nickname associated with this DM user.

func (*DMClient) GetNotificationLevel ¶ added in v4.7.1

func (dmc *DMClient) GetNotificationLevel(partnerPubKey []byte) (int, error)

GetNotificationLevel returns the notification level for the given channel.

Parameters:

• partnerPubKey - The partner's Ed25519 public key.

Returns:

• int - The dm.NotificationLevel to set for the DM conversation.

func (*DMClient) GetPublicKey ¶ added in v4.4.4

func (dmc *DMClient) GetPublicKey() []byte

GetPublicKey returns the bytes of the public key for this client.

func (*DMClient) GetShareURL ¶ added in v4.6.3

func (dmc *DMClient) GetShareURL(host string) ([]byte, error)

GetShareURL generates a URL that can be used to share a URL to initiate d direct messages with this user.

Parameters:

• host - The URL to append the DM info to.

Returns:

• JSON of DMShareURL.

func (*DMClient) GetToken ¶ added in v4.4.4

func (dmc *DMClient) GetToken() int64

GetToken returns the DM token of this client.

func (*DMClient) IsBlocked ¶ added in v4.5.0

func (dmc *DMClient) IsBlocked(partnerPubKey []byte) bool

IsBlocked indicates if the given partner is blocked.

Parameters:

• partnerPubKey - The partner's Ed25519 public key to check.

func (*DMClient) Send ¶ added in v4.4.4

func (dmc *DMClient) Send(partnerPubKeyBytes []byte,
	partnerToken int32, messageType int, plaintext []byte, leaseTimeMS int64,
	cmixParamsJSON []byte) ([]byte, error)

Send is used to send a raw message. In general, it should be wrapped in a function that defines the wire protocol.

If the final message, before being sent over the wire, is too long, this will return an error. Due to the underlying encoding using compression, it is not possible to define the largest payload that can be sent, but it will always be possible to send a payload of 802 bytes at minimum.

The meaning of leaseTimeMS depends on the use case.

Parameters:

• partnerPubKeyBytes - The bytes of the public key of the partner's ED25519 signing key.
• partnerToken - The token used to derive the reception ID for the partner.
• messageType - The message type of the message. This will be a valid dm.MessageType.
• plaintext - The contents of the message. This need not be of data type string, as the message could be a specified format that the channel may recognize.
• leaseTimeMS - The lease of the message. This will be how long the message is valid until, in milliseconds. As per the channels.Manager documentation, this has different meanings depending on the use case. These use cases may be generic enough that they will not be enumerated here.
• cmixParamsJSON - JSON of xxdk.CMIXParams. If left empty, then GetDefaultCMixParams will be used internally.

Returns:

• []byte - A JSON marshalled ChannelSendReport.

func (*DMClient) SendInvite ¶ added in v4.7.1

func (dmc *DMClient) SendInvite(partnerPubKeyBytes []byte,
	partnerToken int32, inviteToChannelJson []byte, message string,
	host string, cmixParamsJSON []byte) ([]byte, error)

SendInvite is used to send to a DM partner an invitation to another channel.

The reception of an invitation will be handled by [DMReceiver.Receive], passing in a dm.MessageType of value dm.InvitationType. The message will be JSON encoded. Example invite JSON:

{
   "text": "Check this channel out!",
   "inviteLink": "https://internet.speakeasy.tech/?0Name=name&1Description=description&2Level=Public&3Created=1687359213751145652&e=gnnLqhgsNJE7uFTLRsv1q%2FzgHBesVsezln4mg4mQZ70%3D&k=aOULKJDhSkNOou7CwsybaNTrdfrUS55%2Ffv%2FuHjX2Mc4%3D&l=928&m=0&p=1&s=cN2iHg6b5FdViS4q46QMolQUF0BZt98NEiO6NKrL1d0%3D&v=1",
   "password": "secret"
}

Parameters:

• partnerPubKeyBytes - The bytes of the public key of the partner's ED25519 signing key.
• partnerToken - The token used to derive the reception ID for the partner.
• inviteToChannelJson - A JSON marshalled channel. This should be the data of the invitee channel. This can be retrieved from GetChannelJSON.
• message - The contents of the message. The message should be at most 510 bytes. This is expected to be Unicode, and thus a string data type is expected.
• host - The URL to append the channel info to.
• cmixParamsJSON - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.

func (*DMClient) SendReaction ¶ added in v4.4.4

func (dmc *DMClient) SendReaction(partnerPubKeyBytes []byte, partnerToken int32,
	reaction string, reactToBytes []byte,
	cmixParamsJSON []byte) ([]byte, error)

SendReaction is used to send a reaction to a direct message. The reaction must be a single emoji with no other characters, and will be rejected otherwise.

Clients will drop the reaction if they do not recognize the reactTo message.

Parameters:

• partnerPubKeyBytes - The bytes of the public key of the partner's ED25519 signing key.
• partnerToken - The token used to derive the reception ID for the partner.
• reaction - The user's reaction. This should be a single emoji with no other characters. As such, a Unicode string is expected.
• reactToBytes - The bytes of the [message.ID] of the message you wish to react to. This may be found in the ChannelSendReport if replying to your own. Alternatively, if reacting to another user's message, you may retrieve it via the ChannelMessageReceptionCallback registered using ChannelsManager.RegisterReceiveHandler.
• cmixParamsJSON - JSON of xxdk.CMIXParams. If left empty, then GetDefaultCMixParams will be used internally.

Returns:

• []byte - A JSON marshalled ChannelSendReport.

func (*DMClient) SendReply ¶ added in v4.4.4

func (dmc *DMClient) SendReply(partnerPubKeyBytes []byte, partnerToken int32,
	replyMessage string, replyToBytes []byte, leaseTimeMS int64,
	cmixParamsJSON []byte) ([]byte, error)

SendReply is used to send a formatted direct message reply.

If the message ID that the reply is sent to does not exist, then the other side will post the message as a normal message and not as a reply.

The message will auto delete leaseTime after the round it is sent in, lasting forever if ValidForever is used.

Parameters:

• partnerPubKeyBytes - The bytes of the public key of the partner's ED25519 signing key.
• partnerToken - The token used to derive the reception ID for the partner.
• replyMessage - The contents of the reply message. The message should be at most 510 bytes. This is expected to be Unicode, and thus a string data type is expected
• replyToBytes - The bytes of the [message.ID] of the message you wish to reply to. This may be found in the ChannelSendReport if replying to your own. Alternatively, if reacting to another user's message, you may retrieve it via the ChannelMessageReceptionCallback registered using ChannelsManager.RegisterReceiveHandler.
• leaseTimeMS - The lease of the message. This will be how long the message is valid until, in milliseconds. As per the channels.Manager documentation, this has different meanings depending on the use case. These use cases may be generic enough that they will not be enumerated here.
• cmixParamsJSON - JSON of xxdk.CMIXParams. If left empty, then GetDefaultCMixParams will be used internally.

Returns:

• []byte - A JSON marshalled ChannelSendReport

func (*DMClient) SendSilent ¶ added in v4.7.1

func (dmc *DMClient) SendSilent(partnerPubKeyBytes []byte,
	partnerToken int32, cmixParamsJSON []byte) ([]byte, error)

SendSilent is used to send to a channel a message with no notifications. Its primary purpose is to communicate new nicknames without calling [Send].

It takes no payload intentionally as the message should be very lightweight.

Parameters:

• partnerPubKeyBytes - The bytes of the public key of the partner's ED25519 signing key.
• partnerToken - The token used to derive the reception ID for the partner.
• cmixParamsJSON - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.

func (*DMClient) SendText ¶ added in v4.4.4

func (dmc *DMClient) SendText(partnerPubKeyBytes []byte, partnerToken int32,
	message string, leaseTimeMS int64, cmixParamsJSON []byte) ([]byte, error)

SendText is used to send a formatted direct message to a user.

Parameters:

• partnerPubKeyBytes - The bytes of the public key of the partner's ED25519 signing key.
• partnerToken - The token used to derive the reception ID for the partner.
• message - The contents of the message. The message should be at most 510 bytes. This is expected to be Unicode, and thus a string data type is expected
• leaseTimeMS - The lease of the message. This will be how long the message is valid until, in milliseconds. As per the channels.Manager documentation, this has different meanings depending on the use case. These use cases may be generic enough that they will not be enumerated here.
• cmixParamsJSON - JSON of xxdk.CMIXParams. If left empty, then GetDefaultCMixParams will be used internally.

Returns:

• []byte - SON of ChannelSendReport.

func (*DMClient) SetMobileNotificationsLevel ¶ added in v4.7.1

func (dmc *DMClient) SetMobileNotificationsLevel(
	partnerPubKey []byte, level int) error

SetMobileNotificationsLevel sets the notification level for the given DM conversation partner.

Parameters:

• partnerPubKey - The partner's Ed25519 public key.
• level - The dm.NotificationLevel to set for the DM conversation.

func (*DMClient) SetNickname ¶ added in v4.4.4

func (dmc *DMClient) SetNickname(nick string) error

SetNickname sets the nickname to use for this user.

func (*DMClient) UnblockPartner ¶ added in v4.7.1

func (dmc *DMClient) UnblockPartner(partnerPubKey []byte)

UnblockPartner unblocks a blocked partner to allow DM messages.

Parameters:

• partnerPubKey - The partner's Ed25519 public key to unblock.

func (*DummyTraffic) GetStatus ¶

func (dt *DummyTraffic) GetStatus() bool

GetStatus returns the current state of the DummyTraffic manager's sending thread. Note that the status returned here may lag behind a user's earlier call to pause the sending thread. This is a result of a small delay (see DummyTraffic.Pause for more details)

Returns:

• bool - Returns true (dummy.Running) if the sending thread is sending messages and false (dummy.Paused) if the sending thread is not sending messages.

func (*DummyTraffic) Pause ¶ added in v4.4.4

func (dt *DummyTraffic) Pause() error

Pause will pause the Manager's sending thread, meaning messages will no longer be sent. After calling Pause, the sending thread may only be resumed by calling Resume.

There may be a small delay between this call and the pause taking effect. This is because Pause will not cancel the thread when it is in the process of sending messages, but will instead wait for that thread to complete. The thread will then be prevented from beginning another round of sending.

func (*DummyTraffic) Start ¶ added in v4.4.4

func (dt *DummyTraffic) Start() error

Start will start up the Manager's sending thread, meaning messages will

be sent. This should be called after calling NewManager, as by default the
thread is paused. This may also be called after a call to Pause.

This will re-initialize the sending thread with a new randomly generated interval between sending dummy messages. This means that there is zero guarantee that the sending interval prior to pausing will be the same sending interval after a call to Start.

func (*E2e) AddPartnerCallback ¶

func (e *E2e) AddPartnerCallback(partnerID []byte, cb AuthCallbacks) error

AddPartnerCallback adds a new callback that overrides the generic auth callback for the given partner ID.

Parameters:

• partnerID - the marshalled bytes of the id.ID object.

func (*E2e) AddService ¶

func (e *E2e) AddService(tag string, processor Processor) error

AddService adds a service for all partners of the given tag, which will call back on the given processor. These can be sent to using the tag fields in the Params object.

Passing nil for the processor allows you to create a service that is never called but will be visible by notifications. Processes added this way are generally not end-to-end encrypted messages themselves, but other protocols that piggyback on e2e relationships to start communication.

func (*E2e) CallAllReceivedRequests ¶

func (e *E2e) CallAllReceivedRequests()

CallAllReceivedRequests will iterate through all pending contact requests and replay them on the callbacks.

func (*E2e) Confirm ¶

func (e *E2e) Confirm(partnerContact []byte) (int64, error)

Confirm sends a confirmation for a received request. It can only be called once. This both sends keying material to the other party and creates a channel in the e2e handler, after which e2e messages can be sent to the partner using E2e.SendE2E.

The round the request is initially sent on will be returned, but the request will be listed as a critical message, so the underlying cMix client will auto resend it in the event of failure.

A confirmation cannot be sent for a contact who has not sent a request or who is already a partner. This can only be called once for a specific contact. The confirmation sends as a critical message; if the round it sends on fails, it will be auto resent by the cMix client.

If the confirmation must be resent, use ReplayConfirm.

Parameters:

• partnerContact - the marshalled bytes of the contact.Contact object.

Returns:

• int64 - ID of the round (convert to uint64)

func (*E2e) DeleteAllRequests ¶

func (e *E2e) DeleteAllRequests() error

DeleteAllRequests clears all requests from auth storage.

func (*E2e) DeleteContact ¶

func (e *E2e) DeleteContact(partnerID []byte) error

DeleteContact removes a partner from E2e's storage.

Parameters:

• partnerID - the marshalled bytes of id.ID.

func (*E2e) DeletePartnerCallback ¶

func (e *E2e) DeletePartnerCallback(partnerID []byte) error

DeletePartnerCallback deletes the callback that overrides the generic auth callback for the given partner ID.

Parameters:

• partnerID - the marshalled bytes of the id.ID object.

func (*E2e) DeleteReceiveRequests ¶

func (e *E2e) DeleteReceiveRequests() error

DeleteReceiveRequests clears all received requests from auth storage.

func (*E2e) DeleteRequest ¶

func (e *E2e) DeleteRequest(partnerID []byte) error

DeleteRequest deletes sent or received requests for a specific partner ID.

Parameters:

• partnerID - the marshalled bytes of the id.ID object.

func (*E2e) DeleteSentRequests ¶

func (e *E2e) DeleteSentRequests() error

DeleteSentRequests clears all sent requests from auth storage.

func (*E2e) FirstPartitionSize ¶

func (e *E2e) FirstPartitionSize() int

FirstPartitionSize returns the max partition payload size for the first payload.

func (*E2e) GetAllPartnerIDs ¶

func (e *E2e) GetAllPartnerIDs() ([]byte, error)

GetAllPartnerIDs returns a list of all partner IDs that the user has an E2E relationship with.

Returns:

• []byte - the marshalled bytes of []*id.ID.

func (*E2e) GetContact ¶

func (e *E2e) GetContact() []byte

GetContact returns a marshalled contact.Contact object for the E2e ReceptionIdentity.

func (*E2e) GetHistoricalDHPrivkey ¶

func (e *E2e) GetHistoricalDHPrivkey() ([]byte, error)

GetHistoricalDHPrivkey returns the user's marshalled historical DH private key.

Returns:

• []byte - the marshalled bytes of the cyclic.Int object.

func (*E2e) GetHistoricalDHPubkey ¶

func (e *E2e) GetHistoricalDHPubkey() ([]byte, error)

GetHistoricalDHPubkey returns the user's marshalled historical DH public key.

Returns:

• []byte - the marshalled bytes of the cyclic.Int object.

func (*E2e) GetID ¶

func (e *E2e) GetID() int

GetID returns the ID for this E2e in the e2eTracker.

func (*E2e) GetReceivedRequest ¶

func (e *E2e) GetReceivedRequest(partnerID []byte) ([]byte, error)

GetReceivedRequest returns a contact if there is a received request for it.

Parameters:

• partnerID - the marshalled bytes of the id.ID object.

Returns:

• []byte - the marshalled bytes of the contact.Contact object.

func (*E2e) GetReceptionID ¶

func (e *E2e) GetReceptionID() []byte

GetReceptionID returns the marshalled default IDs.

Returns:

• []byte - the marshalled bytes of the id.ID object.

func (*E2e) GetUdAddressFromNdf ¶

func (e *E2e) GetUdAddressFromNdf() string

GetUdAddressFromNdf retrieve the User Discovery's network address fom the NDF.

func (*E2e) GetUdCertFromNdf ¶

func (e *E2e) GetUdCertFromNdf() []byte

GetUdCertFromNdf retrieves the User Discovery's TLS certificate (in PEM format) from the NDF.

func (*E2e) GetUdContactFromNdf ¶

func (e *E2e) GetUdContactFromNdf() ([]byte, error)

GetUdContactFromNdf assembles the User Discovery's contact file from the data within the NDF.

Returns

• []byte - A byte marshalled contact.Contact.

func (*E2e) HasAuthenticatedChannel ¶

func (e *E2e) HasAuthenticatedChannel(partnerId []byte) (bool, error)

HasAuthenticatedChannel returns true if an authenticated channel with the partner exists, otherwise returns false.

Parameters:

• partnerId - the marshalled bytes of the id.ID object.

func (*E2e) PartitionSize ¶

func (e *E2e) PartitionSize(payloadIndex int) int

PartitionSize returns the partition payload size for the given payload index. The first payload is index 0.

func (*E2e) PayloadSize ¶

func (e *E2e) PayloadSize() int

PayloadSize returns the max payload size for a partitionable E2E message.

func (*E2e) RegisterListener ¶

func (e *E2e) RegisterListener(
	senderID []byte, messageType int, newListener Listener) error

RegisterListener registers a new listener.

Parameters:

• senderId - the user ID who sends messages to this user that this function will register a listener for.
• messageType - message type from the sender you want to listen for.
• newListener: A provider for a callback to hear a message. Do not pass nil to this.

func (*E2e) RemoveService ¶

func (e *E2e) RemoveService(tag string) error

RemoveService removes all services for the given tag.

func (*E2e) ReplayConfirm ¶

func (e *E2e) ReplayConfirm(partnerID []byte) (int64, error)

ReplayConfirm resends a confirmation to the partner. It will fail to send if the send relationship with the partner has already ratcheted.

The confirmation sends as a critical message; if the round it sends on fails, it will be auto resent by the cMix client.

This will not be useful if either side has ratcheted.

Parameters:

• partnerID - the marshalled bytes of the id.ID object.

Returns:

• int64 - ID of the round (convert to uint64)

func (*E2e) Request ¶

func (e *E2e) Request(partnerContact, factsListJson []byte) (int64, error)

Request sends a contact request from the user identity in the imported E2e structure to the passed contact, as well as the passed facts (it will error if they are too long).

The other party must accept the request by calling Confirm to be able to send messages using E2e.SendE2E. When the other party does so, the "confirm" callback will get called.

The round the request is initially sent on will be returned, but the request will be listed as a critical message, so the underlying cMix client will auto resend it in the event of failure.

A request cannot be sent for a contact who has already received a request or who is already a partner.

The request sends as a critical message, if the round it sends on fails, it will be auto resent by the cMix client.

Parameters:

• partnerContact - the marshalled bytes of the contact.Contact object.
• factsListJson - the JSON marshalled bytes of fact.FactList.

Returns:

• int64 - ID of the round (convert to uint64)

func (*E2e) Reset ¶

func (e *E2e) Reset(partnerContact []byte) (int64, error)

Reset sends a contact reset request from the user identity in the imported e2e structure to the passed contact, as well as the passed facts (it will error if they are too long).

This deletes all traces of the relationship with the partner from e2e and create a new relationship from scratch.

The round the reset is initially sent on will be returned, but the request will be listed as a critical message, so the underlying cMix client will auto resend it in the event of failure.

A request cannot be sent for a contact who has already received a request or who is already a partner.

Parameters:

• partnerContact - the marshalled bytes of the contact.Contact object.

Returns:

• int64 - ID of the round (convert to uint64)

func (*E2e) SecondPartitionSize ¶

func (e *E2e) SecondPartitionSize() int

SecondPartitionSize returns the max partition payload size for all payloads after the first payload.

func (*E2e) SendE2E ¶

func (e *E2e) SendE2E(messageType int, recipientId, payload,
	e2eParamsJSON []byte) ([]byte, error)

SendE2E send a message containing the payload to the recipient of the passed message type, per the given parameters--encrypted with end-to-end encryption.

Parameters:

• recipientId - the marshalled bytes of the id.ID object.
• e2eParams - the marshalled bytes of the e2e.Params object.

Returns:

• []byte - the JSON marshalled bytes of the E2ESendReport object, which can be passed into Cmix.WaitForRoundResult to see if the send succeeded.

func (*E2e) VerifyOwnership ¶

func (e *E2e) VerifyOwnership(
	receivedContact, verifiedContact []byte, e2eId int) (bool, error)

VerifyOwnership checks if the received ownership proof is valid.

Parameters:

• receivedContact, verifiedContact - the marshalled bytes of the contact.Contact object.
• e2eId - ID of the e2e handler

func (FilePartTracker) GetNumParts ¶

func (fpt FilePartTracker) GetNumParts() int

GetNumParts returns the total number of file parts in the transfer.

func (FilePartTracker) GetPartStatus ¶

func (fpt FilePartTracker) GetPartStatus(partNum int) int

GetPartStatus returns the status of the file part with the given part number.

The possible values for the status are:

• 0 < Part does not exist
• 0 = unsent
• 1 = arrived (sender has sent a part, and it has arrived)
• 2 = received (receiver has received a part)

func (*FileTransfer) CloseSend ¶

func (f *FileTransfer) CloseSend(tidBytes []byte) error

CloseSend deletes a file from the internal storage once a transfer has 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 - the file transfer's unique fileTransfer.TransferID.

func (*FileTransfer) MaxFileNameLen ¶

func (f *FileTransfer) MaxFileNameLen() int

MaxFileNameLen returns the max number of bytes allowed for a file name.

func (*FileTransfer) MaxFileSize ¶

func (f *FileTransfer) MaxFileSize() int

MaxFileSize returns the max number of bytes allowed for a file.

func (*FileTransfer) MaxFileTypeLen ¶

func (f *FileTransfer) MaxFileTypeLen() int

MaxFileTypeLen returns the max number of bytes allowed for a file type.

func (*FileTransfer) MaxPreviewSize ¶

func (f *FileTransfer) MaxPreviewSize() int

MaxPreviewSize returns the max number of bytes allowed for a file preview.

func (*FileTransfer) Receive ¶

func (f *FileTransfer) Receive(tidBytes []byte) ([]byte, error)

Receive returns the full file on the completion of the transfer. It deletes internal references to the data and unregisters any attached progress 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.

Parameters:

• tidBytes - The file transfer's unique fileTransfer.TransferID.

func (*FileTransfer) RegisterReceivedProgressCallback ¶

func (f *FileTransfer) RegisterReceivedProgressCallback(tidBytes []byte,
	callback FileTransferReceiveProgressCallback, period int) error

RegisterReceivedProgressCallback allows for the registration of a callback to track the progress of an individual received file transfer.

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 - 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 (*FileTransfer) RegisterSentProgressCallback ¶

func (f *FileTransfer) RegisterSentProgressCallback(tidBytes []byte,
	callback FileTransferSentProgressCallback, period int) error

RegisterSentProgressCallback allows for the registration of a callback to track the progress of an individual sent file transfer.

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 - 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 (*FileTransfer) Send ¶

func (f *FileTransfer) Send(payload, recipientID []byte, retry float32,
	callback FileTransferSentProgressCallback, period int) ([]byte, error)

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 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:

• The bytes of the unique fileTransfer.TransferID.

func (*Group) GetCreatedMS ¶

func (g *Group) GetCreatedMS() int64

GetCreatedMS returns the time the group was created in milliseconds. This is also the time the group requests were sent.

func (*Group) GetCreatedNano ¶

func (g *Group) GetCreatedNano() int64

GetCreatedNano returns the time the group was created in nanoseconds. This is also the time the group requests were sent.

func (*Group) GetID ¶

func (g *Group) GetID() []byte

GetID return the 33-byte unique group ID. This represents the id.ID object.

func (*Group) GetInitMessage ¶

func (g *Group) GetInitMessage() []byte

GetInitMessage returns initial message sent with the group request.

func (*Group) GetMembership ¶

func (g *Group) GetMembership() ([]byte, error)

GetMembership retrieves a list of group members. The list is in order; the first contact is the leader/creator of the group. All subsequent members are ordered by their ID.

Returns:

• []byte - JSON marshalled [group.Membership], which is an array of [group.Member].

Example JSON [group.Membership] return:

[
  {
    "ID": "U4x/lrFkvxuXu59LtHLon1sUhPJSCcnZND6SugndnVID",
    "DhKey": {
      "Value": 3534334367214237261,
      "Fingerprint": 16801541511233098363
    }
  },
  {
    "ID": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD",
    "DhKey": {
      "Value": 7497468244883513247,
      "Fingerprint": 16801541511233098363
    }
  }
]

func (*Group) GetName ¶

func (g *Group) GetName() []byte

GetName returns the name set by the user for the group.

func (*Group) Serialize ¶

func (g *Group) Serialize() []byte

Serialize serializes the Group.

func (*GroupChat) GetGroup ¶

func (g *GroupChat) GetGroup(groupId []byte) (*Group, error)

GetGroup returns the group with the group ID. If no group exists, then the error "failed to find group" is returned.

Parameters:

• groupId - The byte data representing a group ID (a byte marshalled id.ID). This can be pulled from a marshalled GroupReport.

Returns:

• Group - The bindings-layer representation of a group.

func (*GroupChat) GetGroups ¶

func (g *GroupChat) GetGroups() ([]byte, error)

GetGroups returns a list of group IDs that the user is a member of.

Returns:

• []byte - a JSON marshalled []*id.ID representing all group ID's.

func (*GroupChat) JoinGroup ¶

func (g *GroupChat) JoinGroup(serializedGroupData []byte) error

JoinGroup allows a user to join a group when a request is received. If an error is returned, handle it properly first; you may then retry later with the same trackedGroupId.

Parameters:

• serializedGroupData - the result of calling Group.Serialize() on any Group object returned over the bindings

func (*GroupChat) LeaveGroup ¶

func (g *GroupChat) LeaveGroup(groupId []byte) error

LeaveGroup deletes a group so a user no longer has access.

Parameters:

• groupId - the byte data representing a group ID. This can be pulled from a marshalled GroupReport.

func (*GroupChat) MakeGroup ¶

func (g *GroupChat) MakeGroup(
	membershipBytes, message, name []byte) ([]byte, error)

MakeGroup creates a new Group and sends a group request to all members in the group.

Parameters:

• membershipBytes - the JSON marshalled list of []*id.ID; it contains the IDs of members the user wants to add to the group.
• message - the initial message sent to all members in the group. This is an optional parameter and may be nil.
• name - the name of the group decided by the creator. This is an optional parameter and may be nil. If nil the group will be assigned the default name.

Returns:

• []byte - the JSON marshalled bytes of the GroupReport object, which can be passed into Cmix.WaitForRoundResult to see if the group request message send succeeded.

func (*GroupChat) NumGroups ¶

func (g *GroupChat) NumGroups() int

NumGroups returns the number of groups the user is a part of.

func (*GroupChat) ResendRequest ¶

func (g *GroupChat) ResendRequest(groupId []byte) ([]byte, error)

ResendRequest resends a group request to all members in the group.

Parameters:

• groupId - a byte representation of a group's ID. This can be found in the report returned by GroupChat.MakeGroup.

Returns:

• []byte - the JSON marshalled bytes of the GroupReport object, which can be passed into WaitForRoundResult to see if the group request message send succeeded.

func (*GroupChat) Send ¶

func (g *GroupChat) Send(groupId, message []byte, tag string) ([]byte, error)

Send is the bindings-level function for sending to a group.

Parameters:

• groupId - the byte data representing a group ID. This can be pulled from marshalled GroupReport.
• message - the message that the user wishes to send to the group.
• tag - the tag associated with the message. This tag may be empty.

Returns:

• []byte - the JSON marshalled bytes of the GroupSendReport object, which can be passed into Cmix.WaitForRoundResult to see if the group message send succeeded.

func (*Notifications) AddToken ¶ added in v4.7.1

func (n *Notifications) AddToken(newToken, app string) error

AddToken registers the Token with the remote server if this manager is in set to register, otherwise it will return ErrRemoteRegistrationDisabled This will add the token to the list of tokens which are forwarded the messages for connected IDs. the App will tell the server what App to forward the notifications to.

func (*Notifications) GetID ¶ added in v4.7.1

func (n *Notifications) GetID() int

GetID returns the ID of the notifications object

func (*Notifications) GetMaxState ¶ added in v4.7.1

func (n *Notifications) GetMaxState() int64

GetMaxState returns the current MaxState

func (*Notifications) GetToken ¶ added in v4.7.1

func (n *Notifications) GetToken() ([]byte, error)

GetToken returns the token if it exists

{
  "exists":true,
  "Token":"Z1owNo+GvizWshVW/C5IJ1izPD5oqMkCGr+PsA5If4HZ",
  "App":"havenIOS"
}

func (*Notifications) RemoveToken ¶ added in v4.7.1

func (n *Notifications) RemoveToken() error

RemoveToken removes the given Token from the server It will remove all registered identities if it is the last Token

func (*Notifications) SetMaxState ¶ added in v4.7.1

func (n *Notifications) SetMaxState(maxState int64) error

SetMaxState sets the maximum functional state of any identity downstream moduals will be told to clamp any state greater than maxState down to maxState. Depending on UX requirements, they may still show the state in an altered manner, for example greying out a description. This is designed so when the state is raised, the old configs are maintained. This will unregister / re-register with the push server when leaving or entering the Push maxState. The default maxState is Push will return an error if the maxState isnt a valid state

MaxState can be:

	Mute shows no notifications for the ID.
	- Mute = 0
	WhenOpen shows notifications for this ID only when the app is running and
	open. No registration or privacy leaks occur in this state.
 - WhenOpen = 1
	Push shows notifications for this ID as push notification on applicable
	devices. This state has a minor privacy loss.
	- Push = 2

func (*RemoteKV) Delete ¶ added in v4.7.1

func (r *RemoteKV) Delete(key string, version int64) error

Delete removes a given key from the data store.

func (*RemoteKV) DeleteMapElement ¶ added in v4.7.1

func (r *RemoteKV) DeleteMapElement(mapName, elementName string,
	mapVersion int64) ([]byte, error)

DeleteMapElement removes a versioned map element from the KV.

func (*RemoteKV) DeleteRemoteKeyListener ¶ added in v4.7.1

func (r *RemoteKV) DeleteRemoteKeyListener(key string, id int) error

DeleteRemoteKeyListener deletes a specific id for a provided key

func (*RemoteKV) DeleteRemoteMapListener ¶ added in v4.7.1

func (r *RemoteKV) DeleteRemoteMapListener(key string, id int) error

DeleteRemoteMapListener deletes a specific id for a provided key

func (*RemoteKV) Get ¶ added in v4.7.1

func (r *RemoteKV) Get(key string, version int64) ([]byte, error)

Get returns the object stored at the specified version. returns a json of versioned.Object

func (*RemoteKV) GetAllRemoteKeyListeners ¶ added in v4.7.1

func (r *RemoteKV) GetAllRemoteKeyListeners() []byte

GetAllRemoteKeyListeners returns a JSON of all the listener keys mapped to a list of ids.

func (*RemoteKV) GetAllRemoteMapListeners ¶ added in v4.7.1

func (r *RemoteKV) GetAllRemoteMapListeners() []byte

GetAllRemoteMapListeners returns a JSON of all the listener keys mapped to a list of ids.

func (*RemoteKV) GetFullKey ¶ added in v4.7.1

func (r *RemoteKV) GetFullKey(key string, version int64) string

GetFullKey returns the key with all prefixes appended

func (*RemoteKV) GetMap ¶ added in v4.7.1

func (r *RemoteKV) GetMap(mapName string, version int64) ([]byte, error)

GetMap loads a versioned map from the KV. This relies on the underlying remote [KV.GetMap] function to lock and control updates, but it uses versioned.Object values.

func (*RemoteKV) GetMapElement ¶ added in v4.7.1

func (r *RemoteKV) GetMapElement(mapName, element string, version int64) (
	[]byte, error)

GetMapElement loads a versioned map element from the KV. This relies on the underlying remote [KV.GetMapElement] function to lock and control updates, but it uses versioned.Object values.

func (*RemoteKV) GetPrefix ¶ added in v4.7.1

func (r *RemoteKV) GetPrefix() string

GetPrefix returns the full Prefix of the KV

func (*RemoteKV) GetRemoteKeyListeners ¶ added in v4.7.1

func (r *RemoteKV) GetRemoteKeyListeners(key string) []byte

GetRemoteKeyListeners returns a JSON array of ids for the given key.

func (*RemoteKV) GetRemoteMapListeners ¶ added in v4.7.1

func (r *RemoteKV) GetRemoteMapListeners(key string) []byte

GetRemoteMapListeners returns a JSON array of ids for the given key.

func (*RemoteKV) HasPrefix ¶ added in v4.7.1

func (r *RemoteKV) HasPrefix(prefix string) bool

HasPrefix returns whether this prefix exists in the KV

func (*RemoteKV) IsMemStore ¶ added in v4.7.1

func (r *RemoteKV) IsMemStore() bool

IsMemStore returns true if the underlying KV is memory based

func (*RemoteKV) ListenOnRemoteKey ¶ added in v4.7.1

func (r *RemoteKV) ListenOnRemoteKey(key string, version int64,
	callback KeyChangedByRemoteCallback, localEvents bool) (int, error)

ListenOnRemoteKey sets up a callback listener for the object specified by the key and version. It returns the ID of the callback or -1 and an error. The version and "localEvents" flags are only respected on first call.

func (*RemoteKV) ListenOnRemoteMap ¶ added in v4.7.1

func (r *RemoteKV) ListenOnRemoteMap(mapName string, version int64,
	callback MapChangedByRemoteCallback, localEvents bool) (int, error)

ListenOnRemoteMap allows the caller to receive updates when the map or map elements are updated. It returns the ID of the callback or -1 and an error. The version and "localEvents" flags are only respected on first call.

func (*RemoteKV) Prefix ¶ added in v4.7.1

func (r *RemoteKV) Prefix(prefix string) (*RemoteKV, error)

Prefix returns a new KV with the new prefix appending

func (*RemoteKV) Root ¶ added in v4.7.1

func (r *RemoteKV) Root() (*RemoteKV, error)

Root returns the KV with no prefixes

func (*RemoteKV) Set ¶ added in v4.7.1

func (r *RemoteKV) Set(key string, objectJSON []byte) error

Set upserts new data into the storage When calling this, you are responsible for prefixing the key with the correct type optionally unique id! Call MakeKeyWithPrefix() to do so. The [Object] should contain the versioning if you are maintaining such a functionality.

func (*RemoteKV) StoreMap ¶ added in v4.7.1

func (r *RemoteKV) StoreMap(mapName string,
	valueJSON []byte, version int64) error