To parse and decrypt the keys
`js
const recipientPublicKey = await readKey({ armoredKey: '...' }); // or binaryKey
const senderPrivateKey = await decryptKey({
privateKey: await readPrivateKey({ armoredKey: '...' }),
passphrase: 'personal key passphrase'
});
`
To encrypt and sign:
`js
const {
message: armoredMessage,
encryptedSignature: armoredEncryptedSignature
} = await encryptMessage({
textData: 'text data to encrypt', // or binaryData for Uint8Arrays
encryptionKeys: recipientPublicKey, // and/or passwords
signingKeys: senderPrivateKey,
detached: true,
format: 'armored' // or 'binary' to output a binary message and signature
});

// share armoredMessage
`
To decrypt and verify (non-streamed input):
`js
// load the required keys
const senderPublicKey = await readKey(...);
const recipientPrivateKey = await decryptKey(...);

const { data: decryptedData, verificationStatus } = await decryptMessage({
message: await readMessage({ armoredMessage }), // or binaryMessage
encryptedSignature: await readMessage({ armoredMessage: armoredEncryptedSignature })
decryptionKeys: recipientPrivateKey // and/or 'passwords'
verificationKeys: senderPublicKey
});
`

For streamed inputs:
to encrypt (and/or sign), pass the stream to textData or binaryData based on the streamed data type. Similarly, to decrypt and verify, the input options are the same as the non-streaming case. However, if armoredMessage (or binaryMessage) is a stream, the decryption result needs to be handled differently:
`js
// explicitly loading stream polyfills for legacy browsers is required since v7.2.2
if (!globalThis.TransformStream) {
await import('web-streams-polyfill/es6');
}

const { data: dataStream, verificationStatus: verifiedPromise } = await decryptMessage({
message: await readMessage({ armoredMessage: streamedArmoredMessage }),
... // other options
});

// you need to read dataStream before resolving verifiedPromise, even if you do not need the decrypted data
const decryptedData = await readToEnd(dataStream);
const verificationStatus = await verificationStatus;
`


#### Encrypt/decrypt using the session key directly
In v6, encryptMessage would return the generated session key if options.returnSessionKey: true was given. This option is no longer supported. Instead:
`js
// First generate the session key
const sessionKey = await generateSessionKey({ recipientKeys: recipientPublicKey });

// Then encrypt the data with it
const { message: armoredMessage } = await encryptMessage({
textData: 'text data to encrypt', // or binaryData for Uint8Arrays
sessionKey,
encryptionKeys: recipientPublicKey, // and/or passwords, used to encrypt the session key
signingKeys: senderPrivateKey,
});
`

To decrypt, you can again provide the session key directly:
`js

// Then encrypt the data with it
const { data } = await decryptMessage({
message: await readMessage({ armoredMessage }),
sessionKeys: sessionKey,
verificationKeys: senderPublicKey,
});
`
You can also encrypt the session key on its own:
`js
const armoredEncryptedSessionKey = await encryptSessionKey({
sessionKey,
encryptionKeys, // and/or passwords
format: 'armored'
});

// And decrypt it with:
const sessionKey = await decryptSessionKey({
message: await readMessage({ armoredMessage: armoredEncryptedSessionKey }),
decryptionsKeys // and/or passwords
});

`