@airgap/icp 0.13.15-beta.4 → 0.13.15-beta.6

package/v1/protocol/ICPProtocol.js

@@ -1,4 +1,27 @@
 "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) {
@@ -17,11 +40,15 @@ const coinlib_core_1 = require("@airgap/coinlib-core");
 const index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
 const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
 const errors_1 = require("@airgap/coinlib-core/errors");
+const assert_1 = require("@airgap/coinlib-core/utils/assert");
 const array_1 = require("@airgap/coinlib-core/utils/array");
 const crypto_1 = require("@airgap/crypto");
 const module_kit_1 = require("@airgap/module-kit");
+const governance_1 = require("../types/governance");
 const transaction_1 = require("../types/transaction");
 const account_1 = require("../utils/account");
+const Cbor = __importStar(require("../utils/cbor"));
+const IDL = __importStar(require("../utils/idl"));
 const principal_1 = require("../utils/principal");
 const ICPGovernance_1 = require("./ICPGovernance");
 const ICPImplementation_1 = require("./ICPImplementation");
@@ -73,6 +100,10 @@ class ICPProtocolImpl {
             algorithm: 'secp256k1'
         };
         this.options = createICPProtocolOptions(options.network);
+        this.canisterId = {
+            ledger: this.options.network.ledgerCanisterId,
+            governance: this.options.network.governanceCanisterId
+        };
     }
     getMetadata() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -103,21 +134,19 @@ class ICPProtocolImpl {
                 case transaction_1.ICPActionType.TRANSFER:
                     return (0, ICPImplementation_1.getDetailsFromSignedTransactionTransfer)(encoded, publicKey.value, this.options.network);
                 case transaction_1.ICPActionType.GET_NEURON_INFO:
-                    return (0, ICPGovernance_1.getDetailsFromSignedTransactionGetNeuronInfo)(publicKey.value, this.options.network);
+                    return (0, ICPGovernance_1.getDetailsFromSignedGetNeuronInfo)(publicKey.value, this.options.network);
                 case transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT:
-                    return (0, ICPGovernance_1.getDetailsFromSignedTransactionTransferToSubaccount)(encoded, publicKey.value, this.options.network);
+                    return (0, ICPGovernance_1.getDetailsFromSignedTransferToSubaccount)(encoded, publicKey.value, this.options.network);
                 case transaction_1.ICPActionType.CLAIM_GOVERNANCE:
-                    return (0, ICPGovernance_1.getDetailsFromSignedTransactionClaimGovernance)(publicKey.value, this.options.network);
+                    return (0, ICPGovernance_1.getDetailsFromTransactionClaimGovernance)(publicKey.value, this.options.network);
                 case transaction_1.ICPActionType.FOLLOW_NEURON:
-                    return (0, ICPGovernance_1.getDetailsFromSignedTransactionFollowNeuron)(publicKey.value, this.options.network);
-                case transaction_1.ICPActionType.INCREASE_STAKE:
-                    throw new Error('TODO: implement');
-                case transaction_1.ICPActionType.REMOVE_STAKE:
-                    return (0, ICPGovernance_1.getDetailsFromSignedTransactionRemoveStake)(publicKey.value, this.options.network);
-                case transaction_1.ICPActionType.INCREASE_DELAY:
+                    return (0, ICPGovernance_1.getDetailsFromSignedFollowNeuron)(publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.DISBURSE:
+                    return (0, ICPGovernance_1.getDetailsFromSignedDisburse)(publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.INCREASE_DISSOLVING_DELAY:
                     return (0, ICPGovernance_1.getDetailsFromSignedTransactionIncreaseDelay)(publicKey.value, this.options.network);
                 case transaction_1.ICPActionType.START_DISSOLVING:
-                    return (0, ICPGovernance_1.getDetailsFromSignedTransactionStartDissolving)(publicKey.value, this.options.network);
+                    return (0, ICPGovernance_1.getDetailsFromSignedStartDissolving)(publicKey.value, this.options.network);
                 case transaction_1.ICPActionType.STOP_DISSOLVING:
                     return (0, ICPGovernance_1.getDetailsFromSignedTransactionStopDissolving)(publicKey.value, this.options.network);
                 case transaction_1.ICPActionType.RESTAKE_MATURITY:
@@ -135,23 +164,21 @@ class ICPProtocolImpl {
                 case transaction_1.ICPActionType.TRANSFER:
                     return (0, ICPImplementation_1.getDetailsFromUnsignedTransactionTransfer)(encoded, publicKey.value, this.options.network);
                 case transaction_1.ICPActionType.GET_NEURON_INFO:
-                    return (0, ICPGovernance_1.getDetailsFromUnsignedTransactionGetNeuronInfo)(publicKey.value, this.options.network);
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedGetNeuronInfo)(publicKey.value, this.options.network);
                 case transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT:
-                    return (0, ICPGovernance_1.getDetailsFromUnsignedTransactionTransferToSubaccount)(encoded, publicKey.value, this.options.network);
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedTransferToSubaccount)(encoded, publicKey.value, this.options.network);
                 case transaction_1.ICPActionType.CLAIM_GOVERNANCE:
-                    return (0, ICPGovernance_1.getDetailsFromUnsignedTransactionClaimGovernance)(publicKey.value, this.options.network);
-                case transaction_1.ICPActionType.INCREASE_STAKE:
-                    throw new Error('TODO: implement');
-                case transaction_1.ICPActionType.REMOVE_STAKE:
-                    return (0, ICPGovernance_1.getDetailsFromUnsignedTransactionRemoveStake)(publicKey.value, this.options.network);
-                case transaction_1.ICPActionType.INCREASE_DELAY:
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedClaimGovernance)(publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.DISBURSE:
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedDisburse)(publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.INCREASE_DISSOLVING_DELAY:
                     return (0, ICPGovernance_1.getDetailsFromUnsignedTransactionIncreaseDelay)(publicKey.value, this.options.network);
                 case transaction_1.ICPActionType.START_DISSOLVING:
-                    return (0, ICPGovernance_1.getDetailsFromUnsignedTransactionStartDissolving)(publicKey.value, this.options.network);
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedStartDissolving)(publicKey.value, this.options.network);
                 case transaction_1.ICPActionType.STOP_DISSOLVING:
                     return (0, ICPGovernance_1.getDetailsFromUnsignedTransactionStopDissolving)(publicKey.value, this.options.network);
                 case transaction_1.ICPActionType.FOLLOW_NEURON:
-                    return (0, ICPGovernance_1.getDetailsFromUnsignedTransactionFollowNeuron)(publicKey.value, this.options.network);
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedFollowNeuron)(publicKey.value, this.options.network);
                 case transaction_1.ICPActionType.RESTAKE_MATURITY:
                     return (0, ICPGovernance_1.getDetailsFromUnsignedTransactionRestakeMaturity)(publicKey.value, this.options.network);
                 default:
@@ -186,64 +213,52 @@ class ICPProtocolImpl {
                     case transaction_1.ICPActionType.TRANSFER:
                         return {
                             actionType,
-                            encoded: yield (0, ICPImplementation_1.signTransactionTransfer)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
-                            requestType: 'update'
+                            encoded: yield (0, ICPImplementation_1.signTransactionTransfer)(encoded, secretKey.value, this.options.network.ledgerCanisterId)
                         };
                     case transaction_1.ICPActionType.GET_NEURON_INFO:
                         return {
                             actionType,
-                            encoded: yield (0, ICPGovernance_1.signTransactionGetNeuronInfo)(encoded, secretKey.value, this.options.network.governanceCanisterId),
-                            requestType: 'query'
+                            encoded: yield (0, ICPGovernance_1.signGetNeuronInfo)(encoded, secretKey.value, this.options.network.governanceCanisterId)
                         };
                     case transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT:
                         return {
                             actionType,
-                            encoded: yield (0, ICPGovernance_1.signTransactionTransferToSubaccount)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
-                            requestType: 'update'
+                            encoded: yield (0, ICPGovernance_1.signTransferToSubaccount)(encoded, secretKey.value, this.options.network.ledgerCanisterId)
                         };
                     case transaction_1.ICPActionType.CLAIM_GOVERNANCE:
                         return {
                             actionType,
-                            encoded: yield (0, ICPGovernance_1.signTransactionClaimGovernance)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
-                            requestType: 'update'
+                            encoded: yield (0, ICPGovernance_1.signClaimGovernance)(encoded, secretKey.value, this.options.network.governanceCanisterId)
                         };
-                    case transaction_1.ICPActionType.INCREASE_STAKE:
-                        throw new Error('TODO: implement');
-                    case transaction_1.ICPActionType.REMOVE_STAKE:
+                    case transaction_1.ICPActionType.DISBURSE:
                         return {
                             actionType,
-                            encoded: yield (0, ICPGovernance_1.signTransactionRemoveStake)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
-                            requestType: 'update'
+                            encoded: yield (0, ICPGovernance_1.signDisburse)(encoded, secretKey.value, this.options.network.governanceCanisterId)
                         };
-                    case transaction_1.ICPActionType.INCREASE_DELAY:
+                    case transaction_1.ICPActionType.INCREASE_DISSOLVING_DELAY:
                         return {
                             actionType,
-                            encoded: yield (0, ICPGovernance_1.signTransactionIncreaseDelay)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
-                            requestType: 'update'
+                            encoded: yield (0, ICPGovernance_1.signTransactionIncreaseDelay)(encoded, secretKey.value, this.options.network.governanceCanisterId)
                         };
                     case transaction_1.ICPActionType.START_DISSOLVING:
                         return {
                             actionType,
-                            encoded: yield (0, ICPGovernance_1.signTransactionStartDissolving)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
-                            requestType: 'update'
+                            encoded: yield (0, ICPGovernance_1.signStartDissolving)(encoded, secretKey.value, this.options.network.governanceCanisterId)
                         };
                     case transaction_1.ICPActionType.STOP_DISSOLVING:
                         return {
                             actionType,
-                            encoded: yield (0, ICPGovernance_1.signTransactionStopDissolving)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
-                            requestType: 'update'
+                            encoded: yield (0, ICPGovernance_1.signTransactionStopDissolving)(encoded, secretKey.value, this.options.network.governanceCanisterId)
                         };
                     case transaction_1.ICPActionType.FOLLOW_NEURON:
                         return {
                             actionType,
-                            encoded: yield (0, ICPGovernance_1.signTransactionFollowNeuron)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
-                            requestType: 'update'
+                            encoded: yield (0, ICPGovernance_1.signFollowNeuron)(encoded, secretKey.value, this.options.network.governanceCanisterId)
                         };
                     case transaction_1.ICPActionType.RESTAKE_MATURITY:
                         return {
                             actionType,
-                            encoded: yield (0, ICPGovernance_1.signTransactionRestakeMaturity)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
-                            requestType: 'update'
+                            encoded: yield (0, ICPGovernance_1.signTransactionRestakeMaturity)(encoded, secretKey.value, this.options.network.governanceCanisterId)
                         };
                     default:
                         (0, coinlib_core_1.assertNever)(actionType);
@@ -304,7 +319,16 @@ class ICPProtocolImpl {
     getBalanceOfPublicKey(publicKey) {
         return __awaiter(this, void 0, void 0, function* () {
             const address = (0, ICPImplementation_1.getAddressFromPublicKey)(publicKey.value);
-            return this.getBalanceOfAddress(address);
+            const mainBalance = yield this.getBalanceOfAddress(address);
+            const neuronBalance = yield this.getNeuronBalance(publicKey);
+            const totalBalance = (0, module_kit_1.newAmount)(mainBalance.total)
+                .blockchain(this.units)
+                .toBigNumber()
+                .plus((0, module_kit_1.newAmount)(neuronBalance.total).blockchain(this.units).toBigNumber());
+            return {
+                total: (0, module_kit_1.newAmount)(totalBalance, 'blockchain'),
+                transferable: mainBalance.total
+            };
         });
     }
     getBalanceOfAddress(address) {
@@ -325,7 +349,7 @@ class ICPProtocolImpl {
             }
             else {
                 const feeEstimation = yield this.getTransactionFeeWithPublicKey(publicKey, []);
-                fee = new bignumber_1.default((0, module_kit_1.newAmount)(feeEstimation.medium).value);
+                fee = new bignumber_1.default((0, module_kit_1.newAmount)(feeEstimation).value);
                 if (fee.gte(balanceBn)) {
                     fee = new bignumber_1.default(0);
                 }
@@ -347,7 +371,7 @@ class ICPProtocolImpl {
             //   medium: newAmount(feeDefault.toString(10), 'ICP'),
             //   high: newAmount(feeDefault.toString(10), 'ICP')
             // }
-            return this.feeDefaults;
+            return this.feeDefaults.medium;
         });
     }
     prepareTransactionWithPublicKey(publicKey, details, configuration) {
@@ -363,15 +387,12 @@ class ICPProtocolImpl {
                 throw new errors_1.BalanceError(coinlib_core_1.Domain.ICP, 'not enough balance');
             }
             const amountBn = BigInt((0, module_kit_1.newAmount)(details[0].amount).blockchain(this.units).value);
-            // Transaction object
-            const transaction = {
-                from: (0, ICPImplementation_1.getAddressFromPublicKey)(publicKey.value),
+            // Create unsigned
+            const unsignedTransaction = (0, ICPImplementation_1.createUnsignedTransaction)({
                 to: details[0].to,
                 amount: amountBn,
                 fee: feeBn
-            };
-            // Create unsigned
-            const unsignedTransaction = (0, ICPImplementation_1.createUnsignedTransaction)(transaction);
+            });
             return (0, module_kit_1.newUnsignedTransaction)({
                 transactions: [
                     {
@@ -387,10 +408,87 @@ class ICPProtocolImpl {
     // Search for : Transfer ICP from the caller to the destination accountIdentifier. Returns the index of the block containing the tx if it was successful.
     broadcastTransaction(transaction) {
         return __awaiter(this, void 0, void 0, function* () {
-            const txHashes = yield Promise.all(transaction.transactions.map(({ actionType, encoded }) => (0, ICPImplementation_1.broadcastTransaction)(encoded, this.options.network.rpcUrl, this.options.network.governanceCanisterId, transaction_1.ICP_REQUEST_TYPE_PER_ACTION[actionType])));
-            return txHashes[0];
+            for (const { actionType, encoded } of transaction.transactions) {
+                const requestType = transaction_1.ICP_REQUEST_TYPE_PER_ACTION[actionType];
+                if (requestType !== 'call')
+                    continue;
+                yield (0, ICPImplementation_1.broadcastTransaction)(encoded, this.options.network.rpcUrl, this.canisterId[transaction_1.ICP_CANISTER_TYPE_PER_ACTION[actionType]], transaction_1.ICP_REQUEST_TYPE_PER_ACTION[actionType]);
+            }
+            return '';
         });
     }
+    sendQuery(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.all(transaction.transactions
+                .filter(({ actionType }) => transaction_1.ICP_REQUEST_TYPE_PER_ACTION[actionType] === 'query')
+                .map(({ actionType, encoded }) => __awaiter(this, void 0, void 0, function* () {
+                const response = yield (0, ICPImplementation_1.broadcastTransaction)(encoded, this.options.network.rpcUrl, this.canisterId[transaction_1.ICP_CANISTER_TYPE_PER_ACTION[actionType]], transaction_1.ICP_REQUEST_TYPE_PER_ACTION[actionType]);
+                const queryResponse = Cbor.decode(response);
+                if (queryResponse.status == "rejected" /* QueryResponseStatus.Rejected */) {
+                    throw new errors_1.NetworkError(coinlib_core_1.Domain.ICP, {}, `Error (${queryResponse.reject_code}) ${queryResponse.reject_message}`);
+                }
+                return this.decodeQueryResponse(actionType, queryResponse.reply.arg);
+            })));
+        });
+    }
+    decodeQueryResponse(actionType, response) {
+        switch (actionType) {
+            case transaction_1.ICPActionType.GET_NEURON_INFO:
+                const NeuronId = IDL.Record({ id: IDL.Nat64 });
+                const BallotInfo = IDL.Record({
+                    vote: IDL.Int32,
+                    proposal_id: IDL.Opt(NeuronId)
+                });
+                const DissolveState = IDL.Variant({
+                    DissolveDelaySeconds: IDL.Nat64,
+                    WhenDissolvedTimestampSeconds: IDL.Nat64
+                });
+                const Followees = IDL.Record({ followees: IDL.Vec(NeuronId) });
+                const NeuronStakeTransfer = IDL.Record({
+                    to_subaccount: IDL.Vec(IDL.Nat8),
+                    neuron_stake_e8s: IDL.Nat64,
+                    from: IDL.Opt(IDL.Principal),
+                    memo: IDL.Nat64,
+                    from_subaccount: IDL.Vec(IDL.Nat8),
+                    transfer_timestamp: IDL.Nat64,
+                    block_height: IDL.Nat64
+                });
+                const KnownNeuronData = IDL.Record({
+                    name: IDL.Text,
+                    description: IDL.Opt(IDL.Text)
+                });
+                const Neuron = IDL.Record({
+                    id: IDL.Opt(NeuronId),
+                    staked_maturity_e8s_equivalent: IDL.Opt(IDL.Nat64),
+                    controller: IDL.Opt(IDL.Principal),
+                    recent_ballots: IDL.Vec(BallotInfo),
+                    kyc_verified: IDL.Bool,
+                    not_for_profit: IDL.Bool,
+                    maturity_e8s_equivalent: IDL.Nat64,
+                    cached_neuron_stake_e8s: IDL.Nat64,
+                    created_timestamp_seconds: IDL.Nat64,
+                    auto_stake_maturity: IDL.Opt(IDL.Bool),
+                    aging_since_timestamp_seconds: IDL.Nat64,
+                    hot_keys: IDL.Vec(IDL.Principal),
+                    account: IDL.Vec(IDL.Nat8),
+                    joined_community_fund_timestamp_seconds: IDL.Opt(IDL.Nat64),
+                    dissolve_state: IDL.Opt(DissolveState),
+                    followees: IDL.Vec(IDL.Tuple(IDL.Int32, Followees)),
+                    neuron_fees_e8s: IDL.Nat64,
+                    transfer: IDL.Opt(NeuronStakeTransfer),
+                    known_neuron_data: IDL.Opt(KnownNeuronData),
+                    spawn_at_timestamp_seconds: IDL.Opt(IDL.Nat64)
+                });
+                const GovernanceError = IDL.Record({
+                    error_message: IDL.Text,
+                    error_type: IDL.Int32
+                });
+                const Result = IDL.Variant({ Ok: Neuron, Err: GovernanceError });
+                return IDL.decode([Result], response)[0];
+            default:
+                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ICP, `Decode response for action type ${actionType} is not supported`);
+        }
+    }
     // DELEGATION
     getDefaultDelegatee() {
         var _a, _b, _c;
@@ -400,13 +498,7 @@ class ICPProtocolImpl {
             return (id === null || id === void 0 ? void 0 : id.toString()) || '';
         });
     }
-    getCurrentDelegateesForPublicKey(publicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const address = yield this.getAddressFromPublicKey(publicKey);
-            return this.getCurrentDelegateesForAddress(address);
-        });
-    }
-    getCurrentDelegateesForAddress(address) {
+    getCurrentDelegateesForPublicKey(publicKey, data) {
         return __awaiter(this, void 0, void 0, function* () {
             // Fetch neurons of address from governance canister (listNeurons)
             // Fetch followees from each neuron (get_full_neuron_by_id_or_subaccount)
@@ -414,65 +506,88 @@ class ICPProtocolImpl {
             return [];
         });
     }
-    getDelegateeDetails(address) {
-        var _a, _b;
+    getCurrentDelegateesForAddress(_address, _data) {
         return __awaiter(this, void 0, void 0, function* () {
-            const neuron = yield (0, ICPImplementation_1.getNeuronInfo)(address, this.options.network.rpcUrl, this.options.network.governanceCanisterId);
-            return {
-                name: ((_b = (_a = neuron === null || neuron === void 0 ? void 0 : neuron.known_neuron_data) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.name) || '',
-                address: address
-            };
+            throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ICP, '`getCurrentDelegateesForAddress` is not supported');
         });
     }
-    isPublicKeyDelegating(publicKey) {
+    getDelegateeDetails(address, data) {
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
-            const address = yield this.getAddressFromPublicKey(publicKey);
-            return this.isAddressDelegating(address);
+            const partialNeuron = yield (0, ICPImplementation_1.getNeuronInfo)(address, this.options.network.rpcUrl, this.options.network.governanceCanisterId);
+            const neuronFolowees = (data === null || data === void 0 ? void 0 : data.neuron) ? this.getNeuronFollowees(data.neuron) : undefined;
+            return {
+                name: ((_b = (_a = partialNeuron === null || partialNeuron === void 0 ? void 0 : partialNeuron.known_neuron_data) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.name) || '',
+                address: address,
+                status: neuronFolowees ? (neuronFolowees.includes(address) ? 'followed' : 'not-followed') : 'unknown',
+                votingPower: (_d = (_c = partialNeuron === null || partialNeuron === void 0 ? void 0 : partialNeuron.voting_power) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : '0'
+            };
         });
     }
-    isAddressDelegating(address) {
+    isPublicKeyDelegating(publicKey, data) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            // Fetch neurons of address from governance canister (listNeurons)
-            // Fetch followees from each neuron (get_full_neuron_by_id_or_subaccount)
-            // If each neuron as followes then it is delegating
-            // If no neuron has followes then it is not delegating
-            // If some, but not all, neurons have followes then it is partially delegating
-            return false;
+            const partialNeuron = yield this.getNeuron(publicKey);
+            if (partialNeuron === undefined) {
+                return false;
+            }
+            const neuron = data === null || data === void 0 ? void 0 : data.neuron;
+            // This case is valid for the `undelegated`/`delegated` badge in
+            // without full neuron data we can't be sure if we're actually delegating,
+            // i.e. the neuron has followees
+            // should we return `true` or `false` here?
+            if (neuron === undefined) {
+                return true;
+            }
+            // We should check if partial and full neuron data describe the same neuron
+            // but there's no neuron ID in partial neuron data
+            if (((_a = partialNeuron.known_neuron_data[0]) === null || _a === void 0 ? void 0 : _a.name) !== ((_b = neuron.known_neuron_data[0]) === null || _b === void 0 ? void 0 : _b.name)) {
+                return true;
+            }
+            return this.getNeuronFollowees(neuron).length > 0;
         });
     }
-    getDelegatorDetailsFromPublicKey(publicKey) {
+    isAddressDelegating(_address, data) {
         return __awaiter(this, void 0, void 0, function* () {
-            const address = yield this.getAddressFromPublicKey(publicKey);
-            return this.getDelegatorDetailsFromAddress(address);
+            throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ICP, '`isAddressDelegating` is not supported');
         });
     }
-    getDelegatorDetailsFromAddress(address) {
+    getDelegatorDetailsFromPublicKey(publicKey, data) {
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
-            const metadata = yield this.getMetadata();
+            const address = yield this.getAddressFromPublicKey(publicKey);
             const availableBalance = yield this.getBalanceOfAddress(address);
-            const availableActions = yield this.getAvailableDelegatorActions();
-            const totalBalance = (0, module_kit_1.newAmount)(availableBalance.total).blockchain(metadata.units);
+            const followees = (data === null || data === void 0 ? void 0 : data.neuron) ? this.getNeuronFollowees(data.neuron) : [];
+            const availableActions = yield this.getAvailableDelegatorActions(publicKey, data === null || data === void 0 ? void 0 : data.neuron);
+            const neuronBalance = yield this.getNeuronBalance(publicKey);
+            const partialNeuron = yield this.getNeuron(publicKey);
+            const totalBalance = (0, module_kit_1.newAmount)(availableBalance.total).blockchain(this.units);
+            const subaccountBalance = (0, module_kit_1.newAmount)(neuronBalance.total).blockchain(this.units);
             return {
                 address,
                 balance: totalBalance.value,
-                delegatees: [],
-                availableActions: availableActions
+                delegatees: followees,
+                availableActions: availableActions,
+                subaccountBalance: subaccountBalance.value,
+                stake: (_a = partialNeuron === null || partialNeuron === void 0 ? void 0 : partialNeuron.stake_e8s) === null || _a === void 0 ? void 0 : _a.toString(),
+                votingPower: (_b = partialNeuron === null || partialNeuron === void 0 ? void 0 : partialNeuron.voting_power) === null || _b === void 0 ? void 0 : _b.toString(),
+                age: (_c = partialNeuron === null || partialNeuron === void 0 ? void 0 : partialNeuron.age_seconds) === null || _c === void 0 ? void 0 : _c.toString(),
+                dissolveDelay: (_d = partialNeuron === null || partialNeuron === void 0 ? void 0 : partialNeuron.dissolve_delay_seconds) === null || _d === void 0 ? void 0 : _d.toString()
             };
         });
     }
-    getDelegationDetailsFromPublicKey(publicKey, delegatees) {
+    getDelegatorDetailsFromAddress(_address, data) {
         return __awaiter(this, void 0, void 0, function* () {
-            const address = yield this.getAddressFromPublicKey(publicKey);
-            return this.getDelegationDetailsFromAddress(address, delegatees);
+            throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ICP, '`getDelegatorDetailsFromAddress` is not supported');
         });
     }
-    getDelegationDetailsFromAddress(address, delegatees) {
+    getDelegationDetailsFromPublicKey(publicKey, delegatees, data) {
         return __awaiter(this, void 0, void 0, function* () {
             if (delegatees.length > 1) {
                 return Promise.reject('Multiple validators for a single delegation are not supported.');
             }
             const validator = delegatees[0];
-            const results = yield Promise.all([this.getDelegatorDetailsFromAddress(address), this.getDelegateeDetails(validator)]);
+            const results = yield Promise.all([this.getDelegatorDetailsFromPublicKey(publicKey, data), this.getDelegateeDetails(validator, data)]);
             const delegatorDetails = results[0];
             const validatorDetails = results[1];
             return {
@@ -481,110 +596,218 @@ class ICPProtocolImpl {
             };
         });
     }
-    getAvailableDelegatorActions() {
+    getDelegationDetailsFromAddress(_address, _delegatees, _data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ICP, '`getDelegationDetailsFromAddress` is not supported');
+        });
+    }
+    getAvailableDelegatorActions(publicKey, fullNeuron) {
         return __awaiter(this, void 0, void 0, function* () {
             const actions = [];
-            actions.push({
-                type: transaction_1.ICPActionType.GET_NEURON_INFO
-            });
-            actions.push({
-                type: transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT,
-                args: ['amount']
-            });
-            actions.push({
-                type: transaction_1.ICPActionType.CLAIM_GOVERNANCE
-            });
-            actions.push({
-                type: transaction_1.ICPActionType.INCREASE_DELAY,
-                args: ['delaySeconds']
-            });
-            actions.push({
-                type: transaction_1.ICPActionType.START_DISSOLVING
-            });
-            actions.push({
-                type: transaction_1.ICPActionType.STOP_DISSOLVING
-            });
-            actions.push({
-                type: transaction_1.ICPActionType.FOLLOW_NEURON,
-                args: ['neuronId']
-            });
-            actions.push({
-                type: transaction_1.ICPActionType.RESTAKE_MATURITY,
-                args: ['percentageStake']
-            });
-            actions.push({
-                type: transaction_1.ICPActionType.REMOVE_STAKE
-            });
+            const neuronBalance = yield this.getNeuronBalance(publicKey);
+            const partialNeuron = yield this.getNeuron(publicKey);
+            const isStaking = new bignumber_1.default(neuronBalance.total.value).gt(0);
+            const hasNeuron = partialNeuron !== undefined;
+            const isNeuronUpToDate = hasNeuron && partialNeuron.stake_e8s.toString() === (0, module_kit_1.newAmount)(neuronBalance.total).blockchain(this.units).value;
+            const isFollowing = fullNeuron ? this.getNeuronFollowees(fullNeuron).length > 0 : false;
+            const isDissolving = fullNeuron ? this.isNeuronDissolving(fullNeuron) : false;
+            const canDisburse = partialNeuron ? this.canNeuronDisburse(partialNeuron) : false;
+            if (!isStaking && !hasNeuron) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.CREATE_NEURON,
+                    args: ['followee', 'amount', 'delay']
+                });
+            }
+            if (isStaking && !hasNeuron) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.CLAIM_GOVERNANCE,
+                    args: ['followee', 'amount', 'delay']
+                });
+            }
+            if (!isNeuronUpToDate) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.REFRESH_NEURON,
+                    args: ['amount']
+                });
+            }
+            if (isNeuronUpToDate && fullNeuron === undefined) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.INCREASE_STAKE,
+                    args: ['amount']
+                });
+            }
+            if (isNeuronUpToDate && !isFollowing && fullNeuron !== undefined) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.FOLLOW_NEURON,
+                    args: ['followee', 'amount', 'delay']
+                });
+            }
+            if (isFollowing && fullNeuron !== undefined) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.CHANGE_FOLLOWEE,
+                    args: ['followee', 'amount', 'delay']
+                });
+            }
+            if (hasNeuron) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.GET_STAKING_DETAILS
+                });
+            }
+            if (isStaking && hasNeuron && !isDissolving && fullNeuron !== undefined) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.INCREASE_DISSOLVING_DELAY
+                }, {
+                    type: governance_1.ICPStakingActionType.START_DISSOLVING
+                });
+            }
+            if (isDissolving) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.STOP_DISSOLVING
+                });
+            }
+            if (canDisburse) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.DISBURSE
+                });
+            }
             return actions;
         });
     }
     prepareDelegatorActionFromPublicKey(publicKey, type, data) {
         return __awaiter(this, void 0, void 0, function* () {
             switch (type) {
-                case transaction_1.ICPActionType.GET_NEURON_INFO:
-                    return [yield (0, ICPGovernance_1.createUnsignedTransactionGetNeuronInfo)()];
-                case transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT:
-                    // TODO : get amount from data and fee form defaults
-                    const amount = BigInt(0);
-                    const fee = BigInt(0);
-                    return [yield (0, ICPGovernance_1.createUnsignedTransactionTransferToSubaccount)(publicKey.value, this.options.network.ledgerCanisterId, amount, fee)];
-                case transaction_1.ICPActionType.CLAIM_GOVERNANCE:
-                    return [yield (0, ICPGovernance_1.createUnsignedTransactionClaimGovernance)(publicKey.value)];
-                case transaction_1.ICPActionType.INCREASE_DELAY:
-                    // TODO : get delaySeconds from data
-                    const delaySeconds = 0;
-                    return [yield (0, ICPGovernance_1.createUnsignedTransactionIncreaseDelay)(publicKey.value, delaySeconds)];
-                case transaction_1.ICPActionType.START_DISSOLVING:
-                    return [yield (0, ICPGovernance_1.createUnsignedTransactionStartDissolving)(publicKey.value)];
-                case transaction_1.ICPActionType.STOP_DISSOLVING:
-                    return [yield (0, ICPGovernance_1.createUnsignedTransactionStopDissolving)(publicKey.value)];
-                case transaction_1.ICPActionType.FOLLOW_NEURON:
-                    // TODO : get neuronId from data
-                    const neuronId = 0;
-                    return [yield (0, ICPGovernance_1.createUnsignedTransactionFollowNeuron)(publicKey.value, neuronId)];
-                case transaction_1.ICPActionType.RESTAKE_MATURITY:
-                    // TODO : get percentageStake from data
-                    const percentageStake = 0;
-                    return [yield (0, ICPGovernance_1.createUnsignedTransactionRestakeMaturity)(publicKey.value, percentageStake)];
-                case transaction_1.ICPActionType.REMOVE_STAKE:
-                    return [yield (0, ICPGovernance_1.createUnsignedTransactionRemoveStake)(publicKey.value)];
+                case governance_1.ICPStakingActionType.CREATE_NEURON:
+                case governance_1.ICPStakingActionType.INCREASE_STAKE:
+                    (0, assert_1.assertFields)(`${type} action`, data, 'amount');
+                    return this.prepareTransferToNeuron(publicKey, data.amount);
+                case governance_1.ICPStakingActionType.CLAIM_GOVERNANCE:
+                case governance_1.ICPStakingActionType.REFRESH_NEURON:
+                    (0, assert_1.assertFields)(`${type} action`, data, 'amount');
+                    return this.prepareClaimOrRefreshNeuron(publicKey, data.amount);
+                case governance_1.ICPStakingActionType.GET_STAKING_DETAILS:
+                    return this.prepareGetStakingDetails();
+                case governance_1.ICPStakingActionType.START_DISSOLVING:
+                    return this.prepareStartDissolving(publicKey);
+                case governance_1.ICPStakingActionType.DISBURSE:
+                    return this.prepareDisburse(publicKey);
                 default:
                     return Promise.reject(`Delegator action type ${type} is not supported.`);
             }
         });
     }
-    fetchValidators() {
+    prepareTransferToNeuron(publicKey, amount) {
         return __awaiter(this, void 0, void 0, function* () {
-            return (0, ICPImplementation_1.listKnownNeurons)(this.options.network.rpcUrl, this.options.network.governanceCanisterId);
+            const amountBigInt = BigInt(amount);
+            const feeBigInt = BigInt((0, module_kit_1.newAmount)(this.feeDefaults.medium).blockchain(this.units).value);
+            return [
+                (0, module_kit_1.newUnsignedTransaction)({
+                    transactions: yield Promise.all([
+                        (0, ICPGovernance_1.prepareTransferToSubaccount)(publicKey.value, this.options.network.governanceCanisterId, amountBigInt, feeBigInt),
+                        (0, ICPGovernance_1.prepareClaimOrRefreshNeuron)(publicKey.value)
+                    ])
+                })
+            ];
+        });
+    }
+    prepareClaimOrRefreshNeuron(publicKey, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const amountBigInt = BigInt(amount);
+            const feeBigInt = BigInt((0, module_kit_1.newAmount)(this.feeDefaults.medium).blockchain(this.units).value);
+            return [
+                (0, module_kit_1.newUnsignedTransaction)({
+                    transactions: (yield Promise.all([
+                        amountBigInt > 0
+                            ? (0, ICPGovernance_1.prepareTransferToSubaccount)(publicKey.value, this.options.network.governanceCanisterId, amountBigInt, feeBigInt)
+                            : Promise.resolve(undefined),
+                        (0, ICPGovernance_1.prepareClaimOrRefreshNeuron)(publicKey.value)
+                    ])).filter((tx) => tx !== undefined)
+                })
+            ];
+        });
+    }
+    prepareGetStakingDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [
+                (0, module_kit_1.newUnsignedTransaction)({
+                    transactions: [yield (0, ICPGovernance_1.prepareGetNeuronInfo)()]
+                })
+            ];
         });
     }
-    fetchVotingPower(neuronId) {
+    prepareStartDissolving(publicKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            const neuron = yield (0, ICPImplementation_1.getNeuronInfo)(neuronId, this.options.network.rpcUrl, this.options.network.governanceCanisterId);
-            if (neuron) {
-                return new bignumber_1.default(neuron.voting_power.toString()).div(new bignumber_1.default(10 ** this.units.ICP.decimals));
-            }
-            else
-                return new bignumber_1.default(0);
+            return [
+                (0, module_kit_1.newUnsignedTransaction)({
+                    transactions: [yield (0, ICPGovernance_1.prepareStartDissolving)(publicKey.value)]
+                })
+            ];
+        });
+    }
+    prepareDisburse(publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [
+                (0, module_kit_1.newUnsignedTransaction)({
+                    transactions: [yield (0, ICPGovernance_1.prepareDisburse)(publicKey.value)]
+                })
+            ];
+        });
+    }
+    getMaxStakingAmount(publicKey) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const balance = yield this.getBalanceOfPublicKey(publicKey);
+            const { subAccount } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey.value);
+            const accountIdentifier = account_1.AccountIdentifier.fromPrincipal({
+                principal: principal_1.Principal.from(this.options.network.ledgerCanisterId),
+                subAccount: subAccount
+            });
+            const fee = yield this.getTransactionFeeWithPublicKey(publicKey, [
+                {
+                    to: accountIdentifier.toHex(),
+                    amount: (_a = balance.transferable) !== null && _a !== void 0 ? _a : balance.total
+                }
+            ]);
+            const maxAmount = (0, module_kit_1.newAmount)((_b = balance.transferable) !== null && _b !== void 0 ? _b : balance.total)
+                .blockchain(this.units)
+                .toBigNumber()
+                .minus((0, module_kit_1.newAmount)(fee).blockchain(this.units).value);
+            return (0, module_kit_1.newAmount)(maxAmount, 'blockchain');
         });
     }
-    fetchNeuron(publicKey) {
+    getKnownNeurons() {
         return __awaiter(this, void 0, void 0, function* () {
-            const neuron = yield (0, ICPImplementation_1.getNeuronInfoBySubAccount)(publicKey, this.options.network.rpcUrl, this.options.network.governanceCanisterId);
+            return (0, ICPImplementation_1.listKnownNeurons)(this.options.network.rpcUrl, this.options.network.governanceCanisterId);
+        });
+    }
+    getNeuron(publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const neuron = yield (0, ICPImplementation_1.getNeuronInfoBySubAccount)(publicKey.value, this.options.network.rpcUrl, this.options.network.governanceCanisterId);
             return neuron;
         });
     }
-    fetchSubaccountBalance(publicKey) {
+    getNeuronBalance(publicKey) {
         return __awaiter(this, void 0, void 0, function* () {
             // Create subaccount from publicKey
-            const { subAccount, nonce: _ } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey);
+            const { subAccount, nonce: _ } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey.value);
             const accountIdentifier = account_1.AccountIdentifier.fromPrincipal({
-                principal: principal_1.Principal.from(this.options.network.ledgerCanisterId),
+                principal: principal_1.Principal.from(this.options.network.governanceCanisterId),
                 subAccount: subAccount
             });
             return this.getBalanceOfAddress(accountIdentifier.toHex());
         });
     }
+    getNeuronFollowees(neuron) {
+        return (0, array_1.flattenArray)(neuron.followees.map(([_, { followees }]) => followees.map(({ id }) => id.toString())));
+    }
+    isNeuronDissolving(neuron) {
+        const dissolveState = neuron.dissolve_state[0];
+        return (dissolveState !== undefined &&
+            'WhenDissolvedTimestampSeconds' in dissolveState &&
+            dissolveState.WhenDissolvedTimestampSeconds > BigInt(0));
+    }
+    canNeuronDisburse(neuron) {
+        return neuron.dissolve_delay_seconds === BigInt(0) && neuron.stake_e8s > BigInt(0);
+    }
 }
 exports.ICPProtocolImpl = ICPProtocolImpl;
 // Factory