orgnote-api 0.17.1 → 0.17.2

package/encryption/__tests__/note-encryption.spec.ts

@@ -1,424 +0,0 @@
-import { expect, test } from 'vitest';
-import { decryptNote, encryptNote } from '../note-encryption';
-import { Note } from '../../models';
-import {
-  armoredPublicKey,
-  armoredPrivateKey,
-  privateKeyPassphrase,
-} from './encryption-keys';
-import { ModelsPublicNoteEncryptionTypeEnum } from '../../remote-api';
-
-test('Should encrypt note content via password', async () => {
-  const noteText = `#+ID: qweqwe
-
-#+TITLE: Hello worlld
-
-* Hello?`;
-
-  const note: Note = {
-    id: 'id',
-    meta: {
-      title: 'My note title',
-      images: [],
-      published: false,
-      description: 'Awesome description',
-    },
-    author: {
-      id: '1',
-      name: 'John Doe',
-      email: 'test@mail.com',
-    },
-  };
-
-  const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
-    content: noteText,
-    type: 'gpgPassword',
-    password: '123',
-    format: 'armored',
-  });
-
-  expect(encryptedNoteText.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
-    true
-  );
-  expect(encryptedNote).toMatchSnapshot();
-});
-
-test('Should encrypt note content via password to binary format', async () => {
-  const noteText = `#+ID: qweqwe
-
-#+TITLE: Hello worlld
-
-* Hello?`;
-
-  const note: Note = {
-    id: 'id',
-    meta: {
-      title: 'My note title',
-      images: [],
-      published: false,
-      description: 'Awesome description',
-    },
-    author: {
-      id: '1',
-      name: 'John Doe',
-      email: 'test@mail.com',
-    },
-  };
-
-  const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
-    content: noteText,
-    type: 'gpgPassword',
-    password: '123',
-    format: 'binary',
-  });
-
-  expect(encryptedNote).toMatchSnapshot();
-  expect(encryptedNoteText).toBeInstanceOf(Uint8Array);
-});
-
-test('Should decrypt note content via password', async () => {
-  const noteText = `-----BEGIN PGP MESSAGE-----
-
-wy4ECQMI/CCaKMJEqy/gyROJeRgW9I738dDFBltFlxIjhxrN7nQ6gkX4GgX6
-zt3v0mABvaBJA7corlU8su21TpPApOs/+DMWpVlbI3Zer7QfQK1fSBoSTbCR
-2k3g68Afayke2nLkDNkH62tdOPiTkx7bSlp1zL4uU440IM1g6dC72JkmtoTJ
-5Bjlwt4ZhxFsh+c=
-=csID
------END PGP MESSAGE-----`;
-
-  const note: Note = {
-    id: 'id',
-    meta: {
-      title: 'My note title',
-      images: [],
-      published: false,
-      description: 'Awesome description',
-    },
-  };
-
-  const decryptedNote = await decryptNote(note, {
-    content: noteText,
-    type: 'gpgPassword',
-    password: '123',
-  });
-
-  expect(decryptedNote).toMatchSnapshot();
-});
-
-test('Should encrypt note via keys', async () => {
-  const noteText = `#+ID: qweqwe
-#+TITLE: Hello worlld
-
-* Hello?`;
-
-  const note: Note = {
-    id: 'id',
-    meta: {
-      title: 'My note title for encryption via keys',
-      images: [],
-      published: false,
-      description: 'Awesome description',
-    },
-    author: {
-      id: '1',
-      name: 'John Doe',
-      email: 'test@mail.com',
-    },
-  };
-
-  const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
-    content: noteText,
-    type: ModelsPublicNoteEncryptionTypeEnum.GpgKeys,
-    publicKey: armoredPublicKey,
-    privateKey: armoredPrivateKey,
-    privateKeyPassphrase,
-    format: 'armored',
-  });
-
-  expect(encryptedNoteText.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
-    true
-  );
-  expect(encryptedNote).toMatchSnapshot();
-});
-
-test('Should decrypt note via provided keys', async () => {
-  const encryptedNoteText = `-----BEGIN PGP MESSAGE-----
-
-wcFMA/vryg+TTn0rAQ//TBFRjKmjRQoLhSrgeH+NbsZXbxvo7Ey4k+BQ9XA5
-+CMpXH9uFUxsSaI5+McUSEt32VI17HRpXQDCL9nwaWqWOanMaRe0tXXhtox2
-gfe2f/6zsge9ux+mXF2BG4z+V5T8XIOrfzxosVprdJHZHM3x7cW5USQ0t2i2
-FiOUWxSZO1899J3yICpMvhDXvTLVZuKpSNQho5PyXSeZa83eN+uYkhgt9lsk
-0KW88Nr435S6n6mVw/zpitXIgEKpkqh46mhG+1W3aC0lYx6j9lHm3bjtdb4r
-2mtZbWKwfdBggEy8qEeiUeslvKd6uWtEccomzFgJkaqWVGknLmrBdHfztRIV
-fbZhxHz+J3GFOIgXf/5+fv+zg0nTazgz1mDUfnTHw3+qcAyEJ0ADdyg9EZc+
-bKbK0GwzMDPQeM+cCRDWUTiIa1ruyEETiwMdhWUDztF8XxY2o8jXPerZ0NhG
-R8l+SvAdYQQXPfxEh9lA3thkyz/Vp72pW46lUeJHGSq/fS6KIdLHLP9Z2e1J
-aCFpNMgyAN+BaXwnbLZfz6k5hV8awbRScSWQLEg69D9b287SFDPOYW7OZikn
-CKXL7xyQ5LrWJZN9Z/UPGjy+PdEw1SBhyluW6DQ+Sz1j4K8USTLqY89EInDl
-G7AxHGujR9UkUGyUvvc71XW7jEOogiDgn1ZMoj9Y58LSweUB8vfkY3VF84Fy
-zGVvLFWnFbtnWuoQC4OOXv1F6ETdmEsSMEMWKzRLDGPyqNX7FhG3cejlEuiK
-EsT5oQhz00RECmnR8mJkGmJhzWmmeoQvaucFqhTOZjvYl9ivuEMBZ2jtkdHn
-R6UNcNZRpCbfnl7YoikqbGBgqDFYydFGHXKHDpYhcQYWJsMDUayzUiPtzmaE
-tgfTgNNqgPxkLnWA99KYNU8DH+FwgaYBuw9dwdqwcjxSbZjHhCFGUfsqM+ik
-O9gcoAwVO1usODlESU7OWuSF2tIv5DBG5rhlSyxBp4d4aWmaumTswAdojy2O
-sM70ETbg0mC8niW9lNsgJp55oFmlksvzjUIit5rBEr55rtPcJSgakPpR2yvd
-Q4XjybUmV0IdONMhk/OlqaBPtnA0RG+qTcm7oP1qH/m5zRA0ZplVQ5ylkQwr
-LwGq5JQpJkgxxgLIrUbbtzYBShXSr5c1XXR0LIRiNgtb6s1s4mt+fbyExdJF
-+ceuu+/xYrW/YTuEJpHxLiZ+aNPW5g5Y7Hbqu3hp3UL/kD44cc8JjZh18spX
-p/ncojDhF2r2vhR+CndYcMkpGMV+t1pGKC8wlcFc7lb9GJASnqMGvhQmvIaG
-gO/x7UjuTZSBW+kITHHZJDqYryKUv1j0CkHxIn9tWsYOpa1giOFtXX5v0AAM
-AJR/s/beLlqwCsUdYnw1TkP/0u0ZK3RPio1nJ7S6ckPfsM7DqCWD8ILD8Cdr
-cuzQrWaE30t5PXx53xBPO+6t5wKfDL35WHWG1Irmvz9UuT7tDS3IzwtF4ijF
-PX6alTbxGnoHgZ4bG4J1wfpTNPppP1gJeVg67VqOypzdZi+SjofMWnFgRFmD
-yEN8xpFUs7A9xryVZOosp9Sfe3IbBkO99sAQ7jV4EoMYk3/GKA==
-=LjkG
------END PGP MESSAGE-----`;
-
-  const note: Note = {
-    id: 'id',
-    meta: {
-      title: 'My note title for decryption via keys',
-      images: [],
-      published: false,
-      description: 'Awesome description',
-    },
-  };
-
-  const decryptedNote = await decryptNote(note, {
-    content: encryptedNoteText,
-    type: 'gpgKeys',
-    publicKey: armoredPublicKey,
-    privateKey: armoredPrivateKey,
-    privateKeyPassphrase,
-  });
-
-  expect(decryptedNote).toMatchSnapshot();
-});
-
-test('Should not encrypt public note', async () => {
-  const noteText = `#+ID: qweqwe
-#+TITLE: Hello worlld
-
-* Hello?`;
-
-  const note: Note = {
-    id: 'id',
-    meta: {
-      title: 'My note title',
-      images: [],
-      published: true,
-      description: 'Awesome description',
-    },
-    author: {
-      id: '1',
-      name: 'John Doe',
-      email: 'test@mail.com',
-    },
-  };
-
-  const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
-    content: noteText,
-    type: 'gpgPassword',
-    password: '123',
-    format: 'armored',
-  });
-
-  expect(encryptedNoteText.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
-    false
-  );
-  expect(encryptedNote).toMatchSnapshot();
-});
-
-test('Should encrypt note with empty encrypted property', async () => {
-  const noteText = `#+ID: qweqwe
-#+TITLE: Hello worlld
-
-* Hello?`;
-
-  const note: Note = {
-    id: 'id',
-    meta: {
-      title: 'My note title',
-      images: [],
-      published: false,
-      description: 'Awesome description',
-    },
-    author: {
-      id: '1',
-      name: 'John Doe',
-      email: 'test@mail.com',
-    },
-  };
-
-  const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
-    content: noteText,
-    type: 'gpgPassword',
-    password: '123',
-    format: 'armored',
-  });
-
-  expect(encryptedNoteText.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
-    true
-  );
-
-  expect(encryptedNote).toMatchSnapshot();
-});
-
-test('Should not decrypt note without provided encrypted type', async () => {
-  const noteText = `#+ID: qweqwe
-#+TITLE: Hello worlld
-
-* Hello?`;
-  const note: Note = {
-    id: 'id',
-    meta: {
-      title: 'My note title',
-      images: [],
-      published: false,
-      description: 'Awesome description',
-    },
-    encrypted: undefined,
-    author: {
-      id: '1',
-      name: 'John Doe',
-      email: 'test@mail.com',
-    },
-  };
-
-  const decryptedInfo = await decryptNote(note, {
-    content: noteText,
-    type: 'gpgPassword',
-    password: '123',
-  });
-
-  expect(decryptedInfo).toMatchSnapshot();
-});
-
-test('Should decrypt note and note meta', async () => {
-  const meta = {
-    title: 'My note title',
-    images: ['./image1.png'],
-    published: false,
-    description: 'Awesome description',
-    fileTags: ['tag1', 'tag2'],
-  };
-  const note: Note = {
-    id: 'id',
-    meta: { ...meta },
-  };
-
-  const noteText = `#+TITLE: My note title
-#+DESCRIPTION: Awesome description
-#+PUBLISHED: false
-#+FILETAGS: :tag1:tag2:
-
-[[./image1.png]]
-
-Hello world`;
-
-  const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
-    content: noteText,
-    type: 'gpgPassword',
-    password: '123',
-  });
-
-  const [decryptedNote, decryptedNoteText] = await decryptNote(encryptedNote, {
-    content: encryptedNoteText,
-    type: 'gpgPassword',
-    password: '123',
-  });
-
-  expect(decryptedNote.meta).toEqual(meta);
-  expect(decryptedNoteText).toEqual(noteText);
-});
-
-test('Should set not encrypted status when params type does not provided', async () => {
-  const note: Note = {
-    id: 'id',
-    meta: {
-      title: 'My note title for decryption via keys',
-      images: [],
-      published: false,
-      description: 'Awesome description',
-    },
-  };
-
-  const noteText = `-----BEGIN PGP MESSAGE-----
-
-wcFMA/vryg+TTn0rAQ//TBFRjKmjRQoLhSrgeH+NbsZXbxvo7Ey4k+BQ9XA5
-+CMpXH9uFUxsSaI5+McUSEt32VI17HRpXQDCL9nwaWqWOanMaRe0tXXhtox2
-gfe2f/6zsge9ux+mXF2BG4z+V5T8XIOrfzxosVprdJHZHM3x7cW5USQ0t2i2
-FiOUWxSZO1899J3yICpMvhDXvTLVZuKpSNQho5PyXSeZa83eN+uYkhgt9lsk
-0KW88Nr435S6n6mVw/zpitXIgEKpkqh46mhG+1W3aC0lYx6j9lHm3bjtdb4r
-2mtZbWKwfdBggEy8qEeiUeslvKd6uWtEccomzFgJkaqWVGknLmrBdHfztRIV
-fbZhxHz+J3GFOIgXf/5+fv+zg0nTazgz1mDUfnTHw3+qcAyEJ0ADdyg9EZc+
-bKbK0GwzMDPQeM+cCRDWUTiIa1ruyEETiwMdhWUDztF8XxY2o8jXPerZ0NhG
-R8l+SvAdYQQXPfxEh9lA3thkyz/Vp72pW46lUeJHGSq/fS6KIdLHLP9Z2e1J
-aCFpNMgyAN+BaXwnbLZfz6k5hV8awbRScSWQLEg69D9b287SFDPOYW7OZikn
-CKXL7xyQ5LrWJZN9Z/UPGjy+PdEw1SBhyluW6DQ+Sz1j4K8USTLqY89EInDl
-G7AxHGujR9UkUGyUvvc71XW7jEOogiDgn1ZMoj9Y58LSweUB8vfkY3VF84Fy
-zGVvLFWnFbtnWuoQC4OOXv1F6ETdmEsSMEMWKzRLDGPyqNX7FhG3cejlEuiK
-EsT5oQhz00RECmnR8mJkGmJhzWmmeoQvaucFqhTOZjvYl9ivuEMBZ2jtkdHn
-R6UNcNZRpCbfnl7YoikqbGBgqDFYydFGHXKHDpYhcQYWJsMDUayzUiPtzmaE
-tgfTgNNqgPxkLnWA99KYNU8DH+FwgaYBuw9dwdqwcjxSbZjHhCFGUfsqM+ik
-O9gcoAwVO1usODlESU7OWuSF2tIv5DBG5rhlSyxBp4d4aWmaumTswAdojy2O
-sM70ETbg0mC8niW9lNsgJp55oFmlksvzjUIit5rBEr55rtPcJSgakPpR2yvd
-Q4XjybUmV0IdONMhk/OlqaBPtnA0RG+qTcm7oP1qH/m5zRA0ZplVQ5ylkQwr
-LwGq5JQpJkgxxgLIrUbbtzYBShXSr5c1XXR0LIRiNgtb6s1s4mt+fbyExdJF
-+ceuu+/xYrW/YTuEJpHxLiZ+aNPW5g5Y7Hbqu3hp3UL/kD44cc8JjZh18spX
-p/ncojDhF2r2vhR+CndYcMkpGMV+t1pGKC8wlcFc7lb9GJASnqMGvhQmvIaG
-gO/x7UjuTZSBW+kITHHZJDqYryKUv1j0CkHxIn9tWsYOpa1giOFtXX5v0AAM
-AJR/s/beLlqwCsUdYnw1TkP/0u0ZK3RPio1nJ7S6ckPfsM7DqCWD8ILD8Cdr
-cuzQrWaE30t5PXx53xBPO+6t5wKfDL35WHWG1Irmvz9UuT7tDS3IzwtF4ijF
-PX6alTbxGnoHgZ4bG4J1wfpTNPppP1gJeVg67VqOypzdZi+SjofMWnFgRFmD
-yEN8xpFUs7A9xryVZOosp9Sfe3IbBkO99sAQ7jV4EoMYk3/GKA==
-=LjkG
------END PGP MESSAGE-----`;
-
-  const decryptedNote = await decryptNote(note, {
-    content: noteText,
-    type: 'disabled',
-  });
-
-  expect(decryptedNote).toMatchSnapshot();
-});
-
-test('Should encrypt note to binary format', async () => {
-  const noteText = `#+ID: qweqwe
-#+TITLE: Hello worlld
-
-* Hello?`;
-
-  const note: Note = {
-    id: 'id',
-    meta: {
-      title: 'My note title',
-      images: [],
-      published: false,
-      description: 'Awesome description',
-    },
-    author: {
-      id: '1',
-      name: 'John Doe',
-      email: 'test@mail.com',
-    },
-  };
-
-  const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
-    content: noteText,
-    type: 'gpgPassword',
-    password: '123',
-    format: 'binary',
-  });
-
-  expect(encryptedNoteText).toBeInstanceOf(Uint8Array);
-  expect(encryptedNote).toMatchSnapshot();
-
-  const [_, decryptedNoteText] = await decryptNote(encryptedNote, {
-    content: encryptedNoteText,
-    type: 'gpgPassword',
-    password: '123',
-  });
-
-  expect(decryptedNoteText).toEqual(noteText);
-});

package/encryption/encryption.ts

@@ -1,265 +0,0 @@
-import {
-  createMessage,
-  decrypt as _decrypt,
-  decryptKey,
-  encrypt as _encrypt,
-  readKey,
-  readMessage,
-  readPrivateKey,
-  Stream,
-} from 'openpgp';
-import { ModelsPublicNoteEncryptionTypeEnum } from '../remote-api';
-import {
-  OrgNoteEncryption,
-  OrgNotePasswordEncryption,
-  WithDecryptionContent,
-} from '../models/encryption';
-import { OrgNoteGpgEncryption, WithEncryptionContent } from '../models';
-import { armor as _armor, unarmor as _unarmor, enums } from 'openpgp';
-
-export class IncorrectOrMissingPrivateKeyPasswordError extends Error {}
-export class ImpossibleToDecryptWithProvidedKeysError extends Error {}
-export class IncorrectEncryptionPasswordError extends Error {}
-export class NoKeysProvidedError extends Error {}
-export class NoPasswordProvidedError extends Error {}
-
-const noPrivateKeyPassphraseProvidedErrorMsg =
-  'Error: Signing key is not decrypted.';
-const incorrectPrivateKeyPassphraseErrorMsg =
-  'Error decrypting private key: Incorrect key passphrase';
-const decryptionKeyIsNotDecryptedErrorMsg =
-  'Error decrypting message: Decryption key is not decrypted.';
-const corruptedPrivateKeyErrorMsg = 'Misformed armored text';
-
-const decriptionFailedErrorMsg =
-  'Error decrypting message: Session key decryption failed.';
-const incorrectEncryptionPasswordErrorMsg =
-  'Error decrypting message: Modification detected.';
-
-const noSymmetricallyEncryptedSessionKeyErrorMsg =
-  'Error decrypting message: No symmetrically encrypted session key packet found.';
-
-const armoredTextNotTypePrivateKeyErrorMsg =
-  'Armored text not of type private key';
-
-const notPrivateKeyErrprMsg =
-  'Error decrypting message: No public key encrypted session key packet found.';
-
-export const encryptViaKeys = withCustomErrors(_encryptViaKeys);
-export const encryptViaPassword = withCustomErrors(_encryptViaPassword);
-export const decryptViaPassword = withCustomErrors(_decryptViaPassword);
-export const decryptViaKeys = withCustomErrors(_decryptViaKeys);
-
-export const encrypt = async <
-  T extends WithEncryptionContent<OrgNoteEncryption>,
->(
-  encryptionParams: T
-): Promise<T['format'] extends 'binary' ? Uint8Array : string> => {
-  if (
-    !encryptionParams.type ||
-    encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled
-  ) {
-    return encryptionParams.content as any;
-  }
-
-  const res = (encryptionParams.type ===
-  ModelsPublicNoteEncryptionTypeEnum.GpgKeys
-    ? await encryptViaKeys(encryptionParams)
-    : await encryptViaPassword(encryptionParams)) as unknown as Promise<
-    T['format'] extends 'binary' ? Uint8Array : string
-  >;
-
-  return res;
-};
-
-export const decrypt = async <
-  T extends WithDecryptionContent<OrgNoteEncryption>,
->(
-  decryptionParams: T
-): Promise<T['format'] extends 'binary' ? Uint8Array : string> => {
-  if (
-    !decryptionParams.type ||
-    decryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled
-  ) {
-    return decryptionParams.content as any;
-  }
-  const decryptedNote = (decryptionParams.type ===
-  ModelsPublicNoteEncryptionTypeEnum.GpgKeys
-    ? await decryptViaKeys(decryptionParams)
-    : await decryptViaPassword(decryptionParams)) as unknown as Promise<
-    T['format'] extends 'binary' ? Uint8Array : string
-  >;
-
-  return decryptedNote;
-};
-
-async function _encryptViaPassword<
-  T extends WithEncryptionContent<OrgNotePasswordEncryption>,
->({
-  content,
-  password,
-  format = 'binary',
-}: T): Promise<T['format'] extends 'binary' ? Uint8Array : string> {
-  const message = await createMessage({
-    text: content,
-  });
-
-  const encryptedMessage = await _encrypt({
-    message,
-    format: format as any,
-    passwords: [password],
-  });
-
-  return encryptedMessage as Promise<
-    T['format'] extends 'binary' ? Uint8Array : string
-  >;
-}
-
-export async function _encryptViaKeys<
-  T extends WithEncryptionContent<OrgNoteGpgEncryption>,
->({
-  content,
-  publicKey: armoredPublicKey,
-  privateKey: armoredPrivateKey,
-  privateKeyPassphrase,
-  format = 'binary',
-}: T): Promise<T['format'] extends 'binary' ? Uint8Array : string> {
-  const publicKey = await readKey({ armoredKey: armoredPublicKey });
-
-  const message = await createMessage({
-    text: content,
-  });
-
-  const encryptedPrivateKey = await readPrivateKey({
-    armoredKey: armoredPrivateKey,
-  });
-
-  const privateKey = privateKeyPassphrase
-    ? await decryptKey({
-        privateKey: encryptedPrivateKey,
-        passphrase: privateKeyPassphrase,
-      })
-    : encryptedPrivateKey;
-
-  const encryptedMessage = await _encrypt({
-    message,
-    format: format as any,
-    encryptionKeys: publicKey,
-    signingKeys: privateKey,
-  });
-
-  return encryptedMessage as Promise<
-    T['format'] extends 'binary' ? Uint8Array : string
-  >;
-}
-
-async function _decryptViaPassword<
-  T extends Omit<WithDecryptionContent<OrgNotePasswordEncryption>, 'type'>,
->({
-  content,
-  password,
-  format = 'utf8',
-}: T): Promise<T['format'] extends 'binary' ? Uint8Array : string> {
-  const isArmoredContent = typeof content === 'string';
-
-  const message = await (isArmoredContent
-    ? readMessage({ armoredMessage: content })
-    : readMessage({ binaryMessage: content }));
-
-  const { data: decryptedText } = await _decrypt({
-    message,
-    format,
-    passwords: password,
-  });
-
-  return decryptedText as Promise<
-    T['format'] extends 'binary' ? Uint8Array : string
-  >;
-}
-
-// TODO: master OrgNoteGpgDecryption type
-async function _decryptViaKeys<
-  T extends Omit<WithDecryptionContent<OrgNoteGpgEncryption>, 'type'>,
->({
-  privateKey: armoredPrivateKey,
-  privateKeyPassphrase,
-  content,
-  format = 'utf8',
-}: T): Promise<T['format'] extends 'binary' ? Uint8Array : string> {
-  const encryptedPrivateKey = await readPrivateKey({
-    armoredKey: armoredPrivateKey,
-  });
-
-  const privateKey = privateKeyPassphrase
-    ? await decryptKey({
-        privateKey: encryptedPrivateKey,
-        passphrase: privateKeyPassphrase,
-      })
-    : encryptedPrivateKey;
-
-  const isString = typeof content === 'string';
-  const message = await (isString
-    ? readMessage({ armoredMessage: content })
-    : readMessage({ binaryMessage: content }));
-
-  const { data: decryptedText } = await _decrypt({
-    message,
-    format,
-    decryptionKeys: privateKey,
-  });
-
-  return decryptedText as Promise<
-    T['format'] extends 'binary' ? Uint8Array : string
-  >;
-}
-
-function withCustomErrors<P extends unknown[], T>(
-  fn: (...args: P) => Promise<T | never>
-) {
-  return async (...args: P): Promise<T> => {
-    try {
-      return await fn(...args);
-    } catch (e: unknown) {
-      if (!(e instanceof Error)) {
-        throw e;
-      }
-      if (
-        [
-          noPrivateKeyPassphraseProvidedErrorMsg,
-          incorrectPrivateKeyPassphraseErrorMsg,
-          corruptedPrivateKeyErrorMsg,
-          decryptionKeyIsNotDecryptedErrorMsg,
-          armoredTextNotTypePrivateKeyErrorMsg,
-        ].includes(e.message)
-      ) {
-        throw new IncorrectOrMissingPrivateKeyPasswordError(e.message);
-      }
-      if (e.message === decriptionFailedErrorMsg) {
-        throw new ImpossibleToDecryptWithProvidedKeysError(e.message);
-      }
-      if (e.message === incorrectEncryptionPasswordErrorMsg) {
-        throw new IncorrectEncryptionPasswordError();
-      }
-      if (e.message === noSymmetricallyEncryptedSessionKeyErrorMsg) {
-        throw new NoKeysProvidedError();
-      }
-
-      if (e.message === notPrivateKeyErrprMsg) {
-        throw new NoPasswordProvidedError();
-      }
-
-      throw e;
-    }
-  };
-}
-
-// TODO: feat/native-encryption-support add custom error handling
-export function armor(data: Uint8Array): string {
-  return _armor(enums.armor.message, data);
-}
-
-export async function unarmor(
-  data: string
-): Promise<{ text: string; data: Stream<Uint8Array>; type: enums.armor }> {
-  return await _unarmor(data);
-}