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

package/v1/protocol/ICPProtocol.js

@@ -1,14 +1,26 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
+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); }); }
@@ -19,48 +31,29 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createICPProtocolOptions = exports.ICP_MAINNET_PROTOCOL_NETWORK = exports.createICPProtocol = exports.ICPProtocolImpl = exports.ICP_TRANSACTION_METADATA = exports.ICP_ACCOUNT_METADATA = exports.ICP_DERIVATION_PATH = void 0;
-var coinlib_core_1 = require("@airgap/coinlib-core");
-var index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
-var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
-var errors_1 = require("@airgap/coinlib-core/errors");
-var crypto_1 = require("@airgap/crypto");
-var module_kit_1 = require("@airgap/module-kit");
-var convert_1 = require("../utils/convert");
-var ICPImplementation_1 = require("./ICPImplementation");
+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 array_1 = require("@airgap/coinlib-core/utils/array");
+const assert_1 = require("@airgap/coinlib-core/utils/assert");
+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");
 // Implementation
-exports.ICP_DERIVATION_PATH = "m/44'/223'/0'/0/0";
+exports.ICP_DERIVATION_PATH = `m/44'/223'/0'/0/0`;
 exports.ICP_ACCOUNT_METADATA = {
     standardDerivationPath: exports.ICP_DERIVATION_PATH,
     address: {
@@ -77,9 +70,8 @@ function ICP_TRANSACTION_METADATA() {
     };
 }
 exports.ICP_TRANSACTION_METADATA = ICP_TRANSACTION_METADATA;
-var ICPProtocolImpl = /** @class */ (function () {
-    function ICPProtocolImpl(options) {
-        if (options === void 0) { options = {}; }
+class ICPProtocolImpl {
+    constructor(options = {}) {
         // Common
         this.units = {
             ICP: {
@@ -108,316 +100,769 @@ var ICPProtocolImpl = /** @class */ (function () {
             algorithm: 'secp256k1'
         };
         this.options = createICPProtocolOptions(options.network);
+        this.canisterId = {
+            ledger: this.options.network.ledgerCanisterId,
+            governance: this.options.network.governanceCanisterId
+        };
     }
-    ICPProtocolImpl.prototype.getMetadata = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.metadata];
-            });
+    getMetadata() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.metadata;
         });
-    };
-    ICPProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, (0, ICPImplementation_1.getAddressFromPublicKey)(publicKey.value)];
-            });
+    }
+    getAddressFromPublicKey(publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, ICPImplementation_1.getAddressFromPublicKey)(publicKey.value);
         });
-    };
-    ICPProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, _publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var signedTransactionInfo, args, unsignedTransactionInfo;
-            return __generator(this, function (_a) {
-                switch (transaction.type) {
-                    case 'signed':
-                        signedTransactionInfo = (0, ICPImplementation_1.getInfoFromSignedTransaction)(transaction.transaction);
-                        args = (0, ICPImplementation_1.decodeArguments)(signedTransactionInfo.content.arg)[0];
-                        return [2 /*return*/, [
-                                {
-                                    from: [(0, ICPImplementation_1.getAddressFromPublicKey)(_publicKey.value)],
-                                    to: [(0, convert_1.uint8ArrayToHexString)(args.to)],
-                                    isInbound: false,
-                                    amount: (0, module_kit_1.newAmount)(args.amount.e8s.toString(), 'blockchain'),
-                                    fee: (0, module_kit_1.newAmount)(args.fee.e8s.toString(), 'blockchain'),
-                                    network: this.options.network
-                                }
-                            ]];
-                    case 'unsigned':
-                        unsignedTransactionInfo = (0, ICPImplementation_1.getInfoFromUnsignedTransaction)(transaction.transaction);
-                        return [2 /*return*/, [
-                                {
-                                    from: [(0, ICPImplementation_1.getAddressFromPublicKey)(_publicKey.value)],
-                                    to: [unsignedTransactionInfo.to],
-                                    isInbound: false,
-                                    amount: (0, module_kit_1.newAmount)(unsignedTransactionInfo.amount.toString(), 'blockchain'),
-                                    fee: (0, module_kit_1.newAmount)(unsignedTransactionInfo.fee.toString(), 'blockchain'),
-                                    network: this.options.network
-                                }
-                            ]];
-                    default:
-                        (0, coinlib_core_1.assertNever)(transaction);
-                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ICP, 'Unsupported transaction type.');
-                }
-                return [2 /*return*/];
-            });
+    }
+    getDetailsFromTransaction(transaction, publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (transaction.type) {
+                case 'signed':
+                    return this.getDetailsFromSignedTransaction(transaction, publicKey);
+                case 'unsigned':
+                    return this.getDetailsFromUnsignedTransaction(transaction, publicKey);
+                default:
+                    (0, coinlib_core_1.assertNever)(transaction);
+                    throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ICP, 'Unsupported transaction type.');
+            }
         });
-    };
-    ICPProtocolImpl.prototype.getCryptoConfiguration = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoConfiguration];
-            });
+    }
+    getDetailsFromSignedTransaction(transaction, publicKey) {
+        const transactions = transaction.transactions.map(({ actionType, encoded }) => {
+            switch (actionType) {
+                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.getDetailsFromSignedGetNeuronInfo)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT:
+                    return (0, ICPGovernance_1.getDetailsFromSignedTransferToSubaccount)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.CLAIM_GOVERNANCE:
+                    return (0, ICPGovernance_1.getDetailsFromSignedClaimGovernance)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.FOLLOW_NEURON:
+                    return (0, ICPGovernance_1.getDetailsFromSignedFollowNeuron)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.DISBURSE:
+                    return (0, ICPGovernance_1.getDetailsFromSignedDisburse)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.INCREASE_DISSOLVE_DELAY:
+                    return (0, ICPGovernance_1.getDetailsFromSignedIncreaseDissolveDelay)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.START_DISSOLVING:
+                    return (0, ICPGovernance_1.getDetailsFromSignedStartDissolving)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.STOP_DISSOLVING:
+                    return (0, ICPGovernance_1.getDetailsFromSignedStopDissolving)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.AUTO_STAKE_MATURITY:
+                    return (0, ICPGovernance_1.getDetailsFromSignedAutoStakeMaturity)(encoded, publicKey.value, this.options.network);
+                default:
+                    (0, coinlib_core_1.assertNever)(actionType);
+                    throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ICP, 'Unsupported ICP action type');
+            }
         });
-    };
-    ICPProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
-        return __awaiter(this, void 0, void 0, function () {
-            var bip32Node, _a, publicKey, privateKey;
-            return __generator(this, function (_b) {
-                bip32Node = (0, crypto_1.encodeDerivative)('bip32', derivative);
-                _a = (0, ICPImplementation_1.getKeyPairFromExtendedSecretKey)(bip32Node.secretKey), publicKey = _a.publicKey, privateKey = _a.privateKey;
-                return [2 /*return*/, {
-                        secretKey: (0, module_kit_1.newSecretKey)(privateKey, 'hex'),
-                        publicKey: (0, module_kit_1.newPublicKey)(publicKey, 'hex')
-                    }];
-            });
+        return (0, array_1.flattenArray)(transactions);
+    }
+    getDetailsFromUnsignedTransaction(transaction, publicKey) {
+        const transactions = transaction.transactions.map(({ actionType, encoded }) => {
+            switch (actionType) {
+                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.getDetailsFromUnsignedGetNeuronInfo)(publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT:
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedTransferToSubaccount)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.CLAIM_GOVERNANCE:
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedClaimGovernance)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.DISBURSE:
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedDisburse)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.INCREASE_DISSOLVE_DELAY:
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedIncreaseDissolveDelay)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.START_DISSOLVING:
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedStartDissolving)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.STOP_DISSOLVING:
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedStopDissolving)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.FOLLOW_NEURON:
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedFollowNeuron)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.AUTO_STAKE_MATURITY:
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedAutoStakeMaturity)(encoded, publicKey.value, this.options.network);
+                default:
+                    (0, coinlib_core_1.assertNever)(actionType);
+                    throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ICP, 'Unsupported ICP action type');
+            }
         });
-    };
-    ICPProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var signedTransaction;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (secretKey.format !== 'hex') {
-                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ICP, 'Secret key is of an unexpected format.');
-                        }
-                        return [4 /*yield*/, (0, ICPImplementation_1.signICPTransaction)(transaction.transaction, secretKey.value, this.options.network.ledgerCanisterId)];
-                    case 1:
-                        signedTransaction = _a.sent();
-                        return [2 /*return*/, (0, module_kit_1.newSignedTransaction)({ transaction: signedTransaction })];
+        return (0, array_1.flattenArray)(transactions);
+    }
+    getCryptoConfiguration() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.cryptoConfiguration;
+        });
+    }
+    getKeyPairFromDerivative(derivative) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bip32Node = (0, crypto_1.encodeDerivative)('bip32', derivative);
+            const { publicKey, privateKey } = (0, ICPImplementation_1.getKeyPairFromExtendedSecretKey)(bip32Node.secretKey);
+            return {
+                secretKey: (0, module_kit_1.newSecretKey)(privateKey, 'hex'),
+                publicKey: (0, module_kit_1.newPublicKey)(publicKey, 'hex')
+            };
+        });
+    }
+    signTransactionWithSecretKey(transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (secretKey.format !== 'hex') {
+                throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ICP, 'Secret key is of an unexpected format.');
+            }
+            const transactions = yield Promise.all(transaction.transactions.map(({ encoded, actionType }) => __awaiter(this, void 0, void 0, function* () {
+                switch (actionType) {
+                    case transaction_1.ICPActionType.TRANSFER:
+                        return {
+                            actionType,
+                            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.signGetNeuronInfo)(encoded, secretKey.value, this.options.network.governanceCanisterId)
+                        };
+                    case transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT:
+                        return {
+                            actionType,
+                            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.signClaimGovernance)(encoded, secretKey.value, this.options.network.governanceCanisterId)
+                        };
+                    case transaction_1.ICPActionType.DISBURSE:
+                        return {
+                            actionType,
+                            encoded: yield (0, ICPGovernance_1.signDisburse)(encoded, secretKey.value, this.options.network.governanceCanisterId)
+                        };
+                    case transaction_1.ICPActionType.INCREASE_DISSOLVE_DELAY:
+                        return {
+                            actionType,
+                            encoded: yield (0, ICPGovernance_1.signIncreaseDissolveDelay)(encoded, secretKey.value, this.options.network.governanceCanisterId)
+                        };
+                    case transaction_1.ICPActionType.START_DISSOLVING:
+                        return {
+                            actionType,
+                            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.signStopDissolving)(encoded, secretKey.value, this.options.network.governanceCanisterId)
+                        };
+                    case transaction_1.ICPActionType.FOLLOW_NEURON:
+                        return {
+                            actionType,
+                            encoded: yield (0, ICPGovernance_1.signFollowNeuron)(encoded, secretKey.value, this.options.network.governanceCanisterId)
+                        };
+                    case transaction_1.ICPActionType.AUTO_STAKE_MATURITY:
+                        return {
+                            actionType,
+                            encoded: yield (0, ICPGovernance_1.signAutoStakeMaturity)(encoded, secretKey.value, this.options.network.governanceCanisterId)
+                        };
+                    default:
+                        (0, coinlib_core_1.assertNever)(actionType);
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ICP, `ICP action type ${actionType} is not supported.`);
                 }
-            });
+            })));
+            return (0, module_kit_1.newSignedTransaction)({ transactions });
         });
-    };
+    }
     // Online
-    ICPProtocolImpl.prototype.getNetwork = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.options.network];
-            });
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.options.network;
         });
-    };
-    ICPProtocolImpl.prototype.getTransactionsForPublicKey = function (publicKey, limit, cursor) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        address = _a.sent();
-                        return [2 /*return*/, this.getTransactionsForAddress(address, limit, cursor)];
-                }
-            });
+    }
+    getTransactionsForPublicKey(publicKey, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddressFromPublicKey(publicKey);
+            return this.getTransactionsForAddress(address, limit, cursor);
         });
-    };
-    ICPProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
+    }
+    getTransactionsForAddress(address, limit, cursor) {
         var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var endpoint, url, response, _b, nodeTransactions, tokens, offset, next, transactions;
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        endpoint = cursor === undefined ? "/accounts/".concat(address, "/transactions?limit=").concat(limit, "&offset=0") : cursor.next;
-                        url = endpoint !== undefined ? "".concat(this.options.network.blockExplorerApi).concat(endpoint) : undefined;
-                        if (!(url !== undefined)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, index_1.default.get(url)];
-                    case 1:
-                        _b = _c.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        _b = undefined;
-                        _c.label = 3;
-                    case 3:
-                        response = _b;
-                        nodeTransactions = ((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.blocks) || [];
-                        tokens = endpoint.split('=');
-                        offset = parseInt(tokens[tokens.length - 1]);
-                        tokens[tokens.length - 1] = (offset + limit).toString();
-                        next = tokens.join('=');
-                        transactions = nodeTransactions.map(function (obj) {
-                            return {
-                                from: [obj.from_account_identifier],
-                                to: [obj.to_account_identifier],
-                                isInbound: address === obj.to_account_identifier,
-                                amount: (0, module_kit_1.newAmount)(obj.amount, 'blockchain'),
-                                fee: (0, module_kit_1.newAmount)(obj.fee, 'blockchain'),
-                                network: _this.options.network,
-                                timestamp: obj.created_at,
-                                status: {
-                                    type: obj.transfer_type,
-                                    hash: obj.transaction_hash,
-                                    block: obj.block_height
-                                }
-                            };
-                        });
-                        return [2 /*return*/, {
-                                transactions: transactions,
-                                cursor: {
-                                    hasNext: next !== undefined,
-                                    next: next
-                                }
-                            }];
-                }
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = cursor === undefined ? `/accounts/${address}/transactions?limit=${limit}&offset=0` : cursor.next;
+            const url = endpoint !== undefined ? `${this.options.network.explorerUrl}${endpoint}` : undefined;
+            const response = url !== undefined ? yield index_1.default.get(url) : undefined;
+            const nodeTransactions = ((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.blocks) || [];
+            const tokens = endpoint.split('=');
+            const offset = parseInt(tokens[tokens.length - 1]);
+            tokens[tokens.length - 1] = (offset + limit).toString();
+            const next = tokens.join('=');
+            const transactions = nodeTransactions.map((obj) => {
+                return {
+                    from: [obj.from_account_identifier],
+                    to: [obj.to_account_identifier],
+                    isInbound: address === obj.to_account_identifier,
+                    amount: (0, module_kit_1.newAmount)(obj.amount, 'blockchain'),
+                    fee: (0, module_kit_1.newAmount)(obj.fee, 'blockchain'),
+                    network: this.options.network,
+                    timestamp: obj.created_at,
+                    status: {
+                        type: obj.transfer_type,
+                        hash: obj.transaction_hash,
+                        block: obj.block_height
+                    }
+                };
             });
+            return {
+                transactions,
+                cursor: {
+                    hasNext: next !== undefined,
+                    next
+                }
+            };
         });
-    };
-    ICPProtocolImpl.prototype.getBalanceOfPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address;
-            return __generator(this, function (_a) {
-                address = (0, ICPImplementation_1.getAddressFromPublicKey)(publicKey.value);
-                return [2 /*return*/, this.getBalanceOfAddress(address)];
-            });
+    }
+    getBalanceOfPublicKey(publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = (0, ICPImplementation_1.getAddressFromPublicKey)(publicKey.value);
+            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).blockchain(this.units).toBigNumber());
+            return {
+                total: (0, module_kit_1.newAmount)(totalBalance, 'blockchain'),
+                transferable: mainBalance.total
+            };
         });
-    };
-    ICPProtocolImpl.prototype.getBalanceOfAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var balance;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!address)
-                            return [2 /*return*/, { total: (0, module_kit_1.newAmount)(0, 'blockchain') }];
-                        return [4 /*yield*/, (0, ICPImplementation_1.getBalanceFromAddress)(address, this.options.network.rpcUrl, this.options.network.ledgerCanisterId)];
-                    case 1:
-                        balance = _a.sent();
-                        return [2 /*return*/, { total: (0, module_kit_1.newAmount)(balance.toString(10), 'blockchain') }];
-                }
-            });
+    }
+    getBalanceOfAddress(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!address)
+                return { total: (0, module_kit_1.newAmount)(0, 'blockchain') };
+            const balance = yield (0, ICPImplementation_1.getBalanceFromAddress)(address, this.options.network.rpcUrl, this.options.network.ledgerCanisterId);
+            return { total: (0, module_kit_1.newAmount)(balance.toString(10), 'blockchain') };
         });
-    };
-    ICPProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            var balance, balanceBn, fee, feeEstimation, amountWithoutFees;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
-                    case 1:
-                        balance = _a.sent();
-                        balanceBn = new bignumber_1.default((0, module_kit_1.newAmount)(balance.total).value);
-                        if (!((configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined)) return [3 /*break*/, 2];
-                        fee = new bignumber_1.default((0, module_kit_1.newAmount)(configuration.fee).value);
-                        return [3 /*break*/, 4];
-                    case 2: return [4 /*yield*/, this.getTransactionFeeWithPublicKey(publicKey, [])];
-                    case 3:
-                        feeEstimation = _a.sent();
-                        fee = new bignumber_1.default((0, module_kit_1.newAmount)(feeEstimation.medium).value);
-                        if (fee.gte(balanceBn)) {
-                            fee = new bignumber_1.default(0);
-                        }
-                        _a.label = 4;
-                    case 4:
-                        amountWithoutFees = balanceBn.minus(fee);
-                        if (amountWithoutFees.isNegative()) {
-                            amountWithoutFees = new bignumber_1.default(0);
-                        }
-                        return [2 /*return*/, (0, module_kit_1.newAmount)(amountWithoutFees.toFixed(), 'blockchain')];
+    }
+    getTransactionMaxAmountWithPublicKey(publicKey, to, configuration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const balance = yield this.getBalanceOfPublicKey(publicKey);
+            const balanceBn = new bignumber_1.default((0, module_kit_1.newAmount)(balance.total).value);
+            let fee;
+            if ((configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined) {
+                fee = new bignumber_1.default((0, module_kit_1.newAmount)(configuration.fee).value);
+            }
+            else {
+                const feeEstimation = yield this.getTransactionFeeWithPublicKey(publicKey, []);
+                fee = new bignumber_1.default((0, module_kit_1.newAmount)(feeEstimation).value);
+                if (fee.gte(balanceBn)) {
+                    fee = new bignumber_1.default(0);
                 }
-            });
+            }
+            let amountWithoutFees = balanceBn.minus(fee);
+            if (amountWithoutFees.isNegative()) {
+                amountWithoutFees = new bignumber_1.default(0);
+            }
+            return (0, module_kit_1.newAmount)(amountWithoutFees.toFixed(), 'blockchain');
         });
-    };
+    }
     // TODO : Get default from chain
-    ICPProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (_publicKey, _details, _configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                // const ledger = LedgerCanister.create()
-                // const feeDefault = await ledger.transactionFee()
-                // return {
-                //   low: newAmount(feeDefault.toString(10), 'ICP'),
-                //   medium: newAmount(feeDefault.toString(10), 'ICP'),
-                //   high: newAmount(feeDefault.toString(10), 'ICP')
-                // }
-                return [2 /*return*/, this.feeDefaults];
-            });
+    getTransactionFeeWithPublicKey(_publicKey, _details) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // const ledger = LedgerCanister.create()
+            // const feeDefault = await ledger.transactionFee()
+            // return {
+            //   low: newAmount(feeDefault.toString(10), 'ICP'),
+            //   medium: newAmount(feeDefault.toString(10), 'ICP'),
+            //   high: newAmount(feeDefault.toString(10), 'ICP')
+            // }
+            return this.feeDefaults.medium;
         });
-    };
-    ICPProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            var balance, _a, balanceBn, feeBn, amountBn, transaction, unsignedTransaction;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = module_kit_1.newAmount;
-                        return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
-                    case 1:
-                        balance = _a.apply(void 0, [(_b.sent()).total]).blockchain(this.units);
-                        balanceBn = BigInt(balance.value);
-                        feeBn = (configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined
-                            ? BigInt((0, module_kit_1.newAmount)(configuration.fee).blockchain(this.units).value)
-                            : BigInt((0, module_kit_1.newAmount)(this.feeDefaults.medium).blockchain(this.units).value);
-                        // Throw if not enough balance for fee
-                        if (balanceBn < feeBn) {
-                            throw new errors_1.BalanceError(coinlib_core_1.Domain.ICP, 'not enough balance');
-                        }
-                        amountBn = BigInt((0, module_kit_1.newAmount)(details[0].amount).blockchain(this.units).value);
-                        transaction = {
-                            from: (0, ICPImplementation_1.getAddressFromPublicKey)(publicKey.value),
-                            to: details[0].to,
-                            amount: amountBn,
-                            fee: feeBn
-                        };
-                        unsignedTransaction = (0, ICPImplementation_1.createUnsignedTransaction)(transaction);
-                        return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({
-                                transaction: unsignedTransaction,
-                                networkId: this.networkId()
-                            })];
-                }
+    }
+    prepareTransactionWithPublicKey(publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check balance
+            const balance = (0, module_kit_1.newAmount)((yield this.getBalanceOfPublicKey(publicKey)).total).blockchain(this.units);
+            const balanceBn = BigInt(balance.value);
+            const feeBn = (configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined
+                ? BigInt((0, module_kit_1.newAmount)(configuration.fee).blockchain(this.units).value)
+                : BigInt((0, module_kit_1.newAmount)(this.feeDefaults.medium).blockchain(this.units).value);
+            // Throw if not enough balance for fee
+            if (balanceBn < feeBn) {
+                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);
+            // Create unsigned
+            const unsignedTransaction = (0, ICPImplementation_1.createUnsignedTransaction)({
+                to: details[0].to,
+                amount: amountBn,
+                fee: feeBn
+            });
+            return (0, module_kit_1.newUnsignedTransaction)({
+                transactions: [
+                    {
+                        actionType: transaction_1.ICPActionType.TRANSFER,
+                        encoded: unsignedTransaction
+                    }
+                ]
             });
         });
-    };
-    ICPProtocolImpl.prototype.networkId = function () {
-        switch (this.options.network.type) {
-            case 'mainnet':
-                return 'icp_mainnet';
-            default:
-                throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ICP, 'Network type not supported.');
-        }
-    };
+    }
     // TODO : discover how to get transaction hash after broadcast
     // https://github.com/dfinity/ic-js/tree/main/packages/nns
     // Search for : Transfer ICP from the caller to the destination accountIdentifier. Returns the index of the block containing the tx if it was successful.
-    ICPProtocolImpl.prototype.broadcastTransaction = function (transaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, (0, ICPImplementation_1.broadcastTransaction)(transaction.transaction, this.options.network.rpcUrl, this.options.network.ledgerCanisterId)];
-                    case 1: return [2 /*return*/, _a.sent()];
+    broadcastTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+        return __awaiter(this, void 0, void 0, function* () {
+            const knownNeurons = yield (0, ICPImplementation_1.listKnownNeurons)(this.options.network.rpcUrl, this.options.network.governanceCanisterId);
+            const id = (_c = (_b = (_a = knownNeurons[0]) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.id;
+            return (id === null || id === void 0 ? void 0 : id.toString()) || '';
+        });
+    }
+    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)
+            // Each of the functions needs a identity (signed user)
+            return (data === null || data === void 0 ? void 0 : data.neuron) ? this.getNeuronFollowees(data.neuron) : [];
+        });
+    }
+    getCurrentDelegateesForAddress(_address, _data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ICP, '`getCurrentDelegateesForAddress` is not supported');
+        });
+    }
+    getDelegateeDetails(address, data) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            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'
+            };
+        });
+    }
+    isPublicKeyDelegating(publicKey, data) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const partialNeuron = yield this.getNeuron(publicKey);
+            if (partialNeuron === undefined || partialNeuron.stake_e8s <= BigInt(0)) {
+                return false;
+            }
+            const neuron = data === null || data === void 0 ? void 0 : data.neuron;
+            // Without full neuron data we can't be sure if we're actually delegating,
+            // i.e. the neuron has followees. We assume, however, that if the neuron
+            // has a stake, the public key is delegating.
+            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;
+        });
+    }
+    isAddressDelegating(_address, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ICP, '`isAddressDelegating` is not supported');
+        });
+    }
+    getDelegatorDetailsFromPublicKey(publicKey, data) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            const fullNeuron = data === null || data === void 0 ? void 0 : data.neuron;
+            const address = yield this.getAddressFromPublicKey(publicKey);
+            const totalBalance = yield this.getBalanceOfPublicKey(publicKey);
+            const followees = fullNeuron ? this.getNeuronFollowees(fullNeuron) : [];
+            const availableActions = yield this.getAvailableDelegatorActions(publicKey, data === null || data === void 0 ? void 0 : data.followee, fullNeuron);
+            const neuronBalance = yield this.getNeuronBalance(publicKey);
+            const partialNeuron = yield this.getNeuron(publicKey);
+            const balance = (0, module_kit_1.newAmount)(totalBalance.total).blockchain(this.units);
+            const subaccountBalance = (0, module_kit_1.newAmount)(neuronBalance).blockchain(this.units);
+            return {
+                address,
+                balance: balance.value,
+                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(),
+                maturity: (_e = fullNeuron === null || fullNeuron === void 0 ? void 0 : fullNeuron.maturity_e8s_equivalent) === null || _e === void 0 ? void 0 : _e.toString()
+            };
+        });
+    }
+    getDelegatorDetailsFromAddress(_address, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ICP, '`getDelegatorDetailsFromAddress` is not supported');
+        });
+    }
+    getDelegationDetailsFromPublicKey(publicKey, delegatees, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (delegatees.length > 1) {
+                return Promise.reject('Multiple followees for a single delegation are not supported.');
+            }
+            const followee = delegatees[0];
+            const results = yield Promise.all([
+                this.getDelegatorDetailsFromPublicKey(publicKey, Object.assign(Object.assign({}, data), { followee })),
+                this.getDelegateeDetails(followee, data)
+            ]);
+            const delegatorDetails = results[0];
+            const validatorDetails = results[1];
+            return {
+                delegator: delegatorDetails,
+                delegatees: [validatorDetails]
+            };
+        });
+    }
+    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, followee, fullNeuron) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const actions = [];
+            const results = yield Promise.all([this.getBalanceOfPublicKey(publicKey), this.getNeuronBalance(publicKey), this.getNeuron(publicKey)]);
+            const transferableBalance = (_a = results[0].transferable) !== null && _a !== void 0 ? _a : results[0].total;
+            const neuronBalance = results[1];
+            const partialNeuron = results[2];
+            const canStake = new bignumber_1.default(transferableBalance.value).gt(0);
+            const isStaking = new bignumber_1.default(neuronBalance.value).gt(0);
+            const hasNeuron = partialNeuron !== undefined;
+            const isNeuronUpToDate = !isStaking || (hasNeuron && partialNeuron.stake_e8s.toString() === (0, module_kit_1.newAmount)(neuronBalance).blockchain(this.units).value);
+            const canFollow = fullNeuron && followee ? !this.getNeuronFollowees(fullNeuron).includes(followee) : false;
+            const isDissolving = fullNeuron ? this.isNeuronDissolving(fullNeuron) : false;
+            const canDisburse = partialNeuron ? this.canNeuronDisburse(partialNeuron) : false;
+            if (canStake && isNeuronUpToDate) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.STAKE_AND_FOLLOW,
+                    args: ['followee', 'amount', 'delay']
+                });
+            }
+            if (!canStake && isStaking && canFollow && isNeuronUpToDate) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.FOLLOW,
+                    args: ['followee']
+                });
+            }
+            if (isStaking && isNeuronUpToDate) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.INCREASE_DISSOLVE_DELAY,
+                    args: ['delay']
+                });
+            }
+            if (!isNeuronUpToDate) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.REFRESH_NEURON
+                });
+            }
+            if (hasNeuron) {
+                actions.push({
+                    type: governance_1.ICPStakingActionType.GET_STAKING_DETAILS
+                });
+            }
+            if (isStaking && hasNeuron && !isDissolving && fullNeuron !== undefined) {
+                actions.push({
+                    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_AND_UNFOLLOW
+                });
+            }
+            return actions;
+        });
+    }
+    prepareDelegatorActionFromPublicKey(publicKey, type, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (type) {
+                case governance_1.ICPStakingActionType.GET_STAKING_DETAILS:
+                    return this.prepareGetStakingDetails();
+                case governance_1.ICPStakingActionType.STAKE_AND_FOLLOW:
+                    (0, assert_1.assertFields)(`${type} action`, data, 'followee', 'amount', 'dissolveDelay');
+                    return this.prepareTransferToNeuronAndManage(publicKey, data.followee, data.amount, data.dissolveDelay);
+                case governance_1.ICPStakingActionType.FOLLOW:
+                    (0, assert_1.assertFields)(`${type} action`, data, 'followee');
+                    return this.prepareFollowNeuron(publicKey, data.followee);
+                case governance_1.ICPStakingActionType.REFRESH_NEURON:
+                    return this.prepareClaimOrRefreshNeuron(publicKey);
+                case governance_1.ICPStakingActionType.INCREASE_DISSOLVE_DELAY:
+                    (0, assert_1.assertFields)(`${type} action`, data, 'dissolveDelay');
+                    return this.prepareIncreaseDissolveDelay(publicKey, data.dissolveDelay);
+                case governance_1.ICPStakingActionType.START_DISSOLVING:
+                    return this.prepareStartDissolving(publicKey);
+                case governance_1.ICPStakingActionType.STOP_DISSOLVING:
+                    return this.prepareStopDissolving(publicKey);
+                case governance_1.ICPStakingActionType.DISBURSE_AND_UNFOLLOW:
+                    return this.prepareDisburseAndUnfollow(publicKey);
+                default:
+                    return Promise.reject(`Delegator action type ${type} is not supported.`);
+            }
+        });
+    }
+    prepareGetStakingDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [
+                (0, module_kit_1.newUnsignedTransaction)({
+                    transactions: yield (0, ICPGovernance_1.prepareGetNeuronInfo)()
+                })
+            ];
+        });
+    }
+    prepareTransferToNeuronAndManage(publicKey, followee, amount, dissolveDelay) {
+        var _a, _b;
+        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);
+            const partialNeuron = yield this.getNeuron(publicKey);
+            const currentDissolveDelay = (_b = (_a = partialNeuron === null || partialNeuron === void 0 ? void 0 : partialNeuron.dissolve_delay_seconds) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : '0';
+            const differenceInDissolveDelay = new bignumber_1.default(dissolveDelay).minus(currentDissolveDelay);
+            return [
+                (0, module_kit_1.newUnsignedTransaction)({
+                    transactions: (0, array_1.flattenArray)(yield Promise.all([
+                        ...(amountBigInt > BigInt(0)
+                            ? [
+                                (0, ICPGovernance_1.prepareTransferToSubaccount)(publicKey.value, this.options.network.governanceCanisterId, amountBigInt, feeBigInt),
+                                (0, ICPGovernance_1.prepareClaimOrRefreshNeuron)(publicKey.value)
+                            ]
+                            : []),
+                        (0, ICPGovernance_1.prepareFollowNeuron)(publicKey.value, BigInt(followee)),
+                        differenceInDissolveDelay.gt(0)
+                            ? (0, ICPGovernance_1.prepareIncreaseDissolveDelay)(publicKey.value, BigInt(differenceInDissolveDelay.toFixed()))
+                            : Promise.resolve([]),
+                        (0, ICPGovernance_1.prepareAutoStakeMaturity)(publicKey.value)
+                    ]))
+                })
+            ];
+        });
+    }
+    prepareFollowNeuron(publicKey, followee) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [
+                (0, module_kit_1.newUnsignedTransaction)({
+                    transactions: yield (0, ICPGovernance_1.prepareFollowNeuron)(publicKey.value, BigInt(followee))
+                })
+            ];
+        });
+    }
+    prepareClaimOrRefreshNeuron(publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [
+                (0, module_kit_1.newUnsignedTransaction)({
+                    transactions: yield (0, ICPGovernance_1.prepareClaimOrRefreshNeuron)(publicKey.value)
+                })
+            ];
+        });
+    }
+    prepareIncreaseDissolveDelay(publicKey, dissolveDelay) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const partialNeuron = yield this.getNeuron(publicKey);
+            const currentDissolveDelay = (_b = (_a = partialNeuron === null || partialNeuron === void 0 ? void 0 : partialNeuron.dissolve_delay_seconds) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : '0';
+            const differenceInDissolveDelay = new bignumber_1.default(dissolveDelay).minus(currentDissolveDelay);
+            return [
+                (0, module_kit_1.newUnsignedTransaction)({
+                    transactions: yield (0, ICPGovernance_1.prepareIncreaseDissolveDelay)(publicKey.value, BigInt(differenceInDissolveDelay.toFixed()))
+                })
+            ];
+        });
+    }
+    prepareStartDissolving(publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [
+                (0, module_kit_1.newUnsignedTransaction)({
+                    transactions: yield (0, ICPGovernance_1.prepareStartDissolving)(publicKey.value)
+                })
+            ];
+        });
+    }
+    prepareStopDissolving(publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [
+                (0, module_kit_1.newUnsignedTransaction)({
+                    transactions: yield (0, ICPGovernance_1.prepareStopDissolving)(publicKey.value)
+                })
+            ];
+        });
+    }
+    prepareDisburseAndUnfollow(publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [
+                (0, module_kit_1.newUnsignedTransaction)({
+                    transactions: (0, array_1.flattenArray)(yield Promise.all([(0, ICPGovernance_1.prepareDisburse)(publicKey.value), (0, ICPGovernance_1.prepareFollowNeuron)(publicKey.value, undefined)]))
+                })
+            ];
+        });
+    }
+    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');
         });
-    };
-    return ICPProtocolImpl;
-}());
+    }
+    getKnownNeurons() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+        });
+    }
+    getNeuronBalance(publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Create subaccount from publicKey
+            const { subAccount, nonce: _ } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey.value);
+            const accountIdentifier = account_1.AccountIdentifier.fromPrincipal({
+                principal: principal_1.Principal.from(this.options.network.governanceCanisterId),
+                subAccount: subAccount
+            });
+            return this.getBalanceOfAddress(accountIdentifier.toHex()).then((balance) => balance.total);
+        });
+    }
+    getNeuronFollowees(neuron) {
+        const followees = (0, array_1.flattenArray)(neuron.followees.map(([_, { followees }]) => followees.map(({ id }) => id.toString())));
+        return Array.from(new Set(followees));
+    }
+    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
-function createICPProtocol(options) {
-    if (options === void 0) { options = {}; }
+function createICPProtocol(options = {}) {
     return new ICPProtocolImpl(options);
 }
 exports.createICPProtocol = createICPProtocol;
 exports.ICP_MAINNET_PROTOCOL_NETWORK = {
     name: 'Mainnet',
     type: 'mainnet',
-    rpcUrl: 'https://boundary.ic0.app/',
-    blockExplorerUrl: 'https://dashboard.internetcomputer.org/',
+    rpcUrl: 'https://ic0.app/',
     ledgerCanisterId: 'ryjl3-tyaaa-aaaaa-aaaba-cai',
-    blockExplorerApi: 'https://ledger-api.internetcomputer.org'
+    governanceCanisterId: 'rrkah-fqaaa-aaaaa-aaaaq-cai',
+    explorerUrl: 'https://ledger-api.internetcomputer.org'
 };
-var DEFAULT_ICP_PROTOCOL_NETWORK = exports.ICP_MAINNET_PROTOCOL_NETWORK;
-function createICPProtocolOptions(network) {
-    if (network === void 0) { network = {}; }
+const DEFAULT_ICP_PROTOCOL_NETWORK = exports.ICP_MAINNET_PROTOCOL_NETWORK;
+function createICPProtocolOptions(network = {}) {
     return {
-        network: __assign(__assign({}, DEFAULT_ICP_PROTOCOL_NETWORK), network)
+        network: Object.assign(Object.assign({}, DEFAULT_ICP_PROTOCOL_NETWORK), network)
     };
 }
 exports.createICPProtocolOptions = createICPProtocolOptions;