@airgap/icp 0.13.15-beta.0 → 0.13.15-beta.2

package/v1/protocol/ICPProtocol.js

@@ -1,15 +1,4 @@
 "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 __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) {
@@ -19,48 +8,25 @@ 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 crypto_1 = require("@airgap/crypto");
+const module_kit_1 = require("@airgap/module-kit");
+const transaction_1 = require("../types/transaction");
+const account_1 = require("../utils/account");
+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 +43,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: {
@@ -109,314 +74,536 @@ var ICPProtocolImpl = /** @class */ (function () {
         };
         this.options = createICPProtocolOptions(options.network);
     }
-    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.getDetailsFromSignedTransactionGetNeuronInfo)(publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT:
+                    return (0, ICPGovernance_1.getDetailsFromSignedTransactionTransferToSubaccount)(encoded, publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.CLAIM_GOVERNANCE:
+                    return (0, ICPGovernance_1.getDetailsFromSignedTransactionClaimGovernance)(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.getDetailsFromSignedTransactionIncreaseDelay)(publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.START_DISSOLVING:
+                    return (0, ICPGovernance_1.getDetailsFromSignedTransactionStartDissolving)(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:
+                    return (0, ICPGovernance_1.getDetailsFromSignedTransactionRestakeMaturity)(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.getDetailsFromUnsignedTransactionGetNeuronInfo)(publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT:
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedTransactionTransferToSubaccount)(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.getDetailsFromUnsignedTransactionIncreaseDelay)(publicKey.value, this.options.network);
+                case transaction_1.ICPActionType.START_DISSOLVING:
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedTransactionStartDissolving)(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);
+                case transaction_1.ICPActionType.RESTAKE_MATURITY:
+                    return (0, ICPGovernance_1.getDetailsFromUnsignedTransactionRestakeMaturity)(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),
+                            requestType: 'update'
+                        };
+                    case transaction_1.ICPActionType.GET_NEURON_INFO:
+                        return {
+                            actionType,
+                            encoded: yield (0, ICPGovernance_1.signTransactionGetNeuronInfo)(encoded, secretKey.value, this.options.network.governanceCanisterId),
+                            requestType: 'query'
+                        };
+                    case transaction_1.ICPActionType.TRANSFER_TO_SUBACCOUNT:
+                        return {
+                            actionType,
+                            encoded: yield (0, ICPGovernance_1.signTransactionTransferToSubaccount)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
+                            requestType: 'update'
+                        };
+                    case transaction_1.ICPActionType.CLAIM_GOVERNANCE:
+                        return {
+                            actionType,
+                            encoded: yield (0, ICPGovernance_1.signTransactionClaimGovernance)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
+                            requestType: 'update'
+                        };
+                    case transaction_1.ICPActionType.INCREASE_STAKE:
+                        throw new Error('TODO: implement');
+                    case transaction_1.ICPActionType.REMOVE_STAKE:
+                        return {
+                            actionType,
+                            encoded: yield (0, ICPGovernance_1.signTransactionRemoveStake)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
+                            requestType: 'update'
+                        };
+                    case transaction_1.ICPActionType.INCREASE_DELAY:
+                        return {
+                            actionType,
+                            encoded: yield (0, ICPGovernance_1.signTransactionIncreaseDelay)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
+                            requestType: 'update'
+                        };
+                    case transaction_1.ICPActionType.START_DISSOLVING:
+                        return {
+                            actionType,
+                            encoded: yield (0, ICPGovernance_1.signTransactionStartDissolving)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
+                            requestType: 'update'
+                        };
+                    case transaction_1.ICPActionType.STOP_DISSOLVING:
+                        return {
+                            actionType,
+                            encoded: yield (0, ICPGovernance_1.signTransactionStopDissolving)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
+                            requestType: 'update'
+                        };
+                    case transaction_1.ICPActionType.FOLLOW_NEURON:
+                        return {
+                            actionType,
+                            encoded: yield (0, ICPGovernance_1.signTransactionFollowNeuron)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
+                            requestType: 'update'
+                        };
+                    case transaction_1.ICPActionType.RESTAKE_MATURITY:
+                        return {
+                            actionType,
+                            encoded: yield (0, ICPGovernance_1.signTransactionRestakeMaturity)(encoded, secretKey.value, this.options.network.ledgerCanisterId),
+                            requestType: 'update'
+                        };
+                    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.explorerUrl).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);
+            return this.getBalanceOfAddress(address);
         });
-    };
-    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.medium).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) {
-        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;
         });
-    };
-    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);
+            // Transaction object
+            const transaction = {
+                from: (0, ICPImplementation_1.getAddressFromPublicKey)(publicKey.value),
+                to: details[0].to,
+                amount: amountBn,
+                fee: feeBn
+            };
+            // Create unsigned
+            const unsignedTransaction = (0, ICPImplementation_1.createUnsignedTransaction)(transaction);
+            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* () {
+            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];
+        });
+    }
+    // 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) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddressFromPublicKey(publicKey);
+            return this.getCurrentDelegateesForAddress(address);
+        });
+    }
+    getCurrentDelegateesForAddress(address) {
+        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 [];
+        });
+    }
+    getDelegateeDetails(address) {
+        var _a, _b;
+        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
+            };
+        });
+    }
+    isPublicKeyDelegating(publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddressFromPublicKey(publicKey);
+            return this.isAddressDelegating(address);
+        });
+    }
+    isAddressDelegating(address) {
+        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;
+        });
+    }
+    getDelegatorDetailsFromPublicKey(publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddressFromPublicKey(publicKey);
+            return this.getDelegatorDetailsFromAddress(address);
+        });
+    }
+    getDelegatorDetailsFromAddress(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const metadata = yield this.getMetadata();
+            const availableBalance = yield this.getBalanceOfAddress(address);
+            const availableActions = yield this.getAvailableDelegatorActions();
+            const totalBalance = (0, module_kit_1.newAmount)(availableBalance.total).blockchain(metadata.units);
+            return {
+                address,
+                balance: totalBalance.value,
+                delegatees: [],
+                availableActions: availableActions
+            };
+        });
+    }
+    getDelegationDetailsFromPublicKey(publicKey, delegatees) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddressFromPublicKey(publicKey);
+            return this.getDelegationDetailsFromAddress(address, delegatees);
+        });
+    }
+    getDelegationDetailsFromAddress(address, delegatees) {
+        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 delegatorDetails = results[0];
+            const validatorDetails = results[1];
+            return {
+                delegator: delegatorDetails,
+                delegatees: [validatorDetails]
+            };
+        });
+    }
+    getAvailableDelegatorActions() {
+        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
+            });
+            return actions;
         });
-    };
-    return ICPProtocolImpl;
-}());
+    }
+    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)];
+                default:
+                    return Promise.reject(`Delegator action type ${type} is not supported.`);
+            }
+        });
+    }
+    fetchValidators() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, ICPImplementation_1.listKnownNeurons)(this.options.network.rpcUrl, this.options.network.governanceCanisterId);
+        });
+    }
+    fetchVotingPower(neuronId) {
+        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);
+        });
+    }
+    fetchNeuron(publicKey) {
+        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 neuron;
+        });
+    }
+    fetchSubaccountBalance(publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Create subaccount from publicKey
+            const { subAccount, nonce: _ } = (0, ICPImplementation_1.getFixedSubaccountFromPublicKey)(publicKey);
+            const accountIdentifier = account_1.AccountIdentifier.fromPrincipal({
+                principal: principal_1.Principal.from(this.options.network.ledgerCanisterId),
+                subAccount: subAccount
+            });
+            return this.getBalanceOfAddress(accountIdentifier.toHex());
+        });
+    }
+}
 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/',
+    rpcUrl: 'https://ic0.app/',
     ledgerCanisterId: 'ryjl3-tyaaa-aaaaa-aaaba-cai',
+    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;