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

package/v1/controller/transaction/SubstrateCommonTransactionController.js

@@ -1,4 +1,15 @@
 "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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -15,208 +26,316 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.SubstrateCommonTransactionController = 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"));
+var coinlib_core_1 = require("@airgap/coinlib-core");
+var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
 // @ts-ignore
-const keccak = require("@airgap/coinlib-core/dependencies/src/keccak-1.0.2/js");
+var keccak = require("@airgap/coinlib-core/dependencies/src/keccak-1.0.2/js");
 // @ts-ignore
-const secp256k1 = __importStar(require("@airgap/coinlib-core/dependencies/src/secp256k1-4.0.2/elliptic"));
-const errors_1 = require("@airgap/coinlib-core/errors");
-const blake2b_1 = require("@airgap/coinlib-core/utils/blake2b");
-const wasm_crypto_1 = require("@polkadot/wasm-crypto");
-const SubstrateAddressFactory_1 = require("../../data/account/address/SubstrateAddressFactory");
-const SCALEDecoder_1 = require("../../data/scale/SCALEDecoder");
-const SCALEArray_1 = require("../../data/scale/type/SCALEArray");
-const SCALEBytes_1 = require("../../data/scale/type/SCALEBytes");
-const SCALECompactInt_1 = require("../../data/scale/type/SCALECompactInt");
-const SCALEEnum_1 = require("../../data/scale/type/SCALEEnum");
-const SCALEInt_1 = require("../../data/scale/type/SCALEInt");
-const SCALEOptional_1 = require("../../data/scale/type/SCALEOptional");
-const SCALEString_1 = require("../../data/scale/type/SCALEString");
-const SubstrateSignature_1 = require("../../data/transaction/SubstrateSignature");
-const SubstrateTransaction_1 = require("../../data/transaction/SubstrateTransaction");
-const SubstrateTransactionPayload_1 = require("../../data/transaction/SubstrateTransactionPayload");
-const keys_1 = require("../../utils/keys");
-class SubstrateCommonTransactionController {
-    constructor(configuration, nodeClient) {
+var secp256k1 = __importStar(require("@airgap/coinlib-core/dependencies/src/secp256k1-4.0.2/elliptic"));
+var errors_1 = require("@airgap/coinlib-core/errors");
+var blake2b_1 = require("@airgap/coinlib-core/utils/blake2b");
+var wasm_crypto_1 = require("@polkadot/wasm-crypto");
+var SubstrateAddressFactory_1 = require("../../data/account/address/SubstrateAddressFactory");
+var SCALEDecoder_1 = require("../../data/scale/SCALEDecoder");
+var SCALEArray_1 = require("../../data/scale/type/SCALEArray");
+var SCALEBytes_1 = require("../../data/scale/type/SCALEBytes");
+var SCALECompactInt_1 = require("../../data/scale/type/SCALECompactInt");
+var SCALEEnum_1 = require("../../data/scale/type/SCALEEnum");
+var SCALEInt_1 = require("../../data/scale/type/SCALEInt");
+var SCALEOptional_1 = require("../../data/scale/type/SCALEOptional");
+var SCALEString_1 = require("../../data/scale/type/SCALEString");
+var SubstrateSignature_1 = require("../../data/transaction/SubstrateSignature");
+var SubstrateTransaction_1 = require("../../data/transaction/SubstrateTransaction");
+var SubstrateTransactionPayload_1 = require("../../data/transaction/SubstrateTransactionPayload");
+var keys_1 = require("../../utils/keys");
+var SubstrateCommonTransactionController = /** @class */ (function () {
+    function SubstrateCommonTransactionController(configuration, nodeClient) {
         this.configuration = configuration;
         this.nodeClient = nodeClient;
     }
-    async prepareSubmittableTransactions(accountId, available, params) {
-        const accountInfo = await this.nodeClient.getAccountInfo(this.substrateAddressFrom(accountId));
-        if (!accountInfo) {
-            return Promise.reject('Could not fetch all necessary data');
-        }
-        const nonce = accountInfo.nonce.value;
-        const txs = await Promise.all(params.map((tx, index) => this.prepareTransactionDetails(tx.type, accountId, tx.tip, nonce.plus(index), tx.args)));
-        const totalFee = txs.map((tx) => tx.fee).reduce((total, next) => total.plus(next), new bignumber_1.default(0));
-        if (new bignumber_1.default(available).lt(totalFee)) {
-            throw new coinlib_core_1.BalanceError(coinlib_core_1.Domain.SUBSTRATE, `Not enough balance`);
-        }
-        return this.encodeDetails(txs);
-    }
-    async prepareTransactionDetails(type, accountId, tip, nonce, args = {}) {
-        const chainHeight = await this.nodeClient.getCurrentHeight();
-        const results = await Promise.all([
-            this.createTransaction(type, accountId, tip, args, chainHeight, nonce),
-            this.nodeClient.getLastBlockHash(),
-            this.nodeClient.getFirstBlockHash(),
-            this.nodeClient.getRuntimeVersion()
-        ]);
-        if (results.some((result) => result === null)) {
-            return Promise.reject('Could not fetch all necessary data.');
-        }
-        const transaction = results[0];
-        const fee = await this.calculateTransactionFee(transaction);
-        if (!fee) {
-            return Promise.reject('Could not fetch all necessary data.');
-        }
-        const lastHash = results[1];
-        const genesisHash = results[2];
-        const runtimeVersion = results[3];
-        const payload = SubstrateTransactionPayload_1.SubstrateTransactionPayload.create(transaction, {
-            specVersion: runtimeVersion.specVersion,
-            transactionVersion: runtimeVersion.transactionVersion,
-            genesisHash,
-            lastHash
+    SubstrateCommonTransactionController.prototype.prepareSubmittableTransactions = function (accountId, available, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var accountInfo, nonce, txs, totalFee;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.nodeClient.getAccountInfo(this.substrateAddressFrom(accountId))];
+                    case 1:
+                        accountInfo = _a.sent();
+                        if (!accountInfo) {
+                            return [2 /*return*/, Promise.reject('Could not fetch all necessary data')];
+                        }
+                        nonce = accountInfo.nonce.value;
+                        return [4 /*yield*/, Promise.all(params.map(function (tx, index) { return _this.prepareTransactionDetails(tx.type, accountId, tx.tip, nonce.plus(index), tx.args); }))];
+                    case 2:
+                        txs = _a.sent();
+                        totalFee = txs.map(function (tx) { return tx.fee; }).reduce(function (total, next) { return total.plus(next); }, new bignumber_1.default(0));
+                        if (new bignumber_1.default(available).lt(totalFee)) {
+                            throw new coinlib_core_1.BalanceError(coinlib_core_1.Domain.SUBSTRATE, "Not enough balance");
+                        }
+                        return [2 /*return*/, this.encodeDetails(txs)];
+                }
+            });
         });
-        return {
-            runtimeVersion: runtimeVersion.specVersion,
-            fee,
-            transaction,
-            payload: payload.encode({ configuration: this.configuration, runtimeVersion: runtimeVersion.specVersion })
-        };
-    }
-    async createTransaction(type, accountId, tip = 0, args = {}, chainHeight = 1, nonce = 0) {
-        const methodId = await this.nodeClient.getTransactionMetadata(type);
-        const signatureType = this.getSignatureType('placeholder');
-        return SubstrateTransaction_1.SubstrateTransaction.create(this.configuration, type, {
-            from: accountId,
-            tip: bignumber_1.default.isBigNumber(tip) ? tip : new bignumber_1.default(tip),
-            methodId,
-            args,
-            era: { chainHeight },
-            nonce,
-            signatureType
+    };
+    SubstrateCommonTransactionController.prototype.prepareTransactionDetails = function (type, accountId, tip, nonce, args) {
+        if (args === void 0) { args = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var chainHeight, results, transaction, fee, lastHash, genesisHash, runtimeVersion, payload;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.nodeClient.getCurrentHeight()];
+                    case 1:
+                        chainHeight = _a.sent();
+                        return [4 /*yield*/, Promise.all([
+                                this.createTransaction(type, accountId, tip, args, chainHeight, nonce),
+                                this.nodeClient.getLastBlockHash(),
+                                this.nodeClient.getFirstBlockHash(),
+                                this.nodeClient.getRuntimeVersion()
+                            ])];
+                    case 2:
+                        results = _a.sent();
+                        if (results.some(function (result) { return result === null; })) {
+                            return [2 /*return*/, Promise.reject('Could not fetch all necessary data.')];
+                        }
+                        transaction = results[0];
+                        return [4 /*yield*/, this.calculateTransactionFee(transaction)];
+                    case 3:
+                        fee = _a.sent();
+                        if (!fee) {
+                            return [2 /*return*/, Promise.reject('Could not fetch all necessary data.')];
+                        }
+                        lastHash = results[1];
+                        genesisHash = results[2];
+                        runtimeVersion = results[3];
+                        payload = SubstrateTransactionPayload_1.SubstrateTransactionPayload.create(transaction, {
+                            specVersion: runtimeVersion.specVersion,
+                            transactionVersion: runtimeVersion.transactionVersion,
+                            genesisHash: genesisHash,
+                            lastHash: lastHash
+                        });
+                        return [2 /*return*/, {
+                                runtimeVersion: runtimeVersion.specVersion,
+                                fee: fee,
+                                transaction: transaction,
+                                payload: payload.encode({ configuration: this.configuration, runtimeVersion: runtimeVersion.specVersion })
+                            }];
+                }
+            });
         });
-    }
-    getSignatureType(purpose) {
+    };
+    SubstrateCommonTransactionController.prototype.createTransaction = function (type, accountId, tip, args, chainHeight, nonce) {
+        if (tip === void 0) { tip = 0; }
+        if (args === void 0) { args = {}; }
+        if (chainHeight === void 0) { chainHeight = 1; }
+        if (nonce === void 0) { nonce = 0; }
+        return __awaiter(this, void 0, void 0, function () {
+            var methodId, signatureType;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.nodeClient.getTransactionMetadata(type)];
+                    case 1:
+                        methodId = _a.sent();
+                        signatureType = this.getSignatureType('placeholder');
+                        return [2 /*return*/, SubstrateTransaction_1.SubstrateTransaction.create(this.configuration, type, {
+                                from: accountId,
+                                tip: bignumber_1.default.isBigNumber(tip) ? tip : new bignumber_1.default(tip),
+                                methodId: methodId,
+                                args: args,
+                                era: { chainHeight: chainHeight },
+                                nonce: nonce,
+                                signatureType: signatureType
+                            })];
+                }
+            });
+        });
+    };
+    SubstrateCommonTransactionController.prototype.getSignatureType = function (purpose) {
         switch (this.configuration.account.type) {
             case 'eth':
                 return SubstrateSignature_1.SubstrateSignatureType.Ecdsa;
             case 'ss58':
                 return purpose === 'sign' ? SubstrateSignature_1.SubstrateSignatureType.Sr25519 : SubstrateSignature_1.SubstrateSignatureType.Ed25519;
         }
-    }
-    async signTransaction(secretKey, transaction, payload) {
-        const hexSecretKey = (0, keys_1.convertSecretKey)(secretKey, 'hex');
-        const signatureType = this.getSignatureType('sign');
-        const signature = await this.signPayload(Buffer.from(hexSecretKey.value, 'hex'), transaction.signer.asBytes(), payload, signatureType);
-        return SubstrateTransaction_1.SubstrateTransaction.fromTransaction(transaction, { signature });
-    }
-    async signPayload(privateKey, publicKey, payload, signatureType) {
-        switch (signatureType) {
-            case SubstrateSignature_1.SubstrateSignatureType.Ed25519:
-                return this.signEd25519Payload(privateKey, publicKey, payload);
-            case SubstrateSignature_1.SubstrateSignatureType.Sr25519:
-                return this.signSr25519Payload(privateKey, publicKey, payload);
-            case SubstrateSignature_1.SubstrateSignatureType.Ecdsa:
-                return this.signEcdsaPayload(privateKey, payload);
-            default:
-                return Promise.reject('Signature type not supported.');
-        }
-    }
-    async signEd25519Payload(privateKey, publicKey, payload) {
-        throw new Error('signEd25519Payload not implemented');
-    }
-    async signSr25519Payload(privateKey, publicKey, payload) {
-        await (0, wasm_crypto_1.waitReady)();
-        const payloadBuffer = Buffer.from(payload, 'hex');
-        const message = payloadBuffer.length > 256 ? Buffer.from((0, blake2b_1.blake2bAsBytes)(payloadBuffer, 256)) : payloadBuffer;
-        const signature = (0, wasm_crypto_1.sr25519Sign)(publicKey, privateKey, message);
-        return SubstrateSignature_1.SubstrateSignature.create(SubstrateSignature_1.SubstrateSignatureType.Sr25519, signature);
-    }
-    async signEcdsaPayload(privateKey, payload) {
-        const message = keccak('keccak256').update(Buffer.from(payload, 'hex')).digest();
-        const signatureObj = secp256k1.ecdsaSign(message, privateKey);
-        const signature = Buffer.concat([Buffer.from(signatureObj.signature), Buffer.from([signatureObj.recid ?? 0])]);
-        return SubstrateSignature_1.SubstrateSignature.create(SubstrateSignature_1.SubstrateSignatureType.Ecdsa, signature);
-    }
-    encodeDetails(txs) {
-        const bytesEncoded = txs.map((tx) => {
-            const scaleRuntimeVersion = tx.runtimeVersion !== undefined ? SCALEOptional_1.SCALEOptional.from(SCALEInt_1.SCALEInt.from(tx.runtimeVersion, 32)) : SCALEOptional_1.SCALEOptional.empty();
-            const scaleType = this.encodeTransactionType(tx.transaction.type);
-            const scaleFee = SCALECompactInt_1.SCALECompactInt.from(tx.fee);
+    };
+    SubstrateCommonTransactionController.prototype.signTransaction = function (secretKey, transaction, payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey, signatureType, signature;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        hexSecretKey = (0, keys_1.convertSecretKey)(secretKey, 'hex');
+                        signatureType = this.getSignatureType('sign');
+                        return [4 /*yield*/, this.signPayload(Buffer.from(hexSecretKey.value, 'hex'), transaction.signer.asBytes(), payload, signatureType)];
+                    case 1:
+                        signature = _a.sent();
+                        return [2 /*return*/, SubstrateTransaction_1.SubstrateTransaction.fromTransaction(transaction, { signature: signature })];
+                }
+            });
+        });
+    };
+    SubstrateCommonTransactionController.prototype.signPayload = function (privateKey, publicKey, payload, signatureType) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (signatureType) {
+                    case SubstrateSignature_1.SubstrateSignatureType.Ed25519:
+                        return [2 /*return*/, this.signEd25519Payload(privateKey, publicKey, payload)];
+                    case SubstrateSignature_1.SubstrateSignatureType.Sr25519:
+                        return [2 /*return*/, this.signSr25519Payload(privateKey, publicKey, payload)];
+                    case SubstrateSignature_1.SubstrateSignatureType.Ecdsa:
+                        return [2 /*return*/, this.signEcdsaPayload(privateKey, payload)];
+                    default:
+                        return [2 /*return*/, Promise.reject('Signature type not supported.')];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    SubstrateCommonTransactionController.prototype.signEd25519Payload = function (privateKey, publicKey, payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('signEd25519Payload not implemented');
+            });
+        });
+    };
+    SubstrateCommonTransactionController.prototype.signSr25519Payload = function (privateKey, publicKey, payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payloadBuffer, message, signature;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, wasm_crypto_1.waitReady)()];
+                    case 1:
+                        _a.sent();
+                        payloadBuffer = Buffer.from(payload, 'hex');
+                        message = payloadBuffer.length > 256 ? Buffer.from((0, blake2b_1.blake2bAsBytes)(payloadBuffer, 256)) : payloadBuffer;
+                        signature = (0, wasm_crypto_1.sr25519Sign)(publicKey, privateKey, message);
+                        return [2 /*return*/, SubstrateSignature_1.SubstrateSignature.create(SubstrateSignature_1.SubstrateSignatureType.Sr25519, signature)];
+                }
+            });
+        });
+    };
+    SubstrateCommonTransactionController.prototype.signEcdsaPayload = function (privateKey, payload) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var message, signatureObj, signature;
+            return __generator(this, function (_b) {
+                message = keccak('keccak256').update(Buffer.from(payload, 'hex')).digest();
+                signatureObj = secp256k1.ecdsaSign(message, privateKey);
+                signature = Buffer.concat([Buffer.from(signatureObj.signature), Buffer.from([(_a = signatureObj.recid) !== null && _a !== void 0 ? _a : 0])]);
+                return [2 /*return*/, SubstrateSignature_1.SubstrateSignature.create(SubstrateSignature_1.SubstrateSignatureType.Ecdsa, signature)];
+            });
+        });
+    };
+    SubstrateCommonTransactionController.prototype.encodeDetails = function (txs) {
+        var _this = this;
+        var bytesEncoded = txs.map(function (tx) {
+            var scaleRuntimeVersion = tx.runtimeVersion !== undefined ? SCALEOptional_1.SCALEOptional.from(SCALEInt_1.SCALEInt.from(tx.runtimeVersion, 32)) : SCALEOptional_1.SCALEOptional.empty();
+            var scaleType = _this.encodeTransactionType(tx.transaction.type);
+            var scaleFee = SCALECompactInt_1.SCALECompactInt.from(tx.fee);
             return SCALEBytes_1.SCALEBytes.from(scaleRuntimeVersion.encode() +
-                scaleType.reduce((hex, next) => hex + next.encode({ configuration: this.configuration, runtimeVersion: tx.runtimeVersion }), '') +
-                scaleFee.encode({ configuration: this.configuration, runtimeVersion: tx.runtimeVersion }) +
-                tx.transaction.encode({ configuration: this.configuration, runtimeVersion: tx.runtimeVersion }) +
-                SCALEString_1.SCALEString.from(tx.payload).encode({ configuration: this.configuration, runtimeVersion: tx.runtimeVersion }));
+                scaleType.reduce(function (hex, next) { return hex + next.encode({ configuration: _this.configuration, runtimeVersion: tx.runtimeVersion }); }, '') +
+                scaleFee.encode({ configuration: _this.configuration, runtimeVersion: tx.runtimeVersion }) +
+                tx.transaction.encode({ configuration: _this.configuration, runtimeVersion: tx.runtimeVersion }) +
+                SCALEString_1.SCALEString.from(tx.payload).encode({ configuration: _this.configuration, runtimeVersion: tx.runtimeVersion }));
         });
         return SCALEArray_1.SCALEArray.from(bytesEncoded).encode();
-    }
-    encodeTransactionType(type) {
-        const enumType = transactionTypeAsEnum(this.configuration, type);
+    };
+    SubstrateCommonTransactionController.prototype.encodeTransactionType = function (type) {
+        var enumType = transactionTypeAsEnum(this.configuration, type);
         if (enumType !== undefined) {
             // legacy
             return [SCALEEnum_1.SCALEEnum.from(transactionTypeAsEnum(this.configuration, type))];
         }
         return [SCALEEnum_1.SCALEEnum.from(255), SCALEString_1.SCALEString.from(type)];
-    }
-    decodeDetails(serialized) {
-        const decoder = new SCALEDecoder_1.SCALEDecoder(this.configuration, undefined, serialized);
-        const encodedTxs = decoder
-            .decodeNextArray((_configuration, _runtimeVersion, hex) => SCALEBytes_1.SCALEBytes.decode(hex))
-            .decoded.elements.map((bytesEncoded) => bytesEncoded.bytes.toString('hex'));
-        return encodedTxs.map((encodedTx) => {
-            const runtimeVersionOptional = SCALEOptional_1.SCALEOptional.decode(this.configuration, undefined, encodedTx, (_configuration, _runtimeVersion, hex) => SCALEInt_1.SCALEInt.decode(hex, 32));
-            const _encodedTx = encodedTx.slice(runtimeVersionOptional.bytesDecoded * 2);
-            const runtimeVersion = runtimeVersionOptional.decoded.value?.toNumber();
-            const txDecoder = new SCALEDecoder_1.SCALEDecoder(this.configuration, runtimeVersion, _encodedTx);
-            const type = this.decodeTransactionType(txDecoder);
-            const fee = txDecoder.decodeNextCompactInt();
-            const transaction = txDecoder.decodeNextObject((configuration, runtimeVersion, hex) => SubstrateTransaction_1.SubstrateTransaction.decode(configuration, runtimeVersion, type.decoded, hex));
-            const payload = txDecoder.decodeNextString();
+    };
+    SubstrateCommonTransactionController.prototype.decodeDetails = function (serialized) {
+        var _this = this;
+        var decoder = new SCALEDecoder_1.SCALEDecoder(this.configuration, undefined, serialized);
+        var encodedTxs = decoder
+            .decodeNextArray(function (_configuration, _runtimeVersion, hex) { return SCALEBytes_1.SCALEBytes.decode(hex); })
+            .decoded.elements.map(function (bytesEncoded) { return bytesEncoded.bytes.toString('hex'); });
+        return encodedTxs.map(function (encodedTx) {
+            var _a;
+            var runtimeVersionOptional = SCALEOptional_1.SCALEOptional.decode(_this.configuration, undefined, encodedTx, function (_configuration, _runtimeVersion, hex) { return SCALEInt_1.SCALEInt.decode(hex, 32); });
+            var _encodedTx = encodedTx.slice(runtimeVersionOptional.bytesDecoded * 2);
+            var runtimeVersion = (_a = runtimeVersionOptional.decoded.value) === null || _a === void 0 ? void 0 : _a.toNumber();
+            var txDecoder = new SCALEDecoder_1.SCALEDecoder(_this.configuration, runtimeVersion, _encodedTx);
+            var type = _this.decodeTransactionType(txDecoder);
+            var fee = txDecoder.decodeNextCompactInt();
+            var transaction = txDecoder.decodeNextObject(function (configuration, runtimeVersion, hex) {
+                return SubstrateTransaction_1.SubstrateTransaction.decode(configuration, runtimeVersion, type.decoded, hex);
+            });
+            var payload = txDecoder.decodeNextString();
             return {
-                runtimeVersion,
+                runtimeVersion: runtimeVersion,
                 fee: fee.decoded.value,
                 transaction: transaction.decoded,
                 payload: payload.decoded.value
             };
         });
-    }
-    decodeTransactionType(decoder) {
-        const enumValue = decoder.decodeNextEnum((value) => value);
+    };
+    SubstrateCommonTransactionController.prototype.decodeTransactionType = function (decoder) {
+        var _a;
+        var enumValue = decoder.decodeNextEnum(function (value) { return value; });
         if (enumValue.decoded.value === 255) {
-            const type = decoder.decodeNextString();
+            var type_1 = decoder.decodeNextString();
             return {
-                bytesDecoded: enumValue.bytesDecoded + type.bytesDecoded,
-                decoded: type.decoded.value
+                bytesDecoded: enumValue.bytesDecoded + type_1.bytesDecoded,
+                decoded: type_1.decoded.value
             };
         }
-        const type = Object.entries(transactionTypeIndices(this.configuration)).find(([_, index]) => index === enumValue.decoded.value)?.[0];
+        var type = (_a = Object.entries(transactionTypeIndices(this.configuration)).find(function (_a) {
+            var _ = _a[0], index = _a[1];
+            return index === enumValue.decoded.value;
+        })) === null || _a === void 0 ? void 0 : _a[0];
         if (type === undefined) {
             throw new errors_1.UnsupportedError(coinlib_core_1.Domain.SUBSTRATE, 'Unknown substrate transaction type');
         }
@@ -224,39 +343,82 @@ class SubstrateCommonTransactionController {
             bytesDecoded: enumValue.bytesDecoded,
             decoded: type
         };
-    }
-    async calculateTransactionFee(transaction) {
-        const runtimeVersion = await this.nodeClient.getRuntimeVersion();
-        const encoded = transaction.encode({ configuration: this.configuration, runtimeVersion: runtimeVersion?.specVersion });
-        const partialEstimate = await this.nodeClient.getTransferFeeEstimate(encoded);
-        if (partialEstimate) {
-            this.nodeClient.saveLastFee(transaction.type, partialEstimate);
-        }
-        return partialEstimate?.plus(transaction.tip.value);
-    }
-    async estimateTransactionFees(accountId, transationTypes) {
-        const fees = await Promise.all(transationTypes
-            .map(([type, args]) => [type, args, this.nodeClient.getSavedLastFee(type, 'largest')])
-            .map(async ([type, args, fee]) => fee ? fee : this.calculateTransactionFee(await this.createTransaction(type, this.substrateAddressFrom(accountId), 0, args))));
-        if (fees.some((fee) => fee === undefined)) {
-            return Promise.reject('Could not estimate transaction fees.');
-        }
-        const safetyFactor = 1.2;
-        return fees.reduce((sum, next) => sum.plus(next), new bignumber_1.default(0)).multipliedBy(safetyFactor);
-    }
-    substrateAddressFrom(accountId) {
+    };
+    SubstrateCommonTransactionController.prototype.calculateTransactionFee = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var runtimeVersion, encoded, partialEstimate;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.nodeClient.getRuntimeVersion()];
+                    case 1:
+                        runtimeVersion = _a.sent();
+                        encoded = transaction.encode({ configuration: this.configuration, runtimeVersion: runtimeVersion === null || runtimeVersion === void 0 ? void 0 : runtimeVersion.specVersion });
+                        return [4 /*yield*/, this.nodeClient.getTransferFeeEstimate(encoded)];
+                    case 2:
+                        partialEstimate = _a.sent();
+                        if (partialEstimate) {
+                            this.nodeClient.saveLastFee(transaction.type, partialEstimate);
+                        }
+                        return [2 /*return*/, partialEstimate === null || partialEstimate === void 0 ? void 0 : partialEstimate.plus(transaction.tip.value)];
+                }
+            });
+        });
+    };
+    SubstrateCommonTransactionController.prototype.estimateTransactionFees = function (accountId, transationTypes) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fees, safetyFactor;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(transationTypes
+                            .map(function (_a) {
+                            var type = _a[0], args = _a[1];
+                            return [type, args, _this.nodeClient.getSavedLastFee(type, 'largest')];
+                        })
+                            .map(function (_a) {
+                            var type = _a[0], args = _a[1], fee = _a[2];
+                            return __awaiter(_this, void 0, void 0, function () { var _b, _c; return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        if (!fee) return [3 /*break*/, 1];
+                                        _b = fee;
+                                        return [3 /*break*/, 3];
+                                    case 1:
+                                        _c = this.calculateTransactionFee;
+                                        return [4 /*yield*/, this.createTransaction(type, this.substrateAddressFrom(accountId), 0, args)];
+                                    case 2:
+                                        _b = _c.apply(this, [_d.sent()]);
+                                        _d.label = 3;
+                                    case 3: return [2 /*return*/, _b];
+                                }
+                            }); });
+                        }))];
+                    case 1:
+                        fees = _a.sent();
+                        if (fees.some(function (fee) { return fee === undefined; })) {
+                            return [2 /*return*/, Promise.reject('Could not estimate transaction fees.')];
+                        }
+                        safetyFactor = 1.2;
+                        return [2 /*return*/, fees.reduce(function (sum, next) { return sum.plus(next); }, new bignumber_1.default(0)).multipliedBy(safetyFactor)];
+                }
+            });
+        });
+    };
+    SubstrateCommonTransactionController.prototype.substrateAddressFrom = function (accountId) {
         return (0, SubstrateAddressFactory_1.substrateAddressFactory)(this.configuration).from(accountId);
-    }
-}
+    };
+    return SubstrateCommonTransactionController;
+}());
 exports.SubstrateCommonTransactionController = SubstrateCommonTransactionController;
 function transactionTypeAsEnum(configuration, type) {
     return transactionTypeIndices(configuration)[type];
 }
 function transactionTypeIndices(configuration) {
-    const configuredIndices = Object.entries(configuration.transaction.types).reduce((obj, [type, metadata]) => Object.assign(obj, { [type]: metadata.index }), {});
-    return {
-        ...configuredIndices,
-        transfer: 0
-    };
+    var configuredIndices = Object.entries(configuration.transaction.types).reduce(function (obj, _a) {
+        var _b;
+        var type = _a[0], metadata = _a[1];
+        return Object.assign(obj, (_b = {}, _b[type] = metadata.index, _b));
+    }, {});
+    return __assign(__assign({}, configuredIndices), { transfer: 0 });
 }
 //# sourceMappingURL=SubstrateCommonTransactionController.js.map