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

package/v1/protocol/SubstrateProtocol.d.ts

@@ -1,4 +1,4 @@
-import { Address, AirGapProtocol, AirGapTransaction, AirGapTransactionsWithCursor, Amount, Balance, CryptoDerivative, KeyPair, ProtocolMetadata, PublicKey, SecretKey, Signature, TransactionFullConfiguration, TransactionDetails, TransactionSimpleConfiguration, WalletConnectRequest } from '@airgap/module-kit';
+import { Address, AirGapProtocol, AirGapTransaction, AirGapTransactionsWithCursor, Amount, Balance, CryptoDerivative, KeyPair, ProtocolMetadata, PublicKey, SecretKey, Signature, TransactionFullConfiguration, TransactionDetails, TransactionSimpleConfiguration } from '@airgap/module-kit';
 import { SubstrateBlockExplorerClient } from '../block-explorer/SubstrateBlockExplorerClient';
 import { SubstrateAccountController } from '../controller/account/SubstrateAccountController';
 import { SubstrateTransactionController } from '../controller/transaction/SubstrateTransactionController';
@@ -19,7 +19,7 @@ export interface SubstrateProtocol<_ProtocolConfiguration extends SubstrateProto
     UnsignedTransaction: SubstrateUnsignedTransaction;
     SignedTransaction: SubstrateSignedTransaction;
     TransactionCursor: SubstrateTransactionCursor;
-}, 'Crypto', 'FetchDataForAddress', 'WalletConnect'> {
+}, 'Crypto', 'FetchDataForAddress'> {
     _isSubstrateProtocol: true;
     encodeDetails(txs: SubstrateTransactionDetails<_ProtocolConfiguration>[]): Promise<string>;
     decodeDetails(serialized: string): Promise<SubstrateTransactionDetails<_ProtocolConfiguration>[]>;
@@ -34,8 +34,6 @@ export declare abstract class SubstrateProtocolImpl<_Units extends string, _Prot
     readonly blockExplorer: SubstrateBlockExplorerClient;
     private readonly cryptoClient;
     protected constructor(options: SubstrateProtocolOptions<_Units, _ProtocolConfiguration, _ProtocolNetwork>, nodeClient: _NodeClient, accountController: _AccountController, transactionController: _TransactionController, blockExplorer: SubstrateBlockExplorerClient);
-    getWalletConnectChain(): Promise<string | undefined>;
-    prepareWalletConnectTransactionWithPublicKey(publicKey: PublicKey, request: WalletConnectRequest): Promise<SubstrateUnsignedTransaction>;
     protected readonly metadata: ProtocolMetadata<_Units>;
     getMetadata(): Promise<ProtocolMetadata<_Units, _Units>>;
     getAddressFromPublicKey(publicKey: PublicKey): Promise<string>;

package/v1/protocol/SubstrateProtocol.js

@@ -1,66 +1,19 @@
 "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;
-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");
+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");
 // Implementation
-var SubstrateProtocolImpl = /** @class */ (function () {
-    function SubstrateProtocolImpl(options, nodeClient, accountController, transactionController, blockExplorer) {
+class SubstrateProtocolImpl {
+    constructor(options, nodeClient, accountController, transactionController, blockExplorer) {
         this._isSubstrateProtocol = true;
         this.metadata = options.metadata;
         this.network = options.network;
@@ -79,364 +32,183 @@ var SubstrateProtocolImpl = /** @class */ (function () {
         this.blockExplorer = blockExplorer;
         this.cryptoClient = new SubstrateCryptoClient_1.SubstrateCryptoClient();
     }
-    SubstrateProtocolImpl.prototype.getWalletConnectChain = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var name;
-            return __generator(this, function (_a) {
-                name = this.metadata.name.toLowerCase();
-                if (name === 'kusama') {
-                    return [2 /*return*/, "polkadot:48239ef607d7928874027a43a6768920"];
-                }
-                else if (name === 'polkadot') {
-                    return [2 /*return*/, "polkadot:68d56f15f85d3136970ec16946040bc1"];
-                }
-                return [2 /*return*/, undefined];
-            });
-        });
-    };
-    SubstrateProtocolImpl.prototype.prepareWalletConnectTransactionWithPublicKey = function (publicKey, request) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                throw new Error('Method not implemented.');
-            });
-        });
-    };
-    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)];
-            });
-        });
-    };
+    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);
+    }
     // Offline
-    SubstrateProtocolImpl.prototype.getCryptoConfiguration = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoConfiguration];
-            });
-        });
-    };
-    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]];
-                }
-            });
+    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
         });
-    };
+    }
+    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];
+    }
     // Custom
-    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);
+    async encodeDetails(txs) {
+        return this.transactionController.encodeDetails(txs);
+    }
+    async decodeDetails(serialized) {
+        return this.decodeDetails(serialized);
+    }
+    getDetailsFromEncodedTransaction(encoded) {
+        const txs = this.transactionController.decodeDetails(encoded);
         return txs
-            .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') }));
-            });
+            .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')
+            }));
         })
-            .reduce(function (flatten, toFlatten) { return flatten.concat(toFlatten); }, []);
-    };
-    return SubstrateProtocolImpl;
-}());
+            .reduce((flatten, toFlatten) => flatten.concat(toFlatten), []);
+    }
+}
 exports.SubstrateProtocolImpl = SubstrateProtocolImpl;
 //# sourceMappingURL=SubstrateProtocol.js.map