@ledgerhq/live-common 21.36.3 → 22.0.2

package/src/families/solana/cli-transaction.ts

@@ -10,12 +10,31 @@ import type {
 import { Transaction as SolanaTransaction } from "./types";
 import { assertUnreachable } from "./utils";
 
-const modes = ["send", "optIn"] as const;
+const modes = [
+  "send",
+  "optIn",
+  "stake.createAccount",
+  "stake.delegate",
+  "stake.undelegate",
+  "stake.withdraw",
+  "stake.split",
+] as const;
 type Mode = typeof modes[number];
 
-// options already specified in other blockchains like ethereum.
+// some options already specified for other blockchains like ethereum.
 // trying to reuse existing ones like <token>, <mode>, etc.
-const options = [];
+const options = [
+  {
+    name: "solanaValidator",
+    type: String,
+    desc: "validator address to delegate to",
+  },
+  {
+    name: "solanaStakeAccount",
+    type: String,
+    desc: "stake account address to use in the transaction",
+  },
+];
 
 function inferTransactions(
   transactions: Array<{
@@ -99,6 +118,65 @@ function inferTransactions(
         };
         return solanaTx;
       }
+      case "stake.createAccount": {
+        const validator = opts.solanaValidator;
+        return {
+          ...transaction,
+          model: {
+            kind: "stake.createAccount",
+            uiState: {
+              delegate: {
+                voteAccAddress: validator ?? "",
+              },
+            },
+          },
+        };
+      }
+      case "stake.delegate":
+        return {
+          ...transaction,
+          model: {
+            kind: "stake.delegate",
+            uiState: {
+              stakeAccAddr: opts.solanaStakeAccount ?? "",
+              voteAccAddr: opts.solanaValidator ?? "",
+            },
+          },
+        };
+      case "stake.undelegate":
+        return {
+          ...transaction,
+          model: {
+            kind: "stake.undelegate",
+            uiState: {
+              stakeAccAddr: opts.solanaStakeAccount ?? "",
+            },
+          },
+        };
+      case "stake.withdraw":
+        return {
+          ...transaction,
+          model: {
+            kind: "stake.withdraw",
+            uiState: {
+              stakeAccAddr: opts.solanaStakeAccount ?? "",
+            },
+          },
+        };
+      case "stake.split":
+        if (opts.solanaStakeAccount === undefined) {
+          throw new Error("stake account is required");
+        }
+
+        return {
+          ...transaction,
+          model: {
+            kind: "stake.split",
+            uiState: {
+              stakeAccAddr: opts.solanaStakeAccount,
+            },
+          },
+        };
       default:
         return assertUnreachable(mode);
     }
@@ -146,6 +224,12 @@ function inferAccounts(
       return [subAccount];
     }
     case "optIn":
+    case "stake.createAccount":
+    case "stake.delegate":
+    case "stake.undelegate":
+    case "stake.withdraw":
+    case "stake.split":
+      // TODO: infer stake account for stake ops
       return [mainAccount];
     default:
       return assertUnreachable(mode);

package/src/families/solana/deviceTransactionConfig.ts

@@ -1,17 +1,25 @@
-import type { AccountLike, Account } from "../../types";
+import BigNumber from "bignumber.js";
+import { formatCurrencyUnit } from "../../currencies";
+import type { DeviceTransactionField } from "../../transaction";
+import type { Account, AccountLike } from "../../types";
 import type {
+  CommandDescriptor,
+  StakeCreateAccountCommand,
+  StakeDelegateCommand,
+  StakeSplitCommand,
+  StakeUndelegateCommand,
+  StakeWithdrawCommand,
   TokenCreateATACommand,
   TokenTransferCommand,
   Transaction,
   TransferCommand,
-  ValidCommandDescriptor,
 } from "./types";
-import type { DeviceTransactionField } from "../../transaction";
 import { assertUnreachable } from "./utils";
 
 // do not show fields like 'To', 'Recipient', etc., as per Ledger policy
 
 function getDeviceTransactionConfig({
+  account,
   transaction,
 }: {
   account: AccountLike;
@@ -22,19 +30,18 @@ function getDeviceTransactionConfig({
   if (commandDescriptor === undefined) {
     throw new Error("missing command descriptor");
   }
-  switch (commandDescriptor.status) {
-    case "valid":
-      return fieldsForCommand(commandDescriptor);
-    case "invalid":
-      throw new Error("unexpected invalid command");
-    default:
-      return assertUnreachable(commandDescriptor);
+  if (Object.keys(commandDescriptor.errors).length > 0) {
+    throw new Error("unexpected invalid command");
   }
+
+  return fieldsForCommand(commandDescriptor, account);
 }
 
 export default getDeviceTransactionConfig;
+
 function fieldsForCommand(
-  commandDescriptor: ValidCommandDescriptor
+  commandDescriptor: CommandDescriptor,
+  account: AccountLike
 ): DeviceTransactionField[] {
   const { command } = commandDescriptor;
   switch (command.kind) {
@@ -44,12 +51,24 @@ function fieldsForCommand(
       return fieldsForTokenTransfer(command);
     case "token.createATA":
       return fieldsForCreateATA(command);
+    case "stake.createAccount":
+      return fieldsForStakeCreateAccount(command, account);
+    case "stake.delegate":
+      return fieldsForStakeDelegate(command);
+    case "stake.undelegate":
+      return fieldsForStakeUndelegate(command);
+    case "stake.withdraw":
+      return fieldsForStakeWithdraw(command);
+    case "stake.split":
+      return fieldsForStakeSplit(command);
     default:
       return assertUnreachable(command);
   }
 }
 
-function fieldsForTransfer(command: TransferCommand): DeviceTransactionField[] {
+function fieldsForTransfer(
+  _command: TransferCommand
+): DeviceTransactionField[] {
   const fields: Array<DeviceTransactionField> = [];
 
   fields.push({
@@ -57,18 +76,6 @@ function fieldsForTransfer(command: TransferCommand): DeviceTransactionField[] {
     label: "Transfer",
   });
 
-  fields.push({
-    type: "address",
-    address: command.sender,
-    label: "Sender",
-  });
-
-  fields.push({
-    type: "text",
-    label: "Fee payer",
-    value: "Sender",
-  });
-
   return fields;
 }
 function fieldsForTokenTransfer(
@@ -158,3 +165,152 @@ function fieldsForCreateATA(
 
   return fields;
 }
+function fieldsForStakeCreateAccount(
+  command: StakeCreateAccountCommand,
+  account: AccountLike
+): DeviceTransactionField[] {
+  if (account.type !== "Account") {
+    throw new Error("unsupported account type");
+  }
+
+  const unit = account.currency.units[0];
+
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "address",
+    label: "Delegate from",
+    address: command.stakeAccAddress,
+  });
+
+  // not using 'amount' field here because the field should
+  // show sum of amount and rent exempt amount
+  fields.push({
+    type: "text",
+    label: "Deposit",
+    value: formatCurrencyUnit(
+      unit,
+      new BigNumber(command.amount + command.stakeAccRentExemptAmount),
+      {
+        disableRounding: true,
+        showCode: true,
+      }
+    ),
+  });
+
+  fields.push({
+    type: "address",
+    label: "New authority",
+    address: command.fromAccAddress,
+  });
+
+  fields.push({
+    type: "address",
+    label: "Vote account",
+    address: command.delegate.voteAccAddress,
+  });
+
+  return fields;
+}
+
+function fieldsForStakeDelegate(
+  command: StakeDelegateCommand
+): DeviceTransactionField[] {
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "address",
+    label: "Delegate from",
+    address: command.stakeAccAddr,
+  });
+
+  fields.push({
+    type: "address",
+    label: "Vote account",
+    address: command.voteAccAddr,
+  });
+
+  return fields;
+}
+
+function fieldsForStakeUndelegate(
+  command: StakeUndelegateCommand
+): DeviceTransactionField[] {
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "address",
+    label: "Deactivate stake",
+    address: command.stakeAccAddr,
+  });
+
+  return fields;
+}
+
+function fieldsForStakeWithdraw(
+  command: StakeWithdrawCommand
+): DeviceTransactionField[] {
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "amount",
+    label: "Stake withdraw",
+  });
+
+  fields.push({
+    type: "address",
+    label: "From",
+    address: command.stakeAccAddr,
+  });
+
+  return fields;
+}
+
+function fieldsForStakeSplit(
+  command: StakeSplitCommand
+): DeviceTransactionField[] {
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "amount",
+    label: "Split stake",
+  });
+
+  fields.push({
+    type: "address",
+    label: "From",
+    address: command.stakeAccAddr,
+  });
+
+  fields.push({
+    type: "address",
+    label: "To",
+    address: command.splitStakeAccAddr,
+  });
+
+  fields.push({
+    type: "address",
+    label: "Base",
+    address: command.authorizedAccAddr,
+  });
+
+  fields.push({
+    type: "text",
+    label: "Seed",
+    value: command.seed,
+  });
+
+  fields.push({
+    type: "address",
+    label: "Authorized by",
+    address: command.authorizedAccAddr,
+  });
+
+  fields.push({
+    type: "address",
+    label: "Fee payer",
+    address: command.authorizedAccAddr,
+  });
+
+  return fields;
+}

package/src/families/solana/errors.ts

@@ -26,3 +26,43 @@ export const SolanaAddressOffEd25519 = createCustomErrorClass(
 export const SolanaTokenRecipientIsSenderATA = createCustomErrorClass(
   "SolanaTokenRecipientIsSenderATA"
 );
+
+export const SolanaValidatorRequired = createCustomErrorClass(
+  "SolanaValidatorRequired"
+);
+
+export const SolanaInvalidValidator = createCustomErrorClass(
+  "SolanaInvalidValidator"
+);
+
+export const SolanaStakeAccountRequired = createCustomErrorClass(
+  "SolanaStakeAccountRequired"
+);
+
+export const SolanaStakeAccountNotFound = createCustomErrorClass(
+  "SolanaStakeAccountNotFound"
+);
+
+export const SolanaStakeAccountNothingToWithdraw = createCustomErrorClass(
+  "SolanaStakeAccountNothingToWithdraw"
+);
+
+export const SolanaStakeAccountIsNotDelegatable = createCustomErrorClass(
+  "SolanaStakeAccountIsNotDelegatable"
+);
+
+export const SolanaStakeAccountIsNotUndelegatable = createCustomErrorClass(
+  "SolanaStakeAccountIsNotUndelegatable"
+);
+
+export const SolanaStakeAccountValidatorIsUnchangeable = createCustomErrorClass(
+  "SolanaStakeAccountValidatorIsUnchangeable"
+);
+
+export const SolanaStakeNoWithdrawAuth = createCustomErrorClass(
+  "SolanaStakeNoWithdrawAuth"
+);
+
+export const SolanaStakeNoStakeAuth = createCustomErrorClass(
+  "SolanaStakeNoStakeAuth"
+);

package/src/families/solana/js-buildTransaction.ts

@@ -5,6 +5,11 @@ import {
   buildTransferInstructions,
   buildTokenTransferInstructions,
   buildCreateAssociatedTokenAccountInstruction,
+  buildStakeCreateAccountInstructions,
+  buildStakeDelegateInstructions,
+  buildStakeUndelegateInstructions,
+  buildStakeWithdrawInstructions,
+  buildStakeSplitInstructions,
 } from "./api/chain/web3";
 import { assertUnreachable } from "./utils";
 import {
@@ -44,19 +49,15 @@ export const buildTransactionWithAPI = async (
   ] as const;
 };
 
-function buildInstructions(tx: Transaction) {
+function buildInstructions(tx: Transaction): TransactionInstruction[] {
   const { commandDescriptor } = tx.model;
   if (commandDescriptor === undefined) {
     throw new Error("missing command descriptor");
   }
-  switch (commandDescriptor.status) {
-    case "valid":
-      return buildInstructionsForCommand(commandDescriptor.command);
-    case "invalid":
-      throw new Error("can not build invalid command");
-    default:
-      return assertUnreachable(commandDescriptor);
+  if (Object.keys(commandDescriptor.errors).length > 0) {
+    throw new Error("can not build invalid command");
   }
+  return buildInstructionsForCommand(commandDescriptor.command);
 }
 
 function buildInstructionsForCommand(
@@ -69,6 +70,16 @@ function buildInstructionsForCommand(
       return buildTokenTransferInstructions(command);
     case "token.createATA":
       return buildCreateAssociatedTokenAccountInstruction(command);
+    case "stake.createAccount":
+      return buildStakeCreateAccountInstructions(command);
+    case "stake.delegate":
+      return buildStakeDelegateInstructions(command);
+    case "stake.undelegate":
+      return buildStakeUndelegateInstructions(command);
+    case "stake.withdraw":
+      return buildStakeWithdrawInstructions(command);
+    case "stake.split":
+      return buildStakeSplitInstructions(command);
     default:
       return assertUnreachable(command);
   }

package/src/families/solana/js-estimateMaxSpendable.ts

@@ -2,6 +2,7 @@ import type { AccountBridge } from "../../types";
 import type { Transaction } from "./types";
 import BigNumber from "bignumber.js";
 import { ChainAPI } from "./api";
+import { getStakeAccountMinimumBalanceForRentExemption } from "./api/chain/web3";
 
 const estimateMaxSpendableWithAPI = async (
   {
@@ -10,15 +11,27 @@ const estimateMaxSpendableWithAPI = async (
   }: Parameters<AccountBridge<Transaction>["estimateMaxSpendable"]>[0],
   api: ChainAPI
 ): Promise<BigNumber> => {
-  const feeCalculator =
-    transaction?.feeCalculator ?? (await api.getTxFeeCalculator());
+  const txFee = (await api.getTxFeeCalculator()).lamportsPerSignature;
 
   switch (account.type) {
-    case "Account":
-      return BigNumber.max(
-        account.balance.minus(feeCalculator.lamportsPerSignature),
-        0
-      );
+    case "Account": {
+      const forTransfer = BigNumber.max(account.balance.minus(txFee), 0);
+      if (!transaction) {
+        return forTransfer;
+      }
+      switch (transaction.model.kind) {
+        case "stake.createAccount": {
+          const stakeAccRentExempt =
+            await getStakeAccountMinimumBalanceForRentExemption(api);
+          return BigNumber.max(
+            account.balance.minus(txFee).minus(stakeAccRentExempt),
+            0
+          );
+        }
+        default:
+          return forTransfer;
+      }
+    }
     case "TokenAccount":
       return account.balance;
   }

package/src/families/solana/js-getTransactionStatus.ts

@@ -1,128 +1,69 @@
 import { BigNumber } from "bignumber.js";
 import type { Account, TransactionStatus } from "../../types";
-import type { Command, Transaction, TransactionModel } from "./types";
+import type { Command, CommandDescriptor, Transaction } from "./types";
 import { assertUnreachable } from "./utils";
 
 const getTransactionStatus = async (
-  account: Account,
+  _account: Account,
   tx: Transaction
 ): Promise<TransactionStatus> => {
-  const txFees = new BigNumber(tx.feeCalculator?.lamportsPerSignature ?? 0);
-
   const { commandDescriptor } = tx.model;
 
   if (commandDescriptor === undefined) {
-    const amount = getAmountForModel(account, tx, txFees);
-    const totalSpent = getTotalSpentForModel(tx.model, amount, txFees);
     return {
-      amount,
+      amount: tx.amount,
+      estimatedFees: new BigNumber(0),
+      totalSpent: tx.amount,
       errors: {},
       warnings: {},
-      estimatedFees: txFees,
-      totalSpent,
     };
   }
-  switch (commandDescriptor.status) {
-    case "invalid": {
-      const amount = getAmountForModel(account, tx, txFees);
-      const totalSpent = getTotalSpentForModel(tx.model, amount, txFees);
-      return {
-        amount,
-        errors: commandDescriptor.errors,
-        warnings: commandDescriptor.warnings ?? {},
-        estimatedFees: txFees,
-        totalSpent,
-      };
-    }
-    case "valid": {
-      const { command } = commandDescriptor;
-      const estimatedFees = txFees.plus(commandDescriptor.fees ?? 0);
-      const amount = getAmountForCommand(command);
-      const totalSpent = getTotalSpentForCommand(
-        command,
-        amount,
-        estimatedFees
-      );
 
-      return {
-        amount,
-        estimatedFees,
-        totalSpent,
-        warnings: commandDescriptor.warnings ?? {},
-        errors: {},
-      };
-    }
-    default:
-      return assertUnreachable(commandDescriptor);
-  }
-};
+  const { command, fee, errors, warnings } = commandDescriptor;
 
-function getAmountForModel(
-  account: Account,
-  tx: Transaction,
-  estimatedFees: BigNumber
-) {
-  const { model } = tx;
-  switch (model.kind) {
-    case "transfer": {
-      if (tx.amount.lte(0)) {
-        return tx.amount;
-      }
-      const amount = tx.useAllAmount
-        ? account.balance.minus(estimatedFees)
-        : BigNumber.max(tx.amount, 0);
-      return amount.gte(0) ? amount : account.balance;
-    }
-    case "token.transfer":
-      return tx.useAllAmount ? account.balance : tx.amount;
-    case "token.createATA":
-      return new BigNumber(0);
-    default:
-      return assertUnreachable(model);
-  }
-}
+  const amount = new BigNumber(getAmount(command));
+  const estimatedFees = new BigNumber(fee);
+  const totalSpent = new BigNumber(getTotalSpent(commandDescriptor));
 
-function getTotalSpentForModel(
-  model: TransactionModel,
-  amount: BigNumber,
-  estimatedFees: BigNumber
-) {
-  switch (model.kind) {
-    case "transfer":
-      return amount.plus(estimatedFees);
-    case "token.transfer":
-      return amount;
-    case "token.createATA":
-      return estimatedFees;
-    default:
-      return assertUnreachable(model);
-  }
-}
+  return {
+    amount,
+    estimatedFees,
+    totalSpent,
+    warnings,
+    errors,
+  };
+};
 
-function getAmountForCommand(command: Command) {
+function getAmount(command: Command) {
   switch (command.kind) {
     case "transfer":
     case "token.transfer":
-      return new BigNumber(command.amount);
+    case "stake.createAccount":
+    case "stake.withdraw":
+      return command.amount;
     case "token.createATA":
-      return new BigNumber(0);
+    case "stake.delegate":
+    case "stake.undelegate":
+    case "stake.split":
+      return 0;
     default:
       return assertUnreachable(command);
   }
 }
 
-function getTotalSpentForCommand(
-  command: Command,
-  amount: BigNumber,
-  estimatedFees: BigNumber
-) {
+function getTotalSpent({ command, fee }: CommandDescriptor) {
   switch (command.kind) {
     case "transfer":
-      return amount.plus(estimatedFees);
+    case "stake.createAccount":
+      return command.amount < 0 ? 0 : command.amount + fee;
     case "token.transfer":
-      return amount;
+      return Math.max(command.amount, 0);
     case "token.createATA":
-      return estimatedFees;
+    case "stake.delegate":
+    case "stake.undelegate":
+    case "stake.withdraw":
+    case "stake.split":
+      return fee;
     default:
       return assertUnreachable(command);
   }