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

package/v1/protocol/ICPGovernance.js

@@ -0,0 +1,748 @@
+"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.getDetailsFromSignedTransactionRemoveStake = exports.signTransactionRemoveStake = exports.getDetailsFromUnsignedTransactionRemoveStake = exports.createUnsignedTransactionRemoveStake = exports.getDetailsFromSignedTransactionRestakeMaturity = exports.signTransactionRestakeMaturity = exports.getDetailsFromUnsignedTransactionRestakeMaturity = exports.createUnsignedTransactionRestakeMaturity = exports.getDetailsFromSignedTransactionFollowNeuron = exports.signTransactionFollowNeuron = exports.getDetailsFromUnsignedTransactionFollowNeuron = exports.createUnsignedTransactionFollowNeuron = exports.getDetailsFromSignedTransactionStopDissolving = exports.signTransactionStopDissolving = exports.getDetailsFromUnsignedTransactionStopDissolving = exports.createUnsignedTransactionStopDissolving = exports.getDetailsFromSignedTransactionStartDissolving = exports.signTransactionStartDissolving = exports.getDetailsFromUnsignedTransactionStartDissolving = exports.createUnsignedTransactionStartDissolving = exports.getDetailsFromSignedTransactionIncreaseDelay = exports.signTransactionIncreaseDelay = exports.getDetailsFromUnsignedTransactionIncreaseDelay = exports.createUnsignedTransactionIncreaseDelay = exports.getDetailsFromSignedTransactionClaimGovernance = exports.signTransactionClaimGovernance = exports.getDetailsFromUnsignedTransactionClaimGovernance = exports.createUnsignedTransactionClaimGovernance = exports.getDetailsFromSignedTransactionTransferToSubaccount = exports.signTransactionTransferToSubaccount = exports.getDetailsFromUnsignedTransactionTransferToSubaccount = exports.createUnsignedTransactionTransferToSubaccount = exports.getDetailsFromSignedTransactionGetNeuronInfo = exports.signTransactionGetNeuronInfo = exports.getDetailsFromUnsignedTransactionGetNeuronInfo = exports.createUnsignedTransactionGetNeuronInfo = void 0;
+const module_kit_1 = require("@airgap/module-kit");
+const transaction_1 = require("../types/transaction");
+const account_1 = require("../utils/account");
+const convert_1 = require("../utils/convert");
+const IDL = __importStar(require("../utils/idl"));
+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 createUnsignedTransactionGetNeuronInfo() {
+    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 (0, module_kit_1.newUnsignedTransaction)({
+            transactions: [
+                {
+                    actionType: transaction_1.ICPActionType.GET_NEURON_INFO,
+                    encoded: ''
+                }
+            ]
+        });
+    });
+}
+exports.createUnsignedTransactionGetNeuronInfo = createUnsignedTransactionGetNeuronInfo;
+function getDetailsFromUnsignedTransactionGetNeuronInfo(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
+        }
+    ];
+}
+exports.getDetailsFromUnsignedTransactionGetNeuronInfo = getDetailsFromUnsignedTransactionGetNeuronInfo;
+function signTransactionGetNeuronInfo(unsignedTransaction, privateKey, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ListNeurons = IDL.Record({
+            neuron_ids: IDL.Vec(IDL.Nat64),
+            include_neurons_readable_by_caller: IDL.Bool
+        });
+        const args = IDL.encode([ListNeurons], [{ neuron_ids: [], include_neurons_readable_by_caller: true }]);
+        const signedTransaction = (0, ICPImplementation_1.signTransaction)(privateKey, canisterId, args, 'list_neurons', 'query');
+        return signedTransaction;
+    });
+}
+exports.signTransactionGetNeuronInfo = signTransactionGetNeuronInfo;
+function getDetailsFromSignedTransactionGetNeuronInfo(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
+        }
+    ];
+}
+exports.getDetailsFromSignedTransactionGetNeuronInfo = getDetailsFromSignedTransactionGetNeuronInfo;
+// 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 createUnsignedTransactionTransferToSubaccount(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: amount,
+            to: accountIdentifier.toHex(),
+            fee: fee
+        });
+        return (0, module_kit_1.newUnsignedTransaction)({
+            transactions: [
+                {
+                    actionType: transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT,
+                    encoded: unsignedTransfer
+                }
+            ]
+        });
+    });
+}
+exports.createUnsignedTransactionTransferToSubaccount = createUnsignedTransactionTransferToSubaccount;
+function getDetailsFromUnsignedTransactionTransferToSubaccount(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
+        }
+    ];
+}
+exports.getDetailsFromUnsignedTransactionTransferToSubaccount = getDetailsFromUnsignedTransactionTransferToSubaccount;
+function signTransactionTransferToSubaccount(unsignedTransaction, privateKey, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (0, ICPImplementation_1.signTransactionTransfer)(unsignedTransaction, privateKey, canisterId);
+    });
+}
+exports.signTransactionTransferToSubaccount = signTransactionTransferToSubaccount;
+function getDetailsFromSignedTransactionTransferToSubaccount(signedTransaction, publicKey, network) {
+    return (0, ICPImplementation_1.getDetailsFromSignedTransactionTransfer)(signedTransaction, publicKey, network);
+}
+exports.getDetailsFromSignedTransactionTransferToSubaccount = getDetailsFromSignedTransactionTransferToSubaccount;
+// CLAIM_GOVERNANCE ?
+// CANISTER   : (name: NNS Governance, identifier: rrkah-fqaaa-aaaaa-aaaaq-cai)
+// METHOD     : (name: claim_or_refresh_neuron_from_account, type: call)
+function createUnsignedTransactionClaimGovernance(publicKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Create subaccount from publicKey
+        const { subAccount: _, nonce } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey);
+        // Get Principal from public key
+        const principal = (0, ICPImplementation_1.getPrincipalFromPublicKey)(publicKey);
+        // IDL for ClaimOrRefresh
+        const ClaimOrRefreshNeuronFromAccount = IDL.Record({
+            controller: IDL.Opt(IDL.Principal),
+            memo: IDL.Nat64
+        });
+        // Encode
+        const unsignedTransactionBuffer = IDL.encode([ClaimOrRefreshNeuronFromAccount], [{ controller: [principal], memo: nonce }]);
+        return (0, module_kit_1.newUnsignedTransaction)({
+            transactions: [
+                {
+                    actionType: transaction_1.ICPActionType.CLAIM_GOVERNANCE,
+                    encoded: (0, convert_1.arrayBufferToHexString)(unsignedTransactionBuffer)
+                }
+            ]
+        });
+    });
+}
+exports.createUnsignedTransactionClaimGovernance = createUnsignedTransactionClaimGovernance;
+function getDetailsFromUnsignedTransactionClaimGovernance(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
+        }
+    ];
+}
+exports.getDetailsFromUnsignedTransactionClaimGovernance = getDetailsFromUnsignedTransactionClaimGovernance;
+function signTransactionClaimGovernance(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, 'claim_or_refresh_neuron_from_account', 'call');
+        return signedTransaction;
+    });
+}
+exports.signTransactionClaimGovernance = signTransactionClaimGovernance;
+function getDetailsFromSignedTransactionClaimGovernance(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
+        }
+    ];
+}
+exports.getDetailsFromSignedTransactionClaimGovernance = getDetailsFromSignedTransactionClaimGovernance;
+// INCREASE_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 createUnsignedTransactionIncreaseDelay(publicKey, delaySeconds) {
+    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], [
+            {
+                command: [{ Configure: { operation: [{ IncreaseDissolveDelay: { additional_dissolve_delay_seconds: delaySeconds } }] } }],
+                neuron_id_or_subaccount: [{ Subaccount: subAccount }]
+            }
+        ]);
+        return (0, module_kit_1.newUnsignedTransaction)({
+            transactions: [
+                {
+                    actionType: transaction_1.ICPActionType.INCREASE_DELAY,
+                    encoded: (0, convert_1.arrayBufferToHexString)(unsignedTransactionBuffer)
+                }
+            ]
+        });
+    });
+}
+exports.createUnsignedTransactionIncreaseDelay = createUnsignedTransactionIncreaseDelay;
+function getDetailsFromUnsignedTransactionIncreaseDelay(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: network
+        }
+    ];
+}
+exports.getDetailsFromUnsignedTransactionIncreaseDelay = getDetailsFromUnsignedTransactionIncreaseDelay;
+function signTransactionIncreaseDelay(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.signTransactionIncreaseDelay = signTransactionIncreaseDelay;
+function getDetailsFromSignedTransactionIncreaseDelay(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
+        }
+    ];
+}
+exports.getDetailsFromSignedTransactionIncreaseDelay = getDetailsFromSignedTransactionIncreaseDelay;
+// 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 createUnsignedTransactionStartDissolving(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], [
+            {
+                command: [{ Configure: { operation: [{ StartDissolving: {} }] } }],
+                neuron_id_or_subaccount: [{ Subaccount: subAccount }]
+            }
+        ]);
+        return (0, module_kit_1.newUnsignedTransaction)({
+            transactions: [
+                {
+                    actionType: transaction_1.ICPActionType.START_DISSOLVING,
+                    encoded: (0, convert_1.arrayBufferToHexString)(unsignedTransactionBuffer)
+                }
+            ]
+        });
+    });
+}
+exports.createUnsignedTransactionStartDissolving = createUnsignedTransactionStartDissolving;
+function getDetailsFromUnsignedTransactionStartDissolving(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
+        }
+    ];
+}
+exports.getDetailsFromUnsignedTransactionStartDissolving = getDetailsFromUnsignedTransactionStartDissolving;
+function signTransactionStartDissolving(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.signTransactionStartDissolving = signTransactionStartDissolving;
+function getDetailsFromSignedTransactionStartDissolving(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: network
+        }
+    ];
+}
+exports.getDetailsFromSignedTransactionStartDissolving = getDetailsFromSignedTransactionStartDissolving;
+// 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 createUnsignedTransactionStopDissolving(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 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], [
+            {
+                command: [{ Configure: { operation: [{ StopDissolving: {} }] } }],
+                neuron_id_or_subaccount: [{ Subaccount: subAccount }]
+            }
+        ]);
+        return (0, module_kit_1.newUnsignedTransaction)({
+            transactions: [
+                {
+                    actionType: transaction_1.ICPActionType.STOP_DISSOLVING,
+                    encoded: (0, convert_1.arrayBufferToHexString)(unsignedTransactionBuffer)
+                }
+            ]
+        });
+    });
+}
+exports.createUnsignedTransactionStopDissolving = createUnsignedTransactionStopDissolving;
+function getDetailsFromUnsignedTransactionStopDissolving(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: network
+        }
+    ];
+}
+exports.getDetailsFromUnsignedTransactionStopDissolving = getDetailsFromUnsignedTransactionStopDissolving;
+function signTransactionStopDissolving(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.signTransactionStopDissolving = signTransactionStopDissolving;
+function getDetailsFromSignedTransactionStopDissolving(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
+        }
+    ];
+}
+exports.getDetailsFromSignedTransactionStopDissolving = getDetailsFromSignedTransactionStopDissolving;
+// 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 : {}}])
+function createUnsignedTransactionFollowNeuron(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)
+        });
+        // TODO : get the topic that corresponds to all topics
+        const topic = 0;
+        // Encode
+        const unsignedTransactionBuffer = IDL.encode([ManageNeuron], [
+            {
+                command: [{ Follow: { topic: topic, followees: [neuronId] } }],
+                neuron_id_or_subaccount: [{ Subaccount: subAccount }]
+            }
+        ]);
+        return (0, module_kit_1.newUnsignedTransaction)({
+            transactions: [
+                {
+                    actionType: transaction_1.ICPActionType.FOLLOW_NEURON,
+                    encoded: (0, convert_1.arrayBufferToHexString)(unsignedTransactionBuffer)
+                }
+            ]
+        });
+    });
+}
+exports.createUnsignedTransactionFollowNeuron = createUnsignedTransactionFollowNeuron;
+function getDetailsFromUnsignedTransactionFollowNeuron(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
+        }
+    ];
+}
+exports.getDetailsFromUnsignedTransactionFollowNeuron = getDetailsFromUnsignedTransactionFollowNeuron;
+function signTransactionFollowNeuron(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.signTransactionFollowNeuron = signTransactionFollowNeuron;
+function getDetailsFromSignedTransactionFollowNeuron(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
+        }
+    ];
+}
+exports.getDetailsFromSignedTransactionFollowNeuron = getDetailsFromSignedTransactionFollowNeuron;
+// RESTAKE_MATURITY
+// CANISTER   : (name: NNS Governance, identifier: rrkah-fqaaa-aaaaa-aaaaq-cai)
+// METHOD     : (name: manage_neuron, type: update)
+// PAYLOAD    : (id : [{id : float}], command : [{StakeMaturity : {percentage_to_stake : [int]}}], neuron_id_or_subaccount : [])
+// RESPONSE   : (command : [{StakeMaturity : {maturity_e8s : int, staked_maturity_e8s : int}}])
+function createUnsignedTransactionRestakeMaturity(publicKey, percentageStake) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Create subaccount from publicKey
+        const { subAccount, nonce: _ } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey);
+        // IDL for StakeMaturity
+        const NeuronId = IDL.Record({ id: IDL.Nat64 });
+        const StakeMaturity = IDL.Record({
+            percentage_to_stake: IDL.Opt(IDL.Nat32)
+        });
+        const Command = IDL.Variant({
+            StakeMaturity: StakeMaturity
+        });
+        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], [
+            {
+                command: [{ StakeMaturity: { percentage_to_stake: percentageStake } }],
+                neuron_id_or_subaccount: [{ Subaccount: subAccount }]
+            }
+        ]);
+        return (0, module_kit_1.newUnsignedTransaction)({
+            transactions: [
+                {
+                    actionType: transaction_1.ICPActionType.FOLLOW_NEURON,
+                    encoded: (0, convert_1.arrayBufferToHexString)(unsignedTransactionBuffer)
+                }
+            ]
+        });
+    });
+}
+exports.createUnsignedTransactionRestakeMaturity = createUnsignedTransactionRestakeMaturity;
+function getDetailsFromUnsignedTransactionRestakeMaturity(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: network
+        }
+    ];
+}
+exports.getDetailsFromUnsignedTransactionRestakeMaturity = getDetailsFromUnsignedTransactionRestakeMaturity;
+function signTransactionRestakeMaturity(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.signTransactionRestakeMaturity = signTransactionRestakeMaturity;
+function getDetailsFromSignedTransactionRestakeMaturity(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
+        }
+    ];
+}
+exports.getDetailsFromSignedTransactionRestakeMaturity = getDetailsFromSignedTransactionRestakeMaturity;
+// REMOVE_STAKE
+// Cannot extrapolate method from call since we have to wait 6 months to do so
+function createUnsignedTransactionRemoveStake(publicKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Create subaccount from publicKey
+        const { subAccount, nonce: _ } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey);
+        // IDL for RemoveStake
+        // Encode
+        const unsignedTransactionBuffer = IDL.encode([], [
+            {
+                command: [],
+                neuron_id_or_subaccount: [{ Subaccount: subAccount }]
+            }
+        ]);
+        return (0, module_kit_1.newUnsignedTransaction)({
+            transactions: [
+                {
+                    actionType: transaction_1.ICPActionType.REMOVE_STAKE,
+                    encoded: (0, convert_1.arrayBufferToHexString)(unsignedTransactionBuffer)
+                }
+            ]
+        });
+    });
+}
+exports.createUnsignedTransactionRemoveStake = createUnsignedTransactionRemoveStake;
+function getDetailsFromUnsignedTransactionRemoveStake(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: network
+        }
+    ];
+}
+exports.getDetailsFromUnsignedTransactionRemoveStake = getDetailsFromUnsignedTransactionRemoveStake;
+function signTransactionRemoveStake(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.signTransactionRemoveStake = signTransactionRemoveStake;
+function getDetailsFromSignedTransactionRemoveStake(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
+        }
+    ];
+}
+exports.getDetailsFromSignedTransactionRemoveStake = getDetailsFromSignedTransactionRemoveStake;
+//# sourceMappingURL=ICPGovernance.js.map