NNS1-3270 fix set dissolve delay

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,
  });
  });
  });