@airgap/substrate 0.13.45-beta.3 → 0.13.45-beta.5

package/v0/protocol/SubstrateProtocol.js

@@ -1,352 +1,691 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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.SubstrateProtocol = void 0;
-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 coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
-const NonExtendedProtocol_1 = require("@airgap/coinlib-core/protocols/NonExtendedProtocol");
-const SubstrateAddress_1 = require("./common/data/account/SubstrateAddress");
-const SubstrateTransaction_1 = require("./common/data/transaction/SubstrateTransaction");
-const SubstrateCryptoClient_1 = require("./SubstrateCryptoClient");
-class SubstrateProtocol extends NonExtendedProtocol_1.NonExtendedProtocol {
-    constructor(options) {
-        super();
-        this.options = options;
-        this.supportsHD = false;
-        this.addressIsCaseSensitive = true;
-        this.addressValidationPattern = '^5[a-km-zA-HJ-NP-Z1-9]+$';
-        this.addressPlaceholder = `5ABC...`;
-        this.cryptoClient = new SubstrateCryptoClient_1.SubstrateCryptoClient();
-    }
-    async getSymbol() {
-        return this.symbol;
-    }
-    async getName() {
-        return this.name;
-    }
-    async getMarketSymbol() {
-        return this.marketSymbol;
-    }
-    async getAssetSymbol() {
-        return undefined;
-    }
-    async getFeeSymbol() {
-        return this.feeSymbol;
-    }
-    async getDecimals() {
-        return this.decimals;
-    }
-    async getFeeDecimals() {
-        return this.feeDecimals;
-    }
-    async getIdentifier() {
-        return this.identifier;
-    }
-    async getFeeDefaults() {
-        return this.feeDefaults;
-    }
-    async getUnits() {
-        return this.units;
-    }
-    async getStandardDerivationPath() {
-        return this.standardDerivationPath;
-    }
-    async getSupportsHD() {
-        return this.supportsHD;
-    }
-    async getAddressIsCaseSensitive() {
-        return this.addressIsCaseSensitive;
-    }
-    async getAddressValidationPattern() {
-        return this.addressValidationPattern;
-    }
-    async getAddressPlaceholder() {
-        return this.addressPlaceholder;
-    }
-    async getOptions() {
-        return this.options;
-    }
-    async getBlockExplorerLinkForAddress(address) {
-        return this.options.network.blockExplorer.getAddressLink(address);
-    }
-    async getBlockExplorerLinkForTxId(txId) {
-        return this.options.network.blockExplorer.getTransactionLink(txId);
-    }
-    async getPublicKeyFromMnemonic(mnemonic, derivationPath, password) {
-        const keyPair = await this.options.accountController.createKeyPairFromMnemonic(mnemonic, derivationPath, password);
-        return keyPair.publicKey.toString('hex');
-    }
-    async getPrivateKeyFromMnemonic(mnemonic, derivationPath, password) {
-        const keyPair = await this.options.accountController.createKeyPairFromMnemonic(mnemonic, derivationPath, password);
-        return keyPair.privateKey.toString('hex');
-    }
-    async getPublicKeyFromHexSecret(secret, derivationPath) {
-        const keyPair = await this.options.accountController.createKeyPairFromHexSecret(secret, derivationPath);
-        return keyPair.publicKey.toString('hex');
-    }
-    async getPrivateKeyFromHexSecret(secret, derivationPath) {
-        const keyPair = await this.options.accountController.createKeyPairFromHexSecret(secret, derivationPath);
-        return keyPair.privateKey.toString('hex');
-    }
-    async getAddressFromPublicKey(publicKey, cursor) {
-        const address = await this.options.accountController.createAddressFromPublicKey(publicKey);
-        return {
-            address: address.asString(),
-            cursor: { hasNext: false }
-        };
-    }
-    async getAddressesFromPublicKey(publicKey, cursor) {
-        return [await this.getAddressFromPublicKey(publicKey, cursor)];
-    }
-    async getTransactionsFromPublicKey(publicKey, limit, cursor) {
-        const addresses = await this.getAddressesFromPublicKey(publicKey).then((addresses) => addresses.map((address) => address.address));
-        return this.getTransactionsFromAddresses(addresses, limit, cursor);
-    }
-    async getTransactionsFromAddresses(addresses, limit, cursor) {
-        const txs = await Promise.all(addresses.map((address) => this.options.blockExplorerClient.getTransactions(address, limit, this.decimals, cursor)));
-        const transactions = txs
-            .reduce((flatten, toFlatten) => flatten.concat(toFlatten), [])
-            .map((tx) => ({
-            protocolIdentifier: this.identifier,
-            network: this.options.network,
-            from: [],
-            to: [],
-            isInbound: false,
-            amount: '',
-            fee: '',
-            ...tx
-        }));
-        return { transactions, cursor: { page: cursor ? cursor.page + 1 : 1 } };
-    }
-    async signWithPrivateKey(privateKey, rawTransaction) {
-        const txs = this.options.transactionController.decodeDetails(rawTransaction.encoded);
-        const signed = await Promise.all(txs.map((tx) => this.options.transactionController.signTransaction(Buffer.from(privateKey, 'hex'), tx.transaction, tx.payload)));
-        txs.forEach((tx, index) => (tx.transaction = signed[index]));
-        return this.options.transactionController.encodeDetails(txs);
-    }
-    async getTransactionDetails(transaction) {
-        return this.getTransactionDetailsFromEncoded(transaction.transaction.encoded);
-    }
-    async getTransactionDetailsFromSigned(transaction) {
-        return this.getTransactionDetailsFromEncoded(transaction.transaction);
-    }
-    async getBalanceOfAddresses(addresses) {
-        const balances = await Promise.all(addresses.map((address) => this.options.accountController.getBalance(address)));
-        const balance = balances.reduce((current, next) => current.plus(next));
-        return balance.toString(10);
-    }
-    async getAvailableBalanceOfAddresses(addresses) {
-        const balances = await Promise.all(addresses.map((address) => this.options.accountController.getTransferableBalance(address, false)));
-        const balance = balances.reduce((current, next) => current.plus(next));
-        return balance.toString(10);
-    }
-    async getBalanceOfPublicKey(publicKey) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getBalanceOfAddresses([address.address]);
-    }
-    async getBalanceOfPublicKeyForSubProtocols(publicKey, subProtocols) {
-        throw Promise.reject('get balance of sub protocols not supported');
-    }
-    async estimateMaxTransactionValueFromPublicKey(publicKey, _recipients, fee, data) {
-        const results = await Promise.all([
-            this.options.accountController.getTransferableBalance(publicKey, data?.excludeExistentialDeposit),
-            this.getFutureRequiredTransactions(publicKey, 'transfer')
-        ]);
-        const transferableBalance = results[0];
-        const futureTransactions = results[1];
-        const feeEstimate = await this.options.transactionController.estimateTransactionFees(publicKey, futureTransactions);
-        if (!feeEstimate) {
-            return Promise.reject('Could not estimate max value.');
-        }
-        let maxAmount = transferableBalance.minus(feeEstimate).minus(new bignumber_1.default(fee || 0));
-        if (maxAmount.lt(0)) {
-            maxAmount = new bignumber_1.default(0);
-        }
-        return maxAmount.toFixed();
-    }
-    async estimateFeeDefaultsFromPublicKey(publicKey, recipients, values, data) {
-        const destination = recipients[0];
-        const value = values[0];
-        const transaction = await this.options.transactionController.createTransaction(SubstrateTransaction_1.SubstrateTransactionType.TRANSFER, publicKey, 0, {
-            to: destination && destination.length > 0 ? destination : publicKey,
-            value: new bignumber_1.default(value)
-        });
-        const fee = await this.options.transactionController.calculateTransactionFee(transaction);
-        if (!fee) {
-            return Promise.reject('Could not fetch all necessary data.');
-        }
-        return {
-            low: fee.shiftedBy(-this.feeDecimals).toFixed(),
-            medium: fee.shiftedBy(-this.feeDecimals).toFixed(),
-            high: fee.shiftedBy(-this.feeDecimals).toFixed()
-        };
-    }
-    async prepareTransactionFromPublicKey(publicKey, recipients, values, fee, data) {
-        if (recipients.length !== values.length) {
-            return Promise.reject("Recipients length doesn't match values length.");
-        }
-        const recipientsWithValues = recipients.map((recipient, index) => [recipient, values[index]]);
-        const excludeExistentialDeposit = data?.excludeExistentialDeposit;
-        const transferableBalance = await this.options.accountController.getTransferableBalance(publicKey, excludeExistentialDeposit);
-        const totalValue = values.map((value) => new bignumber_1.default(value)).reduce((total, next) => total.plus(next), new bignumber_1.default(0));
-        const available = new bignumber_1.default(transferableBalance).minus(totalValue);
-        const encoded = await this.options.transactionController.prepareSubmittableTransactions(publicKey, available, recipientsWithValues.map(([recipient, value]) => ({
-            type: SubstrateTransaction_1.SubstrateTransactionType.TRANSFER,
-            tip: 0, // temporary, until we handle Substrate fee/tip model
-            args: {
-                to: recipient,
-                value: new bignumber_1.default(value)
-            }
-        })));
-        return { encoded };
-    }
-    async broadcastTransaction(encoded) {
-        const txs = this.options.transactionController
-            .decodeDetails(encoded)
-            .map((tx) => [tx.runtimeVersion, tx.transaction]);
-        const txHashes = await Promise.all(txs.map((tx) => this.options.nodeClient.submitTransaction(tx[1].encode({ network: this.options.network.extras.network, runtimeVersion: tx[0] })))).catch((error) => {
-            throw new errors_1.NetworkError(coinlib_error_1.Domain.SUBSTRATE, error);
-        });
-        return txs[0][1]?.type !== SubstrateTransaction_1.SubstrateTransactionType.SUBMIT_BATCH ? txHashes[0] : '';
-    }
-    async getFutureRequiredTransactions(accountId, intention) {
-        const results = await Promise.all([
-            this.options.accountController.isBonded(accountId),
-            this.options.accountController.isDelegating(accountId),
-            this.options.accountController.getTransferableBalance(accountId),
-            this.options.accountController.getTransferableBalance(accountId, false, false),
-            this.options.accountController.getUnlockingBalance(accountId)
-        ]);
-        const isBonded = results[0];
-        const isNominating = results[1];
-        const transferableBalance = results[2];
-        const stakingBalance = results[3];
-        const unlockingBalance = results[4];
-        const isUnbonding = unlockingBalance.gt(0);
-        const requiredTransactions = [];
-        if (intention === 'transfer') {
-            requiredTransactions.push([
-                SubstrateTransaction_1.SubstrateTransactionType.TRANSFER,
-                {
-                    to: SubstrateAddress_1.SubstrateAddress.createPlaceholder(),
-                    value: transferableBalance
+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 coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
+var NonExtendedProtocol_1 = require("@airgap/coinlib-core/protocols/NonExtendedProtocol");
+var SubstrateAddress_1 = require("./common/data/account/SubstrateAddress");
+var SubstrateTransaction_1 = require("./common/data/transaction/SubstrateTransaction");
+var SubstrateCryptoClient_1 = require("./SubstrateCryptoClient");
+var SubstrateProtocol = /** @class */ (function (_super) {
+    __extends(SubstrateProtocol, _super);
+    function SubstrateProtocol(options) {
+        var _this = _super.call(this) || this;
+        _this.options = options;
+        _this.supportsHD = false;
+        _this.addressIsCaseSensitive = true;
+        _this.addressValidationPattern = '^5[a-km-zA-HJ-NP-Z1-9]+$';
+        _this.addressPlaceholder = "5ABC...";
+        _this.cryptoClient = new SubstrateCryptoClient_1.SubstrateCryptoClient();
+        return _this;
+    }
+    SubstrateProtocol.prototype.getSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.symbol];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getName = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.name];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getMarketSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.marketSymbol];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getAssetSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, undefined];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getFeeSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.feeSymbol];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getDecimals = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.decimals];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getFeeDecimals = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.feeDecimals];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getIdentifier = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.identifier];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getFeeDefaults = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.feeDefaults];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getUnits = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.units];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getStandardDerivationPath = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.standardDerivationPath];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getSupportsHD = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.supportsHD];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getAddressIsCaseSensitive = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.addressIsCaseSensitive];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getAddressValidationPattern = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.addressValidationPattern];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getAddressPlaceholder = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.addressPlaceholder];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getOptions = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getBlockExplorerLinkForAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network.blockExplorer.getAddressLink(address)];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getBlockExplorerLinkForTxId = function (txId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network.blockExplorer.getTransactionLink(txId)];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getPublicKeyFromMnemonic = function (mnemonic, derivationPath, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var keyPair;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.options.accountController.createKeyPairFromMnemonic(mnemonic, derivationPath, password)];
+                    case 1:
+                        keyPair = _a.sent();
+                        return [2 /*return*/, keyPair.publicKey.toString('hex')];
                 }
-            ]);
-        }
-        if (!isBonded && !isUnbonding && intention === 'delegate') {
-            // not delegated & unbond
-            requiredTransactions.push([
-                SubstrateTransaction_1.SubstrateTransactionType.BOND,
-                {
-                    controller: SubstrateAddress_1.SubstrateAddress.createPlaceholder(),
-                    value: stakingBalance,
-                    payee: 0
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getPrivateKeyFromMnemonic = function (mnemonic, derivationPath, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var keyPair;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.options.accountController.createKeyPairFromMnemonic(mnemonic, derivationPath, password)];
+                    case 1:
+                        keyPair = _a.sent();
+                        return [2 /*return*/, keyPair.privateKey.toString('hex')];
                 }
-            ], [
-                SubstrateTransaction_1.SubstrateTransactionType.NOMINATE,
-                {
-                    targets: [SubstrateAddress_1.SubstrateAddress.createPlaceholder()]
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getPublicKeyFromHexSecret = function (secret, derivationPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var keyPair;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.options.accountController.createKeyPairFromHexSecret(secret, derivationPath)];
+                    case 1:
+                        keyPair = _a.sent();
+                        return [2 /*return*/, keyPair.publicKey.toString('hex')];
                 }
-            ], [SubstrateTransaction_1.SubstrateTransactionType.CANCEL_NOMINATION, {}], [
-                SubstrateTransaction_1.SubstrateTransactionType.UNBOND,
-                {
-                    value: stakingBalance
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getPrivateKeyFromHexSecret = function (secret, derivationPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var keyPair;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.options.accountController.createKeyPairFromHexSecret(secret, derivationPath)];
+                    case 1:
+                        keyPair = _a.sent();
+                        return [2 /*return*/, keyPair.privateKey.toString('hex')];
                 }
-            ], [
-                SubstrateTransaction_1.SubstrateTransactionType.WITHDRAW_UNBONDED,
-                {
-                    slashingSpansNumber: 0
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getAddressFromPublicKey = function (publicKey, 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.options.accountController.createAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, {
+                                address: address.asString(),
+                                cursor: { hasNext: false }
+                            }];
                 }
-            ]);
-        }
-        else if (isUnbonding && intention === 'delegate') {
-            requiredTransactions.push([
-                SubstrateTransaction_1.SubstrateTransactionType.REBOND,
-                {
-                    value: unlockingBalance
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getAddressesFromPublicKey = function (publicKey, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey, cursor)];
+                    case 1: return [2 /*return*/, [_a.sent()]];
                 }
-            ], [
-                SubstrateTransaction_1.SubstrateTransactionType.NOMINATE,
-                {
-                    targets: [SubstrateAddress_1.SubstrateAddress.createPlaceholder()]
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getTransactionsFromPublicKey = function (publicKey, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var addresses;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressesFromPublicKey(publicKey).then(function (addresses) {
+                            return addresses.map(function (address) { return address.address; });
+                        })];
+                    case 1:
+                        addresses = _a.sent();
+                        return [2 /*return*/, this.getTransactionsFromAddresses(addresses, limit, cursor)];
                 }
-            ], [SubstrateTransaction_1.SubstrateTransactionType.CANCEL_NOMINATION, {}], [
-                SubstrateTransaction_1.SubstrateTransactionType.UNBOND,
-                {
-                    value: stakingBalance.plus(unlockingBalance)
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getTransactionsFromAddresses = function (addresses, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txs, transactions;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(addresses.map(function (address) { return _this.options.blockExplorerClient.getTransactions(address, limit, _this.decimals, cursor); }))];
+                    case 1:
+                        txs = _a.sent();
+                        transactions = txs
+                            .reduce(function (flatten, toFlatten) { return flatten.concat(toFlatten); }, [])
+                            .map(function (tx) { return (__assign({ protocolIdentifier: _this.identifier, network: _this.options.network, from: [], to: [], isInbound: false, amount: '', fee: '' }, tx)); });
+                        return [2 /*return*/, { transactions: transactions, cursor: { page: cursor ? cursor.page + 1 : 1 } }];
                 }
-            ], [
-                SubstrateTransaction_1.SubstrateTransactionType.WITHDRAW_UNBONDED,
-                {
-                    slashingSpansNumber: 0
+            });
+        });
+    };
+    SubstrateProtocol.prototype.signWithPrivateKey = function (privateKey, rawTransaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txs, signed;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        txs = this.options.transactionController.decodeDetails(rawTransaction.encoded);
+                        return [4 /*yield*/, Promise.all(txs.map(function (tx) { return _this.options.transactionController.signTransaction(Buffer.from(privateKey, 'hex'), tx.transaction, tx.payload); }))];
+                    case 1:
+                        signed = _a.sent();
+                        txs.forEach(function (tx, index) { return (tx.transaction = signed[index]); });
+                        return [2 /*return*/, this.options.transactionController.encodeDetails(txs)];
                 }
-            ]);
-        }
-        else if (isBonded) {
-            requiredTransactions.push([
-                SubstrateTransaction_1.SubstrateTransactionType.UNBOND,
-                {
-                    value: stakingBalance
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getTransactionDetails = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getTransactionDetailsFromEncoded(transaction.transaction.encoded)];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getTransactionDetailsFromSigned = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getTransactionDetailsFromEncoded(transaction.transaction)];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getBalanceOfAddresses = function (addresses) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balances, balance;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(addresses.map(function (address) { return _this.options.accountController.getBalance(address); }))];
+                    case 1:
+                        balances = _a.sent();
+                        balance = balances.reduce(function (current, next) { return current.plus(next); });
+                        return [2 /*return*/, balance.toString(10)];
                 }
-            ], [
-                SubstrateTransaction_1.SubstrateTransactionType.WITHDRAW_UNBONDED,
-                {
-                    slashingSpansNumber: 0
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getAvailableBalanceOfAddresses = function (addresses) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balances, balance;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(addresses.map(function (address) { return _this.options.accountController.getTransferableBalance(address, false); }))];
+                    case 1:
+                        balances = _a.sent();
+                        balance = balances.reduce(function (current, next) { return current.plus(next); });
+                        return [2 /*return*/, balance.toString(10)];
                 }
-            ]);
-        }
-        if (isNominating) {
-            requiredTransactions.push([SubstrateTransaction_1.SubstrateTransactionType.CANCEL_NOMINATION, {}]);
-        }
-        return requiredTransactions;
-    }
-    async getTransactionDetailsFromEncoded(encoded) {
-        const txs = this.options.transactionController.decodeDetails(encoded);
-        return txs
-            .map((tx) => {
-            return tx.transaction.toAirGapTransactions().map((part) => ({
-                from: [],
-                to: [],
-                amount: '',
-                fee: tx.fee.toString(),
-                protocolIdentifier: this.identifier,
-                network: this.options.network,
-                isInbound: false,
-                ...part
-            }));
-        })
-            .reduce((flatten, toFlatten) => flatten.concat(toFlatten), []);
-    }
-    async signMessage(message, keypair) {
-        return this.cryptoClient.signMessage(message, keypair);
-    }
-    async verifyMessage(message, signature, publicKey) {
-        return this.cryptoClient.verifyMessage(message, signature, publicKey);
-    }
-    async encryptAsymmetric(message, publicKey) {
-        return this.cryptoClient.encryptAsymmetric(message, publicKey);
-    }
-    async decryptAsymmetric(message, keypair) {
-        return this.cryptoClient.decryptAsymmetric(message, keypair);
-    }
-    async encryptAES(message, privateKey) {
-        // https://github.com/w3f/schnorrkel/blob/master/src/keys.rs
-        // https://github.com/polkadot-js/wasm/blob/master/packages/wasm-crypto/src/sr25519.rs
-        const key = Buffer.from(privateKey, 'hex').slice(0, 32); // Substrate key is 32 bytes key + 32 bytes nonce
-        return this.cryptoClient.encryptAES(message, key.toString('hex'));
-    }
-    async decryptAES(message, privateKey) {
-        // https://github.com/w3f/schnorrkel/blob/master/src/keys.rs
-        // https://github.com/polkadot-js/wasm/blob/master/packages/wasm-crypto/src/sr25519.rs
-        const key = Buffer.from(privateKey, 'hex').slice(0, 32); // Substrate key is 32 bytes key + 32 bytes nonce
-        return this.cryptoClient.decryptAES(message, key.toString('hex'));
-    }
-    async getTransactionStatuses(transactionHashes) {
-        return Promise.reject('Transaction status not implemented');
-    }
-}
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getBalanceOfPublicKey = function (publicKey) {
+        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.getBalanceOfAddresses([address.address])];
+                }
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getBalanceOfPublicKeyForSubProtocols = function (publicKey, subProtocols) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw Promise.reject('get balance of sub protocols not supported');
+            });
+        });
+    };
+    SubstrateProtocol.prototype.estimateMaxTransactionValueFromPublicKey = function (publicKey, _recipients, fee, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var results, transferableBalance, futureTransactions, feeEstimate, maxAmount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            this.options.accountController.getTransferableBalance(publicKey, data === null || data === void 0 ? void 0 : data.excludeExistentialDeposit),
+                            this.getFutureRequiredTransactions(publicKey, 'transfer')
+                        ])];
+                    case 1:
+                        results = _a.sent();
+                        transferableBalance = results[0];
+                        futureTransactions = results[1];
+                        return [4 /*yield*/, this.options.transactionController.estimateTransactionFees(publicKey, futureTransactions)];
+                    case 2:
+                        feeEstimate = _a.sent();
+                        if (!feeEstimate) {
+                            return [2 /*return*/, Promise.reject('Could not estimate max value.')];
+                        }
+                        maxAmount = transferableBalance.minus(feeEstimate).minus(new bignumber_1.default(fee || 0));
+                        if (maxAmount.lt(0)) {
+                            maxAmount = new bignumber_1.default(0);
+                        }
+                        return [2 /*return*/, maxAmount.toFixed()];
+                }
+            });
+        });
+    };
+    SubstrateProtocol.prototype.estimateFeeDefaultsFromPublicKey = function (publicKey, recipients, values, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var destination, value, transaction, fee;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        destination = recipients[0];
+                        value = values[0];
+                        return [4 /*yield*/, this.options.transactionController.createTransaction(SubstrateTransaction_1.SubstrateTransactionType.TRANSFER, publicKey, 0, {
+                                to: destination && destination.length > 0 ? destination : publicKey,
+                                value: new bignumber_1.default(value)
+                            })];
+                    case 1:
+                        transaction = _a.sent();
+                        return [4 /*yield*/, this.options.transactionController.calculateTransactionFee(transaction)];
+                    case 2:
+                        fee = _a.sent();
+                        if (!fee) {
+                            return [2 /*return*/, Promise.reject('Could not fetch all necessary data.')];
+                        }
+                        return [2 /*return*/, {
+                                low: fee.shiftedBy(-this.feeDecimals).toFixed(),
+                                medium: fee.shiftedBy(-this.feeDecimals).toFixed(),
+                                high: fee.shiftedBy(-this.feeDecimals).toFixed()
+                            }];
+                }
+            });
+        });
+    };
+    SubstrateProtocol.prototype.prepareTransactionFromPublicKey = function (publicKey, recipients, values, fee, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var recipientsWithValues, excludeExistentialDeposit, transferableBalance, totalValue, available, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (recipients.length !== values.length) {
+                            return [2 /*return*/, Promise.reject("Recipients length doesn't match values length.")];
+                        }
+                        recipientsWithValues = recipients.map(function (recipient, index) { return [recipient, values[index]]; });
+                        excludeExistentialDeposit = data === null || data === void 0 ? void 0 : data.excludeExistentialDeposit;
+                        return [4 /*yield*/, this.options.accountController.getTransferableBalance(publicKey, excludeExistentialDeposit)];
+                    case 1:
+                        transferableBalance = _a.sent();
+                        totalValue = values.map(function (value) { return new bignumber_1.default(value); }).reduce(function (total, next) { return total.plus(next); }, new bignumber_1.default(0));
+                        available = new bignumber_1.default(transferableBalance).minus(totalValue);
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, available, recipientsWithValues.map(function (_a) {
+                                var recipient = _a[0], value = _a[1];
+                                return ({
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.TRANSFER,
+                                    tip: 0,
+                                    args: {
+                                        to: recipient,
+                                        value: new bignumber_1.default(value)
+                                    }
+                                });
+                            }))];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, { encoded: encoded }];
+                }
+            });
+        });
+    };
+    SubstrateProtocol.prototype.broadcastTransaction = function (encoded) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var txs, txHashes;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        txs = this.options.transactionController
+                            .decodeDetails(encoded)
+                            .map(function (tx) { return [tx.runtimeVersion, tx.transaction]; });
+                        return [4 /*yield*/, Promise.all(txs.map(function (tx) {
+                                return _this.options.nodeClient.submitTransaction(tx[1].encode({ network: _this.options.network.extras.network, runtimeVersion: tx[0] }));
+                            })).catch(function (error) {
+                                throw new errors_1.NetworkError(coinlib_error_1.Domain.SUBSTRATE, error);
+                            })];
+                    case 1:
+                        txHashes = _b.sent();
+                        return [2 /*return*/, ((_a = txs[0][1]) === null || _a === void 0 ? void 0 : _a.type) !== SubstrateTransaction_1.SubstrateTransactionType.SUBMIT_BATCH ? txHashes[0] : ''];
+                }
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getFutureRequiredTransactions = function (accountId, intention) {
+        return __awaiter(this, void 0, void 0, function () {
+            var results, isBonded, isNominating, transferableBalance, stakingBalance, unlockingBalance, isUnbonding, requiredTransactions;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            this.options.accountController.isBonded(accountId),
+                            this.options.accountController.isDelegating(accountId),
+                            this.options.accountController.getTransferableBalance(accountId),
+                            this.options.accountController.getTransferableBalance(accountId, false, false),
+                            this.options.accountController.getUnlockingBalance(accountId)
+                        ])];
+                    case 1:
+                        results = _a.sent();
+                        isBonded = results[0];
+                        isNominating = results[1];
+                        transferableBalance = results[2];
+                        stakingBalance = results[3];
+                        unlockingBalance = results[4];
+                        isUnbonding = unlockingBalance.gt(0);
+                        requiredTransactions = [];
+                        if (intention === 'transfer') {
+                            requiredTransactions.push([
+                                SubstrateTransaction_1.SubstrateTransactionType.TRANSFER,
+                                {
+                                    to: SubstrateAddress_1.SubstrateAddress.createPlaceholder(),
+                                    value: transferableBalance
+                                }
+                            ]);
+                        }
+                        if (!isBonded && !isUnbonding && intention === 'delegate') {
+                            // not delegated & unbond
+                            requiredTransactions.push([
+                                SubstrateTransaction_1.SubstrateTransactionType.BOND,
+                                {
+                                    controller: SubstrateAddress_1.SubstrateAddress.createPlaceholder(),
+                                    value: stakingBalance,
+                                    payee: 0
+                                }
+                            ], [
+                                SubstrateTransaction_1.SubstrateTransactionType.NOMINATE,
+                                {
+                                    targets: [SubstrateAddress_1.SubstrateAddress.createPlaceholder()]
+                                }
+                            ], [SubstrateTransaction_1.SubstrateTransactionType.CANCEL_NOMINATION, {}], [
+                                SubstrateTransaction_1.SubstrateTransactionType.UNBOND,
+                                {
+                                    value: stakingBalance
+                                }
+                            ], [
+                                SubstrateTransaction_1.SubstrateTransactionType.WITHDRAW_UNBONDED,
+                                {
+                                    slashingSpansNumber: 0
+                                }
+                            ]);
+                        }
+                        else if (isUnbonding && intention === 'delegate') {
+                            requiredTransactions.push([
+                                SubstrateTransaction_1.SubstrateTransactionType.REBOND,
+                                {
+                                    value: unlockingBalance
+                                }
+                            ], [
+                                SubstrateTransaction_1.SubstrateTransactionType.NOMINATE,
+                                {
+                                    targets: [SubstrateAddress_1.SubstrateAddress.createPlaceholder()]
+                                }
+                            ], [SubstrateTransaction_1.SubstrateTransactionType.CANCEL_NOMINATION, {}], [
+                                SubstrateTransaction_1.SubstrateTransactionType.UNBOND,
+                                {
+                                    value: stakingBalance.plus(unlockingBalance)
+                                }
+                            ], [
+                                SubstrateTransaction_1.SubstrateTransactionType.WITHDRAW_UNBONDED,
+                                {
+                                    slashingSpansNumber: 0
+                                }
+                            ]);
+                        }
+                        else if (isBonded) {
+                            requiredTransactions.push([
+                                SubstrateTransaction_1.SubstrateTransactionType.UNBOND,
+                                {
+                                    value: stakingBalance
+                                }
+                            ], [
+                                SubstrateTransaction_1.SubstrateTransactionType.WITHDRAW_UNBONDED,
+                                {
+                                    slashingSpansNumber: 0
+                                }
+                            ]);
+                        }
+                        if (isNominating) {
+                            requiredTransactions.push([SubstrateTransaction_1.SubstrateTransactionType.CANCEL_NOMINATION, {}]);
+                        }
+                        return [2 /*return*/, requiredTransactions];
+                }
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getTransactionDetailsFromEncoded = function (encoded) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txs;
+            var _this = this;
+            return __generator(this, function (_a) {
+                txs = this.options.transactionController.decodeDetails(encoded);
+                return [2 /*return*/, txs
+                        .map(function (tx) {
+                        return tx.transaction.toAirGapTransactions().map(function (part) { return (__assign({ from: [], to: [], amount: '', fee: tx.fee.toString(), protocolIdentifier: _this.identifier, network: _this.options.network, isInbound: false }, part)); });
+                    })
+                        .reduce(function (flatten, toFlatten) { return flatten.concat(toFlatten); }, [])];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.signMessage = function (message, keypair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.signMessage(message, keypair)];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.verifyMessage = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.verifyMessage(message, signature, publicKey)];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.encryptAsymmetric = function (message, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.encryptAsymmetric(message, publicKey)];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.decryptAsymmetric = function (message, keypair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.decryptAsymmetric(message, keypair)];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.encryptAES = function (message, privateKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var key;
+            return __generator(this, function (_a) {
+                key = Buffer.from(privateKey, 'hex').slice(0, 32) // Substrate key is 32 bytes key + 32 bytes nonce
+                ;
+                return [2 /*return*/, this.cryptoClient.encryptAES(message, key.toString('hex'))];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.decryptAES = function (message, privateKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var key;
+            return __generator(this, function (_a) {
+                key = Buffer.from(privateKey, 'hex').slice(0, 32) // Substrate key is 32 bytes key + 32 bytes nonce
+                ;
+                return [2 /*return*/, this.cryptoClient.decryptAES(message, key.toString('hex'))];
+            });
+        });
+    };
+    SubstrateProtocol.prototype.getTransactionStatuses = function (transactionHashes) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Promise.reject('Transaction status not implemented')];
+            });
+        });
+    };
+    return SubstrateProtocol;
+}(NonExtendedProtocol_1.NonExtendedProtocol));
 exports.SubstrateProtocol = SubstrateProtocol;
 //# sourceMappingURL=SubstrateProtocol.js.map