@ohos-ports/azle 0.33.0-beta.0

package/src/stable/lib/canisters/nns_cycles_minting/idl/README.md

@@ -0,0 +1,9 @@
+- `index.did` manual Candid source: https://dashboard.internetcomputer.org/canister/rkp4c-7iaaa-aaaaa-aaaca-cai
+- Licensing is assumed to be that described in ../../NOTICE
+
+# How to update the IDL and TypeScript types
+
+1. Go to the URL above
+2. Find the Candid on that page and copy it
+3. Paste the Candid into `index.did`
+4. From this directory run `npx azle generate index.did > index.ts`

package/src/stable/lib/canisters/nns_cycles_minting/idl/index.did

@@ -0,0 +1,241 @@
+type Cycles = nat;
+type BlockIndex = nat64;
+type log_visibility = variant {
+  controllers;
+  public;
+};
+type CanisterSettings = record {
+  controllers : opt vec principal;
+  compute_allocation : opt nat;
+  memory_allocation : opt nat;
+  freezing_threshold : opt nat;
+  reserved_cycles_limit : opt nat;
+  log_visibility : opt log_visibility;
+  wasm_memory_limit : opt nat;
+  wasm_memory_threshold : opt nat;
+};
+type Subaccount = opt blob;
+type Memo = opt blob;
+
+// The argument of the [notify_top_up] method.
+type NotifyTopUpArg = record {
+  // Index of the block on the ICP ledger that contains the payment.
+  block_index : BlockIndex;
+
+  // The canister to top up.
+  canister_id : principal;
+};
+
+type SubnetSelection = variant {
+  /// Choose a specific subnet
+  Subnet : record {
+    subnet : principal;
+  };
+  /// Choose a random subnet that fulfills the specified properties
+  Filter : SubnetFilter;
+};
+
+type SubnetFilter = record {
+  subnet_type : opt text;
+};
+
+// The argument of the [create_canister] method.
+type CreateCanisterArg = record {
+  // Optional canister settings that, if set, are applied to the newly created canister.
+  // If not specified, the caller is the controller of the canister and the other settings are set to default values.
+  settings : opt CanisterSettings;
+
+  // An optional subnet type that, if set, determines what type of subnet
+  // the new canister will be created on.
+  // Deprecated. Use subnet_selection instead.
+  subnet_type : opt text;
+
+  // Optional instructions to select on which subnet the new canister will be created on.
+  subnet_selection : opt SubnetSelection;
+};
+
+// The argument of the [notify_create_canister] method.
+type NotifyCreateCanisterArg = record {
+  // Index of the block on the ICP ledger that contains the payment.
+  block_index : BlockIndex;
+
+  // The controller of canister to create.
+  controller : principal;
+
+  // An optional subnet type that, if set, determines what type of subnet
+  // the new canister will be created on.
+  // Deprecated. Use subnet_selection instead.
+  subnet_type : opt text;
+
+  // Optional instructions to select on which subnet the new canister will be created on.
+  // vec may contain no more than one element.
+  subnet_selection : opt SubnetSelection;
+
+  // Optional canister settings that, if set, are applied to the newly created canister.
+  // If not specified, the caller is the controller of the canister and the other settings are set to default values.
+  settings : opt CanisterSettings;
+};
+
+// Canister creation failed and the cycles attached to the call were returned to the calling canister.
+// A small fee may be charged.
+type CreateCanisterError = variant {
+  Refunded : record {
+    // The amount of cycles returned to the calling canister
+    refund_amount : nat;
+
+    // The reason why creating a canister failed.
+    create_error : text;
+  };
+};
+
+type NotifyError = variant {
+  // The payment processing failed and the payment was returned the caller.
+  // This is a non-retriable error.
+  Refunded : record {
+    // The reason for the refund.
+    reason : text;
+    // The index of the block containing the refund.
+    block_index : opt BlockIndex;
+  };
+
+  // The same payment is already being processed by a concurrent request.
+  // This is a retriable error.
+  Processing;
+
+  // The payment was too old to be processed.
+  // The value of the variant is the oldest block index that can still be processed.
+  // This a non-retriable error.
+  TransactionTooOld : BlockIndex;
+
+  // The transaction does not satisfy the cycle minting canister payment protocol.
+  // The text contains the description of the problem.
+  // This is a non-retriable error.
+  InvalidTransaction : text;
+
+  // Other error.
+  Other : record { error_code : nat64; error_message : text };
+};
+
+type NotifyTopUpResult = variant {
+  // The amount of cycles sent to the specified canister.
+  Ok : Cycles;
+  Err : NotifyError;
+};
+
+type CreateCanisterResult = variant {
+  // The principal of the newly created canister.
+  Ok : principal;
+  Err : CreateCanisterError;
+};
+
+type NotifyCreateCanisterResult = variant {
+  // The principal of the newly created canister.
+  Ok : principal;
+  Err : NotifyError;
+};
+
+type IcpXdrConversionRate = record {
+  // The time for which the market data was queried, expressed in UNIX epoch
+  // time in seconds.
+  timestamp_seconds : nat64;
+
+  // The number of 10,000ths of IMF SDR (currency code XDR) that corresponds
+  // to 1 ICP. This value reflects the current market price of one ICP token.
+  xdr_permyriad_per_icp : nat64;
+};
+
+type IcpXdrConversionRateResponse = record {
+  // The latest ICP/XDR conversion rate.
+  data : IcpXdrConversionRate;
+
+  // CBOR-serialized hash tree as specified in
+  // https://internetcomputer.org/docs/interface-spec/index.html#certification-encoding
+  // The hash tree is used for certification and hash the following structure:
+  // ```
+  // *
+  // |
+  // +-- ICP_XDR_CONVERSION_RATE -- [ Candid encoded IcpXdrConversionRate ]
+  // |
+  // `-- AVERAGE_ICP_XDR_CONVERSION_RATE -- [ Candid encoded IcpXdrConversionRate ]
+  // ```
+  hash_tree : blob;
+
+  // System certificate as specified in
+  // https://internetcomputer.org/docs/interface-spec/index.html#certification-encoding
+  certificate : blob;
+};
+
+type SubnetTypesToSubnetsResponse = record {
+  data : vec record { text; vec principal };
+};
+
+type PrincipalsAuthorizedToCreateCanistersToSubnetsResponse = record {
+  data : vec record { principal; vec principal };
+};
+
+type AccountIdentifier = text;
+
+type ExchangeRateCanister = variant {
+  /// Enables the exchange rate canister with the given canister ID.
+  Set : principal;
+  /// Disable the exchange rate canister.
+  Unset;
+};
+
+type CyclesCanisterInitPayload = record {
+  ledger_canister_id : opt principal;
+  governance_canister_id : opt principal;
+  minting_account_id : opt AccountIdentifier;
+  last_purged_notification : opt nat64;
+  exchange_rate_canister : opt ExchangeRateCanister;
+  cycles_ledger_canister_id : opt principal;
+};
+
+type NotifyMintCyclesArg = record {
+  block_index : BlockIndex;
+  to_subaccount : Subaccount;
+  deposit_memo : Memo;
+};
+
+type NotifyMintCyclesResult = variant {
+  Ok : NotifyMintCyclesSuccess;
+  Err : NotifyError;
+};
+
+type NotifyMintCyclesSuccess = record {
+  // Cycles ledger block index of deposit
+  block_index : nat;
+  // Amount of cycles that were minted and deposited to the cycles ledger
+  minted : nat;
+  // New balance of the cycles ledger account
+  balance : nat;
+};
+
+service : (opt CyclesCanisterInitPayload) -> {
+  // Prompts the cycles minting canister to process a payment by converting ICP
+  // into cycles and sending the cycles the specified canister.
+  notify_top_up : (NotifyTopUpArg) -> (NotifyTopUpResult);
+
+  // Creates a canister using the cycles attached to the function call.
+  create_canister : (CreateCanisterArg) -> (CreateCanisterResult);
+
+  // Prompts the cycles minting canister to process a payment for canister creation.
+  notify_create_canister : (NotifyCreateCanisterArg) -> (NotifyCreateCanisterResult);
+
+  // Mints cycles and deposits them to the cycles ledger
+  notify_mint_cycles : (NotifyMintCyclesArg) -> (NotifyMintCyclesResult);
+
+  // Returns the ICP/XDR conversion rate.
+  get_icp_xdr_conversion_rate : () -> (IcpXdrConversionRateResponse) query;
+
+  // Returns the current mapping of subnet types to subnets.
+  get_subnet_types_to_subnets : () -> (SubnetTypesToSubnetsResponse) query;
+
+  // Returns the mapping from principals to subnets in which they are authorized
+  // to create canisters.
+  get_principals_authorized_to_create_canisters_to_subnets : () -> (PrincipalsAuthorizedToCreateCanistersToSubnetsResponse) query;
+
+  get_default_subnets: () -> (vec principal) query;
+
+  get_build_metadata : () -> (text) query;
+};

package/src/stable/lib/canisters/nns_cycles_minting/idl/index.ts

@@ -0,0 +1,394 @@
+import { ActorMethod } from '@dfinity/agent';
+import { IDL } from '@dfinity/candid';
+import { Principal } from '@dfinity/principal';
+
+export type AccountIdentifier = string;
+export type BlockIndex = bigint;
+export interface CanisterSettings {
+    freezing_threshold: [] | [bigint];
+    wasm_memory_threshold: [] | [bigint];
+    controllers: [] | [Array<Principal>];
+    reserved_cycles_limit: [] | [bigint];
+    log_visibility: [] | [log_visibility];
+    wasm_memory_limit: [] | [bigint];
+    memory_allocation: [] | [bigint];
+    compute_allocation: [] | [bigint];
+}
+export interface CreateCanisterArg {
+    subnet_selection: [] | [SubnetSelection];
+    settings: [] | [CanisterSettings];
+    subnet_type: [] | [string];
+}
+export type CreateCanisterError = {
+    Refunded: { create_error: string; refund_amount: bigint };
+};
+export type CreateCanisterResult =
+    | { Ok: Principal }
+    | { Err: CreateCanisterError };
+export type Cycles = bigint;
+export interface CyclesCanisterInitPayload {
+    exchange_rate_canister: [] | [ExchangeRateCanister];
+    cycles_ledger_canister_id: [] | [Principal];
+    last_purged_notification: [] | [bigint];
+    governance_canister_id: [] | [Principal];
+    minting_account_id: [] | [AccountIdentifier];
+    ledger_canister_id: [] | [Principal];
+}
+export type ExchangeRateCanister = { Set: Principal } | { Unset: null };
+export interface IcpXdrConversionRate {
+    xdr_permyriad_per_icp: bigint;
+    timestamp_seconds: bigint;
+}
+export interface IcpXdrConversionRateResponse {
+    certificate: Uint8Array | number[];
+    data: IcpXdrConversionRate;
+    hash_tree: Uint8Array | number[];
+}
+export type Memo = [] | [Uint8Array | number[]];
+export interface NotifyCreateCanisterArg {
+    controller: Principal;
+    block_index: BlockIndex;
+    subnet_selection: [] | [SubnetSelection];
+    settings: [] | [CanisterSettings];
+    subnet_type: [] | [string];
+}
+export type NotifyCreateCanisterResult =
+    | { Ok: Principal }
+    | { Err: NotifyError };
+export type NotifyError =
+    | {
+          Refunded: { block_index: [] | [BlockIndex]; reason: string };
+      }
+    | { InvalidTransaction: string }
+    | { Other: { error_message: string; error_code: bigint } }
+    | { Processing: null }
+    | { TransactionTooOld: BlockIndex };
+export interface NotifyMintCyclesArg {
+    block_index: BlockIndex;
+    deposit_memo: Memo;
+    to_subaccount: Subaccount;
+}
+export type NotifyMintCyclesResult =
+    | { Ok: NotifyMintCyclesSuccess }
+    | { Err: NotifyError };
+export interface NotifyMintCyclesSuccess {
+    balance: bigint;
+    block_index: bigint;
+    minted: bigint;
+}
+export interface NotifyTopUpArg {
+    block_index: BlockIndex;
+    canister_id: Principal;
+}
+export type NotifyTopUpResult = { Ok: Cycles } | { Err: NotifyError };
+export interface PrincipalsAuthorizedToCreateCanistersToSubnetsResponse {
+    data: Array<[Principal, Array<Principal>]>;
+}
+export type Subaccount = [] | [Uint8Array | number[]];
+export interface SubnetFilter {
+    subnet_type: [] | [string];
+}
+export type SubnetSelection =
+    | { Filter: SubnetFilter }
+    | { Subnet: { subnet: Principal } };
+export interface SubnetTypesToSubnetsResponse {
+    data: Array<[string, Array<Principal>]>;
+}
+export type log_visibility = { controllers: null } | { public: null };
+export interface _SERVICE {
+    create_canister: ActorMethod<[CreateCanisterArg], CreateCanisterResult>;
+    get_build_metadata: ActorMethod<[], string>;
+    get_default_subnets: ActorMethod<[], Array<Principal>>;
+    get_icp_xdr_conversion_rate: ActorMethod<[], IcpXdrConversionRateResponse>;
+    get_principals_authorized_to_create_canisters_to_subnets: ActorMethod<
+        [],
+        PrincipalsAuthorizedToCreateCanistersToSubnetsResponse
+    >;
+    get_subnet_types_to_subnets: ActorMethod<[], SubnetTypesToSubnetsResponse>;
+    notify_create_canister: ActorMethod<
+        [NotifyCreateCanisterArg],
+        NotifyCreateCanisterResult
+    >;
+    notify_mint_cycles: ActorMethod<
+        [NotifyMintCyclesArg],
+        NotifyMintCyclesResult
+    >;
+    notify_top_up: ActorMethod<[NotifyTopUpArg], NotifyTopUpResult>;
+}
+export type idlFactory = IDL.InterfaceFactory;
+export type init = (args: { IDL: typeof IDL }) => IDL.Type[];
+export const ExchangeRateCanister = IDL.Variant({
+    Set: IDL.Principal,
+    Unset: IDL.Null
+});
+export const AccountIdentifier = IDL.Text;
+export const CyclesCanisterInitPayload = IDL.Record({
+    exchange_rate_canister: IDL.Opt(ExchangeRateCanister),
+    cycles_ledger_canister_id: IDL.Opt(IDL.Principal),
+    last_purged_notification: IDL.Opt(IDL.Nat64),
+    governance_canister_id: IDL.Opt(IDL.Principal),
+    minting_account_id: IDL.Opt(AccountIdentifier),
+    ledger_canister_id: IDL.Opt(IDL.Principal)
+});
+export const SubnetFilter = IDL.Record({ subnet_type: IDL.Opt(IDL.Text) });
+export const SubnetSelection = IDL.Variant({
+    Filter: SubnetFilter,
+    Subnet: IDL.Record({ subnet: IDL.Principal })
+});
+export const log_visibility = IDL.Variant({
+    controllers: IDL.Null,
+    public: IDL.Null
+});
+export const CanisterSettings = IDL.Record({
+    freezing_threshold: IDL.Opt(IDL.Nat),
+    wasm_memory_threshold: IDL.Opt(IDL.Nat),
+    controllers: IDL.Opt(IDL.Vec(IDL.Principal)),
+    reserved_cycles_limit: IDL.Opt(IDL.Nat),
+    log_visibility: IDL.Opt(log_visibility),
+    wasm_memory_limit: IDL.Opt(IDL.Nat),
+    memory_allocation: IDL.Opt(IDL.Nat),
+    compute_allocation: IDL.Opt(IDL.Nat)
+});
+export const CreateCanisterArg = IDL.Record({
+    subnet_selection: IDL.Opt(SubnetSelection),
+    settings: IDL.Opt(CanisterSettings),
+    subnet_type: IDL.Opt(IDL.Text)
+});
+export const CreateCanisterError = IDL.Variant({
+    Refunded: IDL.Record({
+        create_error: IDL.Text,
+        refund_amount: IDL.Nat
+    })
+});
+export const CreateCanisterResult = IDL.Variant({
+    Ok: IDL.Principal,
+    Err: CreateCanisterError
+});
+export const IcpXdrConversionRate = IDL.Record({
+    xdr_permyriad_per_icp: IDL.Nat64,
+    timestamp_seconds: IDL.Nat64
+});
+export const IcpXdrConversionRateResponse = IDL.Record({
+    certificate: IDL.Vec(IDL.Nat8),
+    data: IcpXdrConversionRate,
+    hash_tree: IDL.Vec(IDL.Nat8)
+});
+export const PrincipalsAuthorizedToCreateCanistersToSubnetsResponse =
+    IDL.Record({
+        data: IDL.Vec(IDL.Tuple(IDL.Principal, IDL.Vec(IDL.Principal)))
+    });
+export const SubnetTypesToSubnetsResponse = IDL.Record({
+    data: IDL.Vec(IDL.Tuple(IDL.Text, IDL.Vec(IDL.Principal)))
+});
+export const BlockIndex = IDL.Nat64;
+export const NotifyCreateCanisterArg = IDL.Record({
+    controller: IDL.Principal,
+    block_index: BlockIndex,
+    subnet_selection: IDL.Opt(SubnetSelection),
+    settings: IDL.Opt(CanisterSettings),
+    subnet_type: IDL.Opt(IDL.Text)
+});
+export const NotifyError = IDL.Variant({
+    Refunded: IDL.Record({
+        block_index: IDL.Opt(BlockIndex),
+        reason: IDL.Text
+    }),
+    InvalidTransaction: IDL.Text,
+    Other: IDL.Record({
+        error_message: IDL.Text,
+        error_code: IDL.Nat64
+    }),
+    Processing: IDL.Null,
+    TransactionTooOld: BlockIndex
+});
+export const NotifyCreateCanisterResult = IDL.Variant({
+    Ok: IDL.Principal,
+    Err: NotifyError
+});
+export const Memo = IDL.Opt(IDL.Vec(IDL.Nat8));
+export const Subaccount = IDL.Opt(IDL.Vec(IDL.Nat8));
+export const NotifyMintCyclesArg = IDL.Record({
+    block_index: BlockIndex,
+    deposit_memo: Memo,
+    to_subaccount: Subaccount
+});
+export const NotifyMintCyclesSuccess = IDL.Record({
+    balance: IDL.Nat,
+    block_index: IDL.Nat,
+    minted: IDL.Nat
+});
+export const NotifyMintCyclesResult = IDL.Variant({
+    Ok: NotifyMintCyclesSuccess,
+    Err: NotifyError
+});
+export const NotifyTopUpArg = IDL.Record({
+    block_index: BlockIndex,
+    canister_id: IDL.Principal
+});
+export const Cycles = IDL.Nat;
+export const NotifyTopUpResult = IDL.Variant({
+    Ok: Cycles,
+    Err: NotifyError
+});
+export const idlFactory: idlFactory = ({ IDL }) => {
+    const ExchangeRateCanister = IDL.Variant({
+        Set: IDL.Principal,
+        Unset: IDL.Null
+    });
+    const AccountIdentifier = IDL.Text;
+    const CyclesCanisterInitPayload = IDL.Record({
+        exchange_rate_canister: IDL.Opt(ExchangeRateCanister),
+        cycles_ledger_canister_id: IDL.Opt(IDL.Principal),
+        last_purged_notification: IDL.Opt(IDL.Nat64),
+        governance_canister_id: IDL.Opt(IDL.Principal),
+        minting_account_id: IDL.Opt(AccountIdentifier),
+        ledger_canister_id: IDL.Opt(IDL.Principal)
+    });
+    const SubnetFilter = IDL.Record({ subnet_type: IDL.Opt(IDL.Text) });
+    const SubnetSelection = IDL.Variant({
+        Filter: SubnetFilter,
+        Subnet: IDL.Record({ subnet: IDL.Principal })
+    });
+    const log_visibility = IDL.Variant({
+        controllers: IDL.Null,
+        public: IDL.Null
+    });
+    const CanisterSettings = IDL.Record({
+        freezing_threshold: IDL.Opt(IDL.Nat),
+        wasm_memory_threshold: IDL.Opt(IDL.Nat),
+        controllers: IDL.Opt(IDL.Vec(IDL.Principal)),
+        reserved_cycles_limit: IDL.Opt(IDL.Nat),
+        log_visibility: IDL.Opt(log_visibility),
+        wasm_memory_limit: IDL.Opt(IDL.Nat),
+        memory_allocation: IDL.Opt(IDL.Nat),
+        compute_allocation: IDL.Opt(IDL.Nat)
+    });
+    const CreateCanisterArg = IDL.Record({
+        subnet_selection: IDL.Opt(SubnetSelection),
+        settings: IDL.Opt(CanisterSettings),
+        subnet_type: IDL.Opt(IDL.Text)
+    });
+    const CreateCanisterError = IDL.Variant({
+        Refunded: IDL.Record({
+            create_error: IDL.Text,
+            refund_amount: IDL.Nat
+        })
+    });
+    const CreateCanisterResult = IDL.Variant({
+        Ok: IDL.Principal,
+        Err: CreateCanisterError
+    });
+    const IcpXdrConversionRate = IDL.Record({
+        xdr_permyriad_per_icp: IDL.Nat64,
+        timestamp_seconds: IDL.Nat64
+    });
+    const IcpXdrConversionRateResponse = IDL.Record({
+        certificate: IDL.Vec(IDL.Nat8),
+        data: IcpXdrConversionRate,
+        hash_tree: IDL.Vec(IDL.Nat8)
+    });
+    const PrincipalsAuthorizedToCreateCanistersToSubnetsResponse = IDL.Record({
+        data: IDL.Vec(IDL.Tuple(IDL.Principal, IDL.Vec(IDL.Principal)))
+    });
+    const SubnetTypesToSubnetsResponse = IDL.Record({
+        data: IDL.Vec(IDL.Tuple(IDL.Text, IDL.Vec(IDL.Principal)))
+    });
+    const BlockIndex = IDL.Nat64;
+    const NotifyCreateCanisterArg = IDL.Record({
+        controller: IDL.Principal,
+        block_index: BlockIndex,
+        subnet_selection: IDL.Opt(SubnetSelection),
+        settings: IDL.Opt(CanisterSettings),
+        subnet_type: IDL.Opt(IDL.Text)
+    });
+    const NotifyError = IDL.Variant({
+        Refunded: IDL.Record({
+            block_index: IDL.Opt(BlockIndex),
+            reason: IDL.Text
+        }),
+        InvalidTransaction: IDL.Text,
+        Other: IDL.Record({
+            error_message: IDL.Text,
+            error_code: IDL.Nat64
+        }),
+        Processing: IDL.Null,
+        TransactionTooOld: BlockIndex
+    });
+    const NotifyCreateCanisterResult = IDL.Variant({
+        Ok: IDL.Principal,
+        Err: NotifyError
+    });
+    const Memo = IDL.Opt(IDL.Vec(IDL.Nat8));
+    const Subaccount = IDL.Opt(IDL.Vec(IDL.Nat8));
+    const NotifyMintCyclesArg = IDL.Record({
+        block_index: BlockIndex,
+        deposit_memo: Memo,
+        to_subaccount: Subaccount
+    });
+    const NotifyMintCyclesSuccess = IDL.Record({
+        balance: IDL.Nat,
+        block_index: IDL.Nat,
+        minted: IDL.Nat
+    });
+    const NotifyMintCyclesResult = IDL.Variant({
+        Ok: NotifyMintCyclesSuccess,
+        Err: NotifyError
+    });
+    const NotifyTopUpArg = IDL.Record({
+        block_index: BlockIndex,
+        canister_id: IDL.Principal
+    });
+    const Cycles = IDL.Nat;
+    const NotifyTopUpResult = IDL.Variant({ Ok: Cycles, Err: NotifyError });
+    return IDL.Service({
+        create_canister: IDL.Func(
+            [CreateCanisterArg],
+            [CreateCanisterResult],
+            []
+        ),
+        get_build_metadata: IDL.Func([], [IDL.Text], ['query']),
+        get_default_subnets: IDL.Func([], [IDL.Vec(IDL.Principal)], ['query']),
+        get_icp_xdr_conversion_rate: IDL.Func(
+            [],
+            [IcpXdrConversionRateResponse],
+            ['query']
+        ),
+        get_principals_authorized_to_create_canisters_to_subnets: IDL.Func(
+            [],
+            [PrincipalsAuthorizedToCreateCanistersToSubnetsResponse],
+            ['query']
+        ),
+        get_subnet_types_to_subnets: IDL.Func(
+            [],
+            [SubnetTypesToSubnetsResponse],
+            ['query']
+        ),
+        notify_create_canister: IDL.Func(
+            [NotifyCreateCanisterArg],
+            [NotifyCreateCanisterResult],
+            []
+        ),
+        notify_mint_cycles: IDL.Func(
+            [NotifyMintCyclesArg],
+            [NotifyMintCyclesResult],
+            []
+        ),
+        notify_top_up: IDL.Func([NotifyTopUpArg], [NotifyTopUpResult], [])
+    });
+};
+export const init: init = ({ IDL }) => {
+    const ExchangeRateCanister = IDL.Variant({
+        Set: IDL.Principal,
+        Unset: IDL.Null
+    });
+    const AccountIdentifier = IDL.Text;
+    const CyclesCanisterInitPayload = IDL.Record({
+        exchange_rate_canister: IDL.Opt(ExchangeRateCanister),
+        cycles_ledger_canister_id: IDL.Opt(IDL.Principal),
+        last_purged_notification: IDL.Opt(IDL.Nat64),
+        governance_canister_id: IDL.Opt(IDL.Principal),
+        minting_account_id: IDL.Opt(AccountIdentifier),
+        ledger_canister_id: IDL.Opt(IDL.Principal)
+    });
+    return [IDL.Opt(CyclesCanisterInitPayload)];
+};

package/src/stable/lib/canisters/nns_governance/idl/README.md

@@ -0,0 +1,9 @@
+- `index.did` manual Candid source: https://dashboard.internetcomputer.org/canister/rrkah-fqaaa-aaaaa-aaaaq-cai
+- Licensing is assumed to be that described in ../../NOTICE
+
+# How to update the IDL and TypeScript types
+
+1. Go to the URL above
+2. Find the Candid on that page and copy it
+3. Paste the Candid into `index.did`
+4. From this directory run `npx azle generate index.did > index.ts`