Interface: SealdSDK ​

Properties ​

apiURL ​

apiURL: string

apiURL with which this SealdSDK instance was created. URL of the Seald API Servers to which it should connect.

appId ​

appId: string

appId with which this SealdSDK instance was created.

encryptionSessionCache ​

encryptionSessionCache: EncryptionSessionCache

Cache object to store encryption sessions

encryptionSessionCacheCleanupInterval ​

encryptionSessionCacheCleanupInterval: number

The cleanup interval of encryptionSession cache.

encryptionSessionCacheTTL ​

encryptionSessionCacheTTL: number

The lifetime of encryptionSession cache.

eventBus ​

eventBus: Emittery< Record< PropertyKey, any >, Record< PropertyKey, any > & _OmnipresentEventData, DatalessEventNames< Record< PropertyKey, any > > >

Event bus. See https://github.com/sindresorhus/emittery

goatee ​

goatee: any

Full Goatee library. For advanced use. See Goatee documentation, ask Seald Team.

hairlessURL ​

hairlessURL: string

hairlessURL with which this SealdSDK instance was created. URL of the Seald external decryption interface with which non-Seald users can decrypt documents.

intervals ​

intervals: object

Directly exposing the functions called periodically by "startIntervals". These functions cannot throw, so they are safe to "fire and forget": it's not necessary to await them.

Type declaration ​

intervals.checkMissingKeys ​

checkMissingKeys

intervals.heartbeat ​

heartbeat

keySize ​

keySize: 1024 | 2048 | 4096

The configured key size for newly generated asymmetric keys.

numberPreGeneratedIdentityKeys ​

numberPreGeneratedIdentityKeys: number

Get the number of pre-generated keys currently in the pool

sscrypto ​

sscrypto: SSCrypto

Full SSCrypto library. For advanced use. See SSCrypto documentation at https://github.com/seald/sscrypto

utils ​

utils: object

Various utilities, for advanced use.

Type declaration ​

utils.fetch ​

fetch: FetchFunction

The fetch implementation used by this SDK instance For advanced use.

utils.scrypt ​

scrypt: SCrypt

SCrypt wrapper with reasonable parameters. For advanced use.

utils.cleanEncryptionSessionCache ​

cleanEncryptionSessionCache

utils.deserializeSession ​

deserializeSession

utils.encodePassword ​

encodePassword

utils.getRecipients ​

getRecipients

utils.parseUserLicenseToken ​

parseUserLicenseToken

utils.readKeyBackup ​

readKeyBackup

utils.retrieveEncryptionSessionId ​

retrieveEncryptionSessionId

utils.writeKeyBackup ​

writeKeyBackup

version ​

version: string

The SDK version

Methods ​

addGroupMembers ​

addGroupMembers( groupId, newMembers, newAdmins?): Promise< void >

Add members to a group. Can only be done by a group administrator. Can also specify which of these group members should also be admins.

Parameters ​

Returns ​

Promise< void >

addMissingKeys ​

addMissingKeys(deviceId, retryOptions?): void

Trigger the re-encryption of missing message keys for the given deviceId. This function does not return a promise. It only triggers the re-encryption. To be notified of the end of the re-encryption, you must wait for the 'addMissingKeys-done' event on the event-bus. For example: const { deviceId, failed, done, error } = await sdk.eventBus.once('addMissingKeys-done')

Parameters ​

Returns ​

void

checkGroupSelfAddSecret ​

checkGroupSelfAddSecret(groupId): Promise< boolean >

Check if a self-add secret is set for a given group. Only accessible to group admins.

Parameters ​

Returns ​

Promise< boolean >

checkSigchainHash ​

checkSigchainHash( recipient, sigchainHash, opts?): Promise< { lastPosition: number; position: number; } >

Verify if a hash is included in the recipient sigchain. Use the position option to check the hash of a specific sigchain transaction.

Parameters ​

Returns ​

Promise< { lastPosition: number; position: number; } >

close ​

close(): Promise< void >

Close the database. After this, this SDK instance will no longer be usable. This also calls stopIntervals.

Returns ​

Promise< void >

createEncryptionSession ​

createEncryptionSession(recipients, opts?): Promise< EncryptionSession >

Create an encryption session, with which you can then encrypt / decrypt multiple messages.

Parameters ​

Returns ​

Promise< EncryptionSession >

createGroup ​

createGroup(args): Promise< { groupName: string; id: string; } >

Create a group

Parameters ​

Returns ​

Promise< { groupName: string; id: string; } >

createSubIdentity ​

createSubIdentity(opts?): Promise< { deviceId: string; identity: Buffer; } >

Create a sub-identity for the current identity, for example to use on another device. The created sub-identity Buffer can then be imported into another SDK instance using sdk.importIdentity.

A re-encryption of existing message keys must happen for the new sub-identity to be able to decrypt existing messages for this account:

• If you do not pass any argument, or pass shouldReencrypt: true, it will happen automatically
• Otherwise, you must trigger addMissingKeys with the newly created deviceId, in order for the re-encryption to happen.

Parameters ​

Returns ​

Promise< { deviceId: string; identity: Buffer; } >

decryptFile ​

decryptFile<T>(encryptedFile, opts?): Promise< { data: T; filename: string; sessionId: string; size: number; type: FileType; } >

Decrypt an encrypted file.

Type parameters ​

Parameters ​

Returns ​

Promise< { data: T; filename: string; sessionId: string; size: number; type: FileType; } >

decryptMessage ​

decryptMessage(encryptedString, opts?): Promise< string >

Decrypt a message.

Parameters ​

Returns ​

Promise< string >

deleteGroup ​

deleteGroup(groupId): Promise< void >

Delete a group

Parameters ​

Returns ​

Promise< void >

dropDatabase ​

dropDatabase(): Promise< void >

Drop local database, and delete locally saved backup key. It will also reset the current SDK instance. Call sdk.initialize() or sdk.initiateIdentity() afterward to continue with this sealdSDK instance.

Returns ​

Promise< void >

encryptFile ​

encryptFile<T>( clearFile, filename, recipients, opts?): Promise< T >

Encrypt a file.

Type parameters ​

Parameters ​

Returns ​

Promise< T >

Example ​

// Encrypt a string for another user of the app
const encryptedString = await seald.encryptFile(
  'Secret file content',
  'SecretFile.txt',
  { userIds: ['Other-User'] }
)

// Encrypt a Buffer for a Seald user
const encryptedBuffer = await seald.encryptFile(
  Buffer.from('Secret file content'),
  'SecretFile.txt',
  { sealdIds: [otherUserSealdId] }
)

// Encrypt a Blob for an external user
const encryptedBlob = await seald.encryptFile(
  new Blob(['Secret file content']),
  'SecretFile.txt',
  { emails: ['external@domain.com'] }
)

encryptMessage ​

encryptMessage( clearString, recipients, opts?): Promise< string >

Encrypt a message.

Parameters ​

Returns ​

Promise< string >

exportIdentity ​

exportIdentity(): Promise< Buffer >

Export the current identity, to handle it manually

Returns ​

Promise< Buffer >

getCurrentAccountInfo ​

getCurrentAccountInfo(): Promise< AccountInfo >

Get account info of current SDK instance.

Returns ​

Promise< AccountInfo >

getRSAKeyPromise ​

getRSAKeyPromise(size?): Promise< string >

Function which create a promise that resolves to a newly generated b64 encoded RSA key.

Parameters ​

Returns ​

Promise< string >

getSigchainHash ​

getSigchainHash(recipient?, opts?): Promise< { hash: string; position: number; sealdId: string; } >

Get hash of a user last sigchain transaction. If no recipient is given, return the current user hash.

Parameters ​

Returns ​

Promise< { hash: string; position: number; sealdId: string; } >

importIdentity ​

importIdentity(identity): Promise< AccountInfo >

Import identity manually

Parameters ​

Returns ​

Promise< AccountInfo >

initialize ​

initialize(): Promise< void >

Initialize the SDK. Must be called before any other method. Resolves when the initialization is done, and you can use the Seald SDK. If you use a persistent DB and do not know the registration status for certain, you may want to run sdk.registrationStatus after initialize, to check if you are in the 'no-account' or 'registered' state.

Returns ​

Promise< void >

initiateIdentity ​

initiateIdentity(args): Promise< AccountInfo >

Create the account for the first time.

Parameters ​

Returns ​

Promise< AccountInfo >

listBackupKeys ​

listBackupKeys(acceptBackupKeys?): Promise< { created: Date; createdBy: string; id: string; name: string; publicKey: PublicKey; }[] >

List admin backup keys

Parameters ​

Returns ​

Promise< { created: Date; createdBy: string; id: string; name: string; publicKey: PublicKey; }[] >

listGroupMembers ​

listGroupMembers(groupId): Promise< { displayName: string; id: string; isAdmin: boolean; }[] >

List members of a group

Parameters ​

Returns ​

Promise< { displayName: string; id: string; isAdmin: boolean; }[] >

listGroups ​

listGroups(args?): Promise< { lastPage: number; results: { bearduser: { displayName: string; id: string; }; created: string; deviceId: string; }[]; } >

List all groups in team

Parameters ​

Returns ​

Promise< { lastPage: number; results: { bearduser: { displayName: string; id: string; }; created: string; deviceId: string; }[]; } >

preGenerateIdentityKeys ​

preGenerateIdentityKeys(n?): void

Pre-generate identity keys and add them to the pool. Pre-generation is started for all keys as soon as this function is called. Keys are always added at the end of the pool, and used from the beginning of the pool.

Pre-generated identity keys will be used to accelerate all functions which need new identity keys: initiateIdentity, createSubIdentity, createGroup, renewGroupKey, renewKey.

Parameters ​

Returns ​

void

pullPreGeneratedIdentityKeyFromPool ​

pullPreGeneratedIdentityKeyFromPool(): PreGeneratedIdentityKey

Retrieve an identity key from the pool. If none are available, this will return null. Key is retrieved from the beginning of the pool.

Returns ​

PreGeneratedIdentityKey

pushJwt ​

pushJwt(jwt): Promise< { joinedTeam: boolean; userId: string; } >

Use a JWT on the current identity

Parameters ​

Returns ​

Promise< { joinedTeam: boolean; userId: string; } >

pushPreGeneratedIdentityKeyToPool ​

pushPreGeneratedIdentityKeyToPool(key): void

Add a previously retrieved identity key into the pool. Key is added at the end of the pool.

Parameters ​

Returns ​

void

registrationStatus ​

registrationStatus(): Promise< "no-account" | "no-team" | "registered" >

Returns the registration status of the SDK instance. In the SDK, you should only get the values 'no-account' or 'registered'.

Returns ​

Promise< "no-account" | "no-team" | "registered" >

removeGroupMembers ​

removeGroupMembers(groupId, membersToRemove): Promise< void >

Remove members from a group. Can only be done by a group administrator. You should call renewGroupKey after this.

Parameters ​

Returns ​

Promise< void >

renewGroupKey ​

renewGroupKey(groupId, options?): Promise< void >

Renew group private key. Should be called after removing members.

Parameters ​

Returns ​

Promise< void >

renewKey ​

renewKey(opts?): Promise< void >

Renew the key of this Identity. Be careful, if this Identity is stored on SSKS or with another plugin, you will have to store it again, as the old one will not be valid anymore.

Parameters ​

Returns ​

Promise< void >

retrieveEncryptionSession ​

retrieveEncryptionSession<T>(args): Promise< EncryptionSession >

Retrieve an encryption session, with which you can then encrypt / decrypt multiple messages, either with an encrypted message of this session, or with the sessionId.

Type parameters ​

Parameters ​

Returns ​

Promise< EncryptionSession >

retrieveEncryptionSessionWithSymEncKey ​

retrieveEncryptionSessionWithSymEncKey(args): Promise< EncryptionSession >

Retrieve an encryption session, with which you can then encrypt / decrypt multiple messages, with the sessionId and a SymEncKey.

You must pass either symEncKeyPassword, or both symEncKeyRawSecret and symEncKeyRawSymKey.

Parameters ​

Returns ​

Promise< EncryptionSession >

retrieveMultipleEncryptionSessions ​

retrieveMultipleEncryptionSessions<T>(toRetrieve, args?): Promise< EncryptionSession[] >

Retrieve multiple encryption sessions.

Type parameters ​

Parameters ​

Returns ​

Promise< EncryptionSession[] >

selfAddGroup ​

selfAddGroup(groupId, args): Promise< void >

Add self to a group with a self-add secret.

Parameters ​

Returns ​

Promise< void >

selfAddToEncryptionSessionWithSymEncKey ​

selfAddToEncryptionSessionWithSymEncKey(args): Promise< EncryptionSession >

Self-add to an encryption session, and return it, with the sessionId and a SymEncKey.

You can only call this if the SymEncKey has the forward right.

You must pass either symEncKeyPassword, or both symEncKeyRawSecret and symEncKeyRawSymKey.

Parameters ​

Returns ​

Promise< EncryptionSession >

setGroupAdmin ​

setGroupAdmin( groupId, groupMember, statusToSet): Promise< void >

Set admin status of a group member. Can only be done one recipient at a time. Can only be done by a group administrator. This is deprecated. Use setGroupAdmins instead.

Parameters ​

Returns ​

Promise< void >

Deprecated ​

setGroupAdmins ​

setGroupAdmins(groupId, groupMembers): Promise< void >

Set admin status of group members. Can only be done by a group administrator.

Parameters ​

Returns ​

Promise< void >

setGroupSelfAddSecret ​

setGroupSelfAddSecret(groupId, args): Promise< boolean >

Set or change a self-add secret for a given group. Set selfAddSecret to null to disable. You must pass either a selfAddSecret, or a selfAddPassword that will be derived into one. Only accessible to group admins.

Parameters ​

Returns ​

Promise< boolean >

setLogLevel ​

setLogLevel(logLevel): void

This sets the log level. logLevel must be a string of value silly, debug, info, warn, error, none, or a template of the format ${namespace_1}:${logLevel_for_namespace_1},${namespace_2}:${logLevel_for_namespace_2},.... This will set the log level for all SDK and AnonymousSDK instances, not only the current one.

Parameters ​

Returns ​

void

startIntervals ​

startIntervals(): Promise< void >

Call the functions in "intervals", then setup intervals so they are called periodically. This function cannot throw, so it is safe to "fire and forget": it's not necessary to await it.

Returns ​

Promise< void >

stopIntervals ​

stopIntervals(): void

Stop calling the functions in "intervals" periodically.

Returns ​

void

updateContacts ​

updateContacts(r): Promise< void >

Update the local database for the specified recipients.

Parameters ​

Returns ​

Promise< void >

updateCurrentDevice ​

updateCurrentDevice(): Promise< void >

Updates the locally known information about the current device.

You should never have to call this manually, except if you getting null in sealdAccountInfo.deviceExpires, which can happen if migrating from an older version of the SDK, or if the internal call to sdk.updateCurrentDevice failed when calling sdk.importIdentity.

Returns ​

Promise< void >