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

package/v1/protocol/SubstrateProtocol.js

@@ -1,19 +1,66 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        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.SubstrateProtocolImpl = void 0;
-const coinlib_core_1 = require("@airgap/coinlib-core");
-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 module_kit_1 = require("@airgap/module-kit");
-const SubstrateCryptoClient_1 = require("../crypto/SubstrateCryptoClient");
-const keys_1 = require("../utils/keys");
-const signature_1 = require("../utils/signature");
+var coinlib_core_1 = require("@airgap/coinlib-core");
+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 module_kit_1 = require("@airgap/module-kit");
+var SubstrateCryptoClient_1 = require("../crypto/SubstrateCryptoClient");
+var keys_1 = require("../utils/keys");
+var signature_1 = require("../utils/signature");
 // Implementation
-class SubstrateProtocolImpl {
-    constructor(options, nodeClient, accountController, transactionController, blockExplorer) {
+var SubstrateProtocolImpl = /** @class */ (function () {
+    function SubstrateProtocolImpl(options, nodeClient, accountController, transactionController, blockExplorer) {
         this._isSubstrateProtocol = true;
         this.metadata = options.metadata;
         this.network = options.network;
@@ -32,183 +79,342 @@ class SubstrateProtocolImpl {
         this.blockExplorer = blockExplorer;
         this.cryptoClient = new SubstrateCryptoClient_1.SubstrateCryptoClient();
     }
-    async getMetadata() {
-        return this.metadata;
-    }
-    async getAddressFromPublicKey(publicKey) {
-        const address = this.accountController.createAddressFromPublicKey(publicKey);
-        return address.asString();
-    }
-    async getDetailsFromTransaction(transaction, _publicKey) {
-        return this.getDetailsFromEncodedTransaction(transaction.encoded);
-    }
-    async verifyMessageWithPublicKey(message, signature, publicKey) {
-        const hexSignature = (0, signature_1.convertSignature)(signature, 'hex');
-        const hexPublicKey = (0, keys_1.convertPublicKey)(publicKey, 'hex');
-        return this.cryptoClient.verifyMessage(message, hexSignature.value, hexPublicKey.value);
-    }
-    async encryptAsymmetricWithPublicKey(payload, publicKey) {
-        const hexPublicKey = (0, keys_1.convertPublicKey)(publicKey, 'hex');
-        return this.cryptoClient.encryptAsymmetric(payload, hexPublicKey.value);
-    }
+    SubstrateProtocolImpl.prototype.getMetadata = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.metadata];
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                address = this.accountController.createAddressFromPublicKey(publicKey);
+                return [2 /*return*/, address.asString()];
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, _publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getDetailsFromEncodedTransaction(transaction.encoded)];
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.verifyMessageWithPublicKey = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSignature, hexPublicKey;
+            return __generator(this, function (_a) {
+                hexSignature = (0, signature_1.convertSignature)(signature, 'hex');
+                hexPublicKey = (0, keys_1.convertPublicKey)(publicKey, 'hex');
+                return [2 /*return*/, this.cryptoClient.verifyMessage(message, hexSignature.value, hexPublicKey.value)];
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.encryptAsymmetricWithPublicKey = function (payload, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexPublicKey;
+            return __generator(this, function (_a) {
+                hexPublicKey = (0, keys_1.convertPublicKey)(publicKey, 'hex');
+                return [2 /*return*/, this.cryptoClient.encryptAsymmetric(payload, hexPublicKey.value)];
+            });
+        });
+    };
     // Offline
-    async getCryptoConfiguration() {
-        return this.cryptoConfiguration;
-    }
-    async getKeyPairFromDerivative(derivative) {
-        return this.accountController.createKeyPairFromDerivative(derivative);
-    }
-    async signTransactionWithSecretKey(transaction, secretKey) {
-        const txs = this.transactionController.decodeDetails(transaction.encoded);
-        const signed = await Promise.all(txs.map((tx) => this.transactionController.signTransaction(secretKey, tx.transaction, tx.payload)));
-        txs.forEach((tx, index) => (tx.transaction = signed[index]));
-        return (0, module_kit_1.newSignedTransaction)({ encoded: this.transactionController.encodeDetails(txs) });
-    }
-    async signMessageWithKeyPair(message, keyPair) {
-        const hexSecretKey = (0, keys_1.convertSecretKey)(keyPair.secretKey, 'hex');
-        const hexPublicKey = (0, keys_1.convertPublicKey)(keyPair.publicKey, 'hex');
-        const signature = await this.cryptoClient.signMessage(message, {
-            publicKey: hexPublicKey.value,
-            privateKey: hexSecretKey.value
-        });
-        return (0, module_kit_1.newSignature)(signature, 'hex');
-    }
-    async decryptAsymmetricWithKeyPair(payload, keyPair) {
-        const hexSecretKey = (0, keys_1.convertSecretKey)(keyPair.secretKey, 'hex');
-        const hexPublicKey = (0, keys_1.convertPublicKey)(keyPair.publicKey, 'hex');
-        return this.cryptoClient.decryptAsymmetric(payload, {
-            privateKey: hexSecretKey.value,
-            publicKey: hexPublicKey.value
+    SubstrateProtocolImpl.prototype.getCryptoConfiguration = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoConfiguration];
+            });
         });
-    }
-    async encryptAESWithSecretKey(payload, secretKey) {
-        const hexSecretKey = (0, keys_1.convertSecretKey)(secretKey, 'hex');
-        // 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 bufferSecretKey = Buffer.from(hexSecretKey.value, 'hex').slice(0, 32); // Substrate key is 32 bytes key + 32 bytes nonce
-        return this.cryptoClient.encryptAES(payload, bufferSecretKey.toString('hex'));
-    }
-    async decryptAESWithSecretKey(payload, secretKey) {
-        const hexSecretKey = (0, keys_1.convertSecretKey)(secretKey, 'hex');
-        // 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 bufferSecretKey = Buffer.from(hexSecretKey.value, 'hex').slice(0, 32); // Substrate key is 32 bytes key + 32 bytes nonce
-        return this.cryptoClient.decryptAES(payload, bufferSecretKey.toString('hex'));
-    }
-    async getNetwork() {
-        return this.network;
-    }
-    async getTransactionsForPublicKey(publicKey, limit, cursor) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getTransactionsForAddress(address, limit, cursor);
-    }
-    async getTransactionsForAddress(address, limit, cursor) {
-        const txs = await this.blockExplorer.getTransactions(address, this.metadata.mainUnit, limit, cursor);
-        const transactions = txs.map((tx) => ({
-            from: [],
-            to: [],
-            isInbound: false,
-            network: this.network,
-            ...tx,
-            amount: tx.amount ? tx.amount : (0, module_kit_1.newAmount)('', 'blockchain'),
-            fee: tx.fee ? tx.fee : (0, module_kit_1.newAmount)('', 'blockchain')
-        }));
-        // TODO: use `count` in API response to determine if there's more
-        const hasNext = transactions.length >= limit;
-        return {
-            transactions,
-            cursor: {
-                hasNext: transactions.length >= limit,
-                page: hasNext ? (cursor?.page ?? 0) + 1 : undefined
-            }
-        };
-    }
-    async getBalanceOfPublicKey(publicKey) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getBalanceOfAddress(address);
-    }
-    async getBalanceOfAddress(address) {
-        const balance = await this.accountController.getBalance(address);
-        return {
-            total: (0, module_kit_1.newAmount)(balance.total, 'blockchain'),
-            transferable: (0, module_kit_1.newAmount)(balance.transferable, 'blockchain')
-        };
-    }
-    async getTransactionMaxAmountWithPublicKey(publicKey, to, configuration) {
-        const [balance, futureRequiredTransactions] = await Promise.all([this.accountController.getBalance(publicKey), this.getFutureRequiredTransactions(publicKey, 'transfer')]);
-        const fee = await this.transactionController.estimateTransactionFees(publicKey, futureRequiredTransactions);
-        if (!fee) {
-            throw new errors_1.OperationFailedError(coinlib_core_1.Domain.SUBSTRATE, 'Could not estimate max value');
-        }
-        let maxAmount = balance.transferable.minus(configuration?.keepMinBalance ? balance.existentialDeposit : 0).minus(fee);
-        if (maxAmount.lt(0)) {
-            maxAmount = new bignumber_1.default(0);
-        }
-        return (0, module_kit_1.newAmount)(maxAmount, 'blockchain');
-    }
-    async getTransactionFeeWithPublicKey(publicKey, details, _configuration) {
-        const fees = await Promise.all(details.map(async (details) => {
-            const transaction = await this.transactionController.createTransaction('transfer', publicKey, 0, {
-                to: details.to.length > 0 ? details.to : publicKey,
-                value: new bignumber_1.default((0, module_kit_1.newAmount)(details.amount).blockchain(this.metadata.units).value)
-            });
-            const fee = await this.transactionController.calculateTransactionFee(transaction);
-            if (!fee) {
-                throw new errors_1.OperationFailedError(coinlib_core_1.Domain.SUBSTRATE, 'Could not fetch all necessary data.');
-            }
-            return fee;
-        }));
-        return (0, module_kit_1.newAmount)(fees.reduce((acc, next) => acc.plus(next)), 'blockchain');
-    }
-    async prepareTransactionWithPublicKey(publicKey, details, configuration) {
-        const balance = await this.accountController.getBalance(publicKey);
-        const transferableBalance = balance.transferable.minus(configuration?.keepMinBalance ? balance.existentialDeposit : 0);
-        const totalValue = details
-            .map((details) => new bignumber_1.default((0, module_kit_1.newAmount)(details.amount).blockchain(this.metadata.units).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.transactionController.prepareSubmittableTransactions(publicKey, available, details.map(({ to, amount }) => ({
-            type: 'transfer',
-            tip: 0, // temporary, until we handle Substrate fee/tip model
-            args: {
-                to,
-                value: new bignumber_1.default((0, module_kit_1.newAmount)(amount).blockchain(this.metadata.units).value)
-            }
-        })));
-        return (0, module_kit_1.newUnsignedTransaction)({ encoded });
-    }
-    async broadcastTransaction(transaction) {
-        const txs = this.transactionController
-            .decodeDetails(transaction.encoded)
-            .map((tx) => [tx.runtimeVersion, tx.transaction]);
-        const txHashes = await Promise.all(txs.map((tx) => this.nodeClient.submitTransaction(tx[1].encode({ configuration: this.configuration, runtimeVersion: tx[0] })))).catch((error) => {
-            throw new coinlib_core_1.NetworkError(coinlib_core_1.Domain.SUBSTRATE, error);
-        });
-        return txHashes[0];
-    }
+    };
+    SubstrateProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.accountController.createKeyPairFromDerivative(derivative)];
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
+        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.transactionController.decodeDetails(transaction.encoded);
+                        return [4 /*yield*/, Promise.all(txs.map(function (tx) { return _this.transactionController.signTransaction(secretKey, tx.transaction, tx.payload); }))];
+                    case 1:
+                        signed = _a.sent();
+                        txs.forEach(function (tx, index) { return (tx.transaction = signed[index]); });
+                        return [2 /*return*/, (0, module_kit_1.newSignedTransaction)({ encoded: this.transactionController.encodeDetails(txs) })];
+                }
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.signMessageWithKeyPair = function (message, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey, hexPublicKey, signature;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        hexSecretKey = (0, keys_1.convertSecretKey)(keyPair.secretKey, 'hex');
+                        hexPublicKey = (0, keys_1.convertPublicKey)(keyPair.publicKey, 'hex');
+                        return [4 /*yield*/, this.cryptoClient.signMessage(message, {
+                                publicKey: hexPublicKey.value,
+                                privateKey: hexSecretKey.value
+                            })];
+                    case 1:
+                        signature = _a.sent();
+                        return [2 /*return*/, (0, module_kit_1.newSignature)(signature, 'hex')];
+                }
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.decryptAsymmetricWithKeyPair = function (payload, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey, hexPublicKey;
+            return __generator(this, function (_a) {
+                hexSecretKey = (0, keys_1.convertSecretKey)(keyPair.secretKey, 'hex');
+                hexPublicKey = (0, keys_1.convertPublicKey)(keyPair.publicKey, 'hex');
+                return [2 /*return*/, this.cryptoClient.decryptAsymmetric(payload, {
+                        privateKey: hexSecretKey.value,
+                        publicKey: hexPublicKey.value
+                    })];
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.encryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey, bufferSecretKey;
+            return __generator(this, function (_a) {
+                hexSecretKey = (0, keys_1.convertSecretKey)(secretKey, 'hex');
+                bufferSecretKey = Buffer.from(hexSecretKey.value, 'hex').slice(0, 32) // Substrate key is 32 bytes key + 32 bytes nonce
+                ;
+                return [2 /*return*/, this.cryptoClient.encryptAES(payload, bufferSecretKey.toString('hex'))];
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.decryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey, bufferSecretKey;
+            return __generator(this, function (_a) {
+                hexSecretKey = (0, keys_1.convertSecretKey)(secretKey, 'hex');
+                bufferSecretKey = Buffer.from(hexSecretKey.value, 'hex').slice(0, 32) // Substrate key is 32 bytes key + 32 bytes nonce
+                ;
+                return [2 /*return*/, this.cryptoClient.decryptAES(payload, bufferSecretKey.toString('hex'))];
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.getNetwork = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.network];
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.getTransactionsForPublicKey = function (publicKey, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getTransactionsForAddress(address, limit, cursor)];
+                }
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var txs, transactions, hasNext;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.blockExplorer.getTransactions(address, this.metadata.mainUnit, limit, cursor)];
+                    case 1:
+                        txs = _b.sent();
+                        transactions = txs.map(function (tx) { return (__assign(__assign({ from: [], to: [], isInbound: false, network: _this.network }, tx), { amount: tx.amount ? tx.amount : (0, module_kit_1.newAmount)('', 'blockchain'), fee: tx.fee ? tx.fee : (0, module_kit_1.newAmount)('', 'blockchain') })); });
+                        hasNext = transactions.length >= limit;
+                        return [2 /*return*/, {
+                                transactions: transactions,
+                                cursor: {
+                                    hasNext: transactions.length >= limit,
+                                    page: hasNext ? ((_a = cursor === null || cursor === void 0 ? void 0 : cursor.page) !== null && _a !== void 0 ? _a : 0) + 1 : undefined
+                                }
+                            }];
+                }
+            });
+        });
+    };
+    SubstrateProtocolImpl.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.getBalanceOfAddress(address)];
+                }
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.getBalanceOfAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.accountController.getBalance(address)];
+                    case 1:
+                        balance = _a.sent();
+                        return [2 /*return*/, {
+                                total: (0, module_kit_1.newAmount)(balance.total, 'blockchain'),
+                                transferable: (0, module_kit_1.newAmount)(balance.transferable, 'blockchain')
+                            }];
+                }
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, balance, futureRequiredTransactions, fee, maxAmount;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, Promise.all([this.accountController.getBalance(publicKey), this.getFutureRequiredTransactions(publicKey, 'transfer')])];
+                    case 1:
+                        _a = _b.sent(), balance = _a[0], futureRequiredTransactions = _a[1];
+                        return [4 /*yield*/, this.transactionController.estimateTransactionFees(publicKey, futureRequiredTransactions)];
+                    case 2:
+                        fee = _b.sent();
+                        if (!fee) {
+                            throw new errors_1.OperationFailedError(coinlib_core_1.Domain.SUBSTRATE, 'Could not estimate max value');
+                        }
+                        maxAmount = balance.transferable.minus((configuration === null || configuration === void 0 ? void 0 : configuration.keepMinBalance) ? balance.existentialDeposit : 0).minus(fee);
+                        if (maxAmount.lt(0)) {
+                            maxAmount = new bignumber_1.default(0);
+                        }
+                        return [2 /*return*/, (0, module_kit_1.newAmount)(maxAmount, 'blockchain')];
+                }
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (publicKey, details, _configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fees;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(details.map(function (details) { return __awaiter(_this, void 0, void 0, function () {
+                            var transaction, fee;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.transactionController.createTransaction('transfer', publicKey, 0, {
+                                            to: details.to.length > 0 ? details.to : publicKey,
+                                            value: new bignumber_1.default((0, module_kit_1.newAmount)(details.amount).blockchain(this.metadata.units).value)
+                                        })];
+                                    case 1:
+                                        transaction = _a.sent();
+                                        return [4 /*yield*/, this.transactionController.calculateTransactionFee(transaction)];
+                                    case 2:
+                                        fee = _a.sent();
+                                        if (!fee) {
+                                            throw new errors_1.OperationFailedError(coinlib_core_1.Domain.SUBSTRATE, 'Could not fetch all necessary data.');
+                                        }
+                                        return [2 /*return*/, fee];
+                                }
+                            });
+                        }); }))];
+                    case 1:
+                        fees = _a.sent();
+                        return [2 /*return*/, (0, module_kit_1.newAmount)(fees.reduce(function (acc, next) { return acc.plus(next); }), 'blockchain')];
+                }
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance, transferableBalance, totalValue, available, encoded;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.accountController.getBalance(publicKey)];
+                    case 1:
+                        balance = _a.sent();
+                        transferableBalance = balance.transferable.minus((configuration === null || configuration === void 0 ? void 0 : configuration.keepMinBalance) ? balance.existentialDeposit : 0);
+                        totalValue = details
+                            .map(function (details) { return new bignumber_1.default((0, module_kit_1.newAmount)(details.amount).blockchain(_this.metadata.units).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.transactionController.prepareSubmittableTransactions(publicKey, available, details.map(function (_a) {
+                                var to = _a.to, amount = _a.amount;
+                                return ({
+                                    type: 'transfer',
+                                    tip: 0,
+                                    args: {
+                                        to: to,
+                                        value: new bignumber_1.default((0, module_kit_1.newAmount)(amount).blockchain(_this.metadata.units).value)
+                                    }
+                                });
+                            }))];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })];
+                }
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.broadcastTransaction = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txs, txHashes;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        txs = this.transactionController
+                            .decodeDetails(transaction.encoded)
+                            .map(function (tx) { return [tx.runtimeVersion, tx.transaction]; });
+                        return [4 /*yield*/, Promise.all(txs.map(function (tx) { return _this.nodeClient.submitTransaction(tx[1].encode({ configuration: _this.configuration, runtimeVersion: tx[0] })); })).catch(function (error) {
+                                throw new coinlib_core_1.NetworkError(coinlib_core_1.Domain.SUBSTRATE, error);
+                            })];
+                    case 1:
+                        txHashes = _a.sent();
+                        return [2 /*return*/, txHashes[0]];
+                }
+            });
+        });
+    };
     // Custom
-    async encodeDetails(txs) {
-        return this.transactionController.encodeDetails(txs);
-    }
-    async decodeDetails(serialized) {
-        return this.decodeDetails(serialized);
-    }
-    getDetailsFromEncodedTransaction(encoded) {
-        const txs = this.transactionController.decodeDetails(encoded);
+    SubstrateProtocolImpl.prototype.encodeDetails = function (txs) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.transactionController.encodeDetails(txs)];
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.decodeDetails = function (serialized) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.decodeDetails(serialized)];
+            });
+        });
+    };
+    SubstrateProtocolImpl.prototype.getDetailsFromEncodedTransaction = function (encoded) {
+        var _this = this;
+        var txs = this.transactionController.decodeDetails(encoded);
         return txs
-            .map((tx) => {
-            return tx.transaction.toAirGapTransactions().map((part) => ({
-                from: [],
-                to: [],
-                network: this.network,
-                isInbound: false,
-                ...part,
-                amount: (0, module_kit_1.newAmount)(part.amount ? part.amount?.value : '0', 'blockchain'),
-                fee: (0, module_kit_1.newAmount)(part.fee ? part.fee.value : tx.fee.toString(), 'blockchain')
-            }));
+            .map(function (tx) {
+            return tx.transaction.toAirGapTransactions().map(function (part) {
+                var _a;
+                return (__assign(__assign({ from: [], to: [], network: _this.network, isInbound: false }, part), { amount: (0, module_kit_1.newAmount)(part.amount ? (_a = part.amount) === null || _a === void 0 ? void 0 : _a.value : '0', 'blockchain'), fee: (0, module_kit_1.newAmount)(part.fee ? part.fee.value : tx.fee.toString(), 'blockchain') }));
+            });
         })
-            .reduce((flatten, toFlatten) => flatten.concat(toFlatten), []);
-    }
-}
+            .reduce(function (flatten, toFlatten) { return flatten.concat(toFlatten); }, []);
+    };
+    return SubstrateProtocolImpl;
+}());
 exports.SubstrateProtocolImpl = SubstrateProtocolImpl;
 //# sourceMappingURL=SubstrateProtocol.js.map