@dfinity/sns 3.2.2 → 3.2.3-next-2024-11-14

package/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2021 DFINITY LLC.
+   Copyright 2021 DFINITY Stiftung.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/dist/candid/sns_governance.certified.idl.js

@@ -1,5 +1,24 @@
 /* Do not edit.  Compiled with ./scripts/compile-idl-js from packages/sns/candid/sns_governance.did */
 export const idlFactory = ({ IDL }) => {
+  const Timers = IDL.Record({
+    'last_spawned_timestamp_seconds' : IDL.Opt(IDL.Nat64),
+    'last_reset_timestamp_seconds' : IDL.Opt(IDL.Nat64),
+    'requires_periodic_tasks' : IDL.Opt(IDL.Bool),
+  });
+  const Version = IDL.Record({
+    'archive_wasm_hash' : IDL.Vec(IDL.Nat8),
+    'root_wasm_hash' : IDL.Vec(IDL.Nat8),
+    'swap_wasm_hash' : IDL.Vec(IDL.Nat8),
+    'ledger_wasm_hash' : IDL.Vec(IDL.Nat8),
+    'governance_wasm_hash' : IDL.Vec(IDL.Nat8),
+    'index_wasm_hash' : IDL.Vec(IDL.Nat8),
+  });
+  const Versions = IDL.Record({ 'versions' : IDL.Vec(Version) });
+  const CachedUpgradeSteps = IDL.Record({
+    'upgrade_steps' : IDL.Opt(Versions),
+    'response_timestamp_seconds' : IDL.Opt(IDL.Nat64),
+    'requested_timestamp_seconds' : IDL.Opt(IDL.Nat64),
+  });
   const GenericNervousSystemFunction = IDL.Record({
     'validator_canister_id' : IDL.Opt(IDL.Principal),
     'target_canister_id' : IDL.Opt(IDL.Principal),
@@ -45,6 +64,54 @@ export const idlFactory = ({ IDL }) => {
     'current_basis_points' : IDL.Opt(IDL.Int32),
     'updated_at_timestamp_seconds' : IDL.Opt(IDL.Nat64),
   });
+  const TargetVersionSet = IDL.Record({
+    'old_target_version' : IDL.Opt(Version),
+    'new_target_version' : IDL.Opt(Version),
+  });
+  const UpgradeOutcome = IDL.Record({
+    'status' : IDL.Opt(
+      IDL.Variant({
+        'Success' : IDL.Record({}),
+        'Timeout' : IDL.Record({}),
+        'ExternalFailure' : IDL.Record({}),
+        'InvalidState' : IDL.Record({ 'version' : IDL.Opt(Version) }),
+      })
+    ),
+    'human_readable' : IDL.Opt(IDL.Text),
+  });
+  const ProposalId = IDL.Record({ 'id' : IDL.Nat64 });
+  const UpgradeStarted = IDL.Record({
+    'current_version' : IDL.Opt(Version),
+    'expected_version' : IDL.Opt(Version),
+    'reason' : IDL.Opt(
+      IDL.Variant({
+        'UpgradeSnsToNextVersionProposal' : ProposalId,
+        'BehindTargetVersion' : IDL.Record({}),
+      })
+    ),
+  });
+  const UpgradeStepsRefreshed = IDL.Record({
+    'upgrade_steps' : IDL.Opt(Versions),
+  });
+  const TargetVersionReset = IDL.Record({
+    'old_target_version' : IDL.Opt(Version),
+    'new_target_version' : IDL.Opt(Version),
+  });
+  const UpgradeJournalEntry = IDL.Record({
+    'event' : IDL.Opt(
+      IDL.Variant({
+        'TargetVersionSet' : TargetVersionSet,
+        'UpgradeOutcome' : UpgradeOutcome,
+        'UpgradeStarted' : UpgradeStarted,
+        'UpgradeStepsRefreshed' : UpgradeStepsRefreshed,
+        'TargetVersionReset' : TargetVersionReset,
+      })
+    ),
+    'timestamp_seconds' : IDL.Opt(IDL.Nat64),
+  });
+  const UpgradeJournal = IDL.Record({
+    'entries' : IDL.Vec(UpgradeJournalEntry),
+  });
   const NeuronId = IDL.Record({ 'id' : IDL.Vec(IDL.Nat8) });
   const Followees = IDL.Record({ 'followees' : IDL.Vec(NeuronId) });
   const DefaultFollowees = IDL.Record({
@@ -81,15 +148,6 @@ export const idlFactory = ({ IDL }) => {
     'maturity_modulation_disabled' : IDL.Opt(IDL.Bool),
     'max_number_of_principals_per_neuron' : IDL.Opt(IDL.Nat64),
   });
-  const Version = IDL.Record({
-    'archive_wasm_hash' : IDL.Vec(IDL.Nat8),
-    'root_wasm_hash' : IDL.Vec(IDL.Nat8),
-    'swap_wasm_hash' : IDL.Vec(IDL.Nat8),
-    'ledger_wasm_hash' : IDL.Vec(IDL.Nat8),
-    'governance_wasm_hash' : IDL.Vec(IDL.Nat8),
-    'index_wasm_hash' : IDL.Vec(IDL.Nat8),
-  });
-  const ProposalId = IDL.Record({ 'id' : IDL.Nat64 });
   const RewardEvent = IDL.Record({
     'rounds_since_last_distribution' : IDL.Opt(IDL.Nat64),
     'actual_timestamp_seconds' : IDL.Nat64,
@@ -357,11 +415,14 @@ export const idlFactory = ({ IDL }) => {
   });
   const Governance = IDL.Record({
     'root_canister_id' : IDL.Opt(IDL.Principal),
+    'timers' : IDL.Opt(Timers),
+    'cached_upgrade_steps' : IDL.Opt(CachedUpgradeSteps),
     'id_to_nervous_system_functions' : IDL.Vec(
       IDL.Tuple(IDL.Nat64, NervousSystemFunction)
     ),
     'metrics' : IDL.Opt(GovernanceCachedMetrics),
     'maturity_modulation' : IDL.Opt(MaturityModulation),
+    'upgrade_journal' : IDL.Opt(UpgradeJournal),
     'mode' : IDL.Int32,
     'parameters' : IDL.Opt(NervousSystemParameters),
     'is_finalizing_disburse_maturity' : IDL.Opt(IDL.Bool),
@@ -374,8 +435,8 @@ export const idlFactory = ({ IDL }) => {
     'proposals' : IDL.Vec(IDL.Tuple(IDL.Nat64, ProposalData)),
     'in_flight_commands' : IDL.Vec(IDL.Tuple(IDL.Text, NeuronInFlightCommand)),
     'sns_metadata' : IDL.Opt(ManageSnsMetadata),
-    'migrated_root_wasm_memory_limit' : IDL.Opt(IDL.Bool),
     'neurons' : IDL.Vec(IDL.Tuple(IDL.Text, Neuron)),
+    'target_version' : IDL.Opt(Version),
     'genesis_timestamp_seconds' : IDL.Nat64,
   });
   const Principals = IDL.Record({ 'principals' : IDL.Vec(IDL.Principal) });
@@ -463,6 +524,14 @@ export const idlFactory = ({ IDL }) => {
   const GetSnsInitializationParametersResponse = IDL.Record({
     'sns_initialization_parameters' : IDL.Text,
   });
+  const GetTimersResponse = IDL.Record({ 'timers' : IDL.Opt(Timers) });
+  const GetUpgradeJournalRequest = IDL.Record({});
+  const GetUpgradeJournalResponse = IDL.Record({
+    'upgrade_journal' : IDL.Opt(UpgradeJournal),
+    'upgrade_steps' : IDL.Opt(Versions),
+    'response_timestamp_seconds' : IDL.Opt(IDL.Nat64),
+    'target_version' : IDL.Opt(Version),
+  });
   const ListNervousSystemFunctionsResponse = IDL.Record({
     'reserved_ids' : IDL.Vec(IDL.Nat64),
     'functions' : IDL.Vec(NervousSystemFunction),
@@ -581,6 +650,12 @@ export const idlFactory = ({ IDL }) => {
         [GetSnsInitializationParametersResponse],
         [],
       ),
+    'get_timers' : IDL.Func([IDL.Record({})], [GetTimersResponse], []),
+    'get_upgrade_journal' : IDL.Func(
+        [GetUpgradeJournalRequest],
+        [GetUpgradeJournalResponse],
+        [],
+      ),
     'list_nervous_system_functions' : IDL.Func(
         [],
         [ListNervousSystemFunctionsResponse],
@@ -589,10 +664,30 @@ export const idlFactory = ({ IDL }) => {
     'list_neurons' : IDL.Func([ListNeurons], [ListNeuronsResponse], []),
     'list_proposals' : IDL.Func([ListProposals], [ListProposalsResponse], []),
     'manage_neuron' : IDL.Func([ManageNeuron], [ManageNeuronResponse], []),
+    'reset_timers' : IDL.Func([IDL.Record({})], [IDL.Record({})], []),
     'set_mode' : IDL.Func([SetMode], [IDL.Record({})], []),
   });
 };
 export const init = ({ IDL }) => {
+  const Timers = IDL.Record({
+    'last_spawned_timestamp_seconds' : IDL.Opt(IDL.Nat64),
+    'last_reset_timestamp_seconds' : IDL.Opt(IDL.Nat64),
+    'requires_periodic_tasks' : IDL.Opt(IDL.Bool),
+  });
+  const Version = IDL.Record({
+    'archive_wasm_hash' : IDL.Vec(IDL.Nat8),
+    'root_wasm_hash' : IDL.Vec(IDL.Nat8),
+    'swap_wasm_hash' : IDL.Vec(IDL.Nat8),
+    'ledger_wasm_hash' : IDL.Vec(IDL.Nat8),
+    'governance_wasm_hash' : IDL.Vec(IDL.Nat8),
+    'index_wasm_hash' : IDL.Vec(IDL.Nat8),
+  });
+  const Versions = IDL.Record({ 'versions' : IDL.Vec(Version) });
+  const CachedUpgradeSteps = IDL.Record({
+    'upgrade_steps' : IDL.Opt(Versions),
+    'response_timestamp_seconds' : IDL.Opt(IDL.Nat64),
+    'requested_timestamp_seconds' : IDL.Opt(IDL.Nat64),
+  });
   const GenericNervousSystemFunction = IDL.Record({
     'validator_canister_id' : IDL.Opt(IDL.Principal),
     'target_canister_id' : IDL.Opt(IDL.Principal),
@@ -638,6 +733,54 @@ export const init = ({ IDL }) => {
     'current_basis_points' : IDL.Opt(IDL.Int32),
     'updated_at_timestamp_seconds' : IDL.Opt(IDL.Nat64),
   });
+  const TargetVersionSet = IDL.Record({
+    'old_target_version' : IDL.Opt(Version),
+    'new_target_version' : IDL.Opt(Version),
+  });
+  const UpgradeOutcome = IDL.Record({
+    'status' : IDL.Opt(
+      IDL.Variant({
+        'Success' : IDL.Record({}),
+        'Timeout' : IDL.Record({}),
+        'ExternalFailure' : IDL.Record({}),
+        'InvalidState' : IDL.Record({ 'version' : IDL.Opt(Version) }),
+      })
+    ),
+    'human_readable' : IDL.Opt(IDL.Text),
+  });
+  const ProposalId = IDL.Record({ 'id' : IDL.Nat64 });
+  const UpgradeStarted = IDL.Record({
+    'current_version' : IDL.Opt(Version),
+    'expected_version' : IDL.Opt(Version),
+    'reason' : IDL.Opt(
+      IDL.Variant({
+        'UpgradeSnsToNextVersionProposal' : ProposalId,
+        'BehindTargetVersion' : IDL.Record({}),
+      })
+    ),
+  });
+  const UpgradeStepsRefreshed = IDL.Record({
+    'upgrade_steps' : IDL.Opt(Versions),
+  });
+  const TargetVersionReset = IDL.Record({
+    'old_target_version' : IDL.Opt(Version),
+    'new_target_version' : IDL.Opt(Version),
+  });
+  const UpgradeJournalEntry = IDL.Record({
+    'event' : IDL.Opt(
+      IDL.Variant({
+        'TargetVersionSet' : TargetVersionSet,
+        'UpgradeOutcome' : UpgradeOutcome,
+        'UpgradeStarted' : UpgradeStarted,
+        'UpgradeStepsRefreshed' : UpgradeStepsRefreshed,
+        'TargetVersionReset' : TargetVersionReset,
+      })
+    ),
+    'timestamp_seconds' : IDL.Opt(IDL.Nat64),
+  });
+  const UpgradeJournal = IDL.Record({
+    'entries' : IDL.Vec(UpgradeJournalEntry),
+  });
   const NeuronId = IDL.Record({ 'id' : IDL.Vec(IDL.Nat8) });
   const Followees = IDL.Record({ 'followees' : IDL.Vec(NeuronId) });
   const DefaultFollowees = IDL.Record({
@@ -674,15 +817,6 @@ export const init = ({ IDL }) => {
     'maturity_modulation_disabled' : IDL.Opt(IDL.Bool),
     'max_number_of_principals_per_neuron' : IDL.Opt(IDL.Nat64),
   });
-  const Version = IDL.Record({
-    'archive_wasm_hash' : IDL.Vec(IDL.Nat8),
-    'root_wasm_hash' : IDL.Vec(IDL.Nat8),
-    'swap_wasm_hash' : IDL.Vec(IDL.Nat8),
-    'ledger_wasm_hash' : IDL.Vec(IDL.Nat8),
-    'governance_wasm_hash' : IDL.Vec(IDL.Nat8),
-    'index_wasm_hash' : IDL.Vec(IDL.Nat8),
-  });
-  const ProposalId = IDL.Record({ 'id' : IDL.Nat64 });
   const RewardEvent = IDL.Record({
     'rounds_since_last_distribution' : IDL.Opt(IDL.Nat64),
     'actual_timestamp_seconds' : IDL.Nat64,
@@ -950,11 +1084,14 @@ export const init = ({ IDL }) => {
   });
   const Governance = IDL.Record({
     'root_canister_id' : IDL.Opt(IDL.Principal),
+    'timers' : IDL.Opt(Timers),
+    'cached_upgrade_steps' : IDL.Opt(CachedUpgradeSteps),
     'id_to_nervous_system_functions' : IDL.Vec(
       IDL.Tuple(IDL.Nat64, NervousSystemFunction)
     ),
     'metrics' : IDL.Opt(GovernanceCachedMetrics),
     'maturity_modulation' : IDL.Opt(MaturityModulation),
+    'upgrade_journal' : IDL.Opt(UpgradeJournal),
     'mode' : IDL.Int32,
     'parameters' : IDL.Opt(NervousSystemParameters),
     'is_finalizing_disburse_maturity' : IDL.Opt(IDL.Bool),
@@ -967,8 +1104,8 @@ export const init = ({ IDL }) => {
     'proposals' : IDL.Vec(IDL.Tuple(IDL.Nat64, ProposalData)),
     'in_flight_commands' : IDL.Vec(IDL.Tuple(IDL.Text, NeuronInFlightCommand)),
     'sns_metadata' : IDL.Opt(ManageSnsMetadata),
-    'migrated_root_wasm_memory_limit' : IDL.Opt(IDL.Bool),
     'neurons' : IDL.Vec(IDL.Tuple(IDL.Text, Neuron)),
+    'target_version' : IDL.Opt(Version),
     'genesis_timestamp_seconds' : IDL.Nat64,
   });
   return [Governance];

package/dist/candid/sns_governance.d.ts

@@ -44,6 +44,11 @@ export interface Ballot {
   voting_power: bigint;
 }
 export type By = { MemoAndController: MemoAndController } | { NeuronId: {} };
+export interface CachedUpgradeSteps {
+  upgrade_steps: [] | [Versions];
+  response_timestamp_seconds: [] | [bigint];
+  requested_timestamp_seconds: [] | [bigint];
+}
 export interface CanisterStatusResultV2 {
   status: CanisterStatusType;
   memory_size: bigint;
@@ -217,11 +222,24 @@ export interface GetRunningSnsVersionResponse {
 export interface GetSnsInitializationParametersResponse {
   sns_initialization_parameters: string;
 }
+export interface GetTimersResponse {
+  timers: [] | [Timers];
+}
+export type GetUpgradeJournalRequest = {};
+export interface GetUpgradeJournalResponse {
+  upgrade_journal: [] | [UpgradeJournal];
+  upgrade_steps: [] | [Versions];
+  response_timestamp_seconds: [] | [bigint];
+  target_version: [] | [Version];
+}
 export interface Governance {
   root_canister_id: [] | [Principal];
+  timers: [] | [Timers];
+  cached_upgrade_steps: [] | [CachedUpgradeSteps];
   id_to_nervous_system_functions: Array<[bigint, NervousSystemFunction]>;
   metrics: [] | [GovernanceCachedMetrics];
   maturity_modulation: [] | [MaturityModulation];
+  upgrade_journal: [] | [UpgradeJournal];
   mode: number;
   parameters: [] | [NervousSystemParameters];
   is_finalizing_disburse_maturity: [] | [boolean];
@@ -234,8 +252,8 @@ export interface Governance {
   proposals: Array<[bigint, ProposalData]>;
   in_flight_commands: Array<[string, NeuronInFlightCommand]>;
   sns_metadata: [] | [ManageSnsMetadata];
-  migrated_root_wasm_memory_limit: [] | [boolean];
   neurons: Array<[string, Neuron]>;
+  target_version: [] | [Version];
   genesis_timestamp_seconds: bigint;
 }
 export interface GovernanceCachedMetrics {
@@ -530,6 +548,19 @@ export interface Tally {
   total: bigint;
   timestamp_seconds: bigint;
 }
+export interface TargetVersionReset {
+  old_target_version: [] | [Version];
+  new_target_version: [] | [Version];
+}
+export interface TargetVersionSet {
+  old_target_version: [] | [Version];
+  new_target_version: [] | [Version];
+}
+export interface Timers {
+  last_spawned_timestamp_seconds: [] | [bigint];
+  last_reset_timestamp_seconds: [] | [bigint];
+  requires_periodic_tasks: [] | [boolean];
+}
 export interface Tokens {
   e8s: [] | [bigint];
 }
@@ -546,12 +577,51 @@ export interface UpgradeInProgress {
   proposal_id: bigint;
   target_version: [] | [Version];
 }
+export interface UpgradeJournal {
+  entries: Array<UpgradeJournalEntry>;
+}
+export interface UpgradeJournalEntry {
+  event:
+    | []
+    | [
+        | { TargetVersionSet: TargetVersionSet }
+        | { UpgradeOutcome: UpgradeOutcome }
+        | { UpgradeStarted: UpgradeStarted }
+        | { UpgradeStepsRefreshed: UpgradeStepsRefreshed }
+        | { TargetVersionReset: TargetVersionReset },
+      ];
+  timestamp_seconds: [] | [bigint];
+}
+export interface UpgradeOutcome {
+  status:
+    | []
+    | [
+        | { Success: {} }
+        | { Timeout: {} }
+        | { ExternalFailure: {} }
+        | { InvalidState: { version: [] | [Version] } },
+      ];
+  human_readable: [] | [string];
+}
 export interface UpgradeSnsControlledCanister {
   new_canister_wasm: Uint8Array | number[];
   mode: [] | [number];
   canister_id: [] | [Principal];
   canister_upgrade_arg: [] | [Uint8Array | number[]];
 }
+export interface UpgradeStarted {
+  current_version: [] | [Version];
+  expected_version: [] | [Version];
+  reason:
+    | []
+    | [
+        | { UpgradeSnsToNextVersionProposal: ProposalId }
+        | { BehindTargetVersion: {} },
+      ];
+}
+export interface UpgradeStepsRefreshed {
+  upgrade_steps: [] | [Versions];
+}
 export interface Valuation {
   token: [] | [number];
   account: [] | [Account];
@@ -571,6 +641,9 @@ export interface Version {
   governance_wasm_hash: Uint8Array | number[];
   index_wasm_hash: Uint8Array | number[];
 }
+export interface Versions {
+  versions: Array<Version>;
+}
 export interface VotingRewardsParameters {
   final_reward_rate_basis_points: [] | [bigint];
   initial_reward_rate_basis_points: [] | [bigint];
@@ -600,6 +673,11 @@ export interface _SERVICE {
     [{}],
     GetSnsInitializationParametersResponse
   >;
+  get_timers: ActorMethod<[{}], GetTimersResponse>;
+  get_upgrade_journal: ActorMethod<
+    [GetUpgradeJournalRequest],
+    GetUpgradeJournalResponse
+  >;
   list_nervous_system_functions: ActorMethod<
     [],
     ListNervousSystemFunctionsResponse
@@ -607,6 +685,7 @@ export interface _SERVICE {
   list_neurons: ActorMethod<[ListNeurons], ListNeuronsResponse>;
   list_proposals: ActorMethod<[ListProposals], ListProposalsResponse>;
   manage_neuron: ActorMethod<[ManageNeuron], ManageNeuronResponse>;
+  reset_timers: ActorMethod<[{}], {}>;
   set_mode: ActorMethod<[SetMode], {}>;
 }
 export declare const idlFactory: IDL.InterfaceFactory;

package/dist/candid/sns_governance.did

@@ -1,4 +1,4 @@
-// Generated from IC repo commit c43a488 (2024-09-27 tags: release-2024-09-26_01-31-no-canister-snapshots) 'rs/sns/governance/canister/governance.did' by import-candid
+// Generated from IC repo commit c47e172 (2024-10-25 tags: release-2024-11-07_03-07-6.11-kernel) 'rs/sns/governance/canister/governance.did' by import-candid
 type Account = record {
   owner : opt principal;
   subaccount : opt Subaccount;
@@ -265,6 +265,12 @@ type GetSnsInitializationParametersResponse = record {
   sns_initialization_parameters : text;
 };
 
+type CachedUpgradeSteps = record {
+  upgrade_steps : opt Versions;
+  requested_timestamp_seconds : opt nat64;
+  response_timestamp_seconds : opt nat64;
+};
+
 type Governance = record {
   root_canister_id : opt principal;
   id_to_nervous_system_functions : vec record { nat64; NervousSystemFunction };
@@ -274,6 +280,7 @@ type Governance = record {
   parameters : opt NervousSystemParameters;
   is_finalizing_disburse_maturity : opt bool;
   deployed_version : opt Version;
+  cached_upgrade_steps : opt CachedUpgradeSteps;
   sns_initialization_parameters : text;
   latest_reward_event : opt RewardEvent;
   pending_version : opt UpgradeInProgress;
@@ -284,7 +291,19 @@ type Governance = record {
   sns_metadata : opt ManageSnsMetadata;
   neurons : vec record { text; Neuron };
   genesis_timestamp_seconds : nat64;
-  migrated_root_wasm_memory_limit : opt bool;
+  target_version : opt Version;
+  timers : opt Timers;
+  upgrade_journal : opt UpgradeJournal;
+};
+
+type Timers = record {
+  requires_periodic_tasks : opt bool;
+  last_reset_timestamp_seconds : opt nat64;
+  last_spawned_timestamp_seconds : opt nat64;
+};
+
+type GetTimersResponse = record {
+  timers : opt Timers;
 };
 
 type GovernanceCachedMetrics = record {
@@ -689,6 +708,8 @@ type Version = record {
   index_wasm_hash : blob;
 };
 
+type Versions = record { versions : vec Version };
+
 type VotingRewardsParameters = record {
   final_reward_rate_basis_points : opt nat64;
   initial_reward_rate_basis_points : opt nat64;
@@ -700,6 +721,63 @@ type WaitForQuietState = record {
   current_deadline_timestamp_seconds : nat64;
 };
 
+type UpgradeJournalEntry = record {
+  event : opt variant {
+    UpgradeStepsRefreshed : UpgradeStepsRefreshed;
+    TargetVersionSet : TargetVersionSet;
+    TargetVersionReset : TargetVersionReset;
+    UpgradeStarted : UpgradeStarted;
+    UpgradeOutcome : UpgradeOutcome;
+  };
+  timestamp_seconds : opt nat64;
+};
+
+type UpgradeStepsRefreshed = record {
+  upgrade_steps : opt Versions;
+};
+
+type TargetVersionSet = record {
+  new_target_version : opt Version;
+  old_target_version : opt Version;
+};
+
+type TargetVersionReset = record {
+  new_target_version : opt Version;
+  old_target_version : opt Version;
+};
+
+type UpgradeStarted = record {
+  current_version : opt Version;
+  expected_version : opt Version;
+  reason : opt variant {
+    UpgradeSnsToNextVersionProposal : ProposalId;
+    BehindTargetVersion : record {};
+  }
+};
+
+type UpgradeOutcome = record {
+  human_readable : opt text;
+  status : opt variant {
+    Success : record {};
+    Timeout : record {};
+    InvalidState : record { version : opt Version };
+    ExternalFailure : record {};
+  };
+};
+
+type UpgradeJournal = record {
+  entries : vec UpgradeJournalEntry;
+};
+
+type GetUpgradeJournalRequest = record {};
+
+type GetUpgradeJournalResponse = record {
+  upgrade_steps : opt Versions;
+  response_timestamp_seconds : opt nat64;
+  target_version : opt Version;
+  upgrade_journal : opt UpgradeJournal;
+};
+
 service : (Governance) -> {
   claim_swap_neurons : (ClaimSwapNeuronsRequest) -> (ClaimSwapNeuronsResponse);
   fail_stuck_upgrade_in_progress : (record {}) -> (record {});
@@ -713,14 +791,13 @@ service : (Governance) -> {
   get_proposal : (GetProposal) -> (GetProposalResponse) query;
   get_root_canister_status : (null) -> (CanisterStatusResultV2);
   get_running_sns_version : (record {}) -> (GetRunningSnsVersionResponse) query;
-  get_sns_initialization_parameters : (record {}) -> (
-      GetSnsInitializationParametersResponse,
-    ) query;
-  list_nervous_system_functions : () -> (
-      ListNervousSystemFunctionsResponse,
-    ) query;
+  get_sns_initialization_parameters : (record {}) -> (GetSnsInitializationParametersResponse) query;
+  get_upgrade_journal : (GetUpgradeJournalRequest) -> (GetUpgradeJournalResponse) query;
+  list_nervous_system_functions : () -> (ListNervousSystemFunctionsResponse) query;
   list_neurons : (ListNeurons) -> (ListNeuronsResponse) query;
   list_proposals : (ListProposals) -> (ListProposalsResponse) query;
   manage_neuron : (ManageNeuron) -> (ManageNeuronResponse);
   set_mode : (SetMode) -> (record {});
+  reset_timers : (record {}) -> (record {});
+  get_timers : (record {}) -> (GetTimersResponse) query;
 }