NNS1-3270 fix set dissolve delay (#5560)

# Motivation

Fix sns neuron staking

# Changes

SNS neurons now use new method increaseDissolveDelay

# Tests

Tests has been updated

# Todos

- [ ] Add entry to changelog (if necessary).

frontend/src/lib/api/sns-governance.api.ts

@@ -247,27 +247,27 @@ export const stopDissolving = async ({
   logWithTimestamp(`Stop dissolving sns neuron complete.`);
 };
 
-export const setDissolveDelay = async ({
+export const increaseDissolveDelay = async ({
   identity,
   rootCanisterId,
   neuronId,
-  dissolveTimestampSeconds,
+  additionalDissolveDelaySeconds,
 }: {
   identity: Identity;
   rootCanisterId: Principal;
   neuronId: SnsNeuronId;
-  dissolveTimestampSeconds: number;
+  additionalDissolveDelaySeconds: number;
 }): Promise<void> => {
   logWithTimestamp(`Increase sns dissolve delay call...`);
 
-  const { setDissolveTimestamp } = await wrapper({
+  const { increaseDissolveDelay } = await wrapper({
     identity,
     rootCanisterId: rootCanisterId.toText(),
     certified: true,
   });
-  await setDissolveTimestamp({
+  await increaseDissolveDelay({
     neuronId,
-    dissolveTimestampSeconds: BigInt(dissolveTimestampSeconds),
+    additionalDissolveDelaySeconds: additionalDissolveDelaySeconds,
   });
 
   logWithTimestamp(`Increase sns dissolve delay complete.`);

frontend/src/lib/services/sns-neurons.services.ts

@@ -5,10 +5,10 @@ import {
   disburse as disburseApi,
   disburseMaturity as disburseMaturityApi,
   getSnsNeuron as getSnsNeuronApi,
+  increaseDissolveDelay,
   querySnsNeuron,
   querySnsNeurons,
   removeNeuronPermissions,
-  setDissolveDelay,
   setFollowees,
   splitNeuron as splitNeuronApi,
   stakeMaturity as stakeMaturityApi,
@@ -31,12 +31,13 @@ import {
 } from "$lib/stores/sns-neurons.store";
 import { toastsError, toastsSuccess } from "$lib/stores/toasts.store";
 import type { Account } from "$lib/types/account";
-import { nowInSeconds } from "$lib/utils/date.utils";
 import { notForceCallStrategy } from "$lib/utils/env.utils";
 import { toToastError } from "$lib/utils/error.utils";
 import { ledgerErrorToToastError } from "$lib/utils/sns-ledger.utils";
 import {
   followeesByFunction,
+  getSnsDissolvingTimeInSeconds,
+  getSnsLockedTimeInSeconds,
   getSnsNeuronByHexId,
   hasAutoStakeMaturityOn,
   isEnoughAmountToSplit,
@@ -436,11 +437,18 @@ export const updateDelay = async ({
   try {
     const identity = await getSnsNeuronIdentity();
 
-    await setDissolveDelay({
+    const existingDissolveDelay = Number(
+      getSnsLockedTimeInSeconds(neuron) ??
+        getSnsDissolvingTimeInSeconds(neuron) ??
+        0n
+    );
+
+    await increaseDissolveDelay({
       rootCanisterId,
       identity,
       neuronId: fromDefinedNullable(neuron.id),
-      dissolveTimestampSeconds: nowInSeconds() + dissolveDelaySeconds,
+      additionalDissolveDelaySeconds:
+        dissolveDelaySeconds - existingDissolveDelay,
     });
 
     return { success: true };

frontend/src/tests/lib/api/sns-governance.api.spec.ts

@@ -6,14 +6,14 @@ import {
   disburseMaturity,
   getNeuronBalance,
   getSnsNeuron,
+  increaseDissolveDelay,
   queryProposal,
   queryProposals,
   querySnsNeuron,
   querySnsNeurons,
   refreshNeuron,
   registerVote,
   removeNeuronPermissions,
-  setDissolveDelay,
   setFollowees,
   splitNeuron,
   stakeMaturity,
@@ -73,7 +73,7 @@ describe("sns-api", () => {
   const splitNeuronSpy = vi.fn().mockResolvedValue(undefined);
   const startDissolvingSpy = vi.fn().mockResolvedValue(undefined);
   const stopDissolvingSpy = vi.fn().mockResolvedValue(undefined);
-  const setDissolveDelaySpy = vi.fn().mockResolvedValue(undefined);
+  const increaseDissolveDelaySpy = vi.fn().mockResolvedValue(undefined);
   const getNeuronBalanceSpy = vi.fn().mockResolvedValue(undefined);
   const refreshNeuronSpy = vi.fn().mockResolvedValue(undefined);
   const claimNeuronSpy = vi.fn().mockResolvedValue(undefined);
@@ -125,7 +125,7 @@ describe("sns-api", () => {
         splitNeuron: splitNeuronSpy,
         startDissolving: startDissolvingSpy,
         stopDissolving: stopDissolvingSpy,
-        setDissolveTimestamp: setDissolveDelaySpy,
+        increaseDissolveDelay: increaseDissolveDelaySpy,
         getNeuronBalance: getNeuronBalanceSpy,
         refreshNeuron: refreshNeuronSpy,
         claimNeuron: claimNeuronSpy,
@@ -243,18 +243,18 @@ describe("sns-api", () => {
     expect(stopDissolvingSpy).toBeCalled();
   });
 
-  it("should setDissolveDelay", async () => {
-    const dissolveTimestampSeconds = 123;
+  it("should increaseDissolveDelay", async () => {
+    const additionalDissolveDelaySeconds = 123;
     const neuronId = { id: arrayOfNumberToUint8Array([1, 2, 3]) };
-    await setDissolveDelay({
+    await increaseDissolveDelay({
       identity: mockIdentity,
       rootCanisterId: rootCanisterIdMock,
       neuronId,
-      dissolveTimestampSeconds,
+      additionalDissolveDelaySeconds,
     });
 
-    expect(setDissolveDelaySpy).toBeCalledWith({
-      dissolveTimestampSeconds: BigInt(dissolveTimestampSeconds),
+    expect(increaseDissolveDelaySpy).toBeCalledWith({
+      additionalDissolveDelaySeconds: additionalDissolveDelaySeconds,
       neuronId,
     });
   });

frontend/src/tests/lib/modals/sns/neurons/IncreaseSnsDissolveDelayModal.spec.ts

@@ -166,17 +166,16 @@ describe("IncreaseSnsDissolveDelayModal", () => {
     );
 
     expect(confirmButton).toBeDefined();
-    expect(snsGovernanceApi.setDissolveDelay).toBeCalledTimes(0);
+    expect(snsGovernanceApi.increaseDissolveDelay).toBeCalledTimes(0);
 
     confirmButton && (await fireEvent.click(confirmButton));
 
     await waitFor(() =>
-      expect(snsGovernanceApi.setDissolveDelay).toBeCalledTimes(1)
+      expect(snsGovernanceApi.increaseDissolveDelay).toBeCalledTimes(1)
     );
-    expect(snsGovernanceApi.setDissolveDelay).toBeCalledWith(
+    expect(snsGovernanceApi.increaseDissolveDelay).toBeCalledWith(
       expect.objectContaining({
-        dissolveTimestampSeconds:
-          daysToSeconds(increaseDelayDays) + nowInSeconds,
+        additionalDissolveDelaySeconds: daysToSeconds(increaseDelayDays),
       })
     );
   });

frontend/src/tests/lib/services/sns-neurons.services.spec.ts

@@ -32,12 +32,14 @@ import {
 import { mockSnsMainAccount } from "$tests/mocks/sns-accounts.mock";
 import {
   buildMockSnsNeuronsStoreSubscribe,
+  createMockSnsNeuron,
   mockSnsNeuron,
 } from "$tests/mocks/sns-neurons.mock";
 import { mockSnsToken, mockTokenStore } from "$tests/mocks/sns-projects.mock";
 import { resetMockedConstants } from "$tests/utils/mockable-constants.test-utils";
 import { resetSnsProjects, setSnsProjects } from "$tests/utils/sns.test-utils";
 import { decodeIcrcAccount } from "@dfinity/ledger-icrc";
+import { NeuronState } from "@dfinity/nns";
 import { Principal } from "@dfinity/principal";
 import {
   SnsNeuronPermissionType,
@@ -416,36 +418,40 @@ describe("sns-neurons-services", () => {
   });
 
   describe("updateDelay ", () => {
-    let spyOnSetDissolveDelay;
-    const nowInSeconds = 1689063315;
+    let spyOnIncreaseDissolveDelay;
+    const nowInSeconds = 10;
     const now = nowInSeconds * 1000;
-
     beforeEach(() => {
-      spyOnSetDissolveDelay = vi
-        .spyOn(governanceApi, "setDissolveDelay")
+      spyOnIncreaseDissolveDelay = vi
+        .spyOn(governanceApi, "increaseDissolveDelay")
         .mockImplementation(() => Promise.resolve());
       vi.useFakeTimers().setSystemTime(now);
-      spyOnSetDissolveDelay.mockClear();
+      spyOnIncreaseDissolveDelay.mockClear();
     });
 
-    it("should call sns api setDissolveDelay with dissolve timestamp", async () => {
-      const neuronId = fromDefinedNullable(mockSnsNeuron.id);
+    it("should call sns api setDissolveDelay with additional dissolve delay in seconds", async () => {
+      const mockNeuronWithWhenDissolvedTS = createMockSnsNeuron({
+        state: NeuronState.Dissolving,
+        whenDissolvedTimestampSeconds: BigInt(100),
+      });
+
+      const neuronId = fromDefinedNullable(mockNeuronWithWhenDissolvedTS.id);
       const identity = mockIdentity;
       const rootCanisterId = mockPrincipal;
-      const dissolveDelaySeconds = 123;
+      const delayInSeconds = 150;
       const { success } = await updateDelay({
         rootCanisterId,
-        dissolveDelaySeconds,
-        neuron: mockSnsNeuron,
+        dissolveDelaySeconds: delayInSeconds,
+        neuron: mockNeuronWithWhenDissolvedTS,
       });
 
       expect(success).toBeTruthy();
 
-      expect(spyOnSetDissolveDelay).toBeCalledWith({
+      expect(spyOnIncreaseDissolveDelay).toBeCalledWith({
         neuronId,
         identity,
         rootCanisterId,
-        dissolveTimestampSeconds: nowInSeconds + dissolveDelaySeconds,
+        additionalDissolveDelaySeconds: 60,
       });
     });
   });