@ledgerhq/live-common 21.36.2 → 22.0.0

package/lib/families/solana/js-prepareTransaction.js

@@ -61,40 +61,26 @@ var logic_1 = require("./logic");
 var utils_1 = require("./utils");
 function deriveCommandDescriptor(mainAccount, tx, api) {
     return __awaiter(this, void 0, void 0, function () {
-        var errors, model, memoBytes;
+        var model;
         return __generator(this, function (_a) {
-            errors = {};
             model = tx.model;
             switch (model.kind) {
                 case "transfer":
+                    return [2 /*return*/, deriveTransferCommandDescriptor(mainAccount, tx, model, api)];
                 case "token.transfer":
-                    if (!tx.recipient) {
-                        errors.recipient = new errors_1.RecipientRequired();
-                    }
-                    else if (mainAccount.freshAddress === tx.recipient) {
-                        errors.recipient = new errors_1.InvalidAddressBecauseDestinationIsAlsoSource();
-                    }
-                    else if (!(0, logic_1.isValidBase58Address)(tx.recipient)) {
-                        errors.recipient = new errors_1.InvalidAddress();
-                    }
-                    if (model.uiState.memo) {
-                        memoBytes = Buffer.from(model.uiState.memo, "utf-8");
-                        if (memoBytes.byteLength > logic_1.MAX_MEMO_LENGTH) {
-                            errors.memo = errors.memo = new errors_2.SolanaMemoIsTooLong(undefined, {
-                                maxLength: logic_1.MAX_MEMO_LENGTH
-                            });
-                            // LLM expects <transaction> as error key to disable continue button
-                            errors.transaction = errors.memo;
-                        }
-                    }
-                    if (Object.keys(errors).length > 0) {
-                        return [2 /*return*/, toInvalidStatusCommand(errors)];
-                    }
-                    return [2 /*return*/, model.kind === "transfer"
-                            ? deriveTransferCommandDescriptor(mainAccount, tx, model, api)
-                            : deriveTokenTransferCommandDescriptor(mainAccount, tx, model, api)];
+                    return [2 /*return*/, deriveTokenTransferCommandDescriptor(mainAccount, tx, model, api)];
                 case "token.createATA":
                     return [2 /*return*/, deriveCreateAssociatedTokenAccountCommandDescriptor(mainAccount, model, api)];
+                case "stake.createAccount":
+                    return [2 /*return*/, deriveStakeCreateAccountCommandDescriptor(mainAccount, tx, model, api)];
+                case "stake.delegate":
+                    return [2 /*return*/, deriveStakeDelegateCommandDescriptor(mainAccount, model, api)];
+                case "stake.undelegate":
+                    return [2 /*return*/, deriveStakeUndelegateCommandDescriptor(mainAccount, model, api)];
+                case "stake.withdraw":
+                    return [2 /*return*/, deriveStakeWithdrawCommandDescriptor(mainAccount, tx, model, api)];
+                case "stake.split":
+                    return [2 /*return*/, deriveStakeSplitCommandDescriptor(mainAccount, tx, model, api)];
                 default:
                     return [2 /*return*/, (0, utils_1.assertUnreachable)(model)];
             }
@@ -103,64 +89,27 @@ function deriveCommandDescriptor(mainAccount, tx, api) {
     });
 }
 var prepareTransaction = function (mainAccount, tx, api) { return __awaiter(void 0, void 0, void 0, function () {
-    var patch, errors, feeCalculator, _a, txToDeriveFrom, commandDescriptor, command, totalSpend, totalFees;
-    var _b, _c;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
+    var txToDeriveFrom, commandDescriptor, model, preparedTx;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
             case 0:
-                patch = {};
-                errors = {};
-                if (!((_b = tx.feeCalculator) !== null && _b !== void 0)) return [3 /*break*/, 1];
-                _a = _b;
-                return [3 /*break*/, 3];
-            case 1: return [4 /*yield*/, api.getTxFeeCalculator()];
-            case 2:
-                _a = (_d.sent());
-                _d.label = 3;
-            case 3:
-                feeCalculator = _a;
-                if (tx.feeCalculator === undefined) {
-                    patch.feeCalculator = feeCalculator;
-                    // LLM requires this field to be truthy to show fees
-                    patch.networkInfo = true;
-                }
-                txToDeriveFrom = __assign(__assign({}, updateModelIfSubAccountIdPresent(tx)), { feeCalculator: feeCalculator });
+                txToDeriveFrom = updateModelIfSubAccountIdPresent(tx);
                 return [4 /*yield*/, deriveCommandDescriptor(mainAccount, txToDeriveFrom, api)];
-            case 4:
-                commandDescriptor = _d.sent();
-                if (commandDescriptor.status === "invalid") {
-                    return [2 /*return*/, toInvalidTx(tx, patch, commandDescriptor.errors, commandDescriptor.warnings)];
-                }
-                command = commandDescriptor.command;
-                switch (command.kind) {
-                    case "transfer": {
-                        totalSpend = command.amount + feeCalculator.lamportsPerSignature;
-                        if (mainAccount.balance.lt(totalSpend)) {
-                            errors.amount = new errors_1.NotEnoughBalance();
-                        }
-                        break;
-                    }
-                    default: {
-                        totalFees = feeCalculator.lamportsPerSignature + ((_c = commandDescriptor.fees) !== null && _c !== void 0 ? _c : 0);
-                        if (mainAccount.balance.lt(totalFees)) {
-                            errors.amount = new errors_1.NotEnoughBalance();
-                        }
-                    }
-                }
-                if (Object.keys(errors).length > 0) {
-                    return [2 /*return*/, toInvalidTx(tx, patch, errors)];
-                }
-                patch.model = __assign(__assign({}, tx.model), { commandDescriptor: commandDescriptor });
-                return [2 /*return*/, Object.keys(patch).length > 0
-                        ? __assign(__assign({}, tx), patch) : tx];
+            case 1:
+                commandDescriptor = _a.sent();
+                model = __assign(__assign({}, tx.model), { commandDescriptor: commandDescriptor });
+                preparedTx = __assign(__assign({}, tx), { model: model });
+                // LLM requires this field to be truthy to show fees
+                preparedTx.networkInfo = true;
+                return [2 /*return*/, preparedTx];
         }
     });
 }); };
 exports.prepareTransaction = prepareTransaction;
 var deriveTokenTransferCommandDescriptor = function (mainAccount, tx, model, api) { return __awaiter(void 0, void 0, void 0, function () {
-    var errors, warnings, subAccount, tokenIdParts, mintAddress, mintDecimals, senderAssociatedTokenAccountAddress, recipientDescriptor, fees, _a, txAmount;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
+    var errors, warnings, subAccount, memo, tokenIdParts, mintAddress, mintDecimals, senderAssociatedTokenAccountAddress, defaultRecipientDescriptor, recipientDescriptorOrError, _a, recipientDescriptor, txFee, assocAccRentExempt, _b, txAmount;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
             case 0:
                 errors = {};
                 warnings = {};
@@ -168,54 +117,68 @@ var deriveTokenTransferCommandDescriptor = function (mainAccount, tx, model, api
                 if (!subAccount || subAccount.type !== "TokenAccount") {
                     throw new Error("subaccount not found");
                 }
+                return [4 /*yield*/, validateRecipientCommon(mainAccount, tx, errors, warnings, api)];
+            case 1:
+                _c.sent();
+                memo = model.uiState.memo;
+                if (typeof memo === "string" && memo.length > 0) {
+                    validateMemoCommon(memo, errors);
+                }
                 tokenIdParts = subAccount.token.id.split("/");
                 mintAddress = tokenIdParts[tokenIdParts.length - 1];
                 mintDecimals = subAccount.token.units[0].magnitude;
                 senderAssociatedTokenAccountAddress = (0, logic_1.decodeAccountIdWithTokenAccountAddress)(subAccount.id).address;
-                if (tx.recipient === senderAssociatedTokenAccountAddress) {
+                if (!errors.recipient &&
+                    tx.recipient === senderAssociatedTokenAccountAddress) {
                     errors.recipient = new errors_2.SolanaTokenRecipientIsSenderATA();
-                    return [2 /*return*/, toInvalidStatusCommand(errors, warnings)];
-                }
-                return [4 /*yield*/, getTokenRecipient(tx.recipient, mintAddress, api)];
-            case 1:
-                recipientDescriptor = _b.sent();
-                if (recipientDescriptor instanceof Error) {
-                    errors.recipient = recipientDescriptor;
-                    return [2 /*return*/, toInvalidStatusCommand(errors, warnings)];
                 }
-                if (!recipientDescriptor.shouldCreateAsAssociatedTokenAccount) return [3 /*break*/, 3];
-                return [4 /*yield*/, api.getAssocTokenAccMinNativeBalance()];
-            case 2:
-                _a = _b.sent();
+                defaultRecipientDescriptor = {
+                    shouldCreateAsAssociatedTokenAccount: false,
+                    tokenAccAddress: "",
+                    walletAddress: ""
+                };
+                if (!errors.recipient) return [3 /*break*/, 2];
+                _a = defaultRecipientDescriptor;
                 return [3 /*break*/, 4];
+            case 2: return [4 /*yield*/, getTokenRecipient(tx.recipient, mintAddress, api)];
             case 3:
-                _a = 0;
-                _b.label = 4;
+                _a = _c.sent();
+                _c.label = 4;
             case 4:
-                fees = _a;
-                if (!recipientDescriptor.shouldCreateAsAssociatedTokenAccount) return [3 /*break*/, 6];
-                warnings.recipientAssociatedTokenAccount =
-                    new errors_2.SolanaRecipientAssociatedTokenAccountWillBeFunded();
-                return [4 /*yield*/, isAccountFunded(tx.recipient, api)];
-            case 5:
-                if (!(_b.sent())) {
-                    warnings.recipient = new errors_2.SolanaAccountNotFunded();
+                recipientDescriptorOrError = _a;
+                if (!errors.recipient && recipientDescriptorOrError instanceof Error) {
+                    errors.recipient = recipientDescriptorOrError;
                 }
-                _b.label = 6;
+                recipientDescriptor = recipientDescriptorOrError instanceof Error
+                    ? defaultRecipientDescriptor
+                    : recipientDescriptorOrError;
+                return [4 /*yield*/, api.getTxFeeCalculator()];
+            case 5:
+                txFee = (_c.sent()).lamportsPerSignature;
+                if (!recipientDescriptor.shouldCreateAsAssociatedTokenAccount) return [3 /*break*/, 7];
+                return [4 /*yield*/, api.getAssocTokenAccMinNativeBalance()];
             case 6:
+                _b = _c.sent();
+                return [3 /*break*/, 8];
+            case 7:
+                _b = 0;
+                _c.label = 8;
+            case 8:
+                assocAccRentExempt = _b;
+                if (recipientDescriptor.shouldCreateAsAssociatedTokenAccount) {
+                    warnings.recipient =
+                        new errors_2.SolanaRecipientAssociatedTokenAccountWillBeFunded();
+                }
                 if (!tx.useAllAmount && tx.amount.lte(0)) {
                     errors.amount = new errors_1.AmountRequired();
-                    return [2 /*return*/, toInvalidStatusCommand(errors, warnings)];
                 }
                 txAmount = tx.useAllAmount
                     ? subAccount.spendableBalance.toNumber()
                     : tx.amount.toNumber();
-                if (txAmount > subAccount.spendableBalance.toNumber()) {
+                if (!errors.amount && txAmount > subAccount.spendableBalance.toNumber()) {
                     errors.amount = new errors_1.NotEnoughBalance();
-                    return [2 /*return*/, toInvalidStatusCommand(errors, warnings)];
                 }
                 return [2 /*return*/, {
-                        status: "valid",
                         command: {
                             kind: "token.transfer",
                             ownerAddress: mainAccount.freshAddress,
@@ -226,8 +189,9 @@ var deriveTokenTransferCommandDescriptor = function (mainAccount, tx, model, api
                             recipientDescriptor: recipientDescriptor,
                             memo: model.uiState.memo
                         },
-                        fees: fees,
-                        warnings: warnings
+                        fee: txFee + assocAccRentExempt,
+                        warnings: warnings,
+                        errors: errors
                     }];
         }
     });
@@ -277,7 +241,7 @@ function getTokenRecipient(recipientAddress, mintAddress, api) {
 }
 function deriveCreateAssociatedTokenAccountCommandDescriptor(mainAccount, model, api) {
     return __awaiter(this, void 0, void 0, function () {
-        var token, tokenIdParts, mint, associatedTokenAccountAddress, fees;
+        var token, tokenIdParts, mint, associatedTokenAccountAddress, txFee, assocAccRentExempt;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -287,18 +251,22 @@ function deriveCreateAssociatedTokenAccountCommandDescriptor(mainAccount, model,
                     return [4 /*yield*/, api.findAssocTokenAccAddress(mainAccount.freshAddress, mint)];
                 case 1:
                     associatedTokenAccountAddress = _a.sent();
-                    return [4 /*yield*/, api.getAssocTokenAccMinNativeBalance()];
+                    return [4 /*yield*/, api.getTxFeeCalculator()];
                 case 2:
-                    fees = _a.sent();
+                    txFee = (_a.sent()).lamportsPerSignature;
+                    return [4 /*yield*/, api.getAssocTokenAccMinNativeBalance()];
+                case 3:
+                    assocAccRentExempt = _a.sent();
                     return [2 /*return*/, {
-                            status: "valid",
-                            fees: fees,
+                            fee: txFee + assocAccRentExempt,
                             command: {
                                 kind: model.kind,
                                 mint: mint,
                                 owner: mainAccount.freshAddress,
                                 associatedTokenAccountAddress: associatedTokenAccountAddress
-                            }
+                            },
+                            warnings: {},
+                            errors: {}
                         }];
             }
         });
@@ -306,57 +274,282 @@ function deriveCreateAssociatedTokenAccountCommandDescriptor(mainAccount, model,
 }
 function deriveTransferCommandDescriptor(mainAccount, tx, model, api) {
     return __awaiter(this, void 0, void 0, function () {
-        var errors, warnings, recipientWalletIsUnfunded, fee, txAmount;
+        var errors, warnings, memo, fee, txAmount, command;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     errors = {};
                     warnings = {};
-                    if (!(0, logic_1.isEd25519Address)(tx.recipient)) {
-                        warnings.recipientOffCurve = new errors_2.SolanaAddressOffEd25519();
-                    }
-                    return [4 /*yield*/, isAccountFunded(tx.recipient, api)];
+                    return [4 /*yield*/, validateRecipientCommon(mainAccount, tx, errors, warnings, api)];
                 case 1:
-                    recipientWalletIsUnfunded = !(_a.sent());
-                    if (recipientWalletIsUnfunded) {
-                        warnings.recipient = new errors_2.SolanaAccountNotFunded();
+                    _a.sent();
+                    memo = model.uiState.memo;
+                    if (typeof memo === "string" && memo.length > 0) {
+                        validateMemoCommon(memo, errors);
+                    }
+                    return [4 /*yield*/, api.getTxFeeCalculator()];
+                case 2:
+                    fee = (_a.sent()).lamportsPerSignature;
+                    txAmount = tx.useAllAmount
+                        ? bignumber_js_1["default"].max(mainAccount.balance.minus(fee), 0)
+                        : tx.amount;
+                    if (tx.useAllAmount) {
+                        if (txAmount.eq(0)) {
+                            errors.amount = new errors_1.NotEnoughBalance();
+                        }
                     }
+                    else {
+                        if (txAmount.lte(0)) {
+                            errors.amount = new errors_1.AmountRequired();
+                        }
+                        else if (txAmount.plus(fee).gt(mainAccount.balance)) {
+                            errors.amount = new errors_1.NotEnoughBalance();
+                        }
+                    }
+                    command = {
+                        kind: "transfer",
+                        amount: txAmount.toNumber(),
+                        sender: mainAccount.freshAddress,
+                        recipient: tx.recipient,
+                        memo: model.uiState.memo
+                    };
+                    return [2 /*return*/, {
+                            command: command,
+                            fee: fee,
+                            warnings: warnings,
+                            errors: errors
+                        }];
+            }
+        });
+    });
+}
+function deriveStakeCreateAccountCommandDescriptor(mainAccount, tx, model, api) {
+    return __awaiter(this, void 0, void 0, function () {
+        var errors, txFee, stakeAccRentExemptAmount, fee, amount, delegate, _a, stakeAccAddress, stakeAccAddressSeed;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    errors = {};
                     if (!tx.useAllAmount && tx.amount.lte(0)) {
                         errors.amount = new errors_1.AmountRequired();
-                        return [2 /*return*/, toInvalidStatusCommand(errors, warnings)];
                     }
-                    fee = tx.feeCalculator.lamportsPerSignature;
-                    txAmount = tx.useAllAmount
+                    return [4 /*yield*/, api.getTxFeeCalculator()];
+                case 1:
+                    txFee = (_b.sent()).lamportsPerSignature;
+                    return [4 /*yield*/, (0, web3_1.getStakeAccountMinimumBalanceForRentExemption)(api)];
+                case 2:
+                    stakeAccRentExemptAmount = _b.sent();
+                    fee = txFee + stakeAccRentExemptAmount;
+                    amount = tx.useAllAmount
                         ? bignumber_js_1["default"].max(mainAccount.balance.minus(fee), 0)
                         : tx.amount;
-                    if (txAmount.plus(fee).gt(mainAccount.balance)) {
+                    if (!errors.amount && mainAccount.balance.lt(amount.plus(fee))) {
                         errors.amount = new errors_1.NotEnoughBalance();
-                        return [2 /*return*/, toInvalidStatusCommand(errors, warnings)];
                     }
+                    delegate = model.uiState.delegate;
+                    return [4 /*yield*/, validateValidatorCommon(delegate.voteAccAddress, errors, api)];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, nextStakeAccAddr(mainAccount)];
+                case 4:
+                    _a = _b.sent(), stakeAccAddress = _a.addr, stakeAccAddressSeed = _a.seed;
                     return [2 /*return*/, {
-                            status: "valid",
                             command: {
-                                kind: "transfer",
-                                sender: mainAccount.freshAddress,
-                                recipient: tx.recipient,
-                                amount: txAmount.toNumber(),
-                                memo: model.uiState.memo
+                                kind: "stake.createAccount",
+                                amount: amount.toNumber(),
+                                stakeAccRentExemptAmount: stakeAccRentExemptAmount,
+                                fromAccAddress: mainAccount.freshAddress,
+                                stakeAccAddress: stakeAccAddress,
+                                delegate: delegate,
+                                seed: stakeAccAddressSeed
                             },
-                            warnings: Object.keys(warnings).length > 0 ? warnings : undefined
+                            fee: fee,
+                            warnings: {},
+                            errors: errors
                         }];
             }
         });
     });
 }
-function toInvalidTx(tx, patch, errors, warnings) {
-    return __assign(__assign(__assign({}, tx), patch), { model: __assign(__assign({}, tx.model), { commandDescriptor: toInvalidStatusCommand(errors, warnings) }) });
+function deriveStakeDelegateCommandDescriptor(mainAccount, model, api) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function () {
+        var errors, uiState, stake, txFee;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    errors = {};
+                    uiState = model.uiState;
+                    stake = validateAndTryGetStakeAccount(mainAccount, uiState.stakeAccAddr, errors);
+                    if (stake !== undefined && !stake.hasStakeAuth && !stake.hasWithdrawAuth) {
+                        errors.stakeAccAddr = new errors_2.SolanaStakeNoStakeAuth();
+                    }
+                    return [4 /*yield*/, validateValidatorCommon(uiState.voteAccAddr, errors, api)];
+                case 1:
+                    _b.sent();
+                    if (!errors.voteAccAddr && stake !== undefined) {
+                        switch (stake.activation.state) {
+                            case "active":
+                            case "activating":
+                                errors.stakeAccAddr = new errors_2.SolanaStakeAccountIsNotDelegatable();
+                                break;
+                            case "inactive":
+                                break;
+                            case "deactivating":
+                                if (((_a = stake.delegation) === null || _a === void 0 ? void 0 : _a.voteAccAddr) !== uiState.voteAccAddr) {
+                                    errors.stakeAccAddr = new errors_2.SolanaStakeAccountValidatorIsUnchangeable();
+                                }
+                                break;
+                            default:
+                                return [2 /*return*/, (0, utils_1.assertUnreachable)(stake.activation.state)];
+                        }
+                    }
+                    return [4 /*yield*/, api.getTxFeeCalculator()];
+                case 2:
+                    txFee = (_b.sent()).lamportsPerSignature;
+                    if (mainAccount.balance.lt(txFee)) {
+                        errors.fee = new errors_1.NotEnoughBalance();
+                    }
+                    return [2 /*return*/, {
+                            command: {
+                                kind: "stake.delegate",
+                                authorizedAccAddr: mainAccount.freshAddress,
+                                stakeAccAddr: uiState.stakeAccAddr,
+                                voteAccAddr: uiState.voteAccAddr
+                            },
+                            fee: txFee,
+                            warnings: {},
+                            errors: errors
+                        }];
+            }
+        });
+    });
 }
-function toInvalidStatusCommand(errors, warnings) {
-    return {
-        status: "invalid",
-        errors: errors,
-        warnings: warnings
-    };
+function deriveStakeUndelegateCommandDescriptor(mainAccount, model, api) {
+    return __awaiter(this, void 0, void 0, function () {
+        var errors, uiState, stake, txFee;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    errors = {};
+                    uiState = model.uiState;
+                    stake = validateAndTryGetStakeAccount(mainAccount, uiState.stakeAccAddr, errors);
+                    if (stake !== undefined) {
+                        switch (stake.activation.state) {
+                            case "active":
+                            case "activating":
+                                break;
+                            case "inactive":
+                            case "deactivating":
+                                errors.stakeAccAddr = new errors_2.SolanaStakeAccountIsNotUndelegatable();
+                                break;
+                            default:
+                                return [2 /*return*/, (0, utils_1.assertUnreachable)(stake.activation.state)];
+                        }
+                        if (!errors.stakeAccAddr && !stake.hasStakeAuth && !stake.hasWithdrawAuth) {
+                            errors.stakeAccAddr = new errors_2.SolanaStakeNoStakeAuth();
+                        }
+                    }
+                    return [4 /*yield*/, api.getTxFeeCalculator()];
+                case 1:
+                    txFee = (_a.sent()).lamportsPerSignature;
+                    if (mainAccount.balance.lt(txFee)) {
+                        errors.fee = new errors_1.NotEnoughBalance();
+                    }
+                    return [2 /*return*/, {
+                            command: {
+                                kind: "stake.undelegate",
+                                authorizedAccAddr: mainAccount.freshAddress,
+                                stakeAccAddr: uiState.stakeAccAddr
+                            },
+                            fee: txFee,
+                            warnings: {},
+                            errors: errors
+                        }];
+            }
+        });
+    });
+}
+function deriveStakeWithdrawCommandDescriptor(mainAccount, tx, model, api) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function () {
+        var errors, uiState, stake, txFee;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    errors = {};
+                    uiState = model.uiState;
+                    stake = validateAndTryGetStakeAccount(mainAccount, uiState.stakeAccAddr, errors);
+                    if (!errors.stakeAccAddr && stake !== undefined) {
+                        if (!stake.hasWithdrawAuth) {
+                            errors.stakeAccAddr = new errors_2.SolanaStakeNoWithdrawAuth();
+                        }
+                        else if (stake.withdrawable <= 0) {
+                            errors.stakeAccAddr = new errors_2.SolanaStakeAccountNothingToWithdraw();
+                        }
+                    }
+                    return [4 /*yield*/, api.getTxFeeCalculator()];
+                case 1:
+                    txFee = (_b.sent()).lamportsPerSignature;
+                    if (mainAccount.balance.lt(txFee)) {
+                        errors.fee = new errors_1.NotEnoughBalance();
+                    }
+                    return [2 /*return*/, {
+                            command: {
+                                kind: "stake.withdraw",
+                                authorizedAccAddr: mainAccount.freshAddress,
+                                stakeAccAddr: uiState.stakeAccAddr,
+                                amount: (_a = stake === null || stake === void 0 ? void 0 : stake.withdrawable) !== null && _a !== void 0 ? _a : 0,
+                                toAccAddr: mainAccount.freshAddress
+                            },
+                            fee: txFee,
+                            warnings: {},
+                            errors: errors
+                        }];
+            }
+        });
+    });
+}
+function deriveStakeSplitCommandDescriptor(mainAccount, tx, model, api) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function () {
+        var errors, uiState, commandFees, _c, splitStakeAccAddr, splitStakeAccAddrSeed;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    errors = {};
+                    uiState = model.uiState;
+                    // TODO: use all amount
+                    if (tx.amount.lte(0)) {
+                        errors.amount = new errors_1.AmountRequired();
+                    }
+                    // TODO: else if amount > stake balance
+                    if (!(0, logic_1.isValidBase58Address)(uiState.stakeAccAddr)) {
+                        errors.stakeAccAddr = new errors_1.InvalidAddress();
+                    }
+                    (_b = (_a = mainAccount.solanaResources) === null || _a === void 0 ? void 0 : _a.stakes) !== null && _b !== void 0 ? _b : [];
+                    return [4 /*yield*/, (0, web3_1.getStakeAccountMinimumBalanceForRentExemption)(api)];
+                case 1:
+                    commandFees = _d.sent();
+                    return [4 /*yield*/, nextStakeAccAddr(mainAccount)];
+                case 2:
+                    _c = _d.sent(), splitStakeAccAddr = _c.addr, splitStakeAccAddrSeed = _c.seed;
+                    return [2 /*return*/, {
+                            command: {
+                                kind: "stake.split",
+                                authorizedAccAddr: mainAccount.freshAddress,
+                                stakeAccAddr: uiState.stakeAccAddr,
+                                amount: tx.amount.toNumber(),
+                                seed: splitStakeAccAddrSeed,
+                                splitStakeAccAddr: splitStakeAccAddr
+                            },
+                            fee: commandFees,
+                            warnings: {},
+                            errors: {}
+                        }];
+            }
+        });
+    });
 }
 // if subaccountid present - it's a token transfer
 function updateModelIfSubAccountIdPresent(tx) {
@@ -381,4 +574,122 @@ function isAccountFunded(address, api) {
         });
     });
 }
+function nextStakeAccAddr(account, base) {
+    var _a, _b;
+    if (base === void 0) { base = "stake"; }
+    return __awaiter(this, void 0, void 0, function () {
+        var usedStakeAccAddrs;
+        return __generator(this, function (_c) {
+            usedStakeAccAddrs = ((_b = (_a = account.solanaResources) === null || _a === void 0 ? void 0 : _a.stakes) !== null && _b !== void 0 ? _b : []).map(function (s) { return s.stakeAccAddr; });
+            return [2 /*return*/, nextStakeAccAddrRoutine(account.freshAddress, new Set(usedStakeAccAddrs), base, 0)];
+        });
+    });
+}
+function nextStakeAccAddrRoutine(fromAddress, usedAddresses, base, idx) {
+    return __awaiter(this, void 0, void 0, function () {
+        var seed, addr;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    seed = "".concat(base, ":").concat(idx);
+                    return [4 /*yield*/, (0, web3_1.getStakeAccountAddressWithSeed)({
+                            fromAddress: fromAddress,
+                            seed: seed
+                        })];
+                case 1:
+                    addr = _a.sent();
+                    return [2 /*return*/, usedAddresses.has(addr)
+                            ? nextStakeAccAddrRoutine(fromAddress, usedAddresses, base, idx + 1)
+                            : {
+                                seed: seed,
+                                addr: addr
+                            }];
+            }
+        });
+    });
+}
+function validateRecipientCommon(mainAccount, tx, errors, warnings, api) {
+    return __awaiter(this, void 0, void 0, function () {
+        var recipientWalletIsUnfunded;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!!tx.recipient) return [3 /*break*/, 1];
+                    errors.recipient = new errors_1.RecipientRequired();
+                    return [3 /*break*/, 5];
+                case 1:
+                    if (!(mainAccount.freshAddress === tx.recipient)) return [3 /*break*/, 2];
+                    errors.recipient = new errors_1.InvalidAddressBecauseDestinationIsAlsoSource();
+                    return [3 /*break*/, 5];
+                case 2:
+                    if (!!(0, logic_1.isValidBase58Address)(tx.recipient)) return [3 /*break*/, 3];
+                    errors.recipient = new errors_1.InvalidAddress();
+                    return [3 /*break*/, 5];
+                case 3: return [4 /*yield*/, isAccountFunded(tx.recipient, api)];
+                case 4:
+                    recipientWalletIsUnfunded = !(_a.sent());
+                    if (recipientWalletIsUnfunded) {
+                        warnings.recipient = new errors_2.SolanaAccountNotFunded();
+                    }
+                    if (!(0, logic_1.isEd25519Address)(tx.recipient)) {
+                        warnings.recipientOffCurve = new errors_2.SolanaAddressOffEd25519();
+                    }
+                    _a.label = 5;
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+function validateMemoCommon(memo, errors) {
+    var memoBytes = Buffer.from(memo, "utf-8");
+    if (memoBytes.byteLength > logic_1.MAX_MEMO_LENGTH) {
+        errors.memo = errors.memo = new errors_2.SolanaMemoIsTooLong(undefined, {
+            maxLength: logic_1.MAX_MEMO_LENGTH
+        });
+        // LLM expects <transaction> as error key to disable continue button
+        errors.transaction = errors.memo;
+    }
+}
+function validateValidatorCommon(addr, errors, api) {
+    return __awaiter(this, void 0, void 0, function () {
+        var voteAcc;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(addr.length === 0)) return [3 /*break*/, 1];
+                    errors.voteAccAddr = new errors_2.SolanaValidatorRequired();
+                    return [3 /*break*/, 4];
+                case 1:
+                    if (!!(0, logic_1.isValidBase58Address)(addr)) return [3 /*break*/, 2];
+                    errors.voteAccAddr = new errors_1.InvalidAddress();
+                    return [3 /*break*/, 4];
+                case 2: return [4 /*yield*/, (0, web3_1.getMaybeVoteAccount)(addr, api)];
+                case 3:
+                    voteAcc = _a.sent();
+                    if (voteAcc instanceof Error || voteAcc === undefined) {
+                        errors.voteAccAddr = new errors_2.SolanaInvalidValidator();
+                    }
+                    _a.label = 4;
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+function validateAndTryGetStakeAccount(account, stakeAccAddr, errors) {
+    var _a;
+    if (stakeAccAddr.length === 0) {
+        errors.stakeAccAddr = new errors_2.SolanaStakeAccountRequired();
+    }
+    else if (!(0, logic_1.isValidBase58Address)(stakeAccAddr)) {
+        errors.stakeAccAddr = new errors_1.InvalidAddress();
+    }
+    if (!errors.stakeAccAddr) {
+        var stake = (_a = account.solanaResources) === null || _a === void 0 ? void 0 : _a.stakes.find(function (stake) { return stake.stakeAccAddr === stakeAccAddr; });
+        if (stake === undefined) {
+            errors.stakeAccAddr = new errors_2.SolanaStakeAccountNotFound();
+        }
+        return stake;
+    }
+    return undefined;
+}
 //# sourceMappingURL=js-prepareTransaction.js.map