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 (*ChannelDbCipher) Decrypt ¶

func (c *ChannelDbCipher) Decrypt(ciphertext []byte) ([]byte, error)

Decrypt will decrypt the passed in encrypted value. The plaintext will be returned by this function. Any padding will be discarded within this function.

Parameters:

• ciphertext - the encrypted data returned by ChannelDbCipher.Encrypt.

func (*ChannelDbCipher) Encrypt ¶

func (c *ChannelDbCipher) Encrypt(plaintext []byte) ([]byte, error)

Encrypt will encrypt the raw data. It will return a ciphertext. Padding is done on the plaintext so all encrypted data looks uniform at rest.

Parameters:

• plaintext - The data to be encrypted. This must be smaller than the block size passed into NewChannelsDatabaseCipher. If it is larger, this will return an error.

func (*ChannelDbCipher) GetID ¶

func (c *ChannelDbCipher) GetID() int

GetID returns the ID for this ChannelDbCipher in the channelDbCipherTracker.

func (*ChannelsManager) DeleteNickname ¶

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

DeleteNickname deletes the nickname for a given channel.

func (*ChannelsManager) ExportPrivateIdentity ¶

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

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

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 list of IDs.

JSON Example:

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

func (*ChannelsManager) GetID ¶

func (cm *ChannelsManager) GetID() int

GetID returns the channelManagerTracker ID for the ChannelsManager object.

func (*ChannelsManager) GetIdentity ¶

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

GetIdentity returns the marshaled public identity ([channel.Identity]) that the channel is using.

func (*ChannelsManager) GetNickname ¶

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

GetNickname returns the nickname set for a given channel. Returns an error if there is no nickname set.

func (*ChannelsManager) GetShareURL ¶

func (cm *ChannelsManager) GetShareURL(cmixID int, host string, maxUses int,
	marshalledChanId []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, is will be verified when calling [ChannelsManager.JoinChannelFromURL]. There is no enforcement for public URLs.

Parameters:

• cmixID - The tracked Cmix object ID.
• host - The URL to append the channel info to.
• maxUses - The maximum number of uses the link can be used (0 for unlimited).
• marshalledChanId - A marshalled channel ID (id.ID).

Returns:

• JSON of ShareURL.

func (*ChannelsManager) GetStorageTag ¶

func (cm *ChannelsManager) GetStorageTag() string

GetStorageTag returns the storage tag needed to reload the manager.

func (*ChannelsManager) JoinChannel ¶

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

JoinChannel joins the given channel. It will fail if the channel has already been joined.

Parameters:

• channelPretty - A portable channel string. Should be received from another user or generated via 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(marshalledChanId []byte) error

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

Parameters:

• marshalledChanId - A JSON marshalled channel ID (id.ID).

func (*ChannelsManager) RegisterReceiveHandler ¶

func (cm *ChannelsManager) RegisterReceiveHandler(messageType int,
	listenerCb ChannelMessageReceptionCallback) error

RegisterReceiveHandler is used to register handlers for non-default message types. They can be processed by modules. It is important that such modules sync up with the event model implementation.

There can only be one handler per channels.MessageType, and this will return an error on any re-registration.

Parameters:

• messageType - represents the channels.MessageType which will have a registered listener.
• listenerCb - the callback which will be executed when a channel message of messageType is received.

func (*ChannelsManager) ReplayChannel ¶

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

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

Parameters:

• marshalledChanId - A JSON marshalled channel ID (id.ID).

func (*ChannelsManager) SendAdminGeneric ¶

func (cm *ChannelsManager) SendAdminGeneric(adminPrivateKey,
	marshalledChanId []byte,
	messageType int, message []byte, leaseTimeMS int64,
	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.

Parameters:

• adminPrivateKey - The PEM-encoded admin RSA private key.
• marshalledChanId - A JSON marshalled channel ID (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.
• 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 - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.

Returns:

• []byte - A JSON marshalled ChannelSendReport.

func (*ChannelsManager) SendGeneric ¶

func (cm *ChannelsManager) SendGeneric(marshalledChanId []byte,
	messageType int, message []byte, leaseTimeMS int64,
	cmixParamsJSON []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 isn't 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 validUntil depends on the use case.

Parameters:

• marshalledChanId - A JSON marshalled channel ID (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.
• 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 - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.

Returns:

• []byte - A JSON marshalled ChannelSendReport.

func (*ChannelsManager) SendMessage ¶

func (cm *ChannelsManager) SendMessage(marshalledChanId []byte,
	message string, leaseTimeMS int64, cmixParamsJSON []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:

• marshalledChanId - A JSON marshalled channel ID (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
• 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 - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.

Returns:

• []byte - A JSON marshalled ChannelSendReport

func (*ChannelsManager) SendReaction ¶

func (cm *ChannelsManager) SendReaction(marshalledChanId []byte,
	reaction string, messageToReactTo []byte,
	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. Users will drop the reaction if they do not recognize the reactTo message.

Parameters:

• marshalledChanId - A JSON marshalled channel ID (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.
• cmixParamsJSON - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.

Returns:

• []byte - A JSON marshalled ChannelSendReport.

func (*ChannelsManager) SendReply ¶

func (cm *ChannelsManager) SendReply(marshalledChanId []byte,
	message string, messageToReactTo []byte, leaseTimeMS int64,
	cmixParamsJSON []byte) ([]byte, error)

SendReply 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 766 bytes at minimum.

If the message ID the reply is sent to is nonexistent, the other side will post the message as a normal message and not a reply. The message will auto delete validUntil after the round it is sent in, lasting forever if channels.ValidForever is used.

Parameters:

• marshalledChanId - A JSON marshalled channel ID (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.
• 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 - A JSON marshalled xxdk.CMIXParams. This may be empty, and GetDefaultCMixParams will be used internally.

Returns:

• []byte - A JSON marshalled ChannelSendReport

func (*ChannelsManager) SetNickname ¶

func (cm *ChannelsManager) SetNickname(newNick string, ch []byte) error

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

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) 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) GetReceptionRegistrationValidationSignature ¶

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

GetReceptionRegistrationValidationSignature returns the signature provided by the xx network.

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) 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 the backend keeps track of, which is formally referred to as a message.ServiceList. This may be passed into other bindings call which may need context on the available services for this client. This will provide services for all identities that the client tracks.

Parameters:

• cb - A TrackServicesCallback, which will be passed the marshalled message.ServiceList.

func (*Cmix) TrackServicesWithIdentity ¶

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

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

Parameters:

• e2eID - e2e object ID in the tracker.
• cb - A TrackServicesCallback, which will be passed the marshalled message.ServiceList.

func (*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 (*DummyTraffic) GetStatus ¶

func (dt *DummyTraffic) GetStatus() bool

GetStatus returns the current state of the DummyTraffic manager's sending thread. Note that this function does not return the status set by the most recent call to SetStatus. Instead, this call returns the current status of the sending thread. This is due to the small delay that may occur between calling SetStatus and the sending thread taking into effect that status change.

Returns:

• bool - Returns true if sending thread is sending dummy messages and false if sending thread is paused/stopped and is not sending dummy messages.

func (*DummyTraffic) SetStatus ¶

func (dt *DummyTraffic) SetStatus(status bool) error

SetStatus sets the state of the DummyTraffic manager's send thread by passing in a boolean parameter. There may be a small delay in between this call and the status of the sending thread to change accordingly. For example, passing false into this call while the sending thread is currently sending messages will not cancel nor halt the sending operation, but will pause the thread once that operation has completed.

Parameters:

• status - Input should be true if you want to send dummy messages and false if you want to pause dummy messages.

Returns:

• error - if the DummyTraffic.SetStatus is called too frequently, causing the internal status channel to fill.

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 (RoundsList) Marshal ¶

func (rl RoundsList) Marshal() ([]byte, error)

Marshal JSON marshals the RoundsList.

func (*UserDiscovery) ConfirmFact ¶

func (ud *UserDiscovery) ConfirmFact(confirmationID, code string) error

ConfirmFact confirms a fact first registered via SendRegisterFact. The confirmation ID comes from SendRegisterFact while the code will come over the associated communications system.

func (*UserDiscovery) GetContact ¶

func (ud *UserDiscovery) GetContact() ([]byte, error)

GetContact returns the marshalled bytes of the contact.Contact for UD as retrieved from the NDF.

func (*UserDiscovery) GetFacts ¶

func (ud *UserDiscovery) GetFacts() []byte

GetFacts returns a JSON marshalled list of fact.Fact objects that exist within the Store's registeredFacts map.

func (*UserDiscovery) GetID ¶

func (ud *UserDiscovery) GetID() int

GetID returns the udTracker ID for the UserDiscovery object.

func (*UserDiscovery) PermanentDeleteAccount ¶

func (ud *UserDiscovery) PermanentDeleteAccount(factJson []byte) error

PermanentDeleteAccount removes the username associated with this user from the UD service. This will only take a username type fact, and the fact must be associated with this user.

Parameters:

• factJson - a JSON marshalled fact.Fact

func (*UserDiscovery) RemoveFact ¶

func (ud *UserDiscovery) RemoveFact(factJson []byte) error

RemoveFact removes a previously confirmed fact. This will fail if the fact passed in is not UD service does not associate this fact with this user.

Parameters:

• factJson - a JSON marshalled fact.Fact

func (*UserDiscovery) SendRegisterFact ¶

func (ud *UserDiscovery) SendRegisterFact(factJson []byte) (string, error)

SendRegisterFact adds a fact for the user to user discovery. Will only succeed if the user is already registered and the system does not have the fact currently registered for any user.

This does not complete the fact registration process, it returns a confirmation ID instead. Over the communications system the fact is associated with, a code will be sent. This confirmation ID needs to be called along with the code to finalize the fact.

Parameters:

• factJson - a JSON marshalled fact.Fact