@airgap/icp 0.13.15-beta.1 → 0.13.15-beta.10

package/v1/protocol/ICPGovernance.js

@@ -0,0 +1,1177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDetailsFromSignedDisburse = exports.signDisburse = exports.getDetailsFromUnsignedDisburse = exports.prepareDisburse = exports.getDetailsFromSignedFollowNeuron = exports.signFollowNeuron = exports.getDetailsFromUnsignedFollowNeuron = exports.prepareFollowNeuron = exports.getDetailsFromSignedAutoStakeMaturity = exports.signAutoStakeMaturity = exports.getDetailsFromUnsignedAutoStakeMaturity = exports.prepareAutoStakeMaturity = exports.getDetailsFromSignedStopDissolving = exports.signStopDissolving = exports.getDetailsFromUnsignedStopDissolving = exports.prepareStopDissolving = exports.getDetailsFromSignedStartDissolving = exports.signStartDissolving = exports.getDetailsFromUnsignedStartDissolving = exports.prepareStartDissolving = exports.getDetailsFromSignedIncreaseDissolveDelay = exports.signIncreaseDissolveDelay = exports.getDetailsFromUnsignedIncreaseDissolveDelay = exports.prepareIncreaseDissolveDelay = exports.getDetailsFromSignedClaimGovernance = exports.signClaimGovernance = exports.getDetailsFromUnsignedClaimGovernance = exports.prepareClaimOrRefreshNeuron = exports.getDetailsFromSignedTransferToSubaccount = exports.signTransferToSubaccount = exports.getDetailsFromUnsignedTransferToSubaccount = exports.prepareTransferToSubaccount = exports.getDetailsFromSignedGetNeuronInfo = exports.signGetNeuronInfo = exports.getDetailsFromUnsignedGetNeuronInfo = exports.prepareGetNeuronInfo = void 0;
+const module_kit_1 = require("@airgap/module-kit");
+const transaction_1 = require("../types/transaction");
+const account_1 = require("../utils/account");
+const Cbor = __importStar(require("../utils/cbor"));
+const convert_1 = require("../utils/convert");
+const IDL = __importStar(require("../utils/idl"));
+const json_1 = require("../utils/json");
+const principal_1 = require("../utils/principal");
+const ICPImplementation_1 = require("./ICPImplementation");
+// GET_NEURON_INFO
+// CANISTER   : (name: NNS Governance, identifier: rrkah-fqaaa-aaaaa-aaaaq-cai)
+// METHOD     : (name: list_neurons, type: query)
+// PAYLOAD    : (neuron_ids : {}, include_neurons_readable_by_caller : true)
+// RESPONSE   :
+// root : {
+//   neuron_infos : [
+//     [
+//       neuronId : float,
+//       {
+//         dissolve_delay_seconds: int,
+//         recent_ballots: [],
+//         created_timestamp_seconds: int,
+//         state: int,
+//         stake_e8s: int,
+//         joined_community_fund_timestamp_seconds: [],
+//         retrieved_at_timestamp_seconds: int,
+//         known_neuron_data:[],
+//         voting_power: int,
+//         age_seconds: int
+//       }
+//     ]
+//   ],
+//   full_neurons : [
+//     {
+//       id: [],
+//       staked_maturity_e8s_equivalent: [],
+//       controller: [],
+//       recent_ballots: [],
+//       kyc_verified: bool,
+//       not_for_profit: bool,
+//       maturity_e8s_equivalent: int,
+//       cached_neuron_stake_e8s: int,
+//       created_timestamp_seconds: int,
+//       auto_stake_maturity: [],
+//       aging_since_timestamp_seconds: float,
+//       hot_keys: [],
+//       account: {},
+//       joined_community_fund_timestamp_seconds: [],
+//       dissolve_state: [],
+//       followees: [],
+//       neuron_fees_e8s: int,
+//       transfer: [],
+//       known_neuron_data: [],
+//       spawn_at_timestamp_seconds: []
+//     }
+//   ]
+// }
+function prepareGetNeuronInfo() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Does not need to create a transaction as it is only a call to the governance token
+        return [
+            {
+                actionType: transaction_1.ICPActionType.GET_NEURON_INFO,
+                encoded: ''
+            }
+        ];
+    });
+}
+exports.prepareGetNeuronInfo = prepareGetNeuronInfo;
+function getDetailsFromUnsignedGetNeuronInfo(publicKey, network) {
+    // Does not need info from transaction because it is only a call to the governance canister
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [network.governanceCanisterId],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.GET_NEURON_INFO
+        }
+    ];
+}
+exports.getDetailsFromUnsignedGetNeuronInfo = getDetailsFromUnsignedGetNeuronInfo;
+function signGetNeuronInfo(_unsignedTransaction, privateKey, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const NeuronIdOrSubaccount = IDL.Variant({
+            Subaccount: IDL.Vec(IDL.Nat8)
+        });
+        const { subAccount } = (0, ICPImplementation_1.getFixedSubaccountFromPrivateKey)(privateKey);
+        const args = IDL.encode([NeuronIdOrSubaccount], [{ Subaccount: subAccount.toUint8Array() }]);
+        const signedTransaction = (0, ICPImplementation_1.signTransaction)(privateKey, canisterId, args, 'get_full_neuron_by_id_or_subaccount', 'query');
+        return signedTransaction;
+    });
+}
+exports.signGetNeuronInfo = signGetNeuronInfo;
+function getDetailsFromSignedGetNeuronInfo(encoded, publicKey, network) {
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8)
+    });
+    const cborDecoded = Cbor.decode((0, convert_1.hexStringToArrayBuffer)(encoded));
+    const neuronIdOrSubaccount = IDL.decode([NeuronIdOrSubaccount], cborDecoded.content.arg)[0];
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [network.governanceCanisterId],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.GET_NEURON_INFO,
+            json: Object.assign(Object.assign({}, cborDecoded.content), { arg: (0, json_1.idlDecodedToJsonStringifiable)(neuronIdOrSubaccount) })
+        }
+    ];
+}
+exports.getDetailsFromSignedGetNeuronInfo = getDetailsFromSignedGetNeuronInfo;
+// TRANSFER_TO_SUBACCOUNT
+// CANISTER   : (name: NNS Ledger, identifier: ryjl3-tyaaa-aaaaa-aaaba-cai)
+// METHOD     : (name: transfer, type: update)
+// PAYLOAD    : (to : {}, fee : {e8s: int}, memo: int, from_subaccount: [], created_at_time: [{timestamp_nanos : float}], amount: {e8s: int})
+// RESPONSE   : (Ok : int)
+function prepareTransferToSubaccount(publicKey, canisterId, amount, fee) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Create subaccount from publicKey
+        const { subAccount, nonce } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey);
+        const accountIdentifier = account_1.AccountIdentifier.fromPrincipal({
+            principal: principal_1.Principal.from(canisterId),
+            subAccount: subAccount
+        });
+        const unsignedTransfer = (0, ICPImplementation_1.createUnsignedTransaction)({
+            memo: nonce,
+            amount,
+            to: accountIdentifier.toHex(),
+            fee
+        });
+        return [
+            {
+                actionType: transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT,
+                encoded: unsignedTransfer
+            }
+        ];
+    });
+}
+exports.prepareTransferToSubaccount = prepareTransferToSubaccount;
+function getDetailsFromUnsignedTransferToSubaccount(unsignedTransaction, publicKey, network) {
+    const info = (0, ICPImplementation_1.getInfoFromUnsignedTransaction)(unsignedTransaction);
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [info.to],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)(info.amount.toString(), 'blockchain'),
+            fee: (0, module_kit_1.newAmount)(info.fee.toString(), 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT,
+            json: (0, json_1.idlDecodedToJsonStringifiable)(info.json)
+        }
+    ];
+}
+exports.getDetailsFromUnsignedTransferToSubaccount = getDetailsFromUnsignedTransferToSubaccount;
+function signTransferToSubaccount(unsignedTransaction, privateKey, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (0, ICPImplementation_1.signTransactionTransfer)(unsignedTransaction, privateKey, canisterId);
+    });
+}
+exports.signTransferToSubaccount = signTransferToSubaccount;
+function getDetailsFromSignedTransferToSubaccount(signedTransaction, publicKey, network) {
+    const info = (0, ICPImplementation_1.getDetailsFromSignedTransactionTransfer)(signedTransaction, publicKey, network);
+    return info.map((tx) => (Object.assign(Object.assign({}, tx), { type: transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT })));
+}
+exports.getDetailsFromSignedTransferToSubaccount = getDetailsFromSignedTransferToSubaccount;
+// CLAIM_GOVERNANCE ?
+// CANISTER   : (name: NNS Governance, identifier: rrkah-fqaaa-aaaaa-aaaaq-cai)
+// METHOD     : (name: claim_or_refresh_neuron_from_account, type: call)
+function prepareClaimOrRefreshNeuron(publicKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Create subaccount from publicKey
+        const { nonce } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey);
+        // Get Principal from public key
+        const principal = (0, ICPImplementation_1.getPrincipalFromPublicKey)(publicKey);
+        // IDL for ManageNeuron
+        const NeuronId = IDL.Record({ id: IDL.Nat64 });
+        const ClaimOrRefreshNeuronFromAccount = IDL.Record({
+            controller: IDL.Opt(IDL.Principal),
+            memo: IDL.Nat64
+        });
+        const By = IDL.Variant({
+            NeuronIdOrSubaccount: IDL.Record({}),
+            MemoAndController: ClaimOrRefreshNeuronFromAccount,
+            Memo: IDL.Nat64
+        });
+        const ClaimOrRefresh = IDL.Record({ by: IDL.Opt(By) });
+        const Command = IDL.Variant({
+            ClaimOrRefresh: ClaimOrRefresh
+        });
+        const NeuronIdOrSubaccount = IDL.Variant({
+            Subaccount: IDL.Vec(IDL.Nat8),
+            NeuronId: NeuronId
+        });
+        const ManageNeuron = IDL.Record({
+            id: IDL.Opt(NeuronId),
+            command: IDL.Opt(Command),
+            neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+        });
+        // Encode
+        const unsignedTransactionBuffer = IDL.encode([ManageNeuron], [
+            {
+                id: [],
+                command: [
+                    {
+                        ClaimOrRefresh: {
+                            by: [
+                                {
+                                    MemoAndController: { controller: [principal], memo: nonce }
+                                }
+                            ]
+                        }
+                    }
+                ],
+                neuron_id_or_subaccount: []
+            }
+        ]);
+        return [
+            {
+                actionType: transaction_1.ICPActionType.CLAIM_GOVERNANCE,
+                encoded: (0, convert_1.arrayBufferToHexString)(unsignedTransactionBuffer)
+            }
+        ];
+    });
+}
+exports.prepareClaimOrRefreshNeuron = prepareClaimOrRefreshNeuron;
+function getDetailsFromUnsignedClaimGovernance(encoded, publicKey, network) {
+    // IDL for ManageNeuron
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const ClaimOrRefreshNeuronFromAccount = IDL.Record({
+        controller: IDL.Opt(IDL.Principal),
+        memo: IDL.Nat64
+    });
+    const By = IDL.Variant({
+        NeuronIdOrSubaccount: IDL.Record({}),
+        MemoAndController: ClaimOrRefreshNeuronFromAccount,
+        Memo: IDL.Nat64
+    });
+    const ClaimOrRefresh = IDL.Record({ by: IDL.Opt(By) });
+    const Command = IDL.Variant({
+        ClaimOrRefresh: ClaimOrRefresh
+    });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    const manageNeuron = IDL.decode([ManageNeuron], (0, convert_1.hexStringToArrayBuffer)(encoded))[0];
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [network.governanceCanisterId],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.CLAIM_GOVERNANCE,
+            json: {
+                ManageNeuron: (0, json_1.idlDecodedToJsonStringifiable)(manageNeuron)
+            }
+        }
+    ];
+}
+exports.getDetailsFromUnsignedClaimGovernance = getDetailsFromUnsignedClaimGovernance;
+function signClaimGovernance(unsignedTransaction, privateKey, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // unsignedTransaction has already the arguments needed for signing, just need to be in a Buffer
+        const args = (0, convert_1.hexStringToArrayBuffer)(unsignedTransaction);
+        // Sign transaction
+        const signedTransaction = (0, ICPImplementation_1.signTransaction)(privateKey, canisterId, args, 'manage_neuron', 'call');
+        return signedTransaction;
+    });
+}
+exports.signClaimGovernance = signClaimGovernance;
+function getDetailsFromSignedClaimGovernance(encoded, publicKey, network) {
+    // IDL for ManageNeuron
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const ClaimOrRefreshNeuronFromAccount = IDL.Record({
+        controller: IDL.Opt(IDL.Principal),
+        memo: IDL.Nat64
+    });
+    const By = IDL.Variant({
+        NeuronIdOrSubaccount: IDL.Record({}),
+        MemoAndController: ClaimOrRefreshNeuronFromAccount,
+        Memo: IDL.Nat64
+    });
+    const ClaimOrRefresh = IDL.Record({ by: IDL.Opt(By) });
+    const Command = IDL.Variant({
+        ClaimOrRefresh: ClaimOrRefresh
+    });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    const cborDecoded = Cbor.decode((0, convert_1.hexStringToArrayBuffer)(encoded));
+    const manageNeuron = IDL.decode([ManageNeuron], cborDecoded.content.arg)[0];
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [network.governanceCanisterId],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.CLAIM_GOVERNANCE,
+            json: Object.assign(Object.assign({}, cborDecoded.content), { arg: (0, json_1.idlDecodedToJsonStringifiable)(manageNeuron) })
+        }
+    ];
+}
+exports.getDetailsFromSignedClaimGovernance = getDetailsFromSignedClaimGovernance;
+// INCREASE_DISSOLVE_DELAY
+// CANISTER   : (name: NNS Governance, identifier: rrkah-fqaaa-aaaaa-aaaaq-cai)
+// METHOD     : (name: manage_neuron, type: update)
+// PAYLOAD    : (id : [{id : float}], command : [{Configure : {operation : [{IncreaseDissolveDelay : {additional_dissolve_delay_seconds : int}}]}}], neuron_id_or_subaccount : [])
+// RESPONSE   : (command : [{configure : {}}])
+function prepareIncreaseDissolveDelay(publicKey, additionalDissolveDelay) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Create subaccount from publicKey
+        const { subAccount, nonce: _ } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey);
+        // IDL for IncreaseDissolveDelay
+        const NeuronId = IDL.Record({ id: IDL.Nat64 });
+        const IncreaseDissolveDelay = IDL.Record({
+            additional_dissolve_delay_seconds: IDL.Nat32
+        });
+        const Operation = IDL.Variant({
+            IncreaseDissolveDelay: IncreaseDissolveDelay
+        });
+        const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
+        const Command = IDL.Variant({
+            Configure: Configure
+        });
+        const NeuronIdOrSubaccount = IDL.Variant({
+            Subaccount: IDL.Vec(IDL.Nat8),
+            NeuronId: NeuronId
+        });
+        const ManageNeuron = IDL.Record({
+            id: IDL.Opt(NeuronId),
+            command: IDL.Opt(Command),
+            neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+        });
+        // Encode
+        const unsignedTransactionBuffer = IDL.encode([ManageNeuron], [
+            {
+                id: [],
+                command: [
+                    {
+                        Configure: {
+                            operation: [
+                                {
+                                    IncreaseDissolveDelay: { additional_dissolve_delay_seconds: additionalDissolveDelay }
+                                }
+                            ]
+                        }
+                    }
+                ],
+                neuron_id_or_subaccount: [{ Subaccount: subAccount.toUint8Array() }]
+            }
+        ]);
+        return [
+            {
+                actionType: transaction_1.ICPActionType.INCREASE_DISSOLVE_DELAY,
+                encoded: (0, convert_1.arrayBufferToHexString)(unsignedTransactionBuffer)
+            }
+        ];
+    });
+}
+exports.prepareIncreaseDissolveDelay = prepareIncreaseDissolveDelay;
+function getDetailsFromUnsignedIncreaseDissolveDelay(encoded, publicKey, network) {
+    // IDL for IncreaseDissolveDelay
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const IncreaseDissolveDelay = IDL.Record({
+        additional_dissolve_delay_seconds: IDL.Nat32
+    });
+    const Operation = IDL.Variant({
+        IncreaseDissolveDelay: IncreaseDissolveDelay
+    });
+    const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
+    const Command = IDL.Variant({
+        Configure: Configure
+    });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    const manageNeuron = IDL.decode([ManageNeuron], (0, convert_1.hexStringToArrayBuffer)(encoded))[0];
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [network.governanceCanisterId],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.INCREASE_DISSOLVE_DELAY,
+            json: {
+                ManageNeuron: (0, json_1.idlDecodedToJsonStringifiable)(manageNeuron)
+            }
+        }
+    ];
+}
+exports.getDetailsFromUnsignedIncreaseDissolveDelay = getDetailsFromUnsignedIncreaseDissolveDelay;
+function signIncreaseDissolveDelay(unsignedTransaction, privateKey, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // unsignedTransaction has already the arguments needed for signing, just need to be in a Buffer
+        const args = (0, convert_1.hexStringToArrayBuffer)(unsignedTransaction);
+        // Sign transaction
+        const signedTransaction = (0, ICPImplementation_1.signTransaction)(privateKey, canisterId, args, 'manage_neuron', 'call');
+        return signedTransaction;
+    });
+}
+exports.signIncreaseDissolveDelay = signIncreaseDissolveDelay;
+function getDetailsFromSignedIncreaseDissolveDelay(encoded, publicKey, network) {
+    // IDL for IncreaseDissolveDelay
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const IncreaseDissolveDelay = IDL.Record({
+        additional_dissolve_delay_seconds: IDL.Nat32
+    });
+    const Operation = IDL.Variant({
+        IncreaseDissolveDelay: IncreaseDissolveDelay
+    });
+    const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
+    const Command = IDL.Variant({
+        Configure: Configure
+    });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    const cborDecoded = Cbor.decode((0, convert_1.hexStringToArrayBuffer)(encoded));
+    const manageNeuron = IDL.decode([ManageNeuron], cborDecoded.content.arg)[0];
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [network.governanceCanisterId],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.INCREASE_DISSOLVE_DELAY,
+            json: Object.assign(Object.assign({}, cborDecoded.content), { arg: (0, json_1.idlDecodedToJsonStringifiable)(manageNeuron) })
+        }
+    ];
+}
+exports.getDetailsFromSignedIncreaseDissolveDelay = getDetailsFromSignedIncreaseDissolveDelay;
+// START_DISSOLVING
+// CANISTER   : (name: NNS Governance, identifier: rrkah-fqaaa-aaaaa-aaaaq-cai)
+// METHOD     : (name: manage_neuron, type: update)
+// PAYLOAD    : (id : [{id : float}], command : [{Configure : {operation : [{StartDissolving : {}}]}}], neuron_id_or_subaccount : [])
+// RESPONSE   : (command : [{configure : {}}])
+function prepareStartDissolving(publicKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Create subaccount from publicKey
+        const { subAccount, nonce: _ } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey);
+        // IDL for StartDissolving
+        const NeuronId = IDL.Record({ id: IDL.Nat64 });
+        const StartDissolving = IDL.Record({});
+        const Operation = IDL.Variant({
+            StartDissolving: StartDissolving
+        });
+        const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
+        const Command = IDL.Variant({
+            Configure: Configure
+        });
+        const NeuronIdOrSubaccount = IDL.Variant({
+            Subaccount: IDL.Vec(IDL.Nat8),
+            NeuronId: NeuronId
+        });
+        const ManageNeuron = IDL.Record({
+            id: IDL.Opt(NeuronId),
+            command: IDL.Opt(Command),
+            neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+        });
+        // Encode
+        const unsignedTransactionBuffer = IDL.encode([ManageNeuron], [
+            {
+                id: [],
+                command: [{ Configure: { operation: [{ StartDissolving: {} }] } }],
+                neuron_id_or_subaccount: [{ Subaccount: subAccount.toUint8Array() }]
+            }
+        ]);
+        return [
+            {
+                actionType: transaction_1.ICPActionType.START_DISSOLVING,
+                encoded: (0, convert_1.arrayBufferToHexString)(unsignedTransactionBuffer)
+            }
+        ];
+    });
+}
+exports.prepareStartDissolving = prepareStartDissolving;
+function getDetailsFromUnsignedStartDissolving(encoded, publicKey, network) {
+    // IDL for StartDissolving
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const StartDissolving = IDL.Record({});
+    const Operation = IDL.Variant({
+        StartDissolving: StartDissolving
+    });
+    const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
+    const Command = IDL.Variant({
+        Configure: Configure
+    });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    const manageNeuron = IDL.decode([ManageNeuron], (0, convert_1.hexStringToArrayBuffer)(encoded))[0];
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [network.governanceCanisterId],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.START_DISSOLVING,
+            json: {
+                ManageNeuron: (0, json_1.idlDecodedToJsonStringifiable)(manageNeuron)
+            }
+        }
+    ];
+}
+exports.getDetailsFromUnsignedStartDissolving = getDetailsFromUnsignedStartDissolving;
+function signStartDissolving(unsignedTransaction, privateKey, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // unsignedTransaction has already the arguments needed for signing, just need to be in a Buffer
+        const args = (0, convert_1.hexStringToArrayBuffer)(unsignedTransaction);
+        // Sign transaction
+        const signedTransaction = (0, ICPImplementation_1.signTransaction)(privateKey, canisterId, args, 'manage_neuron', 'call');
+        return signedTransaction;
+    });
+}
+exports.signStartDissolving = signStartDissolving;
+function getDetailsFromSignedStartDissolving(encoded, publicKey, network) {
+    // IDL for StartDissolving
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const StartDissolving = IDL.Record({});
+    const Operation = IDL.Variant({
+        StartDissolving: StartDissolving
+    });
+    const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
+    const Command = IDL.Variant({
+        Configure: Configure
+    });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    const cborDecoded = Cbor.decode((0, convert_1.hexStringToArrayBuffer)(encoded));
+    const manageNeuron = IDL.decode([ManageNeuron], cborDecoded.content.arg)[0];
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [network.governanceCanisterId],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.START_DISSOLVING,
+            json: Object.assign(Object.assign({}, cborDecoded.content), { arg: (0, json_1.idlDecodedToJsonStringifiable)(manageNeuron) })
+        }
+    ];
+}
+exports.getDetailsFromSignedStartDissolving = getDetailsFromSignedStartDissolving;
+// STOP_DISSOLVING
+// CANISTER   : (name: NNS Governance, identifier: rrkah-fqaaa-aaaaa-aaaaq-cai)
+// METHOD     : (name: manage_neuron, type: update)
+// PAYLOAD    : (id : [{id : float}], command : [{Configure : {operation : [{StopDissolving : {}}]}}], neuron_id_or_subaccount : [])
+// RESPONSE   : (command : [{configure : {}}])
+function prepareStopDissolving(publicKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Create subaccount from publicKey
+        const { subAccount, nonce: _ } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey);
+        // IDL for StopDissolving
+        const NeuronId = IDL.Record({ id: IDL.Nat64 });
+        const StopDissolving = IDL.Record({});
+        const Operation = IDL.Variant({
+            StopDissolving: StopDissolving
+        });
+        const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
+        const Command = IDL.Variant({
+            Configure: Configure
+        });
+        const NeuronIdOrSubaccount = IDL.Variant({
+            Subaccount: IDL.Vec(IDL.Nat8),
+            NeuronId: NeuronId
+        });
+        const ManageNeuron = IDL.Record({
+            id: IDL.Opt(NeuronId),
+            command: IDL.Opt(Command),
+            neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+        });
+        // Encode
+        const unsignedTransactionBuffer = IDL.encode([ManageNeuron], [
+            {
+                id: [],
+                command: [{ Configure: { operation: [{ StopDissolving: {} }] } }],
+                neuron_id_or_subaccount: [{ Subaccount: subAccount.toUint8Array() }]
+            }
+        ]);
+        return [
+            {
+                actionType: transaction_1.ICPActionType.STOP_DISSOLVING,
+                encoded: (0, convert_1.arrayBufferToHexString)(unsignedTransactionBuffer)
+            }
+        ];
+    });
+}
+exports.prepareStopDissolving = prepareStopDissolving;
+function getDetailsFromUnsignedStopDissolving(encoded, publicKey, network) {
+    // IDL for StopDissolving
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const StopDissolving = IDL.Record({});
+    const Operation = IDL.Variant({
+        StopDissolving: StopDissolving
+    });
+    const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
+    const Command = IDL.Variant({
+        Configure: Configure
+    });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    const manageNeuron = IDL.decode([ManageNeuron], (0, convert_1.hexStringToArrayBuffer)(encoded))[0];
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [network.governanceCanisterId],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.STOP_DISSOLVING,
+            json: {
+                ManageNeuron: (0, json_1.idlDecodedToJsonStringifiable)(manageNeuron)
+            }
+        }
+    ];
+}
+exports.getDetailsFromUnsignedStopDissolving = getDetailsFromUnsignedStopDissolving;
+function signStopDissolving(unsignedTransaction, privateKey, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // unsignedTransaction has already the arguments needed for signing, just need to be in a Buffer
+        const args = (0, convert_1.hexStringToArrayBuffer)(unsignedTransaction);
+        // Sign transaction
+        const signedTransaction = (0, ICPImplementation_1.signTransaction)(privateKey, canisterId, args, 'manage_neuron', 'call');
+        return signedTransaction;
+    });
+}
+exports.signStopDissolving = signStopDissolving;
+function getDetailsFromSignedStopDissolving(encoded, publicKey, network) {
+    // IDL for StopDissolving
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const StopDissolving = IDL.Record({});
+    const Operation = IDL.Variant({
+        StopDissolving: StopDissolving
+    });
+    const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
+    const Command = IDL.Variant({
+        Configure: Configure
+    });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    const cborDecoded = Cbor.decode((0, convert_1.hexStringToArrayBuffer)(encoded));
+    const manageNeuron = IDL.decode([ManageNeuron], cborDecoded.content.arg)[0];
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [network.governanceCanisterId],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.STOP_DISSOLVING,
+            json: Object.assign(Object.assign({}, cborDecoded.content), { arg: (0, json_1.idlDecodedToJsonStringifiable)(manageNeuron) })
+        }
+    ];
+}
+exports.getDetailsFromSignedStopDissolving = getDetailsFromSignedStopDissolving;
+// AUTO_STAKE_MATURITY
+function prepareAutoStakeMaturity(publicKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Create subaccount from publicKey
+        const { subAccount, nonce: _ } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey);
+        // IDL for ChangeAutoStakeMaturity
+        const NeuronId = IDL.Record({ id: IDL.Nat64 });
+        const ChangeAutoStakeMaturity = IDL.Record({
+            requested_setting_for_auto_stake_maturity: IDL.Bool
+        });
+        const Operation = IDL.Variant({
+            ChangeAutoStakeMaturity: ChangeAutoStakeMaturity
+        });
+        const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
+        const Command = IDL.Variant({
+            Configure: Configure
+        });
+        const NeuronIdOrSubaccount = IDL.Variant({
+            Subaccount: IDL.Vec(IDL.Nat8),
+            NeuronId: NeuronId
+        });
+        const ManageNeuron = IDL.Record({
+            id: IDL.Opt(NeuronId),
+            command: IDL.Opt(Command),
+            neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+        });
+        // Encode
+        const unsignedTransactionBuffer = IDL.encode([ManageNeuron], [
+            {
+                id: [],
+                command: [
+                    {
+                        Configure: {
+                            operation: [
+                                {
+                                    ChangeAutoStakeMaturity: {
+                                        requested_setting_for_auto_stake_maturity: true
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                ],
+                neuron_id_or_subaccount: [{ Subaccount: subAccount.toUint8Array() }]
+            }
+        ]);
+        return [
+            {
+                actionType: transaction_1.ICPActionType.AUTO_STAKE_MATURITY,
+                encoded: (0, convert_1.arrayBufferToHexString)(unsignedTransactionBuffer)
+            }
+        ];
+    });
+}
+exports.prepareAutoStakeMaturity = prepareAutoStakeMaturity;
+function getDetailsFromUnsignedAutoStakeMaturity(encoded, publicKey, network) {
+    // IDL for ChangeAutoStakeMaturity
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const ChangeAutoStakeMaturity = IDL.Record({
+        requested_setting_for_auto_stake_maturity: IDL.Bool
+    });
+    const Operation = IDL.Variant({
+        ChangeAutoStakeMaturity: ChangeAutoStakeMaturity
+    });
+    const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
+    const Command = IDL.Variant({
+        Configure: Configure
+    });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    const manageNeuron = IDL.decode([ManageNeuron], (0, convert_1.hexStringToArrayBuffer)(encoded))[0];
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [network.governanceCanisterId],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.AUTO_STAKE_MATURITY,
+            json: {
+                ManageNeuron: (0, json_1.idlDecodedToJsonStringifiable)(manageNeuron)
+            }
+        }
+    ];
+}
+exports.getDetailsFromUnsignedAutoStakeMaturity = getDetailsFromUnsignedAutoStakeMaturity;
+function signAutoStakeMaturity(unsignedTransaction, privateKey, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // unsignedTransaction has already the arguments needed for signing, just need to be in a Buffer
+        const args = (0, convert_1.hexStringToArrayBuffer)(unsignedTransaction);
+        // Sign transaction
+        const signedTransaction = (0, ICPImplementation_1.signTransaction)(privateKey, canisterId, args, 'manage_neuron', 'call');
+        return signedTransaction;
+    });
+}
+exports.signAutoStakeMaturity = signAutoStakeMaturity;
+function getDetailsFromSignedAutoStakeMaturity(encoded, publicKey, network) {
+    // IDL for ChangeAutoStakeMaturity
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const ChangeAutoStakeMaturity = IDL.Record({
+        requested_setting_for_auto_stake_maturity: IDL.Bool
+    });
+    const Operation = IDL.Variant({
+        ChangeAutoStakeMaturity: ChangeAutoStakeMaturity
+    });
+    const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
+    const Command = IDL.Variant({
+        Configure: Configure
+    });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    const cborDecoded = Cbor.decode((0, convert_1.hexStringToArrayBuffer)(encoded));
+    const manageNeuron = IDL.decode([ManageNeuron], cborDecoded.content.arg)[0];
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [network.governanceCanisterId],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.AUTO_STAKE_MATURITY,
+            json: Object.assign(Object.assign({}, cborDecoded.content), { arg: (0, json_1.idlDecodedToJsonStringifiable)(manageNeuron) })
+        }
+    ];
+}
+exports.getDetailsFromSignedAutoStakeMaturity = getDetailsFromSignedAutoStakeMaturity;
+// FOLLOW_NEURON
+// CANISTER   : (name: NNS Governance, identifier: rrkah-fqaaa-aaaaa-aaaaq-cai)
+// METHOD     : (name: manage_neuron, type: update)
+// PAYLOAD    : (id : [{id : float}], command : [{Follow : {topic : int, followees : [{id: int}]}}], neuron_id_or_subaccount : [])
+// RESPONSE   : (command : [{Follow : {}}])
+const TOPICS = [
+    { id: 0, name: 'All Except Governance, and SNS & Community Fund' },
+    { id: 4, name: 'Governance' },
+    { id: 14, name: 'SNS & Community Fund' }
+];
+function prepareFollowNeuron(publicKey, neuronId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Create subaccount from publicKey
+        const { subAccount, nonce: _ } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey);
+        // IDL for FollowNeuron
+        const NeuronId = IDL.Record({ id: IDL.Nat64 });
+        const Follow = IDL.Record({
+            topic: IDL.Int32,
+            followees: IDL.Vec(NeuronId)
+        });
+        const Command = IDL.Variant({
+            Follow: Follow
+        });
+        const NeuronIdOrSubaccount = IDL.Variant({
+            Subaccount: IDL.Vec(IDL.Nat8),
+            NeuronId: NeuronId
+        });
+        const ManageNeuron = IDL.Record({
+            id: IDL.Opt(NeuronId),
+            command: IDL.Opt(Command),
+            neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+        });
+        return TOPICS.map(({ id }) => {
+            // Encode
+            const unsignedTransactionBuffer = IDL.encode([ManageNeuron], [
+                {
+                    id: [],
+                    command: [{ Follow: { topic: id, followees: neuronId !== undefined ? [{ id: neuronId }] : [] } }],
+                    neuron_id_or_subaccount: [{ Subaccount: subAccount.toUint8Array() }]
+                }
+            ]);
+            return {
+                actionType: transaction_1.ICPActionType.FOLLOW_NEURON,
+                encoded: (0, convert_1.arrayBufferToHexString)(unsignedTransactionBuffer)
+            };
+        });
+    });
+}
+exports.prepareFollowNeuron = prepareFollowNeuron;
+function getDetailsFromUnsignedFollowNeuron(encoded, publicKey, network) {
+    // IDL for FollowNeuron
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const Follow = IDL.Record({
+        topic: IDL.Int32,
+        followees: IDL.Vec(NeuronId)
+    });
+    const Command = IDL.Variant({
+        Follow: Follow
+    });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    const manageNeuron = IDL.decode([ManageNeuron], (0, convert_1.hexStringToArrayBuffer)(encoded))[0];
+    const topicId = manageNeuron.command[0].Follow.topic;
+    const topic = TOPICS.find(({ id }) => id.toString() === topicId.toString());
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [network.governanceCanisterId],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.FOLLOW_NEURON,
+            json: {
+                ManageNeuron: (0, json_1.idlDecodedToJsonStringifiable)(manageNeuron)
+            },
+            extra: {
+                labeled: topic ? { topic: topic.name } : undefined
+            }
+        }
+    ];
+}
+exports.getDetailsFromUnsignedFollowNeuron = getDetailsFromUnsignedFollowNeuron;
+function signFollowNeuron(unsignedTransaction, privateKey, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // unsignedTransaction has already the arguments needed for signing, just need to be in a Buffer
+        const args = (0, convert_1.hexStringToArrayBuffer)(unsignedTransaction);
+        // Sign transaction
+        const signedTransaction = (0, ICPImplementation_1.signTransaction)(privateKey, canisterId, args, 'manage_neuron', 'call');
+        return signedTransaction;
+    });
+}
+exports.signFollowNeuron = signFollowNeuron;
+function getDetailsFromSignedFollowNeuron(encoded, publicKey, network) {
+    // IDL for FollowNeuron
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const Follow = IDL.Record({
+        topic: IDL.Int32,
+        followees: IDL.Vec(NeuronId)
+    });
+    const Command = IDL.Variant({
+        Follow: Follow
+    });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    const cborDecoded = Cbor.decode((0, convert_1.hexStringToArrayBuffer)(encoded));
+    const manageNeuron = IDL.decode([ManageNeuron], cborDecoded.content.arg)[0];
+    const topicId = manageNeuron.command[0].Follow.topic;
+    const topic = TOPICS.find(({ id }) => id.toString() === topicId.toString());
+    return [
+        {
+            from: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            to: [network.governanceCanisterId],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.FOLLOW_NEURON,
+            json: Object.assign(Object.assign({}, cborDecoded.content), { arg: (0, json_1.idlDecodedToJsonStringifiable)(manageNeuron) }),
+            extra: {
+                labeled: topic ? { topic: topic.name } : undefined
+            }
+        }
+    ];
+}
+exports.getDetailsFromSignedFollowNeuron = getDetailsFromSignedFollowNeuron;
+// DISBURSE
+// Cannot extrapolate method from call since we have to wait 6 months to do so
+function prepareDisburse(publicKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Create subaccount from publicKey
+        const { subAccount, nonce: _ } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey);
+        // IDL for Disburse
+        const NeuronId = IDL.Record({ id: IDL.Nat64 });
+        const AccountIdentifier = IDL.Record({ hash: IDL.Vec(IDL.Nat8) });
+        const Amount = IDL.Record({ e8s: IDL.Nat64 });
+        const Disburse = IDL.Record({
+            to_account: IDL.Opt(AccountIdentifier),
+            amount: IDL.Opt(Amount)
+        });
+        const Command = IDL.Variant({
+            Disburse: Disburse
+        });
+        const NeuronIdOrSubaccount = IDL.Variant({
+            Subaccount: IDL.Vec(IDL.Nat8),
+            NeuronId: NeuronId
+        });
+        const ManageNeuron = IDL.Record({
+            id: IDL.Opt(NeuronId),
+            command: IDL.Opt(Command),
+            neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+        });
+        // Encode
+        const unsignedTransactionBuffer = IDL.encode([ManageNeuron], [
+            {
+                id: [],
+                command: [
+                    {
+                        Disburse: {
+                            to_account: [],
+                            amount: []
+                        }
+                    }
+                ],
+                neuron_id_or_subaccount: [{ Subaccount: subAccount.toUint8Array() }]
+            }
+        ]);
+        return [
+            {
+                actionType: transaction_1.ICPActionType.DISBURSE,
+                encoded: (0, convert_1.arrayBufferToHexString)(unsignedTransactionBuffer)
+            }
+        ];
+    });
+}
+exports.prepareDisburse = prepareDisburse;
+function getDetailsFromUnsignedDisburse(encoded, publicKey, network) {
+    // IDL for Disburse
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const AccountIdentifier = IDL.Record({ hash: IDL.Vec(IDL.Nat8) });
+    const Amount = IDL.Record({ e8s: IDL.Nat64 });
+    const Disburse = IDL.Record({
+        to_account: IDL.Opt(AccountIdentifier),
+        amount: IDL.Opt(Amount)
+    });
+    const Command = IDL.Variant({
+        Disburse: Disburse
+    });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    const manageNeuron = IDL.decode([ManageNeuron], (0, convert_1.hexStringToArrayBuffer)(encoded))[0];
+    return [
+        {
+            from: [network.governanceCanisterId],
+            to: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.DISBURSE,
+            json: {
+                ManageNeuron: (0, json_1.idlDecodedToJsonStringifiable)(manageNeuron)
+            }
+        }
+    ];
+}
+exports.getDetailsFromUnsignedDisburse = getDetailsFromUnsignedDisburse;
+function signDisburse(unsignedTransaction, privateKey, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // unsignedTransaction has already the arguments needed for signing, just need to be in a Buffer
+        const args = (0, convert_1.hexStringToArrayBuffer)(unsignedTransaction);
+        // Sign transaction
+        const signedTransaction = (0, ICPImplementation_1.signTransaction)(privateKey, canisterId, args, 'manage_neuron', 'call');
+        return signedTransaction;
+    });
+}
+exports.signDisburse = signDisburse;
+function getDetailsFromSignedDisburse(encoded, publicKey, network) {
+    // IDL for Disburse
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const AccountIdentifier = IDL.Record({ hash: IDL.Vec(IDL.Nat8) });
+    const Amount = IDL.Record({ e8s: IDL.Nat64 });
+    const Disburse = IDL.Record({
+        to_account: IDL.Opt(AccountIdentifier),
+        amount: IDL.Opt(Amount)
+    });
+    const Command = IDL.Variant({
+        Disburse: Disburse
+    });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    const cborDecoded = Cbor.decode((0, convert_1.hexStringToArrayBuffer)(encoded));
+    const manageNeuron = IDL.decode([ManageNeuron], cborDecoded.content.arg)[0];
+    return [
+        {
+            from: [network.governanceCanisterId],
+            to: [(0, ICPImplementation_1.getAddressFromPublicKey)(publicKey)],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            fee: (0, module_kit_1.newAmount)('0', 'blockchain'),
+            network,
+            type: transaction_1.ICPActionType.DISBURSE,
+            json: Object.assign(Object.assign({}, cborDecoded.content), { arg: (0, json_1.idlDecodedToJsonStringifiable)(manageNeuron) })
+        }
+    ];
+}
+exports.getDetailsFromSignedDisburse = getDetailsFromSignedDisburse;
+//# sourceMappingURL=ICPGovernance.js.map