@ledgerhq/coin-solana 0.12.0 → 0.12.1

package/lib/prepareTransaction.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareTransaction = void 0;
 const cryptoassets_1 = require("@ledgerhq/cryptoassets");
@@ -19,52 +10,53 @@ const logic_1 = require("./logic");
 const utils_1 = require("./utils");
 const jsHelpers_1 = require("@ledgerhq/coin-framework/bridge/jsHelpers");
 const estimateMaxSpendable_1 = require("./estimateMaxSpendable");
-function deriveCommandDescriptor(mainAccount, tx, api) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { model } = tx;
-        switch (model.kind) {
-            case "transfer":
-                return deriveTransferCommandDescriptor(mainAccount, tx, model, api);
-            case "token.transfer":
-                return deriveTokenTransferCommandDescriptor(mainAccount, tx, model, api);
-            case "token.createATA":
-                return deriveCreateAssociatedTokenAccountCommandDescriptor(mainAccount, tx, model, api);
-            case "stake.createAccount":
-                return deriveStakeCreateAccountCommandDescriptor(mainAccount, tx, model, api);
-            case "stake.delegate":
-                return deriveStakeDelegateCommandDescriptor(mainAccount, tx, model, api);
-            case "stake.undelegate":
-                return deriveStakeUndelegateCommandDescriptor(mainAccount, tx, model, api);
-            case "stake.withdraw":
-                return deriveStakeWithdrawCommandDescriptor(mainAccount, tx, model, api);
-            case "stake.split":
-                return deriveStakeSplitCommandDescriptor(mainAccount, tx, model, api);
-            default:
-                return (0, utils_1.assertUnreachable)(model);
-        }
-    });
+async function deriveCommandDescriptor(mainAccount, tx, api) {
+    const { model } = tx;
+    switch (model.kind) {
+        case "transfer":
+            return deriveTransferCommandDescriptor(mainAccount, tx, model, api);
+        case "token.transfer":
+            return deriveTokenTransferCommandDescriptor(mainAccount, tx, model, api);
+        case "token.createATA":
+            return deriveCreateAssociatedTokenAccountCommandDescriptor(mainAccount, tx, model, api);
+        case "stake.createAccount":
+            return deriveStakeCreateAccountCommandDescriptor(mainAccount, tx, model, api);
+        case "stake.delegate":
+            return deriveStakeDelegateCommandDescriptor(mainAccount, tx, model, api);
+        case "stake.undelegate":
+            return deriveStakeUndelegateCommandDescriptor(mainAccount, tx, model, api);
+        case "stake.withdraw":
+            return deriveStakeWithdrawCommandDescriptor(mainAccount, tx, model, api);
+        case "stake.split":
+            return deriveStakeSplitCommandDescriptor(mainAccount, tx, model, api);
+        default:
+            return (0, utils_1.assertUnreachable)(model);
+    }
 }
-const prepareTransaction = (mainAccount, tx, api) => __awaiter(void 0, void 0, void 0, function* () {
+const prepareTransaction = async (mainAccount, tx, api) => {
     const txToDeriveFrom = updateModelIfSubAccountIdPresent(tx);
-    const commandDescriptor = yield deriveCommandDescriptor(mainAccount, txToDeriveFrom, api);
-    const model = Object.assign(Object.assign({}, tx.model), { commandDescriptor });
+    const commandDescriptor = await deriveCommandDescriptor(mainAccount, txToDeriveFrom, api);
+    const model = {
+        ...tx.model,
+        commandDescriptor,
+    };
     const patch = {
         model,
     };
     return (0, jsHelpers_1.updateTransaction)(tx, patch);
-});
+};
 exports.prepareTransaction = prepareTransaction;
-const deriveTokenTransferCommandDescriptor = (mainAccount, tx, model, api) => __awaiter(void 0, void 0, void 0, function* () {
+const deriveTokenTransferCommandDescriptor = async (mainAccount, tx, model, api) => {
     const errors = {};
     const warnings = {};
     const subAccount = (0, index_1.findSubAccountById)(mainAccount, model.uiState.subAccountId);
     if (!subAccount || subAccount.type !== "TokenAccount") {
         throw new Error("subaccount not found");
     }
-    if ((subAccount === null || subAccount === void 0 ? void 0 : subAccount.state) === "frozen") {
+    if (subAccount?.state === "frozen") {
         errors.amount = new errors_2.SolanaTokenAccountFrozen();
     }
-    yield validateRecipientCommon(mainAccount, tx, errors, warnings, api, true);
+    await validateRecipientCommon(mainAccount, tx, errors, warnings, api, true);
     const memo = model.uiState.memo;
     if (typeof memo === "string" && memo.length > 0) {
         validateMemoCommon(memo, errors);
@@ -82,7 +74,7 @@ const deriveTokenTransferCommandDescriptor = (mainAccount, tx, model, api) => __
     };
     const recipientDescriptorOrError = errors.recipient
         ? defaultRecipientDescriptor
-        : yield getTokenRecipient(tx.recipient, mintAddress, api);
+        : await getTokenRecipient(tx.recipient, mintAddress, api);
     if (!errors.recipient && recipientDescriptorOrError instanceof Error) {
         errors.recipient = recipientDescriptorOrError;
     }
@@ -90,12 +82,12 @@ const deriveTokenTransferCommandDescriptor = (mainAccount, tx, model, api) => __
         ? defaultRecipientDescriptor
         : recipientDescriptorOrError;
     const assocAccRentExempt = recipientDescriptor.shouldCreateAsAssociatedTokenAccount
-        ? yield api.getAssocTokenAccMinNativeBalance()
+        ? await api.getAssocTokenAccMinNativeBalance()
         : 0;
     if (recipientDescriptor.shouldCreateAsAssociatedTokenAccount) {
         warnings.recipient = new errors_2.SolanaRecipientAssociatedTokenAccountWillBeFunded();
     }
-    const { fee, spendable: spendableSol } = yield (0, estimateMaxSpendable_1.estimateFeeAndSpendable)(api, mainAccount, tx);
+    const { fee, spendable: spendableSol } = await (0, estimateMaxSpendable_1.estimateFeeAndSpendable)(api, mainAccount, tx);
     if (spendableSol.lt(assocAccRentExempt) || spendableSol.isZero()) {
         errors.fee = new errors_1.NotEnoughBalance();
     }
@@ -121,370 +113,353 @@ const deriveTokenTransferCommandDescriptor = (mainAccount, tx, model, api) => __
         warnings,
         errors,
     };
-});
-function getTokenRecipient(recipientAddress, mintAddress, api) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const recipientTokenAccount = yield (0, web3_1.getMaybeTokenAccount)(recipientAddress, api);
-        if (recipientTokenAccount instanceof Error) {
-            throw recipientTokenAccount;
-        }
-        if (recipientTokenAccount === undefined) {
-            if (!(0, logic_1.isEd25519Address)(recipientAddress)) {
-                return new errors_2.SolanaAddressOffEd25519();
-            }
-            const recipientAssociatedTokenAccountAddress = yield api.findAssocTokenAccAddress(recipientAddress, mintAddress);
-            const shouldCreateAsAssociatedTokenAccount = !(yield isAccountFunded(recipientAssociatedTokenAccountAddress, api));
-            if (!shouldCreateAsAssociatedTokenAccount) {
-                const associatedTokenAccount = yield (0, web3_1.getMaybeTokenAccount)(recipientAssociatedTokenAccountAddress, api);
-                if (associatedTokenAccount instanceof Error)
-                    throw recipientTokenAccount;
-                if ((associatedTokenAccount === null || associatedTokenAccount === void 0 ? void 0 : associatedTokenAccount.state) === "frozen") {
-                    return new errors_2.SolanaTokenAccountFrozen();
-                }
-            }
-            return {
-                walletAddress: recipientAddress,
-                shouldCreateAsAssociatedTokenAccount,
-                tokenAccAddress: recipientAssociatedTokenAccountAddress,
-            };
+};
+async function getTokenRecipient(recipientAddress, mintAddress, api) {
+    const recipientTokenAccount = await (0, web3_1.getMaybeTokenAccount)(recipientAddress, api);
+    if (recipientTokenAccount instanceof Error) {
+        throw recipientTokenAccount;
+    }
+    if (recipientTokenAccount === undefined) {
+        if (!(0, logic_1.isEd25519Address)(recipientAddress)) {
+            return new errors_2.SolanaAddressOffEd25519();
         }
-        else {
-            if (recipientTokenAccount.mint.toBase58() !== mintAddress) {
-                return new errors_2.SolanaTokenAccountHoldsAnotherToken();
-            }
-            if (recipientTokenAccount.state === "frozen") {
+        const recipientAssociatedTokenAccountAddress = await api.findAssocTokenAccAddress(recipientAddress, mintAddress);
+        const shouldCreateAsAssociatedTokenAccount = !(await isAccountFunded(recipientAssociatedTokenAccountAddress, api));
+        if (!shouldCreateAsAssociatedTokenAccount) {
+            const associatedTokenAccount = await (0, web3_1.getMaybeTokenAccount)(recipientAssociatedTokenAccountAddress, api);
+            if (associatedTokenAccount instanceof Error)
+                throw recipientTokenAccount;
+            if (associatedTokenAccount?.state === "frozen") {
                 return new errors_2.SolanaTokenAccountFrozen();
             }
-            if (recipientTokenAccount.state !== "initialized") {
-                return new errors_2.SolanaTokenAccounNotInitialized();
-            }
         }
         return {
-            walletAddress: recipientTokenAccount.owner.toBase58(),
-            shouldCreateAsAssociatedTokenAccount: false,
-            tokenAccAddress: recipientAddress,
+            walletAddress: recipientAddress,
+            shouldCreateAsAssociatedTokenAccount,
+            tokenAccAddress: recipientAssociatedTokenAccountAddress,
         };
-    });
-}
-function deriveCreateAssociatedTokenAccountCommandDescriptor(mainAccount, tx, model, api) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const errors = {};
-        const token = (0, cryptoassets_1.getTokenById)(model.uiState.tokenId);
-        const mint = token.contractAddress;
-        const associatedTokenAccountAddress = yield api.findAssocTokenAccAddress(mainAccount.freshAddress, mint);
-        const { fee } = yield (0, estimateMaxSpendable_1.estimateFeeAndSpendable)(api, mainAccount, tx);
-        if (mainAccount.spendableBalance.lt(fee)) {
-            errors.fee = new errors_1.NotEnoughBalance();
-        }
-        return {
-            fee,
-            command: {
-                kind: model.kind,
-                mint: mint,
-                owner: mainAccount.freshAddress,
-                associatedTokenAccountAddress,
-            },
-            warnings: {},
-            errors,
-        };
-    });
-}
-function deriveTransferCommandDescriptor(mainAccount, tx, model, api) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const errors = {};
-        const warnings = {};
-        yield validateRecipientCommon(mainAccount, tx, errors, warnings, api, false);
-        const memo = model.uiState.memo;
-        if (typeof memo === "string" && memo.length > 0) {
-            validateMemoCommon(memo, errors);
+    }
+    else {
+        if (recipientTokenAccount.mint.toBase58() !== mintAddress) {
+            return new errors_2.SolanaTokenAccountHoldsAnotherToken();
         }
-        const { fee, spendable } = yield (0, estimateMaxSpendable_1.estimateFeeAndSpendable)(api, mainAccount, tx);
-        const txAmount = tx.useAllAmount ? spendable : tx.amount;
-        if (tx.useAllAmount) {
-            if (txAmount.eq(0)) {
-                errors.amount = new errors_1.NotEnoughBalance();
-            }
+        if (recipientTokenAccount.state === "frozen") {
+            return new errors_2.SolanaTokenAccountFrozen();
         }
-        else {
-            if (txAmount.lte(0)) {
-                errors.amount = new errors_1.AmountRequired();
-            }
-            else if (txAmount.gt(spendable)) {
-                errors.amount = new errors_1.NotEnoughBalance();
-            }
+        if (recipientTokenAccount.state !== "initialized") {
+            return new errors_2.SolanaTokenAccounNotInitialized();
         }
-        const command = {
-            kind: "transfer",
-            amount: txAmount.toNumber(),
-            sender: mainAccount.freshAddress,
-            recipient: tx.recipient,
-            memo: model.uiState.memo,
-        };
-        return {
-            command,
-            fee,
-            warnings,
-            errors,
-        };
-    });
+    }
+    return {
+        walletAddress: recipientTokenAccount.owner.toBase58(),
+        shouldCreateAsAssociatedTokenAccount: false,
+        tokenAccAddress: recipientAddress,
+    };
 }
-function deriveStakeCreateAccountCommandDescriptor(mainAccount, tx, model, api) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const errors = {};
-        const warnings = {};
-        const { fee, spendable } = yield (0, estimateMaxSpendable_1.estimateFeeAndSpendable)(api, mainAccount, tx);
-        const txAmount = tx.useAllAmount ? spendable : tx.amount;
-        if (tx.useAllAmount) {
-            if (txAmount.eq(0)) {
-                errors.amount = new errors_1.NotEnoughBalance();
-            }
+async function deriveCreateAssociatedTokenAccountCommandDescriptor(mainAccount, tx, model, api) {
+    const errors = {};
+    const token = (0, cryptoassets_1.getTokenById)(model.uiState.tokenId);
+    const mint = token.contractAddress;
+    const associatedTokenAccountAddress = await api.findAssocTokenAccAddress(mainAccount.freshAddress, mint);
+    const { fee } = await (0, estimateMaxSpendable_1.estimateFeeAndSpendable)(api, mainAccount, tx);
+    if (mainAccount.spendableBalance.lt(fee)) {
+        errors.fee = new errors_1.NotEnoughBalance();
+    }
+    return {
+        fee,
+        command: {
+            kind: model.kind,
+            mint: mint,
+            owner: mainAccount.freshAddress,
+            associatedTokenAccountAddress,
+        },
+        warnings: {},
+        errors,
+    };
+}
+async function deriveTransferCommandDescriptor(mainAccount, tx, model, api) {
+    const errors = {};
+    const warnings = {};
+    await validateRecipientCommon(mainAccount, tx, errors, warnings, api, false);
+    const memo = model.uiState.memo;
+    if (typeof memo === "string" && memo.length > 0) {
+        validateMemoCommon(memo, errors);
+    }
+    const { fee, spendable } = await (0, estimateMaxSpendable_1.estimateFeeAndSpendable)(api, mainAccount, tx);
+    const txAmount = tx.useAllAmount ? spendable : 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.gt(spendable)) {
-                errors.amount = new errors_1.NotEnoughBalance();
-            }
+    }
+    else {
+        if (txAmount.lte(0)) {
+            errors.amount = new errors_1.AmountRequired();
         }
-        const { uiState: { delegate }, } = model;
-        yield validateValidatorCommon(delegate.voteAccAddress, errors, api);
-        const stakeAccAddressSeed = `stake:${Math.random().toString()}`;
-        const stakeAccAddress = yield (0, web3_1.getStakeAccountAddressWithSeed)({
-            fromAddress: mainAccount.freshAddress,
-            seed: stakeAccAddressSeed,
-        });
-        const stakeAccRentExemptAmount = yield (0, web3_1.getStakeAccountMinimumBalanceForRentExemption)(api);
-        return {
-            command: {
-                kind: "stake.createAccount",
-                amount: txAmount.toNumber(),
-                stakeAccRentExemptAmount,
-                fromAccAddress: mainAccount.freshAddress,
-                stakeAccAddress,
-                delegate,
-                seed: stakeAccAddressSeed,
-            },
-            fee,
-            warnings,
-            errors,
-        };
-    });
+        else if (txAmount.gt(spendable)) {
+            errors.amount = new errors_1.NotEnoughBalance();
+        }
+    }
+    const command = {
+        kind: "transfer",
+        amount: txAmount.toNumber(),
+        sender: mainAccount.freshAddress,
+        recipient: tx.recipient,
+        memo: model.uiState.memo,
+    };
+    return {
+        command,
+        fee,
+        warnings,
+        errors,
+    };
 }
-function deriveStakeDelegateCommandDescriptor(mainAccount, tx, model, api) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const errors = {};
-        const { uiState } = model;
-        const stake = validateAndTryGetStakeAccount(mainAccount, uiState.stakeAccAddr, errors);
-        if (stake !== undefined && !stake.hasStakeAuth && !stake.hasWithdrawAuth) {
-            errors.stakeAccAddr = new errors_2.SolanaStakeNoStakeAuth();
+async function deriveStakeCreateAccountCommandDescriptor(mainAccount, tx, model, api) {
+    const errors = {};
+    const warnings = {};
+    const { fee, spendable } = await (0, estimateMaxSpendable_1.estimateFeeAndSpendable)(api, mainAccount, tx);
+    const txAmount = tx.useAllAmount ? spendable : tx.amount;
+    if (tx.useAllAmount) {
+        if (txAmount.eq(0)) {
+            errors.amount = new errors_1.NotEnoughBalance();
         }
-        yield validateValidatorCommon(uiState.voteAccAddr, errors, api);
-        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 (0, utils_1.assertUnreachable)(stake.activation.state);
-            }
+    }
+    else {
+        if (txAmount.lte(0)) {
+            errors.amount = new errors_1.AmountRequired();
         }
-        const { fee } = yield (0, estimateMaxSpendable_1.estimateFeeAndSpendable)(api, mainAccount, tx);
-        if (mainAccount.spendableBalance.lt(fee)) {
-            errors.fee = new errors_1.NotEnoughBalance();
+        else if (txAmount.gt(spendable)) {
+            errors.amount = new errors_1.NotEnoughBalance();
         }
-        return {
-            command: {
-                kind: "stake.delegate",
-                authorizedAccAddr: mainAccount.freshAddress,
-                stakeAccAddr: uiState.stakeAccAddr,
-                voteAccAddr: uiState.voteAccAddr,
-            },
-            fee,
-            warnings: {},
-            errors,
-        };
+    }
+    const { uiState: { delegate }, } = model;
+    await validateValidatorCommon(delegate.voteAccAddress, errors, api);
+    const stakeAccAddressSeed = `stake:${Math.random().toString()}`;
+    const stakeAccAddress = await (0, web3_1.getStakeAccountAddressWithSeed)({
+        fromAddress: mainAccount.freshAddress,
+        seed: stakeAccAddressSeed,
     });
+    const stakeAccRentExemptAmount = await (0, web3_1.getStakeAccountMinimumBalanceForRentExemption)(api);
+    return {
+        command: {
+            kind: "stake.createAccount",
+            amount: txAmount.toNumber(),
+            stakeAccRentExemptAmount,
+            fromAccAddress: mainAccount.freshAddress,
+            stakeAccAddress,
+            delegate,
+            seed: stakeAccAddressSeed,
+        },
+        fee,
+        warnings,
+        errors,
+    };
 }
-function deriveStakeUndelegateCommandDescriptor(mainAccount, tx, model, api) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const errors = {};
-        const { uiState } = model;
-        const 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 (0, utils_1.assertUnreachable)(stake.activation.state);
-            }
-            if (!errors.stakeAccAddr && !stake.hasStakeAuth && !stake.hasWithdrawAuth) {
-                errors.stakeAccAddr = new errors_2.SolanaStakeNoStakeAuth();
-            }
-        }
-        const { fee } = yield (0, estimateMaxSpendable_1.estimateFeeAndSpendable)(api, mainAccount, tx);
-        if (mainAccount.solanaResources.unstakeReserve.lt(fee)) {
-            errors.fee = new errors_1.NotEnoughBalance();
+async function deriveStakeDelegateCommandDescriptor(mainAccount, tx, model, api) {
+    const errors = {};
+    const { uiState } = model;
+    const stake = validateAndTryGetStakeAccount(mainAccount, uiState.stakeAccAddr, errors);
+    if (stake !== undefined && !stake.hasStakeAuth && !stake.hasWithdrawAuth) {
+        errors.stakeAccAddr = new errors_2.SolanaStakeNoStakeAuth();
+    }
+    await validateValidatorCommon(uiState.voteAccAddr, errors, api);
+    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 (stake.delegation?.voteAccAddr !== uiState.voteAccAddr) {
+                    errors.stakeAccAddr = new errors_2.SolanaStakeAccountValidatorIsUnchangeable();
+                }
+                break;
+            default:
+                return (0, utils_1.assertUnreachable)(stake.activation.state);
         }
-        return {
-            command: {
-                kind: "stake.undelegate",
-                authorizedAccAddr: mainAccount.freshAddress,
-                stakeAccAddr: uiState.stakeAccAddr,
-            },
-            fee,
-            warnings: {},
-            errors,
-        };
-    });
+    }
+    const { fee } = await (0, estimateMaxSpendable_1.estimateFeeAndSpendable)(api, mainAccount, tx);
+    if (mainAccount.spendableBalance.lt(fee)) {
+        errors.fee = new errors_1.NotEnoughBalance();
+    }
+    return {
+        command: {
+            kind: "stake.delegate",
+            authorizedAccAddr: mainAccount.freshAddress,
+            stakeAccAddr: uiState.stakeAccAddr,
+            voteAccAddr: uiState.voteAccAddr,
+        },
+        fee,
+        warnings: {},
+        errors,
+    };
 }
-function deriveStakeWithdrawCommandDescriptor(mainAccount, tx, model, api) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const errors = {};
-        const { uiState } = model;
-        const 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();
-            }
+async function deriveStakeUndelegateCommandDescriptor(mainAccount, tx, model, api) {
+    const errors = {};
+    const { uiState } = model;
+    const 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 (0, utils_1.assertUnreachable)(stake.activation.state);
         }
-        const { fee } = yield (0, estimateMaxSpendable_1.estimateFeeAndSpendable)(api, mainAccount, tx);
-        if (mainAccount.solanaResources.unstakeReserve.lt(fee)) {
-            errors.fee = new errors_1.NotEnoughBalance();
+        if (!errors.stakeAccAddr && !stake.hasStakeAuth && !stake.hasWithdrawAuth) {
+            errors.stakeAccAddr = new errors_2.SolanaStakeNoStakeAuth();
         }
-        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,
-            warnings: {},
-            errors,
-        };
-    });
+    }
+    const { fee } = await (0, estimateMaxSpendable_1.estimateFeeAndSpendable)(api, mainAccount, tx);
+    if (mainAccount.solanaResources.unstakeReserve.lt(fee)) {
+        errors.fee = new errors_1.NotEnoughBalance();
+    }
+    return {
+        command: {
+            kind: "stake.undelegate",
+            authorizedAccAddr: mainAccount.freshAddress,
+            stakeAccAddr: uiState.stakeAccAddr,
+        },
+        fee,
+        warnings: {},
+        errors,
+    };
 }
-function deriveStakeSplitCommandDescriptor(mainAccount, tx, model, api) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const errors = {};
-        // TODO: find stake account in the main acc when synced
-        const { uiState } = model;
-        // TODO: use all amount
-        if (tx.amount.lte(0)) {
-            errors.amount = new errors_1.AmountRequired();
+async function deriveStakeWithdrawCommandDescriptor(mainAccount, tx, model, api) {
+    const errors = {};
+    const { uiState } = model;
+    const stake = validateAndTryGetStakeAccount(mainAccount, uiState.stakeAccAddr, errors);
+    if (!errors.stakeAccAddr && stake !== undefined) {
+        if (!stake.hasWithdrawAuth) {
+            errors.stakeAccAddr = new errors_2.SolanaStakeNoWithdrawAuth();
         }
-        // TODO: else if amount > stake balance
-        if (!(0, logic_1.isValidBase58Address)(uiState.stakeAccAddr)) {
-            errors.stakeAccAddr = new errors_1.InvalidAddress("", {
-                currencyName: mainAccount.currency.name,
-            });
+        else if (stake.withdrawable <= 0) {
+            errors.stakeAccAddr = new errors_2.SolanaStakeAccountNothingToWithdraw();
         }
-        (_b = (_a = mainAccount.solanaResources) === null || _a === void 0 ? void 0 : _a.stakes) !== null && _b !== void 0 ? _b : [];
-        const commandFees = yield (0, web3_1.getStakeAccountMinimumBalanceForRentExemption)(api);
-        const splitStakeAccAddrSeed = `stake:${Math.random().toString()}`;
-        const splitStakeAccAddr = yield (0, web3_1.getStakeAccountAddressWithSeed)({
-            fromAddress: mainAccount.freshAddress,
-            seed: splitStakeAccAddrSeed,
+    }
+    const { fee } = await (0, estimateMaxSpendable_1.estimateFeeAndSpendable)(api, mainAccount, tx);
+    if (mainAccount.solanaResources.unstakeReserve.lt(fee)) {
+        errors.fee = new errors_1.NotEnoughBalance();
+    }
+    return {
+        command: {
+            kind: "stake.withdraw",
+            authorizedAccAddr: mainAccount.freshAddress,
+            stakeAccAddr: uiState.stakeAccAddr,
+            amount: stake?.withdrawable ?? 0,
+            toAccAddr: mainAccount.freshAddress,
+        },
+        fee,
+        warnings: {},
+        errors,
+    };
+}
+async function deriveStakeSplitCommandDescriptor(mainAccount, tx, model, api) {
+    const errors = {};
+    // TODO: find stake account in the main acc when synced
+    const { uiState } = model;
+    // 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("", {
+            currencyName: mainAccount.currency.name,
         });
-        return {
-            command: {
-                kind: "stake.split",
-                authorizedAccAddr: mainAccount.freshAddress,
-                stakeAccAddr: uiState.stakeAccAddr,
-                amount: tx.amount.toNumber(),
-                seed: splitStakeAccAddrSeed,
-                splitStakeAccAddr,
-            },
-            fee: commandFees,
-            warnings: {},
-            errors: {},
-        };
+    }
+    mainAccount.solanaResources?.stakes ?? [];
+    const commandFees = await (0, web3_1.getStakeAccountMinimumBalanceForRentExemption)(api);
+    const splitStakeAccAddrSeed = `stake:${Math.random().toString()}`;
+    const splitStakeAccAddr = await (0, web3_1.getStakeAccountAddressWithSeed)({
+        fromAddress: mainAccount.freshAddress,
+        seed: splitStakeAccAddrSeed,
     });
+    return {
+        command: {
+            kind: "stake.split",
+            authorizedAccAddr: mainAccount.freshAddress,
+            stakeAccAddr: uiState.stakeAccAddr,
+            amount: tx.amount.toNumber(),
+            seed: splitStakeAccAddrSeed,
+            splitStakeAccAddr,
+        },
+        fee: commandFees,
+        warnings: {},
+        errors: {},
+    };
 }
 // if subaccountid present - it's a token transfer
 function updateModelIfSubAccountIdPresent(tx) {
     if (tx.subAccountId) {
-        return Object.assign(Object.assign({}, tx), { model: {
+        return {
+            ...tx,
+            model: {
                 kind: "token.transfer",
-                uiState: Object.assign(Object.assign({}, tx.model.uiState), { subAccountId: tx.subAccountId }),
-            } });
+                uiState: {
+                    ...tx.model.uiState,
+                    subAccountId: tx.subAccountId,
+                },
+            },
+        };
     }
     return tx;
 }
-function isAccountFunded(address, api) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const balance = yield api.getBalance(address);
-        return balance > 0;
-    });
+async function isAccountFunded(address, api) {
+    const balance = await api.getBalance(address);
+    return balance > 0;
 }
-function validateRecipientCommon(mainAccount, tx, errors, warnings, api, allowATA) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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("", {
-                currencyName: mainAccount.currency.name,
-            });
+async function validateRecipientCommon(mainAccount, tx, errors, warnings, api, allowATA) {
+    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("", {
+            currencyName: mainAccount.currency.name,
+        });
+    }
+    else {
+        const recipientWalletIsUnfunded = !(await isAccountFunded(tx.recipient, api));
+        const recipientTokenAccount = await (0, web3_1.getMaybeTokenAccount)(tx.recipient, api);
+        if (recipientTokenAccount instanceof Error) {
+            throw recipientTokenAccount;
         }
-        else {
-            const recipientWalletIsUnfunded = !(yield isAccountFunded(tx.recipient, api));
-            const recipientTokenAccount = yield (0, web3_1.getMaybeTokenAccount)(tx.recipient, api);
-            if (recipientTokenAccount instanceof Error) {
-                throw recipientTokenAccount;
-            }
-            if (recipientTokenAccount) {
-                if (allowATA) {
-                    if ((0, logic_1.isEd25519Address)(tx.recipient)) {
-                        errors.recipient = new errors_2.SolanaTokenAccountNotAllowed();
-                    }
-                    else {
-                        warnings.recipient = new errors_2.SolanaTokenAccountWarning();
-                    }
+        if (recipientTokenAccount) {
+            if (allowATA) {
+                if ((0, logic_1.isEd25519Address)(tx.recipient)) {
+                    errors.recipient = new errors_2.SolanaTokenAccountNotAllowed();
                 }
                 else {
-                    errors.recipient = new errors_2.SolanaTokenAccountNotAllowed();
+                    warnings.recipient = new errors_2.SolanaTokenAccountWarning();
                 }
             }
-            const mintTokenAccount = yield (0, web3_1.getMaybeMintAccount)(tx.recipient, api);
-            if (mintTokenAccount instanceof Error) {
-                throw recipientTokenAccount;
-            }
-            if (mintTokenAccount) {
-                errors.recipient = new errors_2.SolanaMintAccountNotAllowed();
-            }
-            if (recipientWalletIsUnfunded) {
-                warnings.recipient = new errors_2.SolanaAccountNotFunded();
-            }
-            if (!(0, logic_1.isEd25519Address)(tx.recipient)) {
-                warnings.recipientOffCurve = new errors_2.SolanaAddressOffEd25519();
+            else {
+                errors.recipient = new errors_2.SolanaTokenAccountNotAllowed();
             }
         }
-    });
+        const mintTokenAccount = await (0, web3_1.getMaybeMintAccount)(tx.recipient, api);
+        if (mintTokenAccount instanceof Error) {
+            throw recipientTokenAccount;
+        }
+        if (mintTokenAccount) {
+            errors.recipient = new errors_2.SolanaMintAccountNotAllowed();
+        }
+        if (recipientWalletIsUnfunded) {
+            warnings.recipient = new errors_2.SolanaAccountNotFunded();
+        }
+        if (!(0, logic_1.isEd25519Address)(tx.recipient)) {
+            warnings.recipientOffCurve = new errors_2.SolanaAddressOffEd25519();
+        }
+    }
 }
 function validateMemoCommon(memo, errors) {
     const memoBytes = Buffer.from(memo, "utf-8");
@@ -496,26 +471,23 @@ function validateMemoCommon(memo, errors) {
         errors.transaction = errors.memo;
     }
 }
-function validateValidatorCommon(addr, errors, api) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (addr.length === 0) {
-            errors.voteAccAddr = new errors_2.SolanaValidatorRequired();
-        }
-        else if (!(0, logic_1.isValidBase58Address)(addr)) {
-            errors.voteAccAddr = new errors_1.InvalidAddress("", {
-                currencyName: "Solana",
-            });
-        }
-        else {
-            const voteAcc = yield (0, web3_1.getMaybeVoteAccount)(addr, api);
-            if (voteAcc instanceof Error || voteAcc === undefined) {
-                errors.voteAccAddr = new errors_2.SolanaInvalidValidator();
-            }
+async function validateValidatorCommon(addr, errors, api) {
+    if (addr.length === 0) {
+        errors.voteAccAddr = new errors_2.SolanaValidatorRequired();
+    }
+    else if (!(0, logic_1.isValidBase58Address)(addr)) {
+        errors.voteAccAddr = new errors_1.InvalidAddress("", {
+            currencyName: "Solana",
+        });
+    }
+    else {
+        const voteAcc = await (0, web3_1.getMaybeVoteAccount)(addr, api);
+        if (voteAcc instanceof Error || voteAcc === undefined) {
+            errors.voteAccAddr = new errors_2.SolanaInvalidValidator();
         }
-    });
+    }
 }
 function validateAndTryGetStakeAccount(account, stakeAccAddr, errors) {
-    var _a;
     if (stakeAccAddr.length === 0) {
         errors.stakeAccAddr = new errors_2.SolanaStakeAccountRequired();
     }
@@ -525,7 +497,7 @@ function validateAndTryGetStakeAccount(account, stakeAccAddr, errors) {
         });
     }
     if (!errors.stakeAccAddr) {
-        const stake = (_a = account.solanaResources) === null || _a === void 0 ? void 0 : _a.stakes.find(stake => stake.stakeAccAddr === stakeAccAddr);
+        const stake = account.solanaResources?.stakes.find(stake => stake.stakeAccAddr === stakeAccAddr);
         if (stake === undefined) {
             errors.stakeAccAddr = new errors_2.SolanaStakeAccountNotFound();
         }