diff --git a/example/src/PolymerToggler/PolymerToggler.tsx b/example/src/PolymerToggler/PolymerToggler.tsx
index bdb6a7ee57..b35a65eab8 100644
--- a/example/src/PolymerToggler/PolymerToggler.tsx
+++ b/example/src/PolymerToggler/PolymerToggler.tsx
@@ -22,7 +22,7 @@ export interface PolymerTogglerProps {
 
 const PolymerToggler = ({ toggle }: PolymerTogglerProps): JSX.Element => {
   return (
-    <label className={styles.switch} data-testid="PolymerToggler">
+    <label className={styles.switch} data-testid="polymer-toggler">
       <input type="checkbox" onChange={(e) => toggle(e.target.checked)} />
       <span className={styles.slider} />
     </label>
diff --git a/ketcher-autotests/constants/testIdConstants.ts b/ketcher-autotests/constants/testIdConstants.ts
index 36c5b0dd1f..3cdd18905c 100644
--- a/ketcher-autotests/constants/testIdConstants.ts
+++ b/ketcher-autotests/constants/testIdConstants.ts
@@ -2,7 +2,7 @@ const PEPTIDES_TAB = 'PEPTIDES_TAB';
 const RNA_TAB = 'RNA_TAB';
 const CHEM_TAB = 'CHEM_TAB';
 const FAVORITES_TAB = 'FAVORITES_TAB';
-const POLYMER_TOGGLER = 'PolymerToggler';
+const POLYMER_TOGGLER = 'polymer-toggler';
 const SUGAR = 'rna-builder-slot--sugar';
 const BASE = 'rna-builder-slot--base';
 const PHOSPHATE = 'rna-builder-slot--phosphate';
diff --git a/ketcher-autotests/tests/Macromolecule-editor/Erase-Tool/erase-tool.spec.ts b/ketcher-autotests/tests/Macromolecule-editor/Erase-Tool/erase-tool.spec.ts
new file mode 100644
index 0000000000..0c58af9516
--- /dev/null
+++ b/ketcher-autotests/tests/Macromolecule-editor/Erase-Tool/erase-tool.spec.ts
@@ -0,0 +1,55 @@
+import { test } from '@playwright/test';
+import {
+  addMonomerToCanvas,
+  selectEraseTool,
+  selectSingleBondTool,
+  takeEditorScreenshot,
+} from '@utils';
+import { turnOnMacromoleculesEditor } from '@utils/macromolecules';
+import { bondTwoMonomers } from '@utils/macromolecules/polymerBond';
+/* eslint-disable no-magic-numbers */
+
+test.describe('Erase Tool', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('');
+    await turnOnMacromoleculesEditor(page);
+  });
+  test.skip('Delete monomer bonded with another monomers', async ({ page }) => {
+    /* 
+    Test case: #2370 - "Erase" tool for macromolecules editor
+    Description: Erase Tool
+    */
+
+    // Create 4 peptides on canvas
+    const MONOMER_NAME = 'Tza___3-thiazolylalanine';
+    const MONOMER_ALIAS = 'Tza';
+    await addMonomerToCanvas(page, MONOMER_NAME, 300, 300);
+    await addMonomerToCanvas(page, MONOMER_NAME, 400, 400);
+    await addMonomerToCanvas(page, MONOMER_NAME, 500, 500);
+    await addMonomerToCanvas(page, MONOMER_NAME, 500, 200);
+
+    // Get 4 peptides locators
+    const peptides = await page.getByText(MONOMER_ALIAS).locator('..');
+    const peptide1 = peptides.nth(0);
+    const peptide2 = peptides.nth(1);
+    const peptide3 = peptides.nth(2);
+    const peptide4 = peptides.nth(3);
+
+    // Select bond tool
+    await selectSingleBondTool(page);
+
+    // Create bonds between peptides
+    await bondTwoMonomers(page, peptide1, peptide2);
+    await bondTwoMonomers(page, peptide3, peptide2);
+    await bondTwoMonomers(page, peptide3, peptide4);
+
+    await takeEditorScreenshot(page);
+
+    await selectEraseTool(page);
+
+    // Delete peptide linked with two other peptides by bonds
+    await peptide3.click();
+
+    await takeEditorScreenshot(page);
+  });
+});
diff --git a/ketcher-autotests/tests/Macromolecule-editor/Erase-Tool/erase-tool.spec.ts-snapshots/Erase-Tool-Delete-monomer-bonded-with-another-monomers-1-chromium-darwin.png b/ketcher-autotests/tests/Macromolecule-editor/Erase-Tool/erase-tool.spec.ts-snapshots/Erase-Tool-Delete-monomer-bonded-with-another-monomers-1-chromium-darwin.png
new file mode 100644
index 0000000000..0cabf647bc
Binary files /dev/null and b/ketcher-autotests/tests/Macromolecule-editor/Erase-Tool/erase-tool.spec.ts-snapshots/Erase-Tool-Delete-monomer-bonded-with-another-monomers-1-chromium-darwin.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/Erase-Tool/erase-tool.spec.ts-snapshots/Erase-Tool-Delete-monomer-bonded-with-another-monomers-2-chromium-darwin.png b/ketcher-autotests/tests/Macromolecule-editor/Erase-Tool/erase-tool.spec.ts-snapshots/Erase-Tool-Delete-monomer-bonded-with-another-monomers-2-chromium-darwin.png
new file mode 100644
index 0000000000..bd973037f8
Binary files /dev/null and b/ketcher-autotests/tests/Macromolecule-editor/Erase-Tool/erase-tool.spec.ts-snapshots/Erase-Tool-Delete-monomer-bonded-with-another-monomers-2-chromium-darwin.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/Polymer-Bond-Tool/polymer-bond-tool.spec.ts b/ketcher-autotests/tests/Macromolecule-editor/Polymer-Bond-Tool/polymer-bond-tool.spec.ts
index 62b1a30f4f..6c13046fd1 100644
--- a/ketcher-autotests/tests/Macromolecule-editor/Polymer-Bond-Tool/polymer-bond-tool.spec.ts
+++ b/ketcher-autotests/tests/Macromolecule-editor/Polymer-Bond-Tool/polymer-bond-tool.spec.ts
@@ -1,5 +1,6 @@
-import { test, expect } from '@playwright/test';
+import { test } from '@playwright/test';
 import { selectSingleBondTool, waitForPageInit } from '@utils';
+import { turnOnMacromoleculesEditor } from '@utils/macromolecules';
 /* eslint-disable no-magic-numbers */
 
 test.describe('Polymer Bond Tool', () => {
@@ -12,8 +13,7 @@ test.describe('Polymer Bond Tool', () => {
     Description: Polymer bond tool
     */
 
-    await expect(page.getByTestId('PolymerToggler')).toBeVisible();
-    await page.getByTestId('PolymerToggler').click();
+    await turnOnMacromoleculesEditor(page);
 
     // Choose peptide
     await page.getByText('Tza').click();
@@ -25,7 +25,7 @@ test.describe('Polymer Bond Tool', () => {
     await page.mouse.click(500, 200);
 
     // Get 4 peptides locators
-    const peptides = await page.getByText('Tza');
+    const peptides = await page.getByText('Tza').locator('..');
     const peptide1 = peptides.nth(0);
     const peptide2 = peptides.nth(1);
     const peptide3 = peptides.nth(2);
@@ -69,8 +69,7 @@ test.describe('Polymer Bond Tool', () => {
     Description: Polymer bond tool
     */
 
-    await expect(page.getByTestId('PolymerToggler')).toBeVisible();
-    await page.getByTestId('PolymerToggler').click();
+    await turnOnMacromoleculesEditor(page);
 
     // Choose chems
     await page.getByText('CHEM').click();
@@ -81,7 +80,7 @@ test.describe('Polymer Bond Tool', () => {
     await page.mouse.click(400, 400);
 
     // Get 2 chems locators
-    const chems = await page.getByText('hxy');
+    const chems = await page.getByText('hxy').locator('..');
     const chem1 = chems.nth(0);
     const chem2 = chems.nth(1);
 
diff --git a/ketcher-autotests/tests/Macromolecule-editor/RNAEditor/add-default-presets.spec.ts b/ketcher-autotests/tests/Macromolecule-editor/RNAEditor/add-default-presets.spec.ts
index 02ad3a3e3a..68ea5013db 100644
--- a/ketcher-autotests/tests/Macromolecule-editor/RNAEditor/add-default-presets.spec.ts
+++ b/ketcher-autotests/tests/Macromolecule-editor/RNAEditor/add-default-presets.spec.ts
@@ -1,4 +1,5 @@
-import { test, expect } from '@playwright/test';
+import { turnOnMacromoleculesEditor } from '@utils/macromolecules';
+import { test } from '@playwright/test';
 import { waitForPageInit } from '@utils/common';
 
 test.describe('Macromolecules default presets', () => {
@@ -10,8 +11,7 @@ test.describe('Macromolecules default presets', () => {
     Test case: #2934 - rna builder: add default presets
     Description: Switch to Polymer Editor
     */
-    await expect(page.getByTestId('PolymerToggler')).toBeVisible();
-    await page.getByTestId('PolymerToggler').click();
+    await turnOnMacromoleculesEditor(page);
     await page.getByText('RNA').click();
 
     await page.getByTestId('cancel-btn').click();
@@ -25,8 +25,7 @@ test.describe('Macromolecules default presets', () => {
     /* 
     Test case: #2507 - Add RNA monomers to canvas (by click)
     */
-    await expect(page.getByTestId('PolymerToggler')).toBeVisible();
-    await page.getByTestId('PolymerToggler').click();
+    await turnOnMacromoleculesEditor(page);
     await page.getByText('RNA').click();
     await page.getByTestId('cancel-btn').click();
 
diff --git a/ketcher-autotests/tests/Macromolecule-editor/Rectangle-Selection-Tool/rectangle-selection-tool.spec.ts b/ketcher-autotests/tests/Macromolecule-editor/Rectangle-Selection-Tool/rectangle-selection-tool.spec.ts
new file mode 100644
index 0000000000..08407b02e0
--- /dev/null
+++ b/ketcher-autotests/tests/Macromolecule-editor/Rectangle-Selection-Tool/rectangle-selection-tool.spec.ts
@@ -0,0 +1,72 @@
+import { test } from '@playwright/test';
+import {
+  addMonomerToCanvas,
+  selectEraseTool,
+  selectRectangleArea,
+  selectRectangleSelectionTool,
+  selectSingleBondTool,
+} from '@utils';
+import { turnOnMacromoleculesEditor } from '@utils/macromolecules';
+import { bondTwoMonomers } from '@utils/macromolecules/polymerBond';
+/* eslint-disable no-magic-numbers */
+
+test.describe('Rectangle Selection Tool', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('');
+    await turnOnMacromoleculesEditor(page);
+  });
+  test.skip('Select monomer and bonds and then erase', async ({ page }) => {
+    /* 
+    Test case: #2360 - "Select" tool for Macromolecules editor
+    Description: Rectangle Selection Tool
+    */
+
+    // Create 4 peptides on canvas
+    const MONOMER_NAME = 'Tza___3-thiazolylalanine';
+    const MONOMER_ALIAS = 'Tza';
+    await addMonomerToCanvas(page, MONOMER_NAME, 300, 300);
+    await addMonomerToCanvas(page, MONOMER_NAME, 400, 400);
+    await addMonomerToCanvas(page, MONOMER_NAME, 500, 500);
+    await addMonomerToCanvas(page, MONOMER_NAME, 500, 200);
+
+    // Get 4 peptides locators
+    const peptides = await page.getByText(MONOMER_ALIAS).locator('..');
+    const peptide1 = peptides.nth(0);
+    const peptide2 = peptides.nth(1);
+    const peptide3 = peptides.nth(2);
+    const peptide4 = peptides.nth(3);
+
+    // Select bond tool
+    await selectSingleBondTool(page);
+
+    // Create bonds between peptides
+    await bondTwoMonomers(page, peptide1, peptide2);
+    await bondTwoMonomers(page, peptide3, peptide2);
+    await bondTwoMonomers(page, peptide3, peptide4);
+
+    await page.screenshot({
+      path: 'tests/Macromolecule-editor/screenshots/rectangle-selection-tool.png',
+    });
+
+    await selectRectangleSelectionTool(page);
+
+    // Coordinates for rectangle selection
+    const startX = 100;
+    const startY = 100;
+    const endX = 500;
+    const endY = 500;
+
+    await selectRectangleArea(page, startX, startY, endX, endY);
+
+    await page.screenshot({
+      path: 'tests/Macromolecule-editor/screenshots/rectangle-selection-tool2.png',
+    });
+
+    // Erase selected elements
+    await selectEraseTool(page);
+
+    await page.screenshot({
+      path: 'tests/Macromolecule-editor/screenshots/rectangle-selection-tool3.png',
+    });
+  });
+});
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-custom-preset-add-to-canvas.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-custom-preset-add-to-canvas.png
index 2a63b18e65..4dd67b737b 100644
Binary files a/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-custom-preset-add-to-canvas.png and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-custom-preset-add-to-canvas.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-custom-preset-add.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-custom-preset-add.png
index c11c33e1ff..524a1a6be5 100644
Binary files a/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-custom-preset-add.png and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-custom-preset-add.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-custom-preset-duplicate.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-custom-preset-duplicate.png
index c2910986cb..e62d613890 100644
Binary files a/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-custom-preset-duplicate.png and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-custom-preset-duplicate.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-default-preset-to-canvas.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-default-preset-to-canvas.png
index 6e67bf532c..900bda27c2 100644
Binary files a/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-default-preset-to-canvas.png and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/add-default-preset-to-canvas.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/chem-add-to-canvas.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/chem-add-to-canvas.png
index 69a3f3092d..32cfaa262a 100644
Binary files a/ketcher-autotests/tests/Macromolecule-editor/screenshots/chem-add-to-canvas.png and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/chem-add-to-canvas.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/chem-library.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/chem-library.png
index fd7d37d8f8..0a99fd2fdf 100644
Binary files a/ketcher-autotests/tests/Macromolecule-editor/screenshots/chem-library.png and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/chem-library.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/default-presets.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/default-presets.png
index cb7503baa1..3410df86cf 100644
Binary files a/ketcher-autotests/tests/Macromolecule-editor/screenshots/default-presets.png and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/default-presets.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/peptides-add-to-canvas.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/peptides-add-to-canvas.png
index cd4823b9b9..b01c143375 100644
Binary files a/ketcher-autotests/tests/Macromolecule-editor/screenshots/peptides-add-to-canvas.png and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/peptides-add-to-canvas.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool-chem1.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool-chem1.png
index fa6b7217ec..a7eaa2b013 100644
Binary files a/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool-chem1.png and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool-chem1.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool-chem2.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool-chem2.png
index ca262cd2ee..3bed9a7e2d 100644
Binary files a/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool-chem2.png and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool-chem2.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool.png
index 00eebace55..831461b7fd 100644
Binary files a/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool.png and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool2.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool2.png
index 881fca77f1..00493140a4 100644
Binary files a/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool2.png and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool2.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool3.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool3.png
index 484159c2e6..f151adc335 100644
Binary files a/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool3.png and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/polymer-bond-tool3.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/rectangle-selection-tool.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/rectangle-selection-tool.png
new file mode 100644
index 0000000000..b5c96ab916
Binary files /dev/null and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/rectangle-selection-tool.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/rectangle-selection-tool2.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/rectangle-selection-tool2.png
new file mode 100644
index 0000000000..9bc5120ded
Binary files /dev/null and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/rectangle-selection-tool2.png differ
diff --git a/ketcher-autotests/tests/Macromolecule-editor/screenshots/rectangle-selection-tool3.png b/ketcher-autotests/tests/Macromolecule-editor/screenshots/rectangle-selection-tool3.png
new file mode 100644
index 0000000000..a4225f5232
Binary files /dev/null and b/ketcher-autotests/tests/Macromolecule-editor/screenshots/rectangle-selection-tool3.png differ
diff --git a/ketcher-autotests/tests/utils/canvas/helpers.ts b/ketcher-autotests/tests/utils/canvas/helpers.ts
index 7b62f10eb7..e45f6a7a4e 100644
--- a/ketcher-autotests/tests/utils/canvas/helpers.ts
+++ b/ketcher-autotests/tests/utils/canvas/helpers.ts
@@ -134,3 +134,13 @@ export async function resetAllSettingsToDefault(page: Page) {
   await pressButton(page, 'Reset');
   await pressButton(page, 'Apply');
 }
+
+export async function addMonomerToCanvas(
+  page: Page,
+  monomerFullName: string,
+  positionX: number,
+  positionY: number,
+) {
+  await page.getByTestId(monomerFullName).click();
+  await page.mouse.click(positionX, positionY);
+}
diff --git a/ketcher-autotests/tests/utils/canvas/tools/helpers.ts b/ketcher-autotests/tests/utils/canvas/tools/helpers.ts
index 3c74d77b4d..d857f776f8 100644
--- a/ketcher-autotests/tests/utils/canvas/tools/helpers.ts
+++ b/ketcher-autotests/tests/utils/canvas/tools/helpers.ts
@@ -47,6 +47,30 @@ export async function selectSingleBondTool(page: Page) {
   await bondToolButton.click();
 }
 
+export async function selectEraseTool(page: Page) {
+  const bondToolButton = page.locator(`button[title*="Erase"]`);
+  await bondToolButton.click();
+}
+
+export async function selectRectangleSelectionTool(page: Page) {
+  const bondToolButton = page.locator(`button[title*="select-rectangle"]`);
+  await bondToolButton.click();
+}
+
+export async function selectRectangleArea(
+  page: Page,
+  startX: number,
+  startY: number,
+  endX: number,
+  endY: number,
+) {
+  await selectRectangleSelectionTool(page);
+  await page.mouse.move(startX, startY);
+  await page.mouse.down();
+  await page.mouse.move(endX, endY);
+  await page.mouse.up();
+}
+
 export async function selectTopPanelButton(
   buttonName: TopPanelButton,
   page: Page,
diff --git a/ketcher-autotests/tests/utils/macromolecules/index.ts b/ketcher-autotests/tests/utils/macromolecules/index.ts
new file mode 100644
index 0000000000..e028077e58
--- /dev/null
+++ b/ketcher-autotests/tests/utils/macromolecules/index.ts
@@ -0,0 +1,7 @@
+import { expect, Page } from '@playwright/test';
+import { POLYMER_TOGGLER } from '@constants/testIdConstants';
+
+export async function turnOnMacromoleculesEditor(page: Page) {
+  await expect(page.getByTestId(POLYMER_TOGGLER)).toBeVisible();
+  await page.getByTestId(POLYMER_TOGGLER).click();
+}
diff --git a/ketcher-autotests/tests/utils/macromolecules/polymerBond.ts b/ketcher-autotests/tests/utils/macromolecules/polymerBond.ts
new file mode 100644
index 0000000000..d49be15e46
--- /dev/null
+++ b/ketcher-autotests/tests/utils/macromolecules/polymerBond.ts
@@ -0,0 +1,12 @@
+import { Locator, Page } from '@playwright/test';
+
+export async function bondTwoMonomers(
+  page: Page,
+  firstMonomerElement: Locator,
+  secondMonomerElement: Locator,
+) {
+  await firstMonomerElement.hover();
+  await page.mouse.down();
+  await secondMonomerElement.hover();
+  await page.mouse.up();
+}
diff --git a/packages/ketcher-core/.eslintrc.json b/packages/ketcher-core/.eslintrc.json
index a3c1581ffe..79b97f9ceb 100644
--- a/packages/ketcher-core/.eslintrc.json
+++ b/packages/ketcher-core/.eslintrc.json
@@ -1,6 +1,10 @@
 {
   "root": false,
   "extends": "plugin:jest/recommended",
+  "rules": {
+    "@typescript-eslint/no-empty-function": "off",
+    "no-useless-constructor": "off"
+  },
   "overrides": [
     {
       "files": [
diff --git a/packages/ketcher-core/__tests__/application/editor/tools/SelectRectangleTool.test.ts b/packages/ketcher-core/__tests__/application/editor/tools/SelectRectangleTool.test.ts
new file mode 100644
index 0000000000..14e1bf6f41
--- /dev/null
+++ b/packages/ketcher-core/__tests__/application/editor/tools/SelectRectangleTool.test.ts
@@ -0,0 +1,72 @@
+import { CoreEditor } from 'application/editor';
+import { PeptideRenderer } from 'application/render/renderers/PeptideRenderer';
+import {
+  getFinishedPolymerBond,
+  peptideMonomerItem,
+  polymerEditorTheme,
+} from '../../../mock-data';
+import { createPolymerEditorCanvas } from '../../../helpers/dom';
+import { SelectRectangle } from 'application/editor/tools/SelectRectangle';
+
+jest.mock('d3', () => {
+  return {
+    brush() {
+      return {
+        on() {},
+      };
+    },
+    select() {
+      return {
+        call() {
+          return this;
+        },
+        insert() {
+          return this;
+        },
+        select() {
+          return this;
+        },
+        attr() {
+          return this;
+        },
+        style() {
+          return this;
+        },
+      };
+    },
+  };
+});
+
+describe('Select Rectangle Tool', () => {
+  it('should select drawing entity on mousedown', () => {
+    const polymerBond = getFinishedPolymerBond(0, 0, 10, 10);
+    const event = {
+      target: {
+        __data__: polymerBond.renderer,
+      },
+    };
+    const selectRectangleTool = new SelectRectangle(
+      new CoreEditor({
+        theme: polymerEditorTheme,
+        canvas: createPolymerEditorCanvas(),
+      }),
+    );
+
+    expect(polymerBond.selected).toBeFalsy();
+    selectRectangleTool.mousedown(event);
+    expect(polymerBond.selected).toBeTruthy();
+  });
+
+  it('should initiate the render of peptide mousedown', () => {
+    const canvas: SVGSVGElement = createPolymerEditorCanvas();
+    const editor: CoreEditor = new CoreEditor({
+      canvas,
+      theme: polymerEditorTheme,
+    });
+    const onShow = jest.fn();
+    jest.spyOn(PeptideRenderer.prototype, 'show').mockImplementation(onShow);
+    editor.events.selectMonomer.dispatch(peptideMonomerItem);
+    canvas.dispatchEvent(new Event('mouseover', { bubbles: true }));
+    expect(onShow).toHaveBeenCalled();
+  });
+});
diff --git a/packages/ketcher-core/__tests__/application/render/renderers/__snapshots__/PeptideRenderer.test.ts.snap b/packages/ketcher-core/__tests__/application/render/renderers/__snapshots__/PeptideRenderer.test.ts.snap
index 382adc9126..164b521de4 100644
--- a/packages/ketcher-core/__tests__/application/render/renderers/__snapshots__/PeptideRenderer.test.ts.snap
+++ b/packages/ketcher-core/__tests__/application/render/renderers/__snapshots__/PeptideRenderer.test.ts.snap
@@ -6,6 +6,7 @@ exports[`PeptideRenderer should render peptide 1`] = `
   id="polymer-editor-canvas"
   width="500"
 >
+  <defs />
   <g
     transform="translate(0, 0) scale(1)"
     transition="transform 0.2s"
@@ -20,6 +21,7 @@ exports[`PeptideRenderer should render peptide 1`] = `
       font-size="12px"
       font-weight="700"
       line-height="12px"
+      pointer-events="none"
       style="cursor: pointer; user-select: none;"
       x="0"
       y="10"
diff --git a/packages/ketcher-core/__tests__/application/render/renderers/__snapshots__/PolymerBondRenderer.test.ts.snap b/packages/ketcher-core/__tests__/application/render/renderers/__snapshots__/PolymerBondRenderer.test.ts.snap
index f5f45a4aaa..8c300ce424 100644
--- a/packages/ketcher-core/__tests__/application/render/renderers/__snapshots__/PolymerBondRenderer.test.ts.snap
+++ b/packages/ketcher-core/__tests__/application/render/renderers/__snapshots__/PolymerBondRenderer.test.ts.snap
@@ -6,8 +6,20 @@ exports[`Polymer Bond Renderer should render bond 1`] = `
   id="polymer-editor-canvas"
   width="500"
 >
-  <g>
+  <g
+    pointer-events="stroke"
+  >
     <line
+      stroke="transparent"
+      stroke-width="10"
+      x1="10"
+      x2="90"
+      y1="10"
+      y2="100"
+    />
+    <line
+      class="selection-area"
+      pointer-events="stroke"
       stroke="#333333"
       stroke-width="2"
       x1="10"
@@ -16,5 +28,6 @@ exports[`Polymer Bond Renderer should render bond 1`] = `
       y2="100"
     />
   </g>
+  <defs />
 </svg>
 `;
diff --git a/packages/ketcher-core/__tests__/domain/entities/drawingEntitiesManager.test.ts b/packages/ketcher-core/__tests__/domain/entities/drawingEntitiesManager.test.ts
new file mode 100644
index 0000000000..59fa39d4ef
--- /dev/null
+++ b/packages/ketcher-core/__tests__/domain/entities/drawingEntitiesManager.test.ts
@@ -0,0 +1,118 @@
+import { DrawingEntitiesManager } from 'domain/entities/DrawingEntitiesManager';
+import { peptideMonomerItem } from '../../mock-data';
+import { Vec2 } from 'domain/entities';
+import { Peptide } from 'domain/entities/Peptide';
+import {
+  PolymerBondAddOperation,
+  PolymerBondDeleteOperation,
+} from 'application/editor/operations/polymerBond';
+import { PolymerBond } from 'domain/entities/PolymerBond';
+import { DrawingEntity } from 'domain/entities/DrawingEntity';
+import {
+  DrawingEntityHoverOperation,
+  DrawingEntitySelectOperation,
+} from 'application/editor/operations/drawingEntity';
+import {
+  MonomerAddOperation,
+  MonomerDeleteOperation,
+  MonomerHoverOperation,
+  MonomerMoveOperation,
+} from 'application/editor/operations/monomer';
+
+describe('Drawing Entities Manager', () => {
+  it('should create monomer', () => {
+    const drawingEntitiesManager = new DrawingEntitiesManager();
+    const command = drawingEntitiesManager.addMonomer(
+      peptideMonomerItem,
+      new Vec2(0, 0),
+    );
+    expect(command.operations.length).toEqual(1);
+    expect(command.operations[0]).toBeInstanceOf(MonomerAddOperation);
+    expect(drawingEntitiesManager.monomers.get(1)).toBeInstanceOf(Peptide);
+  });
+
+  it('should create polymer bond', () => {
+    const drawingEntitiesManager = new DrawingEntitiesManager();
+    const { command, polymerBond } = drawingEntitiesManager.addPolymerBond(
+      new Peptide(peptideMonomerItem),
+      new Vec2(0, 0),
+      new Vec2(10, 10),
+    );
+    expect(command.operations.length).toEqual(1);
+    expect(command.operations[0]).toBeInstanceOf(PolymerBondAddOperation);
+    expect(polymerBond).toBeInstanceOf(PolymerBond);
+    expect(drawingEntitiesManager.polymerBonds.get(polymerBond.id)).toEqual(
+      polymerBond,
+    );
+  });
+
+  it('should delete peptide', () => {
+    const drawingEntitiesManager = new DrawingEntitiesManager();
+    drawingEntitiesManager.addMonomer(peptideMonomerItem, new Vec2(0, 0));
+    const peptide = Array.from(drawingEntitiesManager.monomers)[0][1];
+    expect(peptide).toBeInstanceOf(Peptide);
+    const command = drawingEntitiesManager.deleteMonomer(peptide);
+    expect(command.operations.length).toEqual(1);
+    expect(command.operations[0]).toBeInstanceOf(MonomerDeleteOperation);
+    expect(drawingEntitiesManager.monomers.size).toEqual(0);
+  });
+
+  it('should delete polymer bond', () => {
+    const drawingEntitiesManager = new DrawingEntitiesManager();
+    const { polymerBond } = drawingEntitiesManager.addPolymerBond(
+      new Peptide(peptideMonomerItem),
+      new Vec2(0, 0),
+      new Vec2(10, 10),
+    );
+    expect(
+      Array.from(drawingEntitiesManager.polymerBonds)[0][1],
+    ).toBeInstanceOf(PolymerBond);
+    const command = drawingEntitiesManager.deletePolymerBond(polymerBond);
+    expect(command.operations.length).toEqual(1);
+    expect(command.operations[0]).toBeInstanceOf(PolymerBondDeleteOperation);
+    expect(drawingEntitiesManager.polymerBonds.size).toEqual(0);
+  });
+
+  it('should select drawing entity', () => {
+    const drawingEntitiesManager = new DrawingEntitiesManager();
+    const drawingEntity = new Peptide(peptideMonomerItem) as DrawingEntity;
+    const command = drawingEntitiesManager.selectDrawingEntity(drawingEntity);
+    expect(drawingEntity.selected).toBeTruthy();
+    expect(command.operations.length).toEqual(1);
+    expect(command.operations[0]).toBeInstanceOf(DrawingEntitySelectOperation);
+  });
+
+  it('should move peptide', () => {
+    const drawingEntitiesManager = new DrawingEntitiesManager();
+    const peptide = new Peptide(peptideMonomerItem);
+    const command = drawingEntitiesManager.moveMonomer(
+      peptide,
+      new Vec2(100, 200),
+    );
+    expect(peptide.position.x).toEqual(100);
+    expect(peptide.position.y).toEqual(200);
+    expect(command.operations.length).toEqual(1);
+    expect(command.operations[0]).toBeInstanceOf(MonomerMoveOperation);
+  });
+
+  it('should hover drawing entity', () => {
+    const drawingEntitiesManager = new DrawingEntitiesManager();
+    const peptide = new Peptide(peptideMonomerItem);
+    const command = drawingEntitiesManager.intendToSelectDrawingEntity(peptide);
+    expect(peptide.hovered).toBeTruthy();
+    expect(command.operations.length).toEqual(1);
+    expect(command.operations[0]).toBeInstanceOf(DrawingEntityHoverOperation);
+  });
+
+  it('should cancel the intention of polymer bond creation and turn off hover', () => {
+    const drawingEntitiesManager = new DrawingEntitiesManager();
+    const peptide = new Peptide(peptideMonomerItem);
+    drawingEntitiesManager.intendToSelectDrawingEntity(peptide);
+    expect(peptide.hovered).toBeTruthy();
+    const command =
+      drawingEntitiesManager.cancelIntentionToFinishBondCreation(peptide);
+    expect(peptide.hovered).toBeFalsy();
+    expect(command.operations.length).toEqual(1);
+    expect(command.operations[0]).toBeInstanceOf(MonomerHoverOperation);
+  });
+});
diff --git a/packages/ketcher-core/__tests__/domain/entities/polymerBond.test.ts b/packages/ketcher-core/__tests__/domain/entities/polymerBond.test.ts
index d63f8922b9..4ce5f88e9c 100644
--- a/packages/ketcher-core/__tests__/domain/entities/polymerBond.test.ts
+++ b/packages/ketcher-core/__tests__/domain/entities/polymerBond.test.ts
@@ -1,7 +1,9 @@
 import { getFinishedPolymerBond } from '../../mock-data';
+import { createPolymerEditorCanvas } from '../../helpers/dom';
 
 describe('Polymer Bond', () => {
   it('should be finished if has links to two monomers', () => {
+    createPolymerEditorCanvas();
     const polymerBond = getFinishedPolymerBond(10, 10, 90, 100);
 
     polymerBond.moveToLinkedMonomers();
diff --git a/packages/ketcher-core/__tests__/helpers/dom.ts b/packages/ketcher-core/__tests__/helpers/dom.ts
index ec6f771a24..7010513d35 100644
--- a/packages/ketcher-core/__tests__/helpers/dom.ts
+++ b/packages/ketcher-core/__tests__/helpers/dom.ts
@@ -9,5 +9,9 @@ export const createPolymerEditorCanvas = (): SVGSVGElement => {
   canvas.setAttribute('height', '500');
   document.body.appendChild(canvas);
 
+  canvas.appendChild(
+    document.createElementNS('http://www.w3.org/2000/svg', 'defs'),
+  );
+
   return canvas;
 };
diff --git a/packages/ketcher-core/__tests__/mock-data.ts b/packages/ketcher-core/__tests__/mock-data.ts
index 332dd9ea42..fc77dd37f9 100644
--- a/packages/ketcher-core/__tests__/mock-data.ts
+++ b/packages/ketcher-core/__tests__/mock-data.ts
@@ -7,6 +7,7 @@ import { MonomerItemType } from 'domain/types';
 import { Peptide } from 'domain/entities/Peptide';
 import { PeptideRenderer } from 'application/render/renderers/PeptideRenderer';
 import { PolymerBond } from 'domain/entities/PolymerBond';
+import { PolymerBondRenderer } from 'application/render/renderers/PolymerBondRenderer';
 
 const mockAtoms = [
   {
@@ -770,5 +771,8 @@ export const getFinishedPolymerBond = (x1, y1, x2, y2) => {
   const polymerBond = new PolymerBond(peptide);
   polymerBond.setSecondMonomer(peptide2);
 
+  // eslint-disable-next-line no-new
+  new PolymerBondRenderer(polymerBond);
+
   return polymerBond;
 };
diff --git a/packages/ketcher-core/src/application/editor/Editor.ts b/packages/ketcher-core/src/application/editor/Editor.ts
index 97cd25f9b1..48c8f74144 100644
--- a/packages/ketcher-core/src/application/editor/Editor.ts
+++ b/packages/ketcher-core/src/application/editor/Editor.ts
@@ -1,7 +1,8 @@
-import { Subscription, DOMSubscription } from 'subscription';
-import { ReStruct } from 'application/render';
-import { Struct, Vec2 } from 'domain/entities';
+import { DOMSubscription } from 'subscription';
+import { Vec2 } from 'domain/entities';
 import {
+  BaseTool,
+  isBaseTool,
   Tool,
   ToolConstructorInterface,
   ToolEventHandlerName,
@@ -9,6 +10,9 @@ import {
 } from 'application/editor/tools/Tool';
 import { toolsMap } from 'application/editor/tools';
 import { MonomerItemType } from 'domain/types';
+import { RenderersManager } from 'application/render/renderers/RenderersManager';
+import { DrawingEntitiesManager } from 'domain/entities/DrawingEntitiesManager';
+import { editorEvents, renderersEvents } from 'application/editor/editorEvents';
 
 interface ICoreEditorConstructorParams {
   theme;
@@ -20,29 +24,23 @@ function isMouseMainButtonPressed(event: MouseEvent) {
 }
 
 export class CoreEditor {
-  public events = {
-    selectMonomer: new Subscription(),
-    selectPreset: new Subscription(),
-    selectTool: new Subscription(),
-    error: new Subscription(),
-  };
-
-  public renderersContainer: ReStruct;
+  public events = editorEvents;
+
+  public renderersContainer: RenderersManager;
+  public drawingEntitiesManager: DrawingEntitiesManager;
   public lastCursorPosition: Vec2 = new Vec2(0, 0);
-  private canvas: SVGSVGElement;
+  public canvas: SVGSVGElement;
   public canvasOffset: DOMRect;
   public theme;
   // private lastEvent: Event | undefined;
-  private tool?: Tool;
+  private tool?: Tool | BaseTool;
 
   constructor({ theme, canvas }: ICoreEditorConstructorParams) {
     this.theme = theme;
     this.canvas = canvas;
     this.subscribeEvents();
-    this.renderersContainer = new ReStruct(new Struct(), {
-      skipRaphaelInitialization: true,
-      theme,
-    });
+    this.renderersContainer = new RenderersManager({ theme });
+    this.drawingEntitiesManager = new DrawingEntitiesManager();
     this.domEventSetup();
     this.canvasOffset = this.canvas.getBoundingClientRect();
   }
@@ -51,6 +49,12 @@ export class CoreEditor {
     this.events.selectMonomer.add((monomer) => this.onSelectMonomer(monomer));
     this.events.selectPreset.add((preset) => this.onSelectRNAPreset(preset));
     this.events.selectTool.add((tool) => this.onSelectTool(tool));
+
+    renderersEvents.forEach((eventName) => {
+      this.events[eventName].add((event) =>
+        this.useToolIfNeeded(eventName, event),
+      );
+    });
   }
 
   private onSelectMonomer(monomer: MonomerItemType) {
@@ -67,8 +71,13 @@ export class CoreEditor {
 
   public selectTool(name: string, options?) {
     const ToolConstructor: ToolConstructorInterface = toolsMap[name];
+    const oldTool = this.tool;
 
     this.tool = new ToolConstructor(this, options);
+
+    if (isBaseTool(oldTool)) {
+      oldTool?.destroy();
+    }
   }
 
   private domEventSetup() {
@@ -167,7 +176,7 @@ export class CoreEditor {
   }
 
   private useToolIfNeeded(eventHandlerName: ToolEventHandlerName, event) {
-    const editorTool = this.tool;
+    const editorTool = this.tool as Tool;
     if (!editorTool) {
       return false;
     }
diff --git a/packages/ketcher-core/src/application/editor/actions/index.ts b/packages/ketcher-core/src/application/editor/actions/index.ts
index af2b587003..0af2498330 100644
--- a/packages/ketcher-core/src/application/editor/actions/index.ts
+++ b/packages/ketcher-core/src/application/editor/actions/index.ts
@@ -18,4 +18,3 @@ export * from './template';
 export * from './text';
 export * from './utils';
 export * from './highlight';
-export * from './monomer';
diff --git a/packages/ketcher-core/src/application/editor/actions/monomer.ts b/packages/ketcher-core/src/application/editor/actions/monomer.ts
deleted file mode 100644
index 644fac2eb4..0000000000
--- a/packages/ketcher-core/src/application/editor/actions/monomer.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-/****************************************************************************
- * Copyright 2021 EPAM Systems
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- ***************************************************************************/
-import { ReStruct } from 'application/render';
-import { Action } from 'application/editor';
-import { MonomerAdd } from 'application/editor/operations/monomer';
-import { PresetAdd } from 'application/editor/operations/monomer/PresetAdd';
-import { Vec2 } from 'domain/entities';
-import { MonomerItemType } from 'domain/types';
-
-type DataPreset = {
-  sugar: MonomerItemType;
-  sugarPosition: Vec2 | undefined;
-  rnaBase: MonomerItemType | undefined;
-  rnaBasePosition: Vec2 | undefined;
-  phosphate: MonomerItemType | undefined;
-  phosphatePosition: Vec2 | undefined;
-};
-
-export function fromMonomerAddition(
-  renderersContainer: ReStruct,
-  monomer: MonomerItemType,
-  position: Vec2,
-): Action {
-  const action = new Action();
-  action.addOp(new MonomerAdd(monomer, position)).perform(renderersContainer);
-  return action;
-}
-
-export function fromPresetAddition(
-  renderersContainer: ReStruct,
-  presets: DataPreset,
-): Action {
-  const action = new Action();
-  action
-    .addOp(new PresetAdd(renderersContainer, presets))
-    .perform(renderersContainer);
-
-  return action;
-}
diff --git a/packages/ketcher-core/src/application/editor/actions/polymerBond.ts b/packages/ketcher-core/src/application/editor/actions/polymerBond.ts
deleted file mode 100644
index 3b4d58526a..0000000000
--- a/packages/ketcher-core/src/application/editor/actions/polymerBond.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-/****************************************************************************
- * Copyright 2021 EPAM Systems
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- ***************************************************************************/
-import { ReStruct } from 'application/render';
-import { Action } from 'application/editor';
-import { PolymerBondAdd } from 'application/editor/operations/polymerBond';
-import { PolymerBondDelete } from 'application/editor/operations/polymerBond/polymerBondDelete';
-import { PolymerBond } from 'domain/entities/PolymerBond';
-
-type Data = {
-  firstMonomer;
-  startPosition;
-  endPosition;
-};
-
-export function fromPolymerBondAddition(
-  renderersContainer: ReStruct,
-  data: Data,
-): Action {
-  const action = new Action();
-  action.addOp(new PolymerBondAdd(data)).perform(renderersContainer);
-
-  return action;
-}
-
-export function fromPolymerBondDeletion(
-  renderersContainer: ReStruct,
-  polymerBond: PolymerBond,
-): Action {
-  const action = new Action();
-  action.addOp(new PolymerBondDelete(polymerBond)).perform(renderersContainer);
-
-  return action;
-}
diff --git a/packages/ketcher-core/src/application/editor/editorEvents.ts b/packages/ketcher-core/src/application/editor/editorEvents.ts
new file mode 100644
index 0000000000..0a6a61ab13
--- /dev/null
+++ b/packages/ketcher-core/src/application/editor/editorEvents.ts
@@ -0,0 +1,26 @@
+import { Subscription } from 'subscription';
+import { ToolEventHandlerName } from 'application/editor/tools/Tool';
+
+export const editorEvents = {
+  selectMonomer: new Subscription(),
+  selectPreset: new Subscription(),
+  selectTool: new Subscription(),
+  error: new Subscription(),
+  mouseOverPolymerBond: new Subscription(),
+  mouseLeavePolymerBond: new Subscription(),
+  mouseOverMonomer: new Subscription(),
+  mouseLeaveMonomer: new Subscription(),
+  mouseOverDrawingEntity: new Subscription(),
+  mouseLeaveDrawingEntity: new Subscription(),
+  mouseUpMonomer: new Subscription(),
+};
+
+export const renderersEvents: ToolEventHandlerName[] = [
+  'mouseOverPolymerBond',
+  'mouseLeavePolymerBond',
+  'mouseOverMonomer',
+  'mouseLeaveMonomer',
+  'mouseOverDrawingEntity',
+  'mouseLeaveDrawingEntity',
+  'mouseUpMonomer',
+];
diff --git a/packages/ketcher-core/src/application/editor/operations/OperationType.ts b/packages/ketcher-core/src/application/editor/operations/OperationType.ts
index 2dab5d6ac1..f11e58545f 100644
--- a/packages/ketcher-core/src/application/editor/operations/OperationType.ts
+++ b/packages/ketcher-core/src/application/editor/operations/OperationType.ts
@@ -72,6 +72,16 @@ export const OperationType = Object.freeze({
   REMOVE_HIGHLIGHT: 'Remove highlight',
   POLYMER_BOND_ADD: 'Add polymer bond',
   POLYMER_BOND_DELETE: 'Remove polymer bond',
+  POLYMER_BOND_MOVE: 'Move polymer bond',
+  POLYMER_BOND_FINISH_CREATION: 'Finish polymer bond creation',
+  POLYMER_BOND_CANCEL_CREATION: 'Cancel polymer bond creation',
+  PEPTIDE_ADD: 'Add peptide',
+  PEPTIDE_REMOVE: 'Remove peptide',
+  PEPTIDE_MOVE: 'Move peptide',
+  PEPTIDE_HOVER: 'Hover peptide',
+  DRAWING_ENTITY_SELECT: 'Select drawing entity',
+  DRAWING_ENTITY_HOVER: 'Hover drawing entity',
+  SHOW_POLYMER_BOND_INFORMATION: 'Show polymer bond information',
 });
 
 export enum OperationPriority {
diff --git a/packages/ketcher-core/src/application/editor/operations/drawingEntity/index.ts b/packages/ketcher-core/src/application/editor/operations/drawingEntity/index.ts
new file mode 100644
index 0000000000..1520285f9c
--- /dev/null
+++ b/packages/ketcher-core/src/application/editor/operations/drawingEntity/index.ts
@@ -0,0 +1,19 @@
+import { RenderersManager } from 'application/render/renderers/RenderersManager';
+import { Operation } from 'domain/entities/Operation';
+import { DrawingEntity } from 'domain/entities/DrawingEntity';
+
+export class DrawingEntityHoverOperation implements Operation {
+  constructor(private drawingEntity: DrawingEntity) {}
+
+  public execute(renderersManager: RenderersManager) {
+    renderersManager.hoverDrawingEntity(this.drawingEntity);
+  }
+}
+
+export class DrawingEntitySelectOperation implements Operation {
+  constructor(private drawingEntity: DrawingEntity) {}
+
+  public execute(renderersManager: RenderersManager) {
+    renderersManager.selectDrawingEntity(this.drawingEntity);
+  }
+}
diff --git a/packages/ketcher-core/src/application/editor/operations/monomer/PresetAdd.ts b/packages/ketcher-core/src/application/editor/operations/monomer/PresetAdd.ts
deleted file mode 100644
index 3360233799..0000000000
--- a/packages/ketcher-core/src/application/editor/operations/monomer/PresetAdd.ts
+++ /dev/null
@@ -1,182 +0,0 @@
-/****************************************************************************
- * Copyright 2021 EPAM Systems
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- ***************************************************************************/
-/* eslint-disable @typescript-eslint/no-use-before-define */
-
-import { Vec2 } from 'domain/entities';
-import { ReStruct } from '../../../render';
-
-import { BaseOperation } from '../base';
-import { OperationType } from '../OperationType';
-import { MonomerItemType } from 'domain/types';
-
-import assert from 'assert';
-
-import { monomerFactory } from './monomerFactory';
-import { fromPolymerBondAddition } from 'application/editor/actions/polymerBond';
-import { BondService } from 'domain/services/bond/BondService';
-import { PolymerBondRenderer } from 'application/render/renderers/PolymerBondRenderer';
-import { BaseMonomer } from 'domain/entities/BaseMonomer';
-
-type Data = {
-  sugar: MonomerItemType;
-  sugarPosition: Vec2 | undefined;
-  rnaBase: MonomerItemType | undefined;
-  rnaBasePosition: Vec2 | undefined;
-  phosphate: MonomerItemType | undefined;
-  phosphatePosition: Vec2 | undefined;
-};
-
-class PresetAdd extends BaseOperation {
-  data: Data;
-  renderersContainer: ReStruct;
-  private bondRenderer?: PolymerBondRenderer; // only for sugar, in two sides
-
-  constructor(renderersContainer: ReStruct, presets: Data) {
-    super(OperationType.ATOM_ADD);
-    this.data = presets;
-    this.renderersContainer = renderersContainer;
-  }
-
-  execute(restruct: ReStruct) {
-    const {
-      sugar,
-      sugarPosition,
-      phosphate,
-      phosphatePosition,
-      rnaBase,
-      rnaBasePosition,
-    } = this.data;
-
-    const struct = restruct.molecule;
-
-    const [Sugar, SugarRenderer] = monomerFactory(sugar);
-    const newSugar = new Sugar(sugar, sugarPosition);
-    const sugarRenderer = new SugarRenderer(newSugar);
-    struct.monomers.set(newSugar.id, newSugar);
-    restruct.monomers.set(newSugar.id, sugarRenderer);
-
-    let rnaBaseRenderer;
-    let phosphateRenderer;
-    if (rnaBase && rnaBasePosition) {
-      const [RNABase, RNABaseRenderer] = monomerFactory(rnaBase);
-      const newRNABase = new RNABase(rnaBase, rnaBasePosition);
-      rnaBaseRenderer = new RNABaseRenderer(newRNABase);
-      struct.monomers.set(newRNABase.id, newRNABase);
-      restruct.monomers.set(newRNABase.id, rnaBaseRenderer);
-    }
-
-    if (phosphate && phosphatePosition) {
-      const [Phosphate, PhosphateRenderer] = monomerFactory(phosphate);
-      const newPhosphate = new Phosphate(phosphate, phosphatePosition);
-      phosphateRenderer = new PhosphateRenderer(newPhosphate);
-      struct.monomers.set(newPhosphate.id, newPhosphate);
-      restruct.monomers.set(newPhosphate.id, phosphateRenderer);
-    }
-
-    this.renderersContainer.update(false);
-    this.makeBonds({ sugarRenderer, rnaBaseRenderer, phosphateRenderer });
-  }
-
-  invert() {
-    const inverted = new PresetAdd(this.renderersContainer, this.data);
-    inverted.data = this.data;
-    return inverted;
-  }
-
-  private makeBonds(monomers) {
-    const { sugarRenderer, rnaBaseRenderer, phosphateRenderer } = monomers;
-    const R1AttachmentPoint = sugarRenderer?.monomer.R1AttachmentPoint;
-    const R2AttachmentPoint = sugarRenderer?.monomer.R2AttachmentPoint;
-
-    if (R1AttachmentPoint && rnaBaseRenderer) {
-      fromPolymerBondAddition(this.renderersContainer, {
-        firstMonomer: sugarRenderer.monomer,
-        startPosition: {
-          x: sugarRenderer.monomer.renderer.center.x,
-          y: sugarRenderer.monomer.renderer.center.y,
-        },
-        endPosition: new Vec2(0, 0),
-      });
-
-      this.bondRenderer =
-        sugarRenderer.monomer?.getPotentialBond(R1AttachmentPoint)?.renderer;
-
-      assert(this.bondRenderer);
-
-      sugarRenderer.monomer.setPotentialBond(
-        R1AttachmentPoint,
-        this.bondRenderer.polymerBond,
-      );
-      rnaBaseRenderer.monomer.setPotentialBond(
-        rnaBaseRenderer?.monomer.R2AttachmentPoint,
-        this.bondRenderer.polymerBond,
-      );
-
-      this.finishBondCreation(rnaBaseRenderer.monomer);
-      this.bondRenderer = undefined;
-      this.renderersContainer.update(false);
-    }
-
-    if (R2AttachmentPoint && phosphateRenderer) {
-      fromPolymerBondAddition(this.renderersContainer, {
-        firstMonomer: phosphateRenderer.monomer,
-        startPosition: {
-          x: phosphateRenderer.monomer.renderer.center.x,
-          y: phosphateRenderer.monomer.renderer.center.y,
-        },
-        endPosition: new Vec2(0, 0),
-      });
-
-      this.bondRenderer =
-        phosphateRenderer.monomer?.getPotentialBond(
-          R1AttachmentPoint,
-        )?.renderer;
-
-      assert(this.bondRenderer);
-
-      sugarRenderer.monomer.setPotentialBond(
-        R2AttachmentPoint,
-        this.bondRenderer.polymerBond,
-      );
-      phosphateRenderer.monomer.setPotentialBond(
-        phosphateRenderer?.monomer.R1AttachmentPoint,
-        this.bondRenderer.polymerBond,
-      );
-
-      this.finishBondCreation(sugarRenderer.monomer);
-      this.bondRenderer = undefined;
-    }
-  }
-
-  private finishBondCreation(secondMonomer: BaseMonomer) {
-    assert(this.bondRenderer);
-
-    const firstMonomerAttachmentPoint =
-      this.bondRenderer.polymerBond.firstMonomer.R1AttachmentPoint;
-    const secondMonomerAttachmentPoint = secondMonomer.R2AttachmentPoint;
-    assert(firstMonomerAttachmentPoint);
-    assert(secondMonomerAttachmentPoint);
-
-    BondService.finishBondCreation(
-      firstMonomerAttachmentPoint,
-      secondMonomerAttachmentPoint,
-      secondMonomer,
-      this.bondRenderer.polymerBond,
-    );
-  }
-}
-
-export { PresetAdd };
diff --git a/packages/ketcher-core/src/application/editor/operations/monomer/index.ts b/packages/ketcher-core/src/application/editor/operations/monomer/index.ts
index 57c6d997d3..ccc67d7c5a 100644
--- a/packages/ketcher-core/src/application/editor/operations/monomer/index.ts
+++ b/packages/ketcher-core/src/application/editor/operations/monomer/index.ts
@@ -15,44 +15,44 @@
  ***************************************************************************/
 /* eslint-disable @typescript-eslint/no-use-before-define */
 
-import { Vec2 } from 'domain/entities';
-import { ReStruct } from '../../../render';
+import { RenderersManager } from 'application/render/renderers/RenderersManager';
+import { Peptide } from 'domain/entities/Peptide';
+import { Operation } from 'domain/entities/Operation';
 
-import { BaseOperation } from '../base';
-import { OperationType } from '../OperationType';
-import { MonomerItemType } from 'domain/types';
-import { monomerFactory } from './monomerFactory';
+export class MonomerAddOperation implements Operation {
+  constructor(private peptide: Peptide, private callback?: () => void) {}
 
-type Data = {
-  monomer: MonomerItemType;
-  position: Vec2;
-};
-
-class MonomerAdd extends BaseOperation {
-  data: Data;
-
-  constructor(monomer: MonomerItemType, position: Vec2) {
-    super(OperationType.ATOM_ADD);
-    this.data = { monomer, position };
+  public execute(renderersManager: RenderersManager) {
+    renderersManager.addMonomer(this.peptide, this.callback);
   }
+}
 
-  execute(restruct: ReStruct) {
-    const { monomer, position } = this.data;
-
-    const struct = restruct.molecule;
+export class MonomerMoveOperation implements Operation {
+  constructor(private peptide: Peptide) {}
 
-    const [Monomer, MonomerRenderer] = monomerFactory(monomer);
-    const newMonomer = new Monomer(monomer, position);
-    const monomerRenderer = new MonomerRenderer(newMonomer);
-    struct.monomers.set(newMonomer.id, newMonomer);
-    restruct.monomers.set(newMonomer.id, monomerRenderer);
+  public execute(renderersManager: RenderersManager) {
+    renderersManager.moveMonomer(this.peptide);
   }
+}
 
-  invert() {
-    const inverted = new MonomerAdd(this.data.monomer, this.data.position);
-    inverted.data = this.data;
-    return inverted;
+export class MonomerHoverOperation implements Operation {
+  constructor(
+    private peptide: Peptide,
+    private needRedrawAttachmentPoints: boolean,
+  ) {}
+
+  public execute(renderersManager: RenderersManager) {
+    renderersManager.hoverMonomer(
+      this.peptide,
+      this.needRedrawAttachmentPoints,
+    );
   }
 }
 
-export { MonomerAdd };
+export class MonomerDeleteOperation implements Operation {
+  constructor(private peptide: Peptide) {}
+
+  public execute(renderersManager: RenderersManager) {
+    renderersManager.deleteMonomer(this.peptide);
+  }
+}
diff --git a/packages/ketcher-core/src/application/editor/operations/polymerBond/index.ts b/packages/ketcher-core/src/application/editor/operations/polymerBond/index.ts
index 9abd5f0795..27405acb59 100644
--- a/packages/ketcher-core/src/application/editor/operations/polymerBond/index.ts
+++ b/packages/ketcher-core/src/application/editor/operations/polymerBond/index.ts
@@ -15,47 +15,54 @@
  ***************************************************************************/
 /* eslint-disable @typescript-eslint/no-use-before-define */
 
-import { ReStruct } from '../../../render';
-
-import { BaseOperation } from '../base';
-import { OperationType } from '../OperationType';
 import { PolymerBond } from 'domain/entities/PolymerBond';
-import { PolymerBondRenderer } from 'application/render/renderers/PolymerBondRenderer';
+import { RenderersManager } from 'application/render/renderers/RenderersManager';
+import { Operation } from 'domain/entities/Operation';
+
+export class PolymerBondAddOperation implements Operation {
+  constructor(private polymerBond: PolymerBond) {}
 
-type Data = {
-  firstMonomer;
-  startPosition;
-  endPosition;
-};
+  public execute(renderersManager: RenderersManager) {
+    renderersManager.addPolymerBond(this.polymerBond);
+  }
+}
 
-class PolymerBondAdd extends BaseOperation {
-  data: Data;
+export class PolymerBondDeleteOperation implements Operation {
+  constructor(private polymerBond: PolymerBond) {}
 
-  constructor(data: Data) {
-    super(OperationType.POLYMER_BOND_ADD);
-    this.data = data;
+  public execute(renderersManager: RenderersManager) {
+    renderersManager.deletePolymerBond(this.polymerBond);
   }
+}
+
+export class PolymerBondMoveOperation implements Operation {
+  constructor(private polymerBond: PolymerBond) {}
 
-  execute(restruct: ReStruct) {
-    const { firstMonomer, startPosition, endPosition } = this.data;
-    const struct = restruct.molecule;
-    const polymerBond = new PolymerBond(firstMonomer);
-    const polymerBondRenderer = new PolymerBondRenderer(polymerBond);
-    struct.polymerBonds.set(polymerBond.id, polymerBond);
-    restruct.polymerBonds.set(polymerBond.id, polymerBondRenderer);
-    firstMonomer.setPotentialBond(
-      firstMonomer.firstFreeAttachmentPoint,
-      polymerBond,
-    );
-    polymerBond.moveBondStartAbsolute(startPosition.x, startPosition.y);
-    polymerBond.moveBondEndAbsolute(endPosition.x, endPosition.y);
+  public execute(renderersManager: RenderersManager) {
+    renderersManager.movePolymerBond(this.polymerBond);
   }
+}
+
+export class PolymerBondShowInfoOperation implements Operation {
+  constructor(private polymerBond: PolymerBond) {}
 
-  invert() {
-    const inverted = new PolymerBondAdd(this.data.firstMonomer);
-    inverted.data = this.data;
-    return inverted;
+  public execute(renderersManager: RenderersManager) {
+    renderersManager.showPolymerBondInformation(this.polymerBond);
   }
 }
 
-export { PolymerBondAdd };
+export class PolymerBondCancelCreationOperation implements Operation {
+  constructor(private polymerBond: PolymerBond) {}
+
+  public execute(renderersManager: RenderersManager) {
+    renderersManager.cancelPolymerBondCreation(this.polymerBond);
+  }
+}
+
+export class PolymerBondFinishCreationOperation implements Operation {
+  constructor(private polymerBond: PolymerBond) {}
+
+  public execute(renderersManager: RenderersManager) {
+    renderersManager.finishPolymerBondCreation(this.polymerBond);
+  }
+}
diff --git a/packages/ketcher-core/src/application/editor/operations/polymerBond/polymerBondDelete.ts b/packages/ketcher-core/src/application/editor/operations/polymerBond/polymerBondDelete.ts
deleted file mode 100644
index fa375617fd..0000000000
--- a/packages/ketcher-core/src/application/editor/operations/polymerBond/polymerBondDelete.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-/****************************************************************************
- * Copyright 2021 EPAM Systems
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- ***************************************************************************/
-/* eslint-disable @typescript-eslint/no-use-before-define */
-
-import { ReStruct } from '../../../render';
-
-import { BaseOperation } from '../base';
-import { OperationType } from '../OperationType';
-import { PolymerBond } from 'domain/entities/PolymerBond';
-
-type Data = {
-  polymerBond: PolymerBond;
-};
-
-class PolymerBondDelete extends BaseOperation {
-  data: Data;
-
-  constructor(polymerBond: PolymerBond) {
-    super(OperationType.POLYMER_BOND_DELETE);
-    this.data = { polymerBond };
-  }
-
-  execute(restruct: ReStruct) {
-    const { polymerBond } = this.data;
-    const struct = restruct.molecule;
-    const polymerBondRenderer = restruct.polymerBonds.get(polymerBond.id);
-    struct.polymerBonds.delete(polymerBond.id);
-    polymerBond.firstMonomer.turnOffSelection();
-    polymerBond.firstMonomer.removePotentialBonds();
-    polymerBond.secondMonomer?.turnOffSelection();
-    polymerBond.secondMonomer?.removePotentialBonds();
-    polymerBondRenderer?.remove();
-    restruct.polymerBonds.delete(polymerBond.id);
-  }
-
-  invert() {
-    const inverted = new PolymerBondDelete(this.data.polymerBond);
-    inverted.data = this.data;
-    return inverted;
-  }
-}
-
-export { PolymerBondDelete };
diff --git a/packages/ketcher-core/src/application/editor/tools/Bond.ts b/packages/ketcher-core/src/application/editor/tools/Bond.ts
index 5b128cd59e..f4c3754d7f 100644
--- a/packages/ketcher-core/src/application/editor/tools/Bond.ts
+++ b/packages/ketcher-core/src/application/editor/tools/Bond.ts
@@ -13,28 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  ***************************************************************************/
-import { Tool } from 'application/editor/tools/Tool';
 import { BaseMonomerRenderer } from 'application/render/renderers';
-import { fromPolymerBondAddition } from 'application/editor/actions/polymerBond';
 import { CoreEditor } from 'application/editor';
 import { PolymerBondRenderer } from 'application/render/renderers/PolymerBondRenderer';
 import { Vec2 } from 'domain/entities';
 import assert from 'assert';
-import { BondService } from 'domain/services/bond/BondService';
 import { BaseMonomer } from 'domain/entities/BaseMonomer';
+import { BaseTool } from 'application/editor/tools/Tool';
 
-class PolymerBond implements Tool {
+class PolymerBond implements BaseTool {
   private bondRenderer?: PolymerBondRenderer;
-  private lastHoveredMonomerRenderer?: BaseMonomerRenderer;
-  private hoveredBondRenderer?: PolymerBondRenderer;
   constructor(private editor: CoreEditor) {
     this.editor = editor;
   }
 
-  mousedown(event) {
-    const selectedItem = event.target.__data__;
-    if (selectedItem instanceof BaseMonomerRenderer) {
-      const freeAttachmentPoint = selectedItem.monomer.firstFreeAttachmentPoint;
+  public mousedown(event) {
+    const selectedRenderer = event.target.__data__;
+    if (selectedRenderer instanceof BaseMonomerRenderer) {
+      const freeAttachmentPoint =
+        selectedRenderer.monomer.firstFreeAttachmentPoint;
 
       if (!freeAttachmentPoint) {
         this.editor.events.error.dispatch(
@@ -44,85 +41,80 @@ class PolymerBond implements Tool {
       }
       const { top: offsetTop, left: offsetLeft } = this.editor.canvasOffset;
 
-      assert(selectedItem.monomer.renderer);
-
-      fromPolymerBondAddition(this.editor.renderersContainer, {
-        firstMonomer: selectedItem.monomer,
-        startPosition: selectedItem.monomer.renderer.center,
-        endPosition: new Vec2(
-          event.clientX - offsetLeft,
-          event.clientY - offsetTop,
-        ),
-      });
-      this.editor.renderersContainer.update(false);
-      this.bondRenderer =
-        selectedItem.monomer.getPotentialBond(freeAttachmentPoint)?.renderer;
+      const { polymerBond, command: modelChanges } =
+        this.editor.drawingEntitiesManager.addPolymerBond(
+          selectedRenderer.monomer,
+          selectedRenderer.center,
+          new Vec2(event.clientX - offsetLeft, event.clientY - offsetTop),
+        );
+
+      this.editor.renderersContainer.update(modelChanges);
+      this.bondRenderer = polymerBond.renderer;
     }
   }
 
-  private handleBondDragging(event: MouseEvent) {
-    assert(this.bondRenderer);
-    const { top: offsetTop, left: offsetLeft } = this.editor.canvasOffset;
-    this.bondRenderer.polymerBond.moveBondEndAbsolute(
-      event.clientX - offsetLeft,
-      event.clientY - offsetTop,
-    );
+  public mousemove(event) {
+    if (this.bondRenderer) {
+      const { top: offsetTop, left: offsetLeft } = this.editor.canvasOffset;
+      const modelChanges = this.editor.drawingEntitiesManager.movePolymerBond(
+        this.bondRenderer.polymerBond,
+        new Vec2(event.clientX - offsetLeft, event.clientY - offsetTop),
+      );
+      this.editor.renderersContainer.update(modelChanges);
+    }
   }
 
-  private setPotentialBondToAttachmentPoint(
-    monomerRenderer: BaseMonomerRenderer,
-  ) {
-    if (!this.bondRenderer) return;
+  public mouseLeavePolymerBond(event) {
+    if (this.bondRenderer) return;
 
-    const attachmentPoint =
-      monomerRenderer.monomer.availableAttachmentPointForBondEnd;
+    const renderer: PolymerBondRenderer = event.target.__data__;
+    const modelChanges =
+      this.editor.drawingEntitiesManager.hidePolymerBondInformation(
+        renderer.polymerBond,
+      );
+    this.editor.renderersContainer.update(modelChanges);
+  }
 
-    if (!attachmentPoint) return;
+  public mouseOverPolymerBond(event) {
+    if (this.bondRenderer) return;
 
-    monomerRenderer.monomer.setPotentialBond(
-      attachmentPoint,
-      this.bondRenderer.polymerBond,
-    );
+    const renderer: PolymerBondRenderer = event.target.__data__;
+    const modelChanges =
+      this.editor.drawingEntitiesManager.showPolymerBondInformation(
+        renderer.polymerBond,
+      );
+    this.editor.renderersContainer.update(modelChanges);
   }
 
-  mousemove(event) {
-    const hoveredElementRenderer = event.toElement.__data__;
-    const isBondHovered = hoveredElementRenderer instanceof PolymerBondRenderer;
-    const isMonomerHovered =
-      hoveredElementRenderer instanceof BaseMonomerRenderer;
-    const isMonomerSelected = hoveredElementRenderer?.monomer?.selected;
-    const isMonomerLastHovered =
-      this.lastHoveredMonomerRenderer === hoveredElementRenderer;
-
-    if (isMonomerHovered && !isMonomerSelected && !isMonomerLastHovered) {
-      hoveredElementRenderer.monomer.turnOnSelection();
-      this.lastHoveredMonomerRenderer = hoveredElementRenderer;
-      this.setPotentialBondToAttachmentPoint(this.lastHoveredMonomerRenderer);
-    } else if (
-      !isMonomerHovered &&
-      this.lastHoveredMonomerRenderer &&
-      this.lastHoveredMonomerRenderer !==
-        this.bondRenderer?.polymerBond?.firstMonomer.renderer
-    ) {
-      this.lastHoveredMonomerRenderer.monomer.turnOffSelection();
-      this.lastHoveredMonomerRenderer.monomer.removePotentialBonds();
-      this.lastHoveredMonomerRenderer = undefined;
-    }
+  public mouseOverMonomer(event) {
+    const renderer: BaseMonomerRenderer = event.target.__data__;
+    let modelChanges;
 
     if (this.bondRenderer) {
-      this.handleBondDragging(event);
-    } else if (isBondHovered && hoveredElementRenderer.polymerBond.finished) {
-      this.hoveredBondRenderer = hoveredElementRenderer;
-      this.hoveredBondRenderer.polymerBond.turnOnSelection();
-    } else if (
-      this.hoveredBondRenderer &&
-      this.hoveredBondRenderer.polymerBond.finished
-    ) {
-      this.hoveredBondRenderer.polymerBond.turnOffSelection();
-      this.hoveredBondRenderer = undefined;
+      modelChanges =
+        this.editor.drawingEntitiesManager.intendToFinishBondCreation(
+          renderer.monomer,
+          this.bondRenderer?.polymerBond,
+        );
+    } else {
+      modelChanges =
+        this.editor.drawingEntitiesManager.intendToStartBondCreation(
+          renderer.monomer,
+        );
     }
 
-    this.editor.renderersContainer.update(false);
+    this.editor.renderersContainer.update(modelChanges);
+  }
+
+  public mouseLeaveMonomer(event) {
+    const renderer: BaseMonomerRenderer = event.target.__data__;
+    if (renderer !== this.bondRenderer?.polymerBond?.firstMonomer?.renderer) {
+      const modelChanges =
+        this.editor.drawingEntitiesManager.cancelIntentionToFinishBondCreation(
+          renderer.monomer,
+        );
+      this.editor.renderersContainer.update(modelChanges);
+    }
   }
 
   private finishBondCreation(secondMonomer: BaseMonomer) {
@@ -131,12 +123,9 @@ class PolymerBond implements Tool {
       this.editor.events.error.dispatch(
         "Monomers don't have any connection point available",
       );
-      BondService.deleteBondWithAllLinks(
-        this.editor.renderersContainer,
+      return this.editor.drawingEntitiesManager.cancelPolymerBondCreation(
         this.bondRenderer.polymerBond,
-        secondMonomer,
       );
-      return;
     }
     const firstMonomerAttachmentPoint =
       this.bondRenderer.polymerBond.firstMonomer.getPotentialAttachmentPointByBond(
@@ -151,34 +140,39 @@ class PolymerBond implements Tool {
         'You have connected monomers with attachment points of the same group',
       );
     }
-    BondService.finishBondCreation(
+    return this.editor.drawingEntitiesManager.finishPolymerBondCreation(
+      this.bondRenderer.polymerBond,
+      secondMonomer,
       firstMonomerAttachmentPoint,
       secondMonomerAttachmentPoint,
-      secondMonomer,
-      this.bondRenderer.polymerBond,
     );
-    this.lastHoveredMonomerRenderer = undefined;
   }
 
-  mouseup(event) {
-    const hoveredElementRenderer = event.toElement.__data__;
-    const isMonomerHovered =
-      hoveredElementRenderer instanceof BaseMonomerRenderer;
+  public mouseup() {
+    if (this.bondRenderer) {
+      const modelChanges =
+        this.editor.drawingEntitiesManager.cancelPolymerBondCreation(
+          this.bondRenderer.polymerBond,
+        );
+      this.editor.renderersContainer.update(modelChanges);
+      this.bondRenderer = undefined;
+    }
+  }
+
+  public mouseUpMonomer(event) {
+    const renderer = event.toElement.__data__;
     const isFirstMonomerHovered =
-      hoveredElementRenderer ===
-      this.bondRenderer?.polymerBond?.firstMonomer?.renderer;
-
-    if (isMonomerHovered && !isFirstMonomerHovered) {
-      this.finishBondCreation(hoveredElementRenderer.monomer);
-    } else if (this.bondRenderer) {
-      BondService.deleteBondWithAllLinks(
-        this.editor.renderersContainer,
-        this.bondRenderer.polymerBond,
-      );
+      renderer === this.bondRenderer?.polymerBond?.firstMonomer?.renderer;
+
+    if (this.bondRenderer && !isFirstMonomerHovered) {
+      const modelChanges = this.finishBondCreation(renderer.monomer);
+      this.editor.renderersContainer.update(modelChanges);
+      this.bondRenderer = undefined;
+      event.stopPropagation();
     }
-    this.bondRenderer = undefined;
-    this.editor.renderersContainer.update(false);
   }
+
+  public destroy() {}
 }
 
 export { PolymerBond };
diff --git a/packages/ketcher-core/src/application/editor/tools/Erase.ts b/packages/ketcher-core/src/application/editor/tools/Erase.ts
new file mode 100644
index 0000000000..7f976fc0c5
--- /dev/null
+++ b/packages/ketcher-core/src/application/editor/tools/Erase.ts
@@ -0,0 +1,44 @@
+/****************************************************************************
+ * Copyright 2021 EPAM Systems
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ ***************************************************************************/
+import { CoreEditor } from 'application/editor';
+import { BaseRenderer } from 'application/render/renderers/BaseRenderer';
+import { BaseTool } from 'application/editor/tools/Tool';
+
+class EraserTool implements BaseTool {
+  constructor(private editor: CoreEditor) {
+    this.editor = editor;
+    if (this.editor.drawingEntitiesManager.selectedEntities.length) {
+      const modelChanges =
+        this.editor.drawingEntitiesManager.deleteSelectedEntities();
+      this.editor.renderersContainer.update(modelChanges);
+    }
+  }
+
+  mousedown(event) {
+    const selectedItemRenderer = event.target.__data__;
+    if (selectedItemRenderer instanceof BaseRenderer) {
+      const modelChanges =
+        this.editor.drawingEntitiesManager.deleteDrawingEntity(
+          selectedItemRenderer.drawingEntity,
+        );
+      this.editor.renderersContainer.update(modelChanges);
+    }
+  }
+
+  destroy() {}
+}
+
+export { EraserTool };
diff --git a/packages/ketcher-core/src/application/editor/tools/Monomer.ts b/packages/ketcher-core/src/application/editor/tools/Monomer.ts
index 2cdfe3dc70..b8a23288b4 100644
--- a/packages/ketcher-core/src/application/editor/tools/Monomer.ts
+++ b/packages/ketcher-core/src/application/editor/tools/Monomer.ts
@@ -20,10 +20,11 @@ import { Sugar } from 'domain/entities/Sugar';
 import { Phosphate } from 'domain/entities/Phosphate';
 import { RNABase } from 'domain/entities/RNABase';
 import { Vec2 } from 'domain/entities';
-import { CoreEditor, fromMonomerAddition } from 'application/editor';
+import { CoreEditor } from 'application/editor';
 import { BaseMonomerRenderer } from 'application/render/renderers';
 import { MonomerItemType } from 'domain/types';
 import { monomerFactory } from '../operations/monomer/monomerFactory';
+import assert from 'assert';
 
 class MonomerTool implements Tool {
   private monomerPreview:
@@ -44,12 +45,9 @@ class MonomerTool implements Tool {
   }
 
   mousedown() {
-    if (!this.monomerPreviewRenderer) {
-      throw new Error('monomerPreviewRenderer is not initialized');
-    }
+    assert(this.monomerPreviewRenderer);
 
-    fromMonomerAddition(
-      this.editor.renderersContainer,
+    const modelChanges = this.editor.drawingEntitiesManager.addMonomer(
       this.monomer,
       new Vec2(
         this.editor.lastCursorPosition.x -
@@ -58,7 +56,8 @@ class MonomerTool implements Tool {
           this.monomerPreviewRenderer.height / 2,
       ),
     );
-    this.editor.renderersContainer.update(false);
+
+    this.editor.renderersContainer.update(modelChanges);
   }
 
   mousemove() {
diff --git a/packages/ketcher-core/src/application/editor/tools/Preset.ts b/packages/ketcher-core/src/application/editor/tools/RnaPreset.ts
similarity index 92%
rename from packages/ketcher-core/src/application/editor/tools/Preset.ts
rename to packages/ketcher-core/src/application/editor/tools/RnaPreset.ts
index 7741c53f51..f60b66f92d 100644
--- a/packages/ketcher-core/src/application/editor/tools/Preset.ts
+++ b/packages/ketcher-core/src/application/editor/tools/RnaPreset.ts
@@ -17,14 +17,15 @@ import { Tool, IRnaPreset } from 'application/editor/tools/Tool';
 import { Sugar } from 'domain/entities/Sugar';
 import { Vec2 } from 'domain/entities';
 
-import { fromPresetAddition, CoreEditor } from 'application/editor';
+import { CoreEditor } from 'application/editor';
 import { BaseMonomerRenderer } from 'application/render/renderers';
 import { MonomerItemType } from 'domain/types';
 import { monomerFactory } from '../operations/monomer/monomerFactory';
 import { RNABase } from 'domain/entities/RNABase';
 import { Phosphate } from 'domain/entities/Phosphate';
+import assert from 'assert';
 
-class PresetTool implements Tool {
+class RnaPresetTool implements Tool {
   rnaBase: MonomerItemType | undefined;
   sugar: MonomerItemType | undefined;
   phosphate: MonomerItemType | undefined;
@@ -52,15 +53,13 @@ class PresetTool implements Tool {
   }
 
   mousedown() {
-    if (!this.sugarPreviewRenderer) {
-      throw new Error('monomerPreviewRenderer is not initialized');
-    }
-
-    if (!this.sugar) {
-      throw new Error('no sugar in preset');
-    }
+    assert(
+      this.sugarPreviewRenderer,
+      'monomerPreviewRenderer is not initialized',
+    );
+    assert(this.sugar, 'no sugar in preset');
 
-    fromPresetAddition(this.editor.renderersContainer, {
+    const modelChanges = this.editor.drawingEntitiesManager.addRnaPreset({
       sugar: this.sugar,
       sugarPosition: new Vec2(
         this.editor.lastCursorPosition.x - this.sugarPreviewRenderer.width / 2,
@@ -90,7 +89,7 @@ class PresetTool implements Tool {
         : undefined,
     });
 
-    this.editor.renderersContainer.update(false);
+    this.editor.renderersContainer.update(modelChanges);
   }
 
   mousemove() {
@@ -177,4 +176,4 @@ class PresetTool implements Tool {
   }
 }
 
-export { PresetTool };
+export { RnaPresetTool };
diff --git a/packages/ketcher-core/src/application/editor/tools/SelectLasso.ts b/packages/ketcher-core/src/application/editor/tools/SelectLasso.ts
deleted file mode 100644
index 7c0a1861c7..0000000000
--- a/packages/ketcher-core/src/application/editor/tools/SelectLasso.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-/****************************************************************************
- * Copyright 2021 EPAM Systems
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- ***************************************************************************/
-import { Tool } from 'application/editor/tools/Tool';
-import { Vec2 } from 'domain/entities';
-import { CoreEditor } from 'application/editor';
-import { BaseMonomerRenderer } from 'application/render/renderers';
-
-class SelectLasso implements Tool {
-  private isMouseDown = false;
-  private selectedItem?: BaseMonomerRenderer;
-
-  constructor(private editor: CoreEditor) {
-    this.editor = editor;
-  }
-
-  mousedown(event) {
-    this.isMouseDown = true;
-    this.selectedItem = event.target.__data__;
-  }
-
-  mousemove(event) {
-    if (this.isMouseDown && this.selectedItem) {
-      if (this.selectedItem instanceof BaseMonomerRenderer) {
-        this.selectedItem.monomer.moveRelative(
-          new Vec2(event.movementX, event.movementY),
-        );
-        if (this.selectedItem.monomer.hasBonds) {
-          this.selectedItem.monomer.forEachBond((bond) => {
-            bond.moveToLinkedMonomers();
-          });
-        }
-        this.selectedItem.move();
-      }
-      this.editor.renderersContainer.update(false);
-    }
-  }
-
-  mouseup() {
-    this.isMouseDown = false;
-    this.selectedItem = undefined;
-  }
-}
-
-export { SelectLasso };
diff --git a/packages/ketcher-core/src/application/editor/tools/SelectRectangle.ts b/packages/ketcher-core/src/application/editor/tools/SelectRectangle.ts
new file mode 100644
index 0000000000..91ee112b4a
--- /dev/null
+++ b/packages/ketcher-core/src/application/editor/tools/SelectRectangle.ts
@@ -0,0 +1,114 @@
+/****************************************************************************
+ * Copyright 2021 EPAM Systems
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ ***************************************************************************/
+import { Vec2 } from 'domain/entities';
+import { CoreEditor } from 'application/editor';
+import { brush as d3Brush, select } from 'd3';
+import { BaseRenderer } from 'application/render/renderers/BaseRenderer';
+import { Command } from 'domain/entities/Command';
+import { BaseTool } from 'application/editor/tools/Tool';
+
+class SelectRectangle implements BaseTool {
+  private brush;
+  private brushArea;
+
+  constructor(private editor: CoreEditor) {
+    this.editor = editor;
+    this.destroy();
+    this.createBrush();
+
+    this.brush.on('brush', (brushEvent) => {
+      const selection = brushEvent.selection;
+      if (!selection) return;
+
+      requestAnimationFrame(() => {
+        const modelChanges =
+          this.editor.drawingEntitiesManager.selectIfLocatedInRectangle(
+            new Vec2(selection[0][0], selection[0][1]),
+            new Vec2(selection[1][0], selection[1][1]),
+          );
+        this.editor.renderersContainer.update(modelChanges);
+      });
+    });
+  }
+
+  private createBrush() {
+    this.brushArea = select(this.editor.canvas)
+      .insert('g', ':first-child')
+      .attr('id', 'rectangle-selection-area');
+
+    const brushed = (mo) => {
+      if (mo.selection) {
+        this.brushArea.call(this.brush.clear);
+      }
+    };
+
+    this.brush = d3Brush();
+    this.brush.on('end', brushed);
+    this.brushArea.call(this.brush);
+
+    this.brushArea
+      .select('rect.selection')
+      .style('fill', 'transparent')
+      .style('stroke', 'darkgrey');
+  }
+
+  mousedown(event) {
+    const renderer = event.target.__data__;
+    let modelChanges: Command;
+    if (renderer instanceof BaseRenderer) {
+      modelChanges = this.editor.drawingEntitiesManager.selectDrawingEntity(
+        renderer.drawingEntity,
+      );
+    } else {
+      modelChanges =
+        this.editor.drawingEntitiesManager.unselectAllDrawingEntities();
+    }
+    this.editor.renderersContainer.update(modelChanges);
+  }
+
+  mouseOverDrawingEntity(event) {
+    const renderer = event.target.__data__;
+    const modelChanges =
+      this.editor.drawingEntitiesManager.intendToSelectDrawingEntity(
+        renderer.drawingEntity,
+      );
+    this.editor.renderersContainer.update(modelChanges);
+  }
+
+  mouseLeaveDrawingEntity(event) {
+    const renderer: BaseRenderer = event.target.__data__;
+
+    const modelChanges =
+      this.editor.drawingEntitiesManager.cancelIntentionToSelectDrawingEntity(
+        renderer.drawingEntity,
+      );
+    this.editor.renderersContainer.update(modelChanges);
+  }
+
+  destroy() {
+    if (this.brush) {
+      this.brushArea.remove();
+      this.brush = null;
+      this.brushArea = null;
+    }
+    const modelChanges =
+      this.editor.drawingEntitiesManager.unselectAllDrawingEntities();
+
+    this.editor.renderersContainer.update(modelChanges);
+  }
+}
+
+export { SelectRectangle };
diff --git a/packages/ketcher-core/src/application/editor/tools/Tool.ts b/packages/ketcher-core/src/application/editor/tools/Tool.ts
index 451029c54c..4b606a5985 100644
--- a/packages/ketcher-core/src/application/editor/tools/Tool.ts
+++ b/packages/ketcher-core/src/application/editor/tools/Tool.ts
@@ -16,6 +16,20 @@ interface ToolEventHandler {
   mouseLeaveClientArea?(event: Event): void;
 
   mouseover?(event: Event): void;
+
+  mouseOverPolymerBond?(event: Event): void;
+
+  mouseLeavePolymerBond?(event: Event): void;
+
+  mouseOverMonomer?(event: Event): void;
+
+  mouseLeaveMonomer?(event: Event): void;
+
+  mouseOverDrawingEntity?(event: Event): void;
+
+  mouseLeaveDrawingEntity?(event: Event): void;
+
+  mouseUpMonomer?(event: Event): void;
 }
 
 export interface IRnaPreset {
@@ -34,13 +48,24 @@ export interface Tool extends ToolEventHandler {
   isNotActiveTool?: boolean;
 }
 
+export interface BaseTool extends Tool {
+  destroy(): void;
+}
+
+export type PeptideToolOptions = MonomerItemType;
+
 // export type ToolOptions = MonomerItemType;
 // !todo
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type ToolOptions = any;
-
 export type ToolConstructorInterface = {
-  new (editor, ...args: ToolOptions[]): Tool;
+  new (editor, ...args: ToolOptions[]): Tool | BaseTool;
 };
 
 export type ToolEventHandlerName = keyof ToolEventHandler;
+
+export function isBaseTool(
+  tool: Tool | BaseTool | undefined,
+): tool is BaseTool {
+  return (tool as BaseTool)?.destroy !== undefined;
+}
diff --git a/packages/ketcher-core/src/application/editor/tools/index.ts b/packages/ketcher-core/src/application/editor/tools/index.ts
index a77ff94a82..4adf55818c 100644
--- a/packages/ketcher-core/src/application/editor/tools/index.ts
+++ b/packages/ketcher-core/src/application/editor/tools/index.ts
@@ -15,13 +15,15 @@
  ***************************************************************************/
 import { ToolConstructorInterface } from './Tool';
 import { MonomerTool } from 'application/editor/tools/Monomer';
-import { PresetTool } from 'application/editor/tools/Preset';
-import { SelectLasso } from 'application/editor/tools/SelectLasso';
+import { RnaPresetTool } from 'application/editor/tools/RnaPreset';
+import { SelectRectangle } from 'application/editor/tools/SelectRectangle';
 import { PolymerBond } from 'application/editor/tools/Bond';
+import { EraserTool } from 'application/editor/tools/Erase';
 
 export const toolsMap: Record<string, ToolConstructorInterface> = {
   monomer: MonomerTool,
-  preset: PresetTool,
-  'select-lasso': SelectLasso,
+  preset: RnaPresetTool,
+  'select-rectangle': SelectRectangle,
   'bond-single': PolymerBond,
+  erase: EraserTool,
 };
diff --git a/packages/ketcher-core/src/application/render/renderers/BaseMonomerRenderer.ts b/packages/ketcher-core/src/application/render/renderers/BaseMonomerRenderer.ts
index 0e8a0a6e74..0ee647165b 100644
--- a/packages/ketcher-core/src/application/render/renderers/BaseMonomerRenderer.ts
+++ b/packages/ketcher-core/src/application/render/renderers/BaseMonomerRenderer.ts
@@ -1,56 +1,29 @@
 import { BaseRenderer } from './BaseRenderer';
-import { Selection } from 'd3';
 import assert from 'assert';
 import { BaseMonomer } from 'domain/entities/BaseMonomer';
+import { D3SvgElementSelection } from 'application/render/types';
+import { DrawingEntity } from 'domain/entities/DrawingEntity';
+import { editorEvents } from 'application/editor/editorEvents';
 
 export abstract class BaseMonomerRenderer extends BaseRenderer {
-  protected rootElement;
-
-  private selectionElement;
-  private bodyElement;
-  private r1AttachmentPoint;
-  private r2AttachmentPoint;
+  private editorEvents: typeof editorEvents;
+  private selectionCircle?: D3SvgElementSelection<SVGCircleElement, void>;
+  private selectionBorder?: D3SvgElementSelection<SVGUseElement, void>;
+  private r1AttachmentPoint?: D3SvgElementSelection<SVGGElement, void>;
+  private r2AttachmentPoint?: D3SvgElementSelection<SVGGElement, void>;
   static isSelectable() {
     return true;
   }
 
-  constructor(
+  protected constructor(
     public monomer: BaseMonomer,
     private monomerSelectedElementId: string,
+    private monomerHoveredElementId: string,
     private scale?: number,
   ) {
-    super();
+    super(monomer as DrawingEntity);
     this.monomer.setRenderer(this);
-  }
-
-  public get rootBBox() {
-    const rootNode = this.rootElement?.node();
-    if (!rootNode) return;
-
-    return rootNode.getBBox();
-  }
-
-  public get width() {
-    return this.rootBBox?.width || 0;
-  }
-
-  public get height() {
-    return this.rootBBox?.height || 0;
-  }
-
-  public get bodyBBox() {
-    const rootNode = this.bodyElement?.node();
-    if (!rootNode) return;
-
-    return rootNode.getBBox();
-  }
-
-  public get bodyWidth() {
-    return this.bodyBBox?.width || 0;
-  }
-
-  public get bodyHeight() {
-    return this.bodyBBox?.height || 0;
+    this.editorEvents = editorEvents;
   }
 
   public get center() {
@@ -78,14 +51,18 @@ export abstract class BaseMonomerRenderer extends BaseRenderer {
   }
 
   public redrawAttachmentPoints() {
-    assert(this.rootElement);
-    this.removeAttachmentPoints();
-    this.r1AttachmentPoint = this.appendR1AttachmentPoint(this.rootElement);
-    this.r2AttachmentPoint = this.appendR2AttachmentPoint(this.rootElement);
+    if (!this.rootElement) return;
+    if (this.monomer.attachmentPointsVisible) {
+      this.removeAttachmentPoints();
+      this.r1AttachmentPoint = this.appendR1AttachmentPoint(this.rootElement);
+      this.r2AttachmentPoint = this.appendR2AttachmentPoint(this.rootElement);
+    } else {
+      this.removeAttachmentPoints();
+    }
   }
 
   public appendAttachmentPoint(
-    rootElement: Selection<SVGGElement, this, HTMLElement, never>,
+    rootElement: D3SvgElementSelection<SVGGElement, void>,
     position,
     rotation,
     isAttachmentPointPotentiallyUsed,
@@ -132,7 +109,7 @@ export abstract class BaseMonomerRenderer extends BaseRenderer {
   }
 
   public appendR1AttachmentPoint(
-    rootElement: Selection<SVGGElement, this, HTMLElement, never>,
+    rootElement: D3SvgElementSelection<SVGGElement, void>,
   ) {
     const attachmentPoint = this.appendAttachmentPoint(
       rootElement,
@@ -147,7 +124,7 @@ export abstract class BaseMonomerRenderer extends BaseRenderer {
   }
 
   public appendR2AttachmentPoint(
-    rootElement: Selection<SVGGElement, this, HTMLElement, never>,
+    rootElement: D3SvgElementSelection<SVGGElement, void>,
   ) {
     const attachmentPoint = this.appendAttachmentPoint(
       rootElement,
@@ -162,7 +139,7 @@ export abstract class BaseMonomerRenderer extends BaseRenderer {
   }
 
   private appendAttachmentPointLabel(
-    attachmentPointElement: Selection<SVGGElement, this, HTMLElement, never>,
+    attachmentPointElement: D3SvgElementSelection<SVGGElement, void>,
     label: string,
     x,
     y,
@@ -183,7 +160,7 @@ export abstract class BaseMonomerRenderer extends BaseRenderer {
   }
 
   private appendRootElement(
-    canvas: Selection<SVGElement, unknown, HTMLElement, never>,
+    canvas: D3SvgElementSelection<SVGSVGElement, void>,
   ) {
     return canvas
       .append('g')
@@ -194,12 +171,10 @@ export abstract class BaseMonomerRenderer extends BaseRenderer {
         `translate(${this.monomer.position.x}, ${
           this.monomer.position.y
         }) scale(${this.scale || 1})`,
-      );
+      ) as never as D3SvgElementSelection<SVGGElement, void>;
   }
 
-  private appendLabel(
-    rootElement: Selection<SVGGElement, this, HTMLElement, never>,
-  ) {
+  private appendLabel(rootElement: D3SvgElementSelection<SVGGElement, void>) {
     const textElement = rootElement
       .append('text')
       .text(this.monomer.label)
@@ -208,7 +183,8 @@ export abstract class BaseMonomerRenderer extends BaseRenderer {
       .attr('line-height', '12px')
       .attr('font-weight', '700')
       .style('cursor', 'pointer')
-      .style('user-select', 'none');
+      .style('user-select', 'none')
+      .attr('pointer-events', 'none');
 
     const textBBox = (textElement.node() as SVGTextElement).getBBox();
 
@@ -217,44 +193,88 @@ export abstract class BaseMonomerRenderer extends BaseRenderer {
       .attr('y', this.height / 2);
   }
 
-  public appendSelection(
-    rootElement: Selection<SVGGElement, this, HTMLElement, never>,
+  public appendHover(
+    hoverAreaElement: D3SvgElementSelection<SVGGElement, void>,
   ) {
-    if (this.selectionElement) this.selectionElement.remove();
-    return rootElement
+    if (this.hoverElement) this.hoverElement.remove();
+    return hoverAreaElement
+      .append('use')
+      .attr('href', this.monomerHoveredElementId)
+      .attr('pointer-events', 'none');
+  }
+
+  public removeHover() {
+    if (!this.hoverElement) return;
+    this.hoverElement.remove();
+  }
+
+  public appendSelection() {
+    this.removeSelection();
+
+    this.selectionBorder = this.rootElement
       ?.append('use')
-      .attr('href', this.monomerSelectedElementId);
+      .attr('href', this.monomerSelectedElementId)
+      .attr('stroke', '#57FF8F')
+      .attr('pointer-events', 'none');
+
+    this.selectionCircle = this.canvas
+      ?.insert('circle', ':first-child')
+      .attr('r', '42px')
+      .attr('cx', this.monomer.position.x + this.bodyWidth / 2)
+      .attr('cy', this.monomer.position.y + this.bodyHeight / 2)
+      .attr('fill', '#57FF8F');
   }
 
-  public removeSelection(
-    rootElement: Selection<SVGGElement, this, HTMLElement, never>,
-  ) {
-    if (!this.selectionElement) return;
-    rootElement?.select(`[href="${this.monomerSelectedElementId}"]`).remove();
+  public removeSelection() {
+    this.selectionCircle?.remove();
+    this.selectionBorder?.remove();
+    this.selectionCircle = undefined;
+    this.selectionBorder = undefined;
   }
 
   protected abstract appendBody(
-    rootElement: Selection<SVGGElement, this, HTMLElement, never>,
+    rootElement: D3SvgElementSelection<SVGGElement, void>,
     theme,
   );
 
+  protected appendHoverAreaElement() {
+    this.hoverAreaElement = this.rootElement;
+  }
+
+  private appendEvents() {
+    assert(this.bodyElement);
+    this.bodyElement
+      .on('mouseover', (event) => {
+        this.editorEvents.mouseOverDrawingEntity.dispatch(event);
+        this.editorEvents.mouseOverMonomer.dispatch(event);
+      })
+      .on('mouseleave', (event) => {
+        this.editorEvents.mouseLeaveDrawingEntity.dispatch(event);
+        this.editorEvents.mouseLeaveMonomer.dispatch(event);
+      })
+      .on('mouseup', (event) => {
+        this.editorEvents.mouseUpMonomer.dispatch(event);
+      });
+  }
+
   public show(theme) {
     this.rootElement = this.rootElement || this.appendRootElement(this.canvas);
     this.bodyElement = this.appendBody(this.rootElement, theme);
+    this.appendEvents();
     this.appendLabel(this.rootElement);
+    this.appendHoverAreaElement();
     if (this.monomer.selected) {
       this.drawSelection();
-      this.redrawAttachmentPoints();
     }
+    this.redrawAttachmentPoints();
   }
 
   public drawSelection() {
     assert(this.rootElement);
     if (this.monomer.selected) {
-      this.selectionElement = this.appendSelection(this.rootElement);
+      this.appendSelection();
     } else {
-      this.removeSelection(this.rootElement);
-      this.selectionElement = null;
+      this.removeSelection();
     }
   }
 
@@ -270,5 +290,6 @@ export abstract class BaseMonomerRenderer extends BaseRenderer {
   public remove() {
     this.rootElement?.remove();
     this.rootElement = undefined;
+    this.removeSelection();
   }
 }
diff --git a/packages/ketcher-core/src/application/render/renderers/BaseRenderer.ts b/packages/ketcher-core/src/application/render/renderers/BaseRenderer.ts
index f70557d531..4fc92a8f4c 100644
--- a/packages/ketcher-core/src/application/render/renderers/BaseRenderer.ts
+++ b/packages/ketcher-core/src/application/render/renderers/BaseRenderer.ts
@@ -1,4 +1,7 @@
-import { select, Selection } from 'd3';
+import { select } from 'd3';
+import { DrawingEntity } from 'domain/entities/DrawingEntity';
+import assert from 'assert';
+import { D3SvgElementSelection } from 'application/render/types';
 
 export interface IBaseRenderer {
   show(theme): void;
@@ -6,20 +9,103 @@ export interface IBaseRenderer {
 }
 
 export abstract class BaseRenderer implements IBaseRenderer {
-  public static isSelectable = () => false;
-  protected abstract rootElement:
-    | Selection<SVGGElement, this, HTMLElement, never>
-    | undefined;
+  protected rootElement?: D3SvgElementSelection<SVGGElement, void>;
 
-  protected canvas: Selection<SVGElement, unknown, HTMLElement, never>;
-  protected constructor() {
-    this.canvas = select<SVGElement, unknown>('#polymer-editor-canvas');
+  protected bodyElement?: D3SvgElementSelection<SVGElement, this>;
+
+  protected hoverElement?: D3SvgElementSelection<
+    SVGUseElement & SVGGElement,
+    void
+  >;
+
+  protected hoverAreaElement?: D3SvgElementSelection<
+    SVGGElement | SVGLineElement,
+    void
+  >;
+
+  protected canvas: D3SvgElementSelection<SVGSVGElement, void>;
+  protected constructor(public drawingEntity: DrawingEntity) {
+    this.canvas = select('#polymer-editor-canvas');
+  }
+
+  public get rootBBox() {
+    const rootNode = this.rootElement?.node();
+    if (!rootNode) return;
+
+    return rootNode.getBBox();
+  }
+
+  public get width() {
+    return this.rootBBox?.width || 0;
+  }
+
+  public get height() {
+    return this.rootBBox?.height || 0;
+  }
+
+  public get x() {
+    return this.rootBBox?.x || 0;
+  }
+
+  public get y() {
+    return this.rootBBox?.y || 0;
+  }
+
+  public get bodyBBox() {
+    const rootNode = this.bodyElement?.node();
+    const canvasNode = this.canvas.node();
+    assert(canvasNode);
+    if (!rootNode) return;
+    const canvasBbox = canvasNode.getBoundingClientRect();
+    const rootBbox = rootNode.getBoundingClientRect();
+
+    return {
+      x: rootBbox.x - canvasBbox.x,
+      y: rootBbox.y - canvasBbox.y,
+      width: rootBbox.width,
+      height: rootBbox.height,
+    };
+  }
+
+  public get bodyWidth() {
+    return this.bodyBBox?.width || 0;
+  }
+
+  public get bodyHeight() {
+    return this.bodyBBox?.height || 0;
+  }
+
+  public get bodyX() {
+    return this.bodyBBox?.x || 0;
+  }
+
+  public get bodyY() {
+    return this.bodyBBox?.y || 0;
   }
 
   public abstract show(theme): void;
+  public abstract drawSelection(): void;
+  protected abstract appendHover(
+    hoverArea,
+  ): D3SvgElementSelection<SVGUseElement, void> | void;
+
+  protected abstract removeHover(): void;
+  protected abstract appendHoverAreaElement(): void;
 
   public remove() {
     this.rootElement?.remove();
     this.rootElement = undefined;
   }
+
+  public redrawHover() {
+    if (this.drawingEntity.hovered) {
+      const hoverElement = this.appendHover(this.hoverAreaElement);
+      if (hoverElement) {
+        this.hoverElement = hoverElement;
+      }
+    } else {
+      this.removeHover();
+      this.hoverElement = undefined;
+    }
+  }
 }
diff --git a/packages/ketcher-core/src/application/render/renderers/ChemRenderer.ts b/packages/ketcher-core/src/application/render/renderers/ChemRenderer.ts
index 0c6fc396cc..d18b951416 100644
--- a/packages/ketcher-core/src/application/render/renderers/ChemRenderer.ts
+++ b/packages/ketcher-core/src/application/render/renderers/ChemRenderer.ts
@@ -6,11 +6,11 @@ const CHEM_SELECTED_ELEMENT_ID = '#chem-selection';
 
 export class ChemRenderer extends BaseMonomerRenderer {
   constructor(public monomer: Chem, scale?: number) {
-    super(monomer, CHEM_SELECTED_ELEMENT_ID, scale);
+    super(monomer, CHEM_SELECTED_ELEMENT_ID, CHEM_SELECTED_ELEMENT_ID, scale);
   }
 
   protected appendBody(
-    rootElement: Selection<SVGGElement, this, HTMLElement, never>,
+    rootElement: Selection<SVGGElement, void, HTMLElement, never>,
     theme,
   ) {
     return rootElement
diff --git a/packages/ketcher-core/src/application/render/renderers/PeptideRenderer.ts b/packages/ketcher-core/src/application/render/renderers/PeptideRenderer.ts
index 13447a7723..877edaf131 100644
--- a/packages/ketcher-core/src/application/render/renderers/PeptideRenderer.ts
+++ b/packages/ketcher-core/src/application/render/renderers/PeptideRenderer.ts
@@ -3,14 +3,20 @@ import { Peptide } from 'domain/entities/Peptide';
 import { BaseMonomerRenderer } from 'application/render/renderers/BaseMonomerRenderer';
 
 const PEPTIDE_SELECTED_ELEMENT_ID = '#peptide-selection';
+const PEPTIDE_HOVERED_ELEMENT_ID = '#peptide-hover';
 
 export class PeptideRenderer extends BaseMonomerRenderer {
   constructor(public monomer: Peptide, scale?: number) {
-    super(monomer, PEPTIDE_SELECTED_ELEMENT_ID, scale);
+    super(
+      monomer,
+      PEPTIDE_SELECTED_ELEMENT_ID,
+      PEPTIDE_HOVERED_ELEMENT_ID,
+      scale,
+    );
   }
 
   protected appendBody(
-    rootElement: Selection<SVGGElement, this, HTMLElement, never>,
+    rootElement: Selection<SVGGElement, void, HTMLElement, never>,
     theme,
   ) {
     return rootElement
diff --git a/packages/ketcher-core/src/application/render/renderers/PhosphateRenderer.ts b/packages/ketcher-core/src/application/render/renderers/PhosphateRenderer.ts
index 48d51ebb32..90b7caa27b 100644
--- a/packages/ketcher-core/src/application/render/renderers/PhosphateRenderer.ts
+++ b/packages/ketcher-core/src/application/render/renderers/PhosphateRenderer.ts
@@ -6,11 +6,16 @@ const PHOSPHATE_SELECTED_ELEMENT_ID = '#phosphate-selection';
 
 export class PhosphateRenderer extends BaseMonomerRenderer {
   constructor(public monomer: Phosphate, scale?: number) {
-    super(monomer, PHOSPHATE_SELECTED_ELEMENT_ID, scale);
+    super(
+      monomer,
+      PHOSPHATE_SELECTED_ELEMENT_ID,
+      PHOSPHATE_SELECTED_ELEMENT_ID,
+      scale,
+    );
   }
 
   protected appendBody(
-    rootElement: Selection<SVGGElement, this, HTMLElement, never>,
+    rootElement: Selection<SVGGElement, void, HTMLElement, never>,
     theme,
   ) {
     return rootElement
diff --git a/packages/ketcher-core/src/application/render/renderers/PolymerBondRenderer.ts b/packages/ketcher-core/src/application/render/renderers/PolymerBondRenderer.ts
index 3b8eef3b8c..a62077be9d 100644
--- a/packages/ketcher-core/src/application/render/renderers/PolymerBondRenderer.ts
+++ b/packages/ketcher-core/src/application/render/renderers/PolymerBondRenderer.ts
@@ -1,17 +1,18 @@
 import { BaseRenderer } from './BaseRenderer';
-import { Selection } from 'd3';
 import { PolymerBond } from 'domain/entities/PolymerBond';
+import { DrawingEntity } from 'domain/entities/DrawingEntity';
+import assert from 'assert';
+import { D3SvgElementSelection } from 'application/render/types';
+import { editorEvents } from 'application/editor/editorEvents';
 
 export class PolymerBondRenderer extends BaseRenderer {
-  protected rootElement:
-    | Selection<SVGGElement, this, HTMLElement, never>
-    | undefined;
-
-  private bondElement;
+  private editorEvents: typeof editorEvents;
+  private selectionElement;
 
   constructor(public polymerBond: PolymerBond) {
-    super();
+    super(polymerBond as DrawingEntity);
     this.polymerBond.setRenderer(this);
+    this.editorEvents = editorEvents;
   }
 
   public get rootBBox() {
@@ -30,30 +31,121 @@ export class PolymerBondRenderer extends BaseRenderer {
   }
 
   public appendBond(rootElement) {
-    this.bondElement = rootElement
+    this.bodyElement = rootElement
       .append('line')
       .attr('stroke', this.polymerBond.finished ? '#333333' : '#0097A8')
       .attr('stroke-width', 2)
+      .attr('class', 'selection-area')
       .attr('x1', this.polymerBond.startPosition.x)
       .attr('y1', this.polymerBond.startPosition.y)
       .attr('x2', this.polymerBond.endPosition.x)
       .attr('y2', this.polymerBond.endPosition.y)
-      .on('mouseleave', () => {
-        this.bondElement.attr('stroke', '#333333');
-      })
-      .on('mouseenter', () => {
-        this.bondElement.attr('stroke', '#0097A8');
-      });
+      .attr('pointer-events', 'stroke');
 
-    return this.bondElement;
+    return this.bodyElement;
   }
 
   private appendRootElement() {
-    return this.canvas.insert('g', ':first-child').data([this]);
+    return this.canvas
+      .insert('g', '#polymer-editor-canvas defs')
+      .data([this])
+      .on('mouseover', (event) => {
+        this.editorEvents.mouseOverPolymerBond.dispatch(event);
+        this.editorEvents.mouseOverDrawingEntity.dispatch(event);
+      })
+      .on('mouseout', (event) => {
+        this.editorEvents.mouseLeavePolymerBond.dispatch(event);
+        this.editorEvents.mouseLeaveDrawingEntity.dispatch(event);
+      })
+      .attr('pointer-events', 'stroke') as never as D3SvgElementSelection<
+      SVGGElement,
+      void
+    >;
   }
 
   public show() {
     this.rootElement = this.rootElement || this.appendRootElement();
+    this.appendHoverAreaElement();
     this.appendBond(this.rootElement);
+    this.drawSelection();
+  }
+
+  public drawSelection() {
+    if (this.polymerBond.selected) {
+      this.selectionElement?.remove();
+      this.selectionElement = this.rootElement
+        ?.insert('line', ':first-child')
+        .attr('stroke', '#57FF8F')
+        .attr('x1', this.polymerBond.startPosition.x)
+        .attr('y1', this.polymerBond.startPosition.y)
+        .attr('x2', this.polymerBond.endPosition.x)
+        .attr('y2', this.polymerBond.endPosition.y)
+        .attr('stroke-width', '10');
+    } else {
+      this.selectionElement?.remove();
+    }
+  }
+
+  public moveEnd() {
+    assert(this.bodyElement);
+    assert(this.hoverAreaElement);
+    this.bodyElement
+      .attr('x2', this.polymerBond.endPosition.x)
+      .attr('y2', this.polymerBond.endPosition.y);
+
+    this.hoverAreaElement
+      .attr('x2', this.polymerBond.endPosition.x)
+      .attr('y2', this.polymerBond.endPosition.y);
+
+    this.selectionElement
+      ?.attr('x2', this.polymerBond.endPosition.x)
+      ?.attr('y2', this.polymerBond.endPosition.y);
+  }
+
+  public moveStart() {
+    assert(this.bodyElement);
+    assert(this.hoverAreaElement);
+    this.bodyElement
+      .attr('x1', this.polymerBond.startPosition.x)
+      .attr('y1', this.polymerBond.startPosition.y);
+
+    this.hoverAreaElement
+      .attr('x1', this.polymerBond.startPosition.x)
+      .attr('y1', this.polymerBond.startPosition.y);
+
+    this.selectionElement
+      ?.attr('x1', this.polymerBond.startPosition.x)
+      ?.attr('y1', this.polymerBond.startPosition.y);
+  }
+
+  protected appendHoverAreaElement() {
+    (<D3SvgElementSelection<SVGLineElement, void> | undefined>(
+      this.hoverAreaElement
+    )) = this.rootElement
+      ?.append('line')
+      .attr('stroke', 'transparent')
+      .attr('x1', this.polymerBond.startPosition.x)
+      .attr('y1', this.polymerBond.startPosition.y)
+      .attr('x2', this.polymerBond.endPosition.x)
+      .attr('y2', this.polymerBond.endPosition.y)
+      .attr('stroke-width', '10');
+  }
+
+  public appendHover() {
+    assert(this.bodyElement);
+    this.bodyElement.attr('stroke', '#0097A8').attr('pointer-events', 'none');
+
+    if (this.polymerBond.selected) {
+      assert(this.hoverAreaElement);
+      this.hoverAreaElement.attr('stroke', '#CCFFDD');
+    }
+  }
+
+  public removeHover() {
+    assert(this.bodyElement);
+    assert(this.hoverAreaElement);
+    this.bodyElement.attr('stroke', '#333333').attr('pointer-events', 'stroke');
+
+    return this.hoverAreaElement.attr('stroke', 'transparent');
   }
 }
diff --git a/packages/ketcher-core/src/application/render/renderers/RNABaseRenderer.ts b/packages/ketcher-core/src/application/render/renderers/RNABaseRenderer.ts
index b8681dea62..85ec9b3460 100644
--- a/packages/ketcher-core/src/application/render/renderers/RNABaseRenderer.ts
+++ b/packages/ketcher-core/src/application/render/renderers/RNABaseRenderer.ts
@@ -6,11 +6,16 @@ const RNABASE_SELECTED_ELEMENT_ID = '#rna-base-selection';
 
 export class RNABaseRenderer extends BaseMonomerRenderer {
   constructor(public monomer: RNABase, scale?: number) {
-    super(monomer, RNABASE_SELECTED_ELEMENT_ID, scale);
+    super(
+      monomer,
+      RNABASE_SELECTED_ELEMENT_ID,
+      RNABASE_SELECTED_ELEMENT_ID,
+      scale,
+    );
   }
 
   protected appendBody(
-    rootElement: Selection<SVGGElement, this, HTMLElement, never>,
+    rootElement: Selection<SVGGElement, void, HTMLElement, never>,
     theme,
   ) {
     return rootElement
diff --git a/packages/ketcher-core/src/application/render/renderers/RenderersManager.ts b/packages/ketcher-core/src/application/render/renderers/RenderersManager.ts
new file mode 100644
index 0000000000..37e2f82894
--- /dev/null
+++ b/packages/ketcher-core/src/application/render/renderers/RenderersManager.ts
@@ -0,0 +1,106 @@
+import { PolymerBondRenderer } from 'application/render/renderers/PolymerBondRenderer';
+import { Command } from 'domain/entities/Command';
+import assert from 'assert';
+import { DrawingEntity } from 'domain/entities/DrawingEntity';
+import { monomerFactory } from 'application/editor/operations/monomer/monomerFactory';
+import { BaseMonomer } from 'domain/entities/BaseMonomer';
+import { BaseMonomerRenderer } from 'application/render/renderers/BaseMonomerRenderer';
+import { PolymerBond } from 'domain/entities/PolymerBond';
+
+export class RenderersManager {
+  private theme;
+  public monomers: Map<number, BaseMonomerRenderer> = new Map();
+  public polymerBonds: Map<number, PolymerBondRenderer> = new Map();
+
+  constructor({ theme }) {
+    this.theme = theme;
+  }
+
+  public hoverDrawingEntity(drawingEntity: DrawingEntity) {
+    assert(drawingEntity.baseRenderer);
+    drawingEntity.baseRenderer.redrawHover();
+  }
+
+  public selectDrawingEntity(drawingEntity: DrawingEntity) {
+    assert(drawingEntity.baseRenderer);
+    drawingEntity.baseRenderer.drawSelection();
+  }
+
+  public addMonomer(monomer: BaseMonomer, callback?: () => void) {
+    const [, MonomerRenderer] = monomerFactory(monomer.monomerItem);
+    const monomerRenderer = new MonomerRenderer(monomer);
+    this.monomers.set(monomer.id, monomerRenderer);
+    monomerRenderer.show(this.theme);
+    if (callback) {
+      callback();
+    }
+  }
+
+  public moveMonomer(monomer: BaseMonomer) {
+    monomer.renderer?.move();
+  }
+
+  public deleteMonomer(monomer: BaseMonomer) {
+    monomer.renderer?.remove();
+    this.monomers.delete(monomer.id);
+  }
+
+  public addPolymerBond(polymerBond) {
+    const polymerBondRenderer = new PolymerBondRenderer(polymerBond);
+    this.polymerBonds.set(polymerBond.id, polymerBondRenderer);
+    polymerBondRenderer.show();
+    polymerBondRenderer.polymerBond.firstMonomer.renderer?.redrawAttachmentPoints();
+  }
+
+  public movePolymerBond(polymerBond: PolymerBond) {
+    polymerBond.renderer?.moveStart();
+    polymerBond.renderer?.moveEnd();
+  }
+
+  public showPolymerBondInformation(polymerBond) {
+    polymerBond.renderer?.redrawHover();
+    polymerBond.firstMonomer.renderer?.redrawAttachmentPoints();
+    polymerBond.firstMonomer.renderer?.redrawHover();
+    polymerBond.secondMonomer?.renderer?.redrawAttachmentPoints();
+    polymerBond.secondMonomer?.renderer?.redrawHover();
+  }
+
+  public deletePolymerBond(polymerBond) {
+    polymerBond.renderer?.remove();
+    polymerBond?.firstMonomer?.renderer?.redrawAttachmentPoints();
+    polymerBond?.secondMonomer?.renderer?.redrawAttachmentPoints();
+    this.monomers.delete(polymerBond.id);
+  }
+
+  public finishPolymerBondCreation(polymerBond) {
+    assert(polymerBond.secondMonomer);
+    polymerBond.renderer?.moveEnd();
+    polymerBond.renderer?.redrawHover();
+    polymerBond.firstMonomer.renderer?.redrawAttachmentPoints();
+    polymerBond.firstMonomer.renderer?.drawSelection();
+    polymerBond.firstMonomer.renderer?.redrawHover();
+    polymerBond.secondMonomer.renderer?.redrawAttachmentPoints();
+    polymerBond.secondMonomer.renderer?.drawSelection();
+    polymerBond.secondMonomer.renderer?.redrawHover();
+  }
+
+  public cancelPolymerBondCreation(polymerBond) {
+    this.deletePolymerBond(polymerBond);
+    polymerBond.firstMonomer.renderer?.redrawAttachmentPoints();
+    polymerBond.firstMonomer.renderer?.drawSelection();
+    polymerBond.firstMonomer.renderer?.redrawHover();
+  }
+
+  public hoverMonomer(monomer, needRedrawAttachmentPoints) {
+    this.hoverDrawingEntity(monomer as DrawingEntity);
+    if (needRedrawAttachmentPoints) {
+      monomer.renderer?.redrawAttachmentPoints();
+    }
+  }
+
+  public update(modelChanges: Command) {
+    modelChanges.operations.forEach((modelChange) => {
+      modelChange.execute(this);
+    });
+  }
+}
diff --git a/packages/ketcher-core/src/application/render/renderers/SugarRenderer.ts b/packages/ketcher-core/src/application/render/renderers/SugarRenderer.ts
index 43fefb963e..60a4dc888c 100644
--- a/packages/ketcher-core/src/application/render/renderers/SugarRenderer.ts
+++ b/packages/ketcher-core/src/application/render/renderers/SugarRenderer.ts
@@ -6,11 +6,11 @@ const SUGAR_SELECTED_ELEMENT_ID = '#sugar-selection';
 
 export class SugarRenderer extends BaseMonomerRenderer {
   constructor(public monomer: Sugar, scale?: number) {
-    super(monomer, SUGAR_SELECTED_ELEMENT_ID, scale);
+    super(monomer, SUGAR_SELECTED_ELEMENT_ID, SUGAR_SELECTED_ELEMENT_ID, scale);
   }
 
   protected appendBody(
-    rootElement: Selection<SVGGElement, this, HTMLElement, never>,
+    rootElement: Selection<SVGGElement, void, HTMLElement, never>,
     theme,
   ) {
     return rootElement
diff --git a/packages/ketcher-core/src/application/render/restruct/restruct.ts b/packages/ketcher-core/src/application/render/restruct/restruct.ts
index 62f892a2c7..fa6320ce8d 100644
--- a/packages/ketcher-core/src/application/render/restruct/restruct.ts
+++ b/packages/ketcher-core/src/application/render/restruct/restruct.ts
@@ -42,8 +42,6 @@ import { Render } from '../raphaelRender';
 import Visel from './visel';
 import util from '../util';
 import { ReRGroupAttachmentPoint } from './rergroupAttachmentPoint';
-import { PolymerBondRenderer } from 'application/render/renderers/PolymerBondRenderer';
-import { BaseMonomerRenderer } from '../renderers';
 
 class ReStruct {
   public static maps = {
@@ -57,8 +55,6 @@ class ReStruct {
     sgroupData: ReDataSGroupData,
     enhancedFlags: ReEnhancedFlag,
     sgroups: ReSGroup,
-    monomers: BaseMonomerRenderer,
-    polymerBonds: PolymerBondRenderer,
     reloops: ReLoop,
     simpleObjects: ReSimpleObject,
     texts: ReText,
@@ -76,8 +72,6 @@ class ReStruct {
   public rgroupAttachmentPoints: Pool<ReRGroupAttachmentPoint> = new Pool();
 
   public sgroups: Map<number, ReSGroup> = new Map();
-  public monomers: Map<number, BaseMonomerRenderer> = new Map();
-  public polymerBonds: Map<number, PolymerBondRenderer> = new Map();
   public sgroupData: Map<number, ReDataSGroupData> = new Map();
   public enhancedFlags: Map<number, ReEnhancedFlag> = new Map();
   private simpleObjects: Map<number, ReSimpleObject> = new Map();
@@ -103,9 +97,7 @@ class ReStruct {
     // eslint-disable-line max-statements
     this.render = render as Render;
     this.molecule = molecule || new Struct();
-    if (!render.skipRaphaelInitialization) {
-      this.initLayers();
-    }
+    this.initLayers();
     this.clearMarks();
     // TODO: eachItem ?
 
@@ -512,9 +504,6 @@ class ReStruct {
     this.assignConnectedComponents();
     this.initialized = true;
 
-    this.showMonomers();
-    this.showPolymerBonds();
-
     this.verifyLoops();
     const updLoops = force || this.structChanged;
     if (updLoops) this.updateLoops();
@@ -708,20 +697,6 @@ class ReStruct {
     });
   }
 
-  private showMonomers(): void {
-    this.monomers.forEach((monomerRenderer) => {
-      monomerRenderer.remove();
-      monomerRenderer.show((this.render as any).theme);
-    });
-  }
-
-  private showPolymerBonds(): void {
-    this.polymerBonds.forEach((polymerBond) => {
-      polymerBond.remove();
-      polymerBond.show();
-    });
-  }
-
   showEnhancedFlags(): void {
     const options = this.render.options;
 
diff --git a/packages/ketcher-core/src/application/render/types.ts b/packages/ketcher-core/src/application/render/types.ts
new file mode 100644
index 0000000000..d5e90a47cc
--- /dev/null
+++ b/packages/ketcher-core/src/application/render/types.ts
@@ -0,0 +1,6 @@
+import { Selection } from 'd3';
+
+export type D3SvgElementSelection<
+  ElementType extends SVGElement,
+  T,
+> = Selection<ElementType, T, HTMLElement, never>;
diff --git a/packages/ketcher-core/src/domain/entities/BaseMonomer.ts b/packages/ketcher-core/src/domain/entities/BaseMonomer.ts
index de6c815cd9..3860e96b97 100644
--- a/packages/ketcher-core/src/domain/entities/BaseMonomer.ts
+++ b/packages/ketcher-core/src/domain/entities/BaseMonomer.ts
@@ -3,9 +3,10 @@ import { Vec2 } from 'domain/entities/vec2';
 import { AttachmentPointName, MonomerItemType } from 'domain/types';
 import { PolymerBond } from 'domain/entities/PolymerBond';
 import { BaseMonomerRenderer } from 'application/render/renderers/BaseMonomerRenderer';
+import { BaseRenderer } from 'application/render/renderers/BaseRenderer';
 
 export class BaseMonomer extends DrawingEntity {
-  public renderer?: BaseMonomerRenderer;
+  public renderer?: BaseMonomerRenderer = undefined;
   public attachmentPointsToBonds: Record<
     AttachmentPointName,
     PolymerBond | null
@@ -21,6 +22,8 @@ export class BaseMonomer extends DrawingEntity {
     R2: null,
   };
 
+  public attachmentPointsVisible = false;
+
   constructor(private _monomerItem: MonomerItemType, _position?: Vec2) {
     super(_position);
   }
@@ -33,6 +36,14 @@ export class BaseMonomer extends DrawingEntity {
     return this.monomerItem.label;
   }
 
+  public turnOnAttachmentPointsVisibility() {
+    this.attachmentPointsVisible = true;
+  }
+
+  public turnOffAttachmentPointsVisibility() {
+    this.attachmentPointsVisible = false;
+  }
+
   public setPotentialBond(
     attachmentPoint: string,
     potentialBond?: PolymerBond | null,
@@ -91,6 +102,7 @@ export class BaseMonomer extends DrawingEntity {
   }
 
   public setRenderer(renderer: BaseMonomerRenderer) {
+    super.setBaseRenderer(renderer as BaseRenderer);
     this.renderer = renderer;
   }
 
diff --git a/packages/ketcher-core/src/domain/entities/Command.ts b/packages/ketcher-core/src/domain/entities/Command.ts
new file mode 100644
index 0000000000..3e1e1d38f1
--- /dev/null
+++ b/packages/ketcher-core/src/domain/entities/Command.ts
@@ -0,0 +1,13 @@
+import { Operation } from 'domain/entities/Operation';
+
+export class Command {
+  public operations: Operation[] = [];
+
+  public addOperation(operation: Operation) {
+    this.operations.push(operation);
+  }
+
+  public merge(command: Command) {
+    this.operations = [...this.operations, ...command.operations];
+  }
+}
diff --git a/packages/ketcher-core/src/domain/entities/DrawingEntitiesManager.ts b/packages/ketcher-core/src/domain/entities/DrawingEntitiesManager.ts
new file mode 100644
index 0000000000..58de7a69eb
--- /dev/null
+++ b/packages/ketcher-core/src/domain/entities/DrawingEntitiesManager.ts
@@ -0,0 +1,432 @@
+import { MonomerItemType } from 'domain/types';
+import { Vec2 } from 'domain/entities/vec2';
+import { Command } from 'domain/entities/Command';
+import { DrawingEntity } from 'domain/entities/DrawingEntity';
+import { PolymerBond } from 'domain/entities/PolymerBond';
+import assert from 'assert';
+import { BaseMonomer } from 'domain/entities/BaseMonomer';
+import {
+  MonomerAddOperation,
+  MonomerDeleteOperation,
+  MonomerHoverOperation,
+  MonomerMoveOperation,
+} from 'application/editor/operations/monomer';
+import {
+  DrawingEntityHoverOperation,
+  DrawingEntitySelectOperation,
+} from 'application/editor/operations/drawingEntity';
+import {
+  PolymerBondAddOperation,
+  PolymerBondCancelCreationOperation,
+  PolymerBondDeleteOperation,
+  PolymerBondFinishCreationOperation,
+  PolymerBondMoveOperation,
+  PolymerBondShowInfoOperation,
+} from 'application/editor/operations/polymerBond';
+import { monomerFactory } from 'application/editor/operations/monomer/monomerFactory';
+
+type RnaPresetAdditionParams = {
+  sugar: MonomerItemType;
+  sugarPosition: Vec2;
+  rnaBase: MonomerItemType | undefined;
+  rnaBasePosition: Vec2 | undefined;
+  phosphate: MonomerItemType | undefined;
+  phosphatePosition: Vec2 | undefined;
+};
+
+export class DrawingEntitiesManager {
+  public monomers: Map<number, BaseMonomer> = new Map();
+  public polymerBonds: Map<number, PolymerBond> = new Map();
+
+  get selectedEntities() {
+    return this.allEntities.filter(
+      ([, drawingEntity]) => drawingEntity.selected,
+    );
+  }
+
+  get allEntities() {
+    return [
+      ...(this.monomers as Map<number, DrawingEntity>),
+      ...(this.polymerBonds as Map<number, DrawingEntity>),
+    ];
+  }
+
+  public deleteSelectedEntities() {
+    const mergedCommand = new Command();
+    this.selectedEntities.forEach(([, drawingEntity]) => {
+      const command = this.deleteDrawingEntity(drawingEntity);
+      mergedCommand.merge(command);
+    });
+    return mergedCommand;
+  }
+
+  public addMonomer(monomerItem: MonomerItemType, position: Vec2) {
+    const [Monomer] = monomerFactory(monomerItem);
+    const monomer = new Monomer(monomerItem, position);
+    monomer.moveAbsolute(position);
+    this.monomers.set(monomer.id, monomer);
+
+    const command = new Command();
+    const operation = new MonomerAddOperation(monomer);
+
+    command.addOperation(operation);
+
+    return command;
+  }
+
+  public deleteDrawingEntity(drawingEntity: DrawingEntity) {
+    if (drawingEntity instanceof BaseMonomer) {
+      return this.deleteMonomer(drawingEntity);
+    } else if (drawingEntity instanceof PolymerBond) {
+      return this.deletePolymerBond(drawingEntity);
+    } else {
+      return new Command();
+    }
+  }
+
+  public selectDrawingEntity(drawingEntity: DrawingEntity) {
+    const command = this.unselectAllDrawingEntities();
+
+    drawingEntity.turnOnSelection();
+    command.merge(this.createDrawingEntitySelectionCommand(drawingEntity));
+
+    return command;
+  }
+
+  public createDrawingEntitySelectionCommand(drawingEntity: DrawingEntity) {
+    const command = new Command();
+
+    const selectionCommand = new DrawingEntitySelectOperation(drawingEntity);
+    command.addOperation(selectionCommand);
+
+    return command;
+  }
+
+  public unselectAllDrawingEntities() {
+    const command = new Command();
+
+    this.allEntities.forEach(([, drawingEntity]) => {
+      if (drawingEntity.selected) {
+        drawingEntity.turnOffSelection();
+        const operation = new DrawingEntitySelectOperation(drawingEntity);
+        command.addOperation(operation);
+      }
+    });
+
+    return command;
+  }
+
+  public deleteMonomer(monomer: BaseMonomer) {
+    this.monomers.delete(monomer.id);
+    const command = new Command();
+    const operation = new MonomerDeleteOperation(monomer);
+    command.addOperation(operation);
+
+    if (monomer.hasBonds) {
+      monomer.forEachBond((bond) => {
+        command.merge(this.deletePolymerBond(bond));
+      });
+    }
+
+    return command;
+  }
+
+  public moveMonomer(monomer: BaseMonomer, position: Vec2) {
+    const command = new Command();
+    monomer.moveAbsolute(position);
+
+    const operation = new MonomerMoveOperation(monomer);
+
+    command.addOperation(operation);
+
+    return command;
+  }
+
+  public selectIfLocatedInRectangle(
+    rectangleTopLeftPoint: Vec2,
+    rectangleBottomRightPoint: Vec2,
+  ) {
+    const command = new Command();
+    this.allEntities.forEach(([, drawingEntity]) => {
+      const isValueChanged = drawingEntity.selectIfLocatedInRectangle(
+        rectangleTopLeftPoint,
+        rectangleBottomRightPoint,
+      );
+
+      if (isValueChanged) {
+        const selectionCommand =
+          this.createDrawingEntitySelectionCommand(drawingEntity);
+
+        command.merge(selectionCommand);
+      }
+    });
+    return command;
+  }
+
+  public addPolymerBond(firstMonomer, startPosition, endPosition) {
+    const polymerBond = new PolymerBond(firstMonomer);
+    this.polymerBonds.set(polymerBond.id, polymerBond);
+    firstMonomer.setPotentialBond(
+      firstMonomer.firstFreeAttachmentPoint,
+      polymerBond,
+    );
+    polymerBond.moveBondStartAbsolute(startPosition.x, startPosition.y);
+    polymerBond.moveBondEndAbsolute(endPosition.x, endPosition.y);
+
+    const command = new Command();
+    const operation = new PolymerBondAddOperation(polymerBond);
+
+    command.addOperation(operation);
+
+    return { command, polymerBond };
+  }
+
+  public deletePolymerBond(polymerBond: PolymerBond) {
+    this.polymerBonds.delete(polymerBond.id);
+    const command = new Command();
+    const firstMonomerAttachmentPoint =
+      polymerBond.firstMonomer.getAttachmentPointByBond(polymerBond);
+    const secondMonomerAttachmentPoint =
+      polymerBond.secondMonomer?.getAttachmentPointByBond(polymerBond);
+    polymerBond.firstMonomer.removePotentialBonds();
+    polymerBond.secondMonomer?.removePotentialBonds();
+    polymerBond.firstMonomer.turnOffSelection();
+    polymerBond.secondMonomer?.turnOffSelection();
+    if (firstMonomerAttachmentPoint) {
+      polymerBond.firstMonomer.unsetBond(firstMonomerAttachmentPoint);
+    }
+    if (secondMonomerAttachmentPoint) {
+      polymerBond.secondMonomer?.unsetBond(secondMonomerAttachmentPoint);
+    }
+    const operation = new PolymerBondDeleteOperation(polymerBond);
+    command.addOperation(operation);
+
+    return command;
+  }
+
+  public cancelPolymerBondCreation(polymerBond: PolymerBond) {
+    this.polymerBonds.delete(polymerBond.id);
+    const command = new Command();
+    polymerBond.firstMonomer.removePotentialBonds();
+    polymerBond.firstMonomer.turnOffSelection();
+    polymerBond.firstMonomer.turnOffHover();
+    polymerBond.firstMonomer.turnOffAttachmentPointsVisibility();
+    const operation = new PolymerBondCancelCreationOperation(polymerBond);
+    command.addOperation(operation);
+
+    return command;
+  }
+
+  public movePolymerBond(polymerBond: PolymerBond, position: Vec2) {
+    const command = new Command();
+    polymerBond.moveBondEndAbsolute(position.x, position.y);
+
+    const operation = new PolymerBondMoveOperation(polymerBond);
+
+    command.addOperation(operation);
+
+    return command;
+  }
+
+  public finishPolymerBondCreation(
+    polymerBond,
+    secondMonomer,
+    firstMonomerAttachmentPoint,
+    secondMonomerAttachmentPoint,
+  ) {
+    const command = new Command();
+
+    polymerBond.setSecondMonomer(secondMonomer);
+    polymerBond.firstMonomer.setBond(firstMonomerAttachmentPoint, polymerBond);
+    assert(polymerBond.secondMonomer);
+    assert(secondMonomer.renderer);
+    polymerBond.secondMonomer.setBond(
+      secondMonomerAttachmentPoint,
+      polymerBond,
+    );
+    polymerBond.firstMonomer.removePotentialBonds();
+    polymerBond.secondMonomer.removePotentialBonds();
+
+    polymerBond.moveBondEndAbsolute(
+      secondMonomer.renderer.center.x,
+      secondMonomer.renderer.center.y,
+    );
+
+    polymerBond.firstMonomer.turnOffSelection();
+    polymerBond.firstMonomer.turnOffHover();
+    polymerBond.firstMonomer.turnOffAttachmentPointsVisibility();
+
+    polymerBond.secondMonomer.turnOffSelection();
+    polymerBond.secondMonomer.turnOffHover();
+    polymerBond.secondMonomer.turnOffAttachmentPointsVisibility();
+
+    polymerBond.turnOffHover();
+
+    const operation = new PolymerBondFinishCreationOperation(polymerBond);
+
+    command.addOperation(operation);
+
+    return command;
+  }
+
+  public intendToStartBondCreation(monomer: BaseMonomer) {
+    const command = new Command();
+    monomer.turnOnHover();
+    monomer.turnOnAttachmentPointsVisibility();
+
+    const operation = new MonomerHoverOperation(monomer, true);
+
+    command.addOperation(operation);
+
+    return command;
+  }
+
+  public intendToFinishBondCreation(monomer: BaseMonomer, bond: PolymerBond) {
+    const command = new Command();
+
+    monomer.turnOnHover();
+    monomer.turnOnAttachmentPointsVisibility();
+    if (monomer.availableAttachmentPointForBondEnd) {
+      monomer.setPotentialBond(
+        monomer.availableAttachmentPointForBondEnd,
+        bond,
+      );
+    }
+
+    const operation = new MonomerHoverOperation(monomer, true);
+
+    command.addOperation(operation);
+
+    return command;
+  }
+
+  public cancelIntentionToFinishBondCreation(monomer: BaseMonomer) {
+    const command = new Command();
+
+    monomer.turnOffHover();
+    monomer.turnOffAttachmentPointsVisibility();
+    monomer.removePotentialBonds();
+
+    const operation = new MonomerHoverOperation(monomer, true);
+
+    command.addOperation(operation);
+
+    return command;
+  }
+
+  public intendToSelectDrawingEntity(drawingEntity: DrawingEntity) {
+    const command = new Command();
+
+    drawingEntity.turnOnHover();
+
+    const operation = new DrawingEntityHoverOperation(drawingEntity);
+
+    command.addOperation(operation);
+
+    return command;
+  }
+
+  public cancelIntentionToSelectDrawingEntity(drawingEntity: DrawingEntity) {
+    const command = new Command();
+
+    drawingEntity.turnOffHover();
+
+    const operation = new DrawingEntityHoverOperation(drawingEntity);
+
+    command.addOperation(operation);
+
+    return command;
+  }
+
+  public showPolymerBondInformation(polymerBond: PolymerBond) {
+    const command = new Command();
+
+    polymerBond.turnOnHover();
+    polymerBond.firstMonomer.turnOnHover();
+    polymerBond.firstMonomer.turnOnAttachmentPointsVisibility();
+
+    assert(polymerBond.secondMonomer);
+
+    polymerBond.secondMonomer.turnOnHover();
+    polymerBond.secondMonomer.turnOnAttachmentPointsVisibility();
+
+    const operation = new PolymerBondShowInfoOperation(polymerBond);
+
+    command.addOperation(operation);
+
+    return command;
+  }
+
+  public hidePolymerBondInformation(polymerBond: PolymerBond) {
+    const command = new Command();
+
+    polymerBond.turnOffHover();
+    polymerBond.firstMonomer.turnOffHover();
+    polymerBond.firstMonomer.turnOffAttachmentPointsVisibility();
+
+    assert(polymerBond.secondMonomer);
+
+    polymerBond.secondMonomer.turnOffHover();
+    polymerBond.secondMonomer.turnOffAttachmentPointsVisibility();
+
+    const operation = new PolymerBondShowInfoOperation(polymerBond);
+
+    command.addOperation(operation);
+
+    return command;
+  }
+
+  public addRnaPreset({
+    sugar,
+    sugarPosition,
+    phosphate,
+    phosphatePosition,
+    rnaBase,
+    rnaBasePosition,
+  }: RnaPresetAdditionParams) {
+    const command = new Command();
+    const monomersToAdd: Array<[MonomerItemType, Vec2]> = [];
+    if (rnaBase && rnaBasePosition) {
+      monomersToAdd.push([rnaBase, rnaBasePosition]);
+    }
+    monomersToAdd.push([sugar, sugarPosition]);
+    if (phosphate && phosphatePosition) {
+      monomersToAdd.push([phosphate, phosphatePosition]);
+    }
+
+    let previousMonomer: BaseMonomer | undefined;
+    monomersToAdd.forEach(([monomerItem, monomerPosition]) => {
+      const [Monomer] = monomerFactory(monomerItem);
+      const monomer = new Monomer(monomerItem, monomerPosition);
+      this.monomers.set(monomer.id, monomer);
+      let monomerAddOperation;
+      if (previousMonomer) {
+        const polymerBond = new PolymerBond(previousMonomer);
+        monomerAddOperation = new MonomerAddOperation(monomer, () => {
+          polymerBond.moveToLinkedMonomers();
+        });
+        command.addOperation(monomerAddOperation);
+        polymerBond.setSecondMonomer(monomer);
+        assert(previousMonomer.firstFreeAttachmentPoint);
+        assert(monomer.availableAttachmentPointForBondEnd);
+        previousMonomer.setBond(
+          previousMonomer.firstFreeAttachmentPoint,
+          polymerBond,
+        );
+        monomer.setBond(
+          monomer.availableAttachmentPointForBondEnd,
+          polymerBond,
+        );
+        const operation = new PolymerBondAddOperation(polymerBond);
+        command.addOperation(operation);
+      } else {
+        monomerAddOperation = new MonomerAddOperation(monomer);
+        command.addOperation(monomerAddOperation);
+      }
+
+      previousMonomer = monomer;
+    });
+
+    return command;
+  }
+}
diff --git a/packages/ketcher-core/src/domain/entities/DrawingEntity.ts b/packages/ketcher-core/src/domain/entities/DrawingEntity.ts
index 9aa9c3bbd1..1ab02951fd 100644
--- a/packages/ketcher-core/src/domain/entities/DrawingEntity.ts
+++ b/packages/ketcher-core/src/domain/entities/DrawingEntity.ts
@@ -1,9 +1,13 @@
 import { Vec2 } from 'domain/entities/vec2';
+import { BaseRenderer } from 'application/render/renderers/BaseRenderer';
+import assert from 'assert';
 let id = 1;
 
 export abstract class DrawingEntity {
   public selected = false;
+  public hovered = false;
   public id = 0;
+  public baseRenderer?: BaseRenderer;
 
   protected constructor(private _position: Vec2 = new Vec2(0, 0)) {
     this._position = _position || new Vec2(0, 0);
@@ -24,6 +28,14 @@ export abstract class DrawingEntity {
     return this._position;
   }
 
+  public turnOnHover() {
+    this.hovered = true;
+  }
+
+  public turnOffHover() {
+    this.hovered = false;
+  }
+
   public turnOnSelection() {
     this.selected = true;
   }
@@ -31,4 +43,30 @@ export abstract class DrawingEntity {
   public turnOffSelection() {
     this.selected = false;
   }
+
+  public selectIfLocatedInRectangle(
+    rectangleTopLeftPoint: Vec2,
+    rectangleBottomRightPoint: Vec2,
+  ) {
+    assert(this.baseRenderer);
+    const prevSelectedValue = this.selected;
+    const centerX = this.baseRenderer.bodyX + this.baseRenderer.bodyWidth / 2;
+    const centerY = this.baseRenderer.bodyY + this.baseRenderer.bodyHeight / 2;
+    if (
+      rectangleBottomRightPoint.x > centerX &&
+      rectangleBottomRightPoint.y > centerY &&
+      rectangleTopLeftPoint.x < centerX &&
+      rectangleTopLeftPoint.y < centerY
+    ) {
+      this.turnOnSelection();
+    } else {
+      this.turnOffSelection();
+    }
+
+    return prevSelectedValue !== this.selected;
+  }
+
+  public setBaseRenderer(renderer: BaseRenderer) {
+    this.baseRenderer = renderer;
+  }
 }
diff --git a/packages/ketcher-core/src/domain/entities/Operation.ts b/packages/ketcher-core/src/domain/entities/Operation.ts
new file mode 100644
index 0000000000..8ea2a95667
--- /dev/null
+++ b/packages/ketcher-core/src/domain/entities/Operation.ts
@@ -0,0 +1,5 @@
+import { RenderersManager } from 'application/render/renderers/RenderersManager';
+
+export interface Operation {
+  execute(renderersManager: RenderersManager): void;
+}
diff --git a/packages/ketcher-core/src/domain/entities/PolymerBond.ts b/packages/ketcher-core/src/domain/entities/PolymerBond.ts
index 0b76e1c419..ef58dff72c 100644
--- a/packages/ketcher-core/src/domain/entities/PolymerBond.ts
+++ b/packages/ketcher-core/src/domain/entities/PolymerBond.ts
@@ -2,13 +2,15 @@ import { DrawingEntity } from 'domain/entities/DrawingEntity';
 import { PolymerBondRenderer } from 'application/render/renderers/PolymerBondRenderer';
 import { Vec2 } from 'domain/entities/vec2';
 import { BaseMonomer } from './BaseMonomer';
+import assert from 'assert';
+import { BaseRenderer } from 'application/render/renderers/BaseRenderer';
 
 export class PolymerBond extends DrawingEntity {
   public secondMonomer?: BaseMonomer;
-  public renderer?: PolymerBondRenderer;
+  public renderer?: PolymerBondRenderer = undefined;
   public endPosition: Vec2 = new Vec2();
 
-  constructor(public firstMonomer) {
+  constructor(public firstMonomer: BaseMonomer) {
     super();
     this.firstMonomer = firstMonomer;
   }
@@ -22,6 +24,7 @@ export class PolymerBond extends DrawingEntity {
   }
 
   public setRenderer(renderer: PolymerBondRenderer) {
+    super.setBaseRenderer(renderer as BaseRenderer);
     this.renderer = renderer;
   }
 
@@ -30,6 +33,7 @@ export class PolymerBond extends DrawingEntity {
   }
 
   public moveToLinkedMonomers() {
+    assert(this.firstMonomer.renderer);
     const firstMonomerCenter = this.firstMonomer.renderer.center;
     const secondMonomerCenter = this.secondMonomer?.renderer?.center;
     this.moveBondStartAbsolute(firstMonomerCenter.x, firstMonomerCenter.y);
@@ -49,16 +53,4 @@ export class PolymerBond extends DrawingEntity {
   public get startPosition() {
     return this.position;
   }
-
-  public override turnOnSelection() {
-    super.turnOnSelection();
-    this.firstMonomer.turnOnSelection();
-    this.secondMonomer?.turnOnSelection();
-  }
-
-  public override turnOffSelection() {
-    super.turnOffSelection();
-    this.firstMonomer.turnOffSelection();
-    this.secondMonomer?.turnOffSelection();
-  }
 }
diff --git a/packages/ketcher-core/src/domain/services/bond/BondService.ts b/packages/ketcher-core/src/domain/services/bond/BondService.ts
deleted file mode 100644
index 973e0df64b..0000000000
--- a/packages/ketcher-core/src/domain/services/bond/BondService.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import { fromPolymerBondDeletion } from 'application/editor/actions/polymerBond';
-import { ReStruct } from 'application/render';
-import { PolymerBond } from 'domain/entities/PolymerBond';
-import { BaseMonomer } from 'domain/entities/BaseMonomer';
-import assert from 'assert';
-
-export class BondService {
-  static deleteBondWithAllLinks(
-    renderersContainer: ReStruct,
-    polymerBond: PolymerBond,
-    secondMonomer?: BaseMonomer,
-  ) {
-    fromPolymerBondDeletion(renderersContainer, polymerBond);
-    secondMonomer
-      ? secondMonomer.removePotentialBonds()
-      : polymerBond.secondMonomer?.removePotentialBonds();
-    polymerBond.firstMonomer.removePotentialBonds();
-  }
-
-  static finishBondCreation(
-    firstMonomerAttachmentPoint: string,
-    secondMonomerAttachmentPoint: string,
-    secondMonomer: BaseMonomer,
-    polymerBond: PolymerBond,
-  ) {
-    polymerBond.setSecondMonomer(secondMonomer);
-    polymerBond.firstMonomer.setBond(firstMonomerAttachmentPoint, polymerBond);
-    assert(polymerBond.secondMonomer);
-    assert(secondMonomer.renderer);
-    polymerBond.secondMonomer.setBond(
-      secondMonomerAttachmentPoint,
-      polymerBond,
-    );
-    polymerBond.firstMonomer.removePotentialBonds();
-    polymerBond.secondMonomer.removePotentialBonds();
-
-    polymerBond.moveBondEndAbsolute(
-      secondMonomer.renderer.center.x,
-      secondMonomer.renderer.center.y,
-    );
-
-    polymerBond.firstMonomer.turnOffSelection();
-    polymerBond.secondMonomer.turnOffSelection();
-  }
-}
diff --git a/packages/ketcher-polymer-editor-react/src/Editor.tsx b/packages/ketcher-polymer-editor-react/src/Editor.tsx
index 78b0929552..79f2cfa43b 100644
--- a/packages/ketcher-polymer-editor-react/src/Editor.tsx
+++ b/packages/ketcher-polymer-editor-react/src/Editor.tsx
@@ -34,6 +34,7 @@ import { MonomerLibrary } from 'components/monomerLibrary';
 import { Menu } from 'components/menu';
 import {
   createEditor,
+  destroyEditor,
   selectEditor,
   selectEditorActiveTool,
   selectTool,
@@ -114,6 +115,10 @@ function Editor({ theme }: EditorProps) {
     const serializer = new SdfSerializer();
     const library = serializer.deserialize(monomersData);
     dispatch(loadMonomerLibrary(library));
+
+    return () => {
+      dispatch(destroyEditor(null));
+    };
   }, [dispatch]);
 
   useEffect(() => {
@@ -121,6 +126,8 @@ function Editor({ theme }: EditorProps) {
       editor.events.error.add((errorText) =>
         dispatch(openErrorTooltip(errorText)),
       );
+      dispatch(selectTool('select-rectangle'));
+      editor.events.selectTool.dispatch('select-rectangle');
     }
   }, [editor]);
 
@@ -138,12 +145,39 @@ function Editor({ theme }: EditorProps) {
         <Layout.Main>
           <svg
             id="polymer-editor-canvas"
+            data-testid="ketcher-canvas"
             ref={canvasRef}
             width="100%"
             height="100%"
           >
             <defs>
               <PeptideAvatar />
+              <symbol
+                id="peptide-hover"
+                viewBox="0 0 70 61"
+                width="70"
+                height="61"
+              >
+                <path
+                  d="M18.2246 1.75116C18.3137 1.59581 18.4792 1.5 18.6583 1.5L51.3417 1.5C51.5208 1.5 51.6863 1.59581 51.7754 1.75116L53.06 1.01408L51.7754 1.75117L68.1279 30.2512C68.2163 30.4053 68.2163 30.5947 68.1279 30.7488L51.7754 59.2488C51.6863 59.4042 51.5208 59.5 51.3417 59.5H18.6583C18.4792 59.5 18.3137 59.4042 18.2246 59.2488L1.87215 30.7488C1.78372 30.5947 1.78372 30.4053 1.87215 30.2512L18.2246 1.75116Z"
+                  fill="none"
+                  stroke="#0097A8"
+                  strokeWidth="3"
+                />{' '}
+              </symbol>
+              <symbol
+                id="peptide-selection"
+                viewBox="0 0 70 61"
+                width="70"
+                height="61"
+              >
+                <path
+                  xmlns="http://www.w3.org/2000/svg"
+                  d="M17.3572 1.25349C17.6247 0.787424 18.1209 0.500001 18.6583 0.500001L51.3417 0.5C51.8791 0.5 52.3753 0.787425 52.6428 1.2535L53.0665 1.01035L52.6428 1.2535L68.9952 29.7535C69.2605 30.2158 69.2605 30.7842 68.9952 31.2465L52.6428 59.7465C52.3753 60.2126 51.8791 60.5 51.3417 60.5H18.6583C18.1209 60.5 17.6247 60.2126 17.3572 59.7465L1.00478 31.2465C0.739513 30.7842 0.739513 30.2158 1.00478 29.7535L17.3572 1.25349Z"
+                  fill="none"
+                  stroke="#0097A8"
+                />
+              </symbol>
               <ChemAvatar />
               <SugarAvatar />
               <PhosphateAvatar />
@@ -204,10 +238,10 @@ function MenuComponent() {
         <Menu.Item itemId="undo" />
       </Menu.Group>
       <Menu.Group>
-        <Menu.Item itemId="erase" />
+        <Menu.Item itemId="erase" title="Erase" />
         <Menu.Submenu vertical>
+          <Menu.Item itemId="select-rectangle" title="Select Rectangle" />
           <Menu.Item itemId="select-lasso" />
-          <Menu.Item itemId="select-rectangle" />
           <Menu.Item itemId="select-fragment" />
         </Menu.Submenu>
         <Menu.Submenu>
diff --git a/packages/ketcher-polymer-editor-react/src/components/menu/subMenu/SubMenu.tsx b/packages/ketcher-polymer-editor-react/src/components/menu/subMenu/SubMenu.tsx
index 24e07bcae3..bc0ad544ad 100644
--- a/packages/ketcher-polymer-editor-react/src/components/menu/subMenu/SubMenu.tsx
+++ b/packages/ketcher-polymer-editor-react/src/components/menu/subMenu/SubMenu.tsx
@@ -60,7 +60,7 @@ const SubMenu = ({
   return (
     <RootContainer>
       <VisibleItem>
-        <MenuItem itemId={visibleItemId} />
+        <MenuItem itemId={visibleItemId} title={visibleItemId} />
         {open || (
           <StyledDropdownIcon
             className="dropdown"
diff --git a/packages/ketcher-polymer-editor-react/src/state/common/editorSlice.ts b/packages/ketcher-polymer-editor-react/src/state/common/editorSlice.ts
index 385396b136..baa6d30b26 100644
--- a/packages/ketcher-polymer-editor-react/src/state/common/editorSlice.ts
+++ b/packages/ketcher-polymer-editor-react/src/state/common/editorSlice.ts
@@ -62,6 +62,9 @@ export const editorSlice: Slice = createSlice({
         canvas: action.payload.canvas,
       });
     },
+    destroyEditor: (state) => {
+      state.editor = undefined;
+    },
     showPreview: (
       state,
       action: PayloadAction<
@@ -84,6 +87,7 @@ export const {
   selectTool,
   createEditor,
   showPreview,
+  destroyEditor,
 } = editorSlice.actions;
 
 export const selectEditorIsReady = (state: RootState) => state.editor.isReady;