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

package/dist/candid/sns_governance_test.d.ts

@@ -42,6 +42,10 @@ export interface AddNeuronPermissions {
   permissions_to_add: [] | [NeuronPermissionList];
   principal_id: [] | [Principal];
 }
+export interface AdvanceTargetVersionRequest {
+  target_version: [] | [Version];
+}
+export type AdvanceTargetVersionResponse = {};
 export interface Amount {
   e8s: bigint;
 }
@@ -51,6 +55,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;
@@ -224,11 +233,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];
@@ -241,8 +263,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 {
@@ -541,6 +563,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];
 }
@@ -557,12 +592,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];
@@ -582,6 +656,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];
@@ -593,6 +670,10 @@ export interface WaitForQuietState {
 }
 export interface _SERVICE {
   add_maturity: ActorMethod<[AddMaturityRequest], AddMaturityResponse>;
+  advance_target_version: ActorMethod<
+    [AdvanceTargetVersionRequest],
+    AdvanceTargetVersionResponse
+  >;
   claim_swap_neurons: ActorMethod<
     [ClaimSwapNeuronsRequest],
     ClaimSwapNeuronsResponse
@@ -612,6 +693,11 @@ export interface _SERVICE {
     [{}],
     GetSnsInitializationParametersResponse
   >;
+  get_timers: ActorMethod<[{}], GetTimersResponse>;
+  get_upgrade_journal: ActorMethod<
+    [GetUpgradeJournalRequest],
+    GetUpgradeJournalResponse
+  >;
   list_nervous_system_functions: ActorMethod<
     [],
     ListNervousSystemFunctionsResponse
@@ -620,6 +706,7 @@ export interface _SERVICE {
   list_proposals: ActorMethod<[ListProposals], ListProposalsResponse>;
   manage_neuron: ActorMethod<[ManageNeuron], ManageNeuronResponse>;
   mint_tokens: ActorMethod<[MintTokensRequest], {}>;
+  reset_timers: ActorMethod<[{}], {}>;
   set_mode: ActorMethod<[SetMode], {}>;
   update_neuron: ActorMethod<[Neuron], [] | [GovernanceError]>;
 }

package/dist/candid/sns_governance_test.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_test.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_test.did' by import-candid
 type Account = record {
   owner : opt principal;
   subaccount : opt Subaccount;
@@ -274,6 +274,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 };
@@ -283,6 +289,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;
@@ -293,7 +300,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 {
@@ -703,6 +722,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;
@@ -714,6 +735,66 @@ 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;
+};
+
+type AdvanceTargetVersionRequest = record { target_version : opt Version; };
+type AdvanceTargetVersionResponse = record {};
+
 service : (Governance) -> {
   add_maturity : (AddMaturityRequest) -> (AddMaturityResponse);
   claim_swap_neurons : (ClaimSwapNeuronsRequest) -> (ClaimSwapNeuronsResponse);
@@ -731,6 +812,7 @@ service : (Governance) -> {
   get_sns_initialization_parameters : (record {}) -> (
       GetSnsInitializationParametersResponse,
     ) query;
+  get_upgrade_journal : (GetUpgradeJournalRequest) -> (GetUpgradeJournalResponse) query;
   list_nervous_system_functions : () -> (
       ListNervousSystemFunctionsResponse,
     ) query;
@@ -740,4 +822,7 @@ service : (Governance) -> {
   mint_tokens : (MintTokensRequest) -> (record {});
   set_mode : (SetMode) -> (record {});
   update_neuron : (Neuron) -> (opt GovernanceError);
+  advance_target_version : (AdvanceTargetVersionRequest) -> (AdvanceTargetVersionResponse);
+  reset_timers : (record {}) -> (record {});
+  get_timers : (record {}) -> (GetTimersResponse) query;
 }

package/dist/candid/sns_governance_test.idl.js

@@ -1,5 +1,24 @@
 /* Do not edit.  Compiled with ./scripts/compile-idl-js from packages/sns/candid/sns_governance_test.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 AddMaturityRequest = IDL.Record({
@@ -385,6 +446,10 @@ export const idlFactory = ({ IDL }) => {
   const AddMaturityResponse = IDL.Record({
     'new_maturity_e8s' : IDL.Opt(IDL.Nat64),
   });
+  const AdvanceTargetVersionRequest = IDL.Record({
+    'target_version' : IDL.Opt(Version),
+  });
+  const AdvanceTargetVersionResponse = IDL.Record({});
   const Principals = IDL.Record({ 'principals' : IDL.Vec(IDL.Principal) });
   const NeuronsFund = IDL.Record({
     'nns_neuron_hotkeys' : IDL.Opt(Principals),
@@ -470,6 +535,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),
@@ -552,6 +625,11 @@ export const idlFactory = ({ IDL }) => {
   const SetMode = IDL.Record({ 'mode' : IDL.Int32 });
   return IDL.Service({
     'add_maturity' : IDL.Func([AddMaturityRequest], [AddMaturityResponse], []),
+    'advance_target_version' : IDL.Func(
+        [AdvanceTargetVersionRequest],
+        [AdvanceTargetVersionResponse],
+        [],
+      ),
     'claim_swap_neurons' : IDL.Func(
         [ClaimSwapNeuronsRequest],
         [ClaimSwapNeuronsResponse],
@@ -597,6 +675,12 @@ export const idlFactory = ({ IDL }) => {
         [GetSnsInitializationParametersResponse],
         ['query'],
       ),
+    'get_timers' : IDL.Func([IDL.Record({})], [GetTimersResponse], ['query']),
+    'get_upgrade_journal' : IDL.Func(
+        [GetUpgradeJournalRequest],
+        [GetUpgradeJournalResponse],
+        ['query'],
+      ),
     'list_nervous_system_functions' : IDL.Func(
         [],
         [ListNervousSystemFunctionsResponse],
@@ -610,11 +694,31 @@ export const idlFactory = ({ IDL }) => {
       ),
     'manage_neuron' : IDL.Func([ManageNeuron], [ManageNeuronResponse], []),
     'mint_tokens' : IDL.Func([MintTokensRequest], [IDL.Record({})], []),
+    'reset_timers' : IDL.Func([IDL.Record({})], [IDL.Record({})], []),
     'set_mode' : IDL.Func([SetMode], [IDL.Record({})], []),
     'update_neuron' : IDL.Func([Neuron], [IDL.Opt(GovernanceError)], []),
   });
 };
 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),
@@ -660,6 +764,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({
@@ -696,15 +848,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,
@@ -972,11 +1115,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),
@@ -989,8 +1135,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_root.certified.idl.js

@@ -1,7 +1,13 @@
 /* Do not edit.  Compiled with ./scripts/compile-idl-js from packages/sns/candid/sns_root.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 SnsRootCanister = IDL.Record({
     'dapp_canister_ids' : IDL.Vec(IDL.Principal),
+    'timers' : IDL.Opt(Timers),
     'testflight' : IDL.Bool,
     'archive_canister_ids' : IDL.Vec(IDL.Principal),
     'governance_canister_id' : IDL.Opt(IDL.Principal),
@@ -82,6 +88,7 @@ export const idlFactory = ({ IDL }) => {
     'dapps' : IDL.Vec(CanisterSummary),
     'archives' : IDL.Vec(CanisterSummary),
   });
+  const GetTimersResponse = IDL.Record({ 'timers' : IDL.Opt(Timers) });
   const ListSnsCanistersResponse = IDL.Record({
     'root' : IDL.Opt(IDL.Principal),
     'swap' : IDL.Opt(IDL.Principal),
@@ -137,6 +144,7 @@ export const idlFactory = ({ IDL }) => {
         [GetSnsCanistersSummaryResponse],
         [],
       ),
+    'get_timers' : IDL.Func([IDL.Record({})], [GetTimersResponse], []),
     'list_sns_canisters' : IDL.Func(
         [IDL.Record({})],
         [ListSnsCanistersResponse],
@@ -157,6 +165,7 @@ export const idlFactory = ({ IDL }) => {
         [IDL.Record({})],
         [],
       ),
+    'reset_timers' : IDL.Func([IDL.Record({})], [IDL.Record({})], []),
     'set_dapp_controllers' : IDL.Func(
         [SetDappControllersRequest],
         [SetDappControllersResponse],
@@ -165,8 +174,14 @@ export const idlFactory = ({ IDL }) => {
   });
 };
 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 SnsRootCanister = IDL.Record({
     'dapp_canister_ids' : IDL.Vec(IDL.Principal),
+    'timers' : IDL.Opt(Timers),
     'testflight' : IDL.Bool,
     'archive_canister_ids' : IDL.Vec(IDL.Principal),
     'governance_canister_id' : IDL.Opt(IDL.Principal),

package/dist/candid/sns_root.d.ts

@@ -79,6 +79,9 @@ export interface GetSnsCanistersSummaryResponse {
   dapps: Array<CanisterSummary>;
   archives: Array<CanisterSummary>;
 }
+export interface GetTimersResponse {
+  timers: [] | [Timers];
+}
 export interface ListSnsCanistersResponse {
   root: [] | [Principal];
   swap: [] | [Principal];
@@ -116,6 +119,7 @@ export interface SetDappControllersResponse {
 }
 export interface SnsRootCanister {
   dapp_canister_ids: Array<Principal>;
+  timers: [] | [Timers];
   testflight: boolean;
   archive_canister_ids: Array<Principal>;
   governance_canister_id: [] | [Principal];
@@ -123,6 +127,11 @@ export interface SnsRootCanister {
   swap_canister_id: [] | [Principal];
   ledger_canister_id: [] | [Principal];
 }
+export interface Timers {
+  last_spawned_timestamp_seconds: [] | [bigint];
+  last_reset_timestamp_seconds: [] | [bigint];
+  requires_periodic_tasks: [] | [boolean];
+}
 export interface _SERVICE {
   canister_status: ActorMethod<[CanisterIdRecord], CanisterStatusResult>;
   change_canister: ActorMethod<[ChangeCanisterRequest], undefined>;
@@ -131,6 +140,7 @@ export interface _SERVICE {
     [GetSnsCanistersSummaryRequest],
     GetSnsCanistersSummaryResponse
   >;
+  get_timers: ActorMethod<[{}], GetTimersResponse>;
   list_sns_canisters: ActorMethod<[{}], ListSnsCanistersResponse>;
   manage_dapp_canister_settings: ActorMethod<
     [ManageDappCanisterSettingsRequest],
@@ -138,6 +148,7 @@ export interface _SERVICE {
   >;
   register_dapp_canister: ActorMethod<[RegisterDappCanisterRequest], {}>;
   register_dapp_canisters: ActorMethod<[RegisterDappCanistersRequest], {}>;
+  reset_timers: ActorMethod<[{}], {}>;
   set_dapp_controllers: ActorMethod<
     [SetDappControllersRequest],
     SetDappControllersResponse