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

package/v0/protocol/SubstrateProtocol.js

@@ -1,691 +1,352 @@
 "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;
-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')];
-                }
-            });
-        });
-    };
-    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')];
-                }
-            });
-        });
-    };
-    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')];
-                }
-            });
-        });
-    };
-    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')];
-                }
-            });
-        });
-    };
-    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 }
-                            }];
-                }
-            });
-        });
-    };
-    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()]];
-                }
-            });
-        });
-    };
-    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)];
+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
                 }
-            });
-        });
-    };
-    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 } }];
+            ]);
+        }
+        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.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)];
+            ], [
+                SubstrateTransaction_1.SubstrateTransactionType.NOMINATE,
+                {
+                    targets: [SubstrateAddress_1.SubstrateAddress.createPlaceholder()]
                 }
-            });
-        });
-    };
-    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.CANCEL_NOMINATION, {}], [
+                SubstrateTransaction_1.SubstrateTransactionType.UNBOND,
+                {
+                    value: stakingBalance
                 }
-            });
-        });
-    };
-    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)];
+            ], [
+                SubstrateTransaction_1.SubstrateTransactionType.WITHDRAW_UNBONDED,
+                {
+                    slashingSpansNumber: 0
                 }
-            });
-        });
-    };
-    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])];
+            ]);
+        }
+        else if (isUnbonding && intention === 'delegate') {
+            requiredTransactions.push([
+                SubstrateTransaction_1.SubstrateTransactionType.REBOND,
+                {
+                    value: unlockingBalance
                 }
-            });
-        });
-    };
-    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()];
+            ], [
+                SubstrateTransaction_1.SubstrateTransactionType.NOMINATE,
+                {
+                    targets: [SubstrateAddress_1.SubstrateAddress.createPlaceholder()]
                 }
-            });
-        });
-    };
-    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()
-                            }];
+            ], [SubstrateTransaction_1.SubstrateTransactionType.CANCEL_NOMINATION, {}], [
+                SubstrateTransaction_1.SubstrateTransactionType.UNBOND,
+                {
+                    value: stakingBalance.plus(unlockingBalance)
                 }
-            });
-        });
-    };
-    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 }];
+            ], [
+                SubstrateTransaction_1.SubstrateTransactionType.WITHDRAW_UNBONDED,
+                {
+                    slashingSpansNumber: 0
                 }
-            });
-        });
-    };
-    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] : ''];
+            ]);
+        }
+        else if (isBonded) {
+            requiredTransactions.push([
+                SubstrateTransaction_1.SubstrateTransactionType.UNBOND,
+                {
+                    value: stakingBalance
                 }
-            });
-        });
-    };
-    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];
+            ], [
+                SubstrateTransaction_1.SubstrateTransactionType.WITHDRAW_UNBONDED,
+                {
+                    slashingSpansNumber: 0
                 }
-            });
-        });
-    };
-    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));
+            ]);
+        }
+        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');
+    }
+}
 exports.SubstrateProtocol = SubstrateProtocol;
 //# sourceMappingURL=SubstrateProtocol.js.map