Class Identity

constructor

• new Identity(
      opts: {
          aes: CryptoKey;
          deviceName: string;
          devices: Record<string, Device>;
          DID: `did:key:z${string}`;
          encryptionKey: CryptoKeyPair;
          humanName: string;
          signingKey: CryptoKeyPair;
          username: string;
      },
  ): Identity

• Parameters

  • opts: {
        aes: CryptoKey;
        deviceName: string;
        devices: Record<string, Device>;
        DID: `did:key:z${string}`;
        encryptionKey: CryptoKeyPair;
        humanName: string;
        signingKey: CryptoKeyPair;
        username: string;
    }

  Returns Identity

aes

deviceName

devices

DID

encryptionKey

humanName

rootDeviceName

rootDID

signingKey

username

StaticENCRYPTION_KEY_NAME

StaticSIGNING_KEY_NAME

StaticSTORAGE_KEY

keys

• get keys(): Record<string, string>

• Returns Record<string, string>

addDevice

• addDevice(opts: Omit<Device, "aes">): Promise<Identity>

• Add another device to this identity.

  Parameters

  • opts: Omit<Device, "aes">

  Returns Promise<Identity>

decryptMsg

• decryptMsg(encryptedMsg: EncryptedMessage<string>): Promise<string>

• Decrypt the given message. Throws if the message does not contain a key for this device.

  Parameters

  • encryptedMsg: EncryptedMessage<string>

    The message to decrypt

  Returns Promise<string>

encryptMsg

• encryptMsg(
      data: string | Uint8Array<ArrayBufferLike>,
      recipients?: SerializedIdentity[],
  ): Promise<EncryptedMessage<string>>

• Generate a new AES key and use it to encrypt a message to the given recipients. The message author (this ID) is appended to the devices in the message, so the author will be able to decrypt the message.

  Omit the recipients to create a self-encrypted message.

  Parameters

  • data: string | Uint8Array<ArrayBufferLike>

    The thing to encrypt
  • Optionalrecipients: SerializedIdentity[]

    The recipients

  Returns Promise<EncryptedMessage<string>>

getDeviceName

• getDeviceName(): Promise<string>

• Get the device name -- a 32 character, DNS-friendly name

  Returns Promise<string>

serialize

• serialize(): Promise<SerializedIdentity>

• Return a JSON stringifiable version of this Identity.

  Returns Promise<SerializedIdentity>

sign

• sign(msg: Msg, charsize?: CharSize): Promise<Uint8Array<ArrayBufferLike>>

• Parameters

  • msg: Msg
  • Optionalcharsize: CharSize

  Returns Promise<Uint8Array<ArrayBufferLike>>

signAsString

• signAsString(msg: string): Promise<string>

• Parameters

  • msg: string

  Returns Promise<string>

Staticcreate

• create(
      opts: {
          humanName: string;
          humanReadableDeviceName: string;
          type?: "rsa";
      },
  ): Promise<Identity>

• Create a new Identity. Use this because async.

  Parameters

  • opts: { humanName: string; humanReadableDeviceName: string; type?: "rsa" }

    Key names used for storing the main keypairs in indexedDB.

  Returns Promise<Identity>

  A new identity instance

StaticcreateDeviceRecord

• createDeviceRecord(
      opts: { humanReadableName: string },
  ): Promise<Omit<Device, "aes">>

• Create a new device record. This does not include an AES key in the device record, because typically you create a device record before adding this device to a different Identity, so you would add an AES key at that point.

  Parameters

  • opts: { humanReadableName: string }

    A human-readable name for the device.

  Returns Promise<Omit<Device, "aes">>

  The device record without aes key.

Staticinit

• init(): Promise<Identity>

• Create an identity, loading saved keys from indexedDB, and saved properties from localStorage.

  Returns Promise<Identity>

Staticsave

• save(id: SerializedIdentity): void

• Save a serialized Identity to localStorage. Crypto keys are already saved to indexedDB.

  Parameters

  • id: SerializedIdentity

    The serialized Identity

  Returns void