@airgap/substrate 0.13.11-beta.1 → 0.13.11-beta.3

package/v0/protocol/SubstrateProtocol.js

@@ -0,0 +1,684 @@
+"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.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)];
+                }
+            });
+        });
+    };
+    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 } }];
+                }
+            });
+        });
+    };
+    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)];
+                }
+            });
+        });
+    };
+    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)];
+                }
+            });
+        });
+    };
+    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)];
+                }
+            });
+        });
+    };
+    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