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

package/v1/controller/transaction/SubstrateCommonTransactionController.js

@@ -1,15 +1,4 @@
 "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);
@@ -26,316 +15,208 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubstrateCommonTransactionController = void 0;
-var coinlib_core_1 = require("@airgap/coinlib-core");
-var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+const coinlib_core_1 = require("@airgap/coinlib-core");
+const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
 // @ts-ignore
-var keccak = require("@airgap/coinlib-core/dependencies/src/keccak-1.0.2/js");
+const keccak = require("@airgap/coinlib-core/dependencies/src/keccak-1.0.2/js");
 // @ts-ignore
-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) {
+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) {
         this.configuration = configuration;
         this.nodeClient = nodeClient;
     }
-    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)];
-                }
-            });
-        });
-    };
-    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 })
-                            }];
-                }
-            });
+    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.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
-                            })];
-                }
-            });
+        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.getSignatureType = function (purpose) {
+    }
+    getSignatureType(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;
         }
-    };
-    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);
+    }
+    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);
             return SCALEBytes_1.SCALEBytes.from(scaleRuntimeVersion.encode() +
-                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 }));
+                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 }));
         });
         return SCALEArray_1.SCALEArray.from(bytesEncoded).encode();
-    };
-    SubstrateCommonTransactionController.prototype.encodeTransactionType = function (type) {
-        var enumType = transactionTypeAsEnum(this.configuration, type);
+    }
+    encodeTransactionType(type) {
+        const 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)];
-    };
-    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();
+    }
+    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();
             return {
-                runtimeVersion: runtimeVersion,
+                runtimeVersion,
                 fee: fee.decoded.value,
                 transaction: transaction.decoded,
                 payload: payload.decoded.value
             };
         });
-    };
-    SubstrateCommonTransactionController.prototype.decodeTransactionType = function (decoder) {
-        var _a;
-        var enumValue = decoder.decodeNextEnum(function (value) { return value; });
+    }
+    decodeTransactionType(decoder) {
+        const enumValue = decoder.decodeNextEnum((value) => value);
         if (enumValue.decoded.value === 255) {
-            var type_1 = decoder.decodeNextString();
+            const type = decoder.decodeNextString();
             return {
-                bytesDecoded: enumValue.bytesDecoded + type_1.bytesDecoded,
-                decoded: type_1.decoded.value
+                bytesDecoded: enumValue.bytesDecoded + type.bytesDecoded,
+                decoded: type.decoded.value
             };
         }
-        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];
+        const type = Object.entries(transactionTypeIndices(this.configuration)).find(([_, index]) => index === enumValue.decoded.value)?.[0];
         if (type === undefined) {
             throw new errors_1.UnsupportedError(coinlib_core_1.Domain.SUBSTRATE, 'Unknown substrate transaction type');
         }
@@ -343,82 +224,39 @@ var SubstrateCommonTransactionController = /** @class */ (function () {
             bytesDecoded: enumValue.bytesDecoded,
             decoded: type
         };
-    };
-    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) {
+    }
+    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) {
         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) {
-    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 });
+    const configuredIndices = Object.entries(configuration.transaction.types).reduce((obj, [type, metadata]) => Object.assign(obj, { [type]: metadata.index }), {});
+    return {
+        ...configuredIndices,
+        transfer: 0
+    };
 }
 //# sourceMappingURL=SubstrateCommonTransactionController.js.map