@ledgerhq/live-common 21.36.2 → 22.0.0

package/src/families/solana/test-specifics.ts

@@ -0,0 +1,171 @@
+import { NotEnoughBalance } from "@ledgerhq/errors";
+import BigNumber from "bignumber.js";
+import { Account, TransactionStatus } from "../../types";
+import { ChainAPI } from "./api";
+import {
+  SolanaStakeAccountIsNotDelegatable,
+  SolanaStakeAccountValidatorIsUnchangeable,
+} from "./errors";
+import getTransactionStatus from "./js-getTransactionStatus";
+import { prepareTransaction } from "./js-prepareTransaction";
+import { testOnChainData } from "./test-dataset";
+import { SolanaStake, Transaction } from "./types";
+
+const baseAccount = {
+  balance: new BigNumber(0),
+} as Account;
+
+const baseTx = {
+  family: "solana",
+  recipient: "",
+  amount: new BigNumber(0),
+} as Transaction;
+
+const baseAPI = {
+  getTxFeeCalculator: () =>
+    Promise.resolve({
+      lamportsPerSignature: testOnChainData.fees.lamportsPerSignature,
+    }),
+} as ChainAPI;
+
+type StakeTestSpec = {
+  activationState: SolanaStake["activation"]["state"];
+  txModel: Transaction["model"];
+  expectedErrors: Record<string, Error>;
+};
+
+/**
+ * Some business logic can not be described in terms of transactions and expected status
+ * in the test-dataset, like stake activation/deactivation, because stake activation is
+ * not determenistic and changes with time. Hence the tests here to mock data
+ * to be determenistic.
+ */
+export default () => {
+  describe("solana staking", () => {
+    test("stake.delegate :: status is error: stake account is not delegatable", async () => {
+      const stakeDelegateModel: Transaction["model"] & {
+        kind: "stake.delegate";
+      } = {
+        kind: "stake.delegate",
+        uiState: {
+          stakeAccAddr: testOnChainData.unfundedAddress,
+          voteAccAddr: testOnChainData.validatorAddress,
+        },
+      };
+
+      const stakeTests: StakeTestSpec[] = [
+        {
+          activationState: "activating",
+          txModel: stakeDelegateModel,
+          expectedErrors: {
+            fee: new NotEnoughBalance(),
+            stakeAccAddr: new SolanaStakeAccountIsNotDelegatable(),
+          },
+        },
+        {
+          activationState: "active",
+          txModel: stakeDelegateModel,
+          expectedErrors: {
+            fee: new NotEnoughBalance(),
+            stakeAccAddr: new SolanaStakeAccountIsNotDelegatable(),
+          },
+        },
+        {
+          activationState: "deactivating",
+          txModel: {
+            ...stakeDelegateModel,
+            uiState: {
+              ...stakeDelegateModel.uiState,
+              voteAccAddr: testOnChainData.unfundedAddress,
+            },
+          },
+          expectedErrors: {
+            fee: new NotEnoughBalance(),
+            stakeAccAddr: new SolanaStakeAccountValidatorIsUnchangeable(),
+          },
+        },
+      ];
+
+      for (const stakeTest of stakeTests) {
+        await runStakeTest(stakeTest);
+      }
+    });
+  });
+};
+
+async function runStakeTest(stakeTestSpec: StakeTestSpec) {
+  const api = {
+    ...baseAPI,
+    getMinimumBalanceForRentExemption: () =>
+      Promise.resolve(testOnChainData.fees.stakeAccountRentExempt),
+    getAccountInfo: () => {
+      return Promise.resolve({ data: mockedVoteAccount } as any);
+    },
+  } as ChainAPI;
+
+  const account: Account = {
+    ...baseAccount,
+    solanaResources: {
+      stakes: [
+        {
+          stakeAccAddr: testOnChainData.unfundedAddress,
+          delegation: {
+            stake: 1,
+            voteAccAddr: testOnChainData.validatorAddress,
+          },
+          activation: {
+            state: stakeTestSpec.activationState,
+          },
+        } as SolanaStake,
+      ],
+    },
+  };
+
+  const tx: Transaction = {
+    ...baseTx,
+    model: stakeTestSpec.txModel,
+  };
+
+  const preparedTx = await prepareTransaction(account, tx, api);
+  const status = await getTransactionStatus(account, preparedTx);
+
+  const expectedStatus: TransactionStatus = {
+    amount: new BigNumber(0),
+    estimatedFees: new BigNumber(testOnChainData.fees.lamportsPerSignature),
+    totalSpent: new BigNumber(testOnChainData.fees.lamportsPerSignature),
+    errors: stakeTestSpec.expectedErrors,
+    warnings: {},
+  };
+
+  expect(status).toEqual(expectedStatus);
+}
+
+const mockedVoteAccount = {
+  parsed: {
+    info: {
+      authorizedVoters: [
+        {
+          authorizedVoter: "EvnRmnMrd69kFdbLMxWkTn1icZ7DCceRhvmb2SJXqDo4",
+          epoch: 283,
+        },
+      ],
+      authorizedWithdrawer: "EvnRmnMrd69kFdbLMxWkTn1icZ7DCceRhvmb2SJXqDo4",
+      commission: 7,
+      epochCredits: [
+        {
+          credits: "98854605",
+          epoch: 283,
+          previousCredits: "98728105",
+        },
+      ],
+      lastTimestamp: { slot: 122422797, timestamp: 1645796249 },
+      nodePubkey: "EvnRmnMrd69kFdbLMxWkTn1icZ7DCceRhvmb2SJXqDo4",
+      priorVoters: [],
+      rootSlot: 122422766,
+      votes: [{ confirmationCount: 1, slot: 122422797 }],
+    },
+    type: "vote",
+  },
+  program: "vote",
+  space: 3731,
+};

package/src/families/solana/transaction.ts

@@ -1,6 +1,11 @@
 import { BigNumber } from "bignumber.js";
 import type {
   Command,
+  StakeCreateAccountCommand,
+  StakeDelegateCommand,
+  StakeSplitCommand,
+  StakeUndelegateCommand,
+  StakeWithdrawCommand,
   TokenCreateATACommand,
   TokenTransferCommand,
   Transaction,
@@ -19,23 +24,21 @@ import { toTokenId } from "./logic";
 
 export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
   const common = fromTransactionCommonRaw(tr);
-  const { family, model, feeCalculator } = tr;
+  const { family, model } = tr;
   return {
     ...common,
     family,
     model: JSON.parse(model),
-    feeCalculator,
   };
 };
 
 export const toTransactionRaw = (t: Transaction): TransactionRaw => {
   const common = toTransactionCommonRaw(t);
-  const { family, model, feeCalculator } = t;
+  const { family, model } = t;
   return {
     ...common,
     family,
     model: JSON.stringify(model),
-    feeCalculator,
   };
 };
 
@@ -54,14 +57,11 @@ export const formatTransaction = (
     throw new Error("can not format unprepared transaction");
   }
   const { commandDescriptor } = tx.model;
-  switch (commandDescriptor.status) {
-    case "valid":
-      return formatCommand(mainAccount, tx, commandDescriptor.command);
-    case "invalid":
-      throw new Error("can not format invalid transaction");
-    default:
-      return assertUnreachable(commandDescriptor);
+
+  if (Object.keys(commandDescriptor.errors).length > 0) {
+    throw new Error("can not format invalid transaction");
   }
+  return formatCommand(mainAccount, tx, commandDescriptor.command);
 };
 
 function formatCommand(
@@ -75,12 +75,44 @@ function formatCommand(
     case "token.transfer":
       return formatTokenTransfer(mainAccount, tx, command);
     case "token.createATA":
-      return formatCreateATA(mainAccount, tx, command);
+      return formatCreateATA(command);
+    case "stake.createAccount":
+      return formatStakeCreateAccount(mainAccount, tx, command);
+    case "stake.delegate":
+      return formatStakeDelegate(command);
+    case "stake.undelegate":
+      return formatStakeUndelegate(command);
+    case "stake.withdraw":
+      return formatStakeWithdraw(mainAccount, tx, command);
+    case "stake.split":
+      return formatStakeSplit(mainAccount, tx, command);
     default:
       return assertUnreachable(command);
   }
 }
 
+function formatStakeCreateAccount(
+  mainAccount: Account,
+  tx: Transaction,
+  command: StakeCreateAccountCommand
+) {
+  const amount = lamportsToSOL(
+    mainAccount,
+    command.amount + command.stakeAccRentExemptAmount
+  );
+  const str = [
+    `  CREATE STAKE ACCOUNT: ${command.stakeAccAddress}`,
+    `  FROM: ${command.fromAccAddress}`,
+    `  AMOUNT: ${amount}${tx.useAllAmount ? " (ALL)" : ""}`,
+    `  SEED: ${command.seed}`,
+    `  VALIDATOR: ${command.delegate.voteAccAddress}`,
+  ]
+    .filter(Boolean)
+    .join("\n");
+
+  return "\n" + str;
+}
+
 function formatTransfer(
   mainAccount: Account,
   tx: Transaction,
@@ -129,13 +161,58 @@ function formatTokenTransfer(
   return "\n" + str;
 }
 
-function formatCreateATA(
+function formatCreateATA(command: TokenCreateATACommand) {
+  const token = getTokenById(toTokenId(command.mint));
+  const str = [`  OPT IN TOKEN: ${token.ticker}`].filter(Boolean).join("\n");
+  return "\n" + str;
+}
+
+function formatStakeDelegate(command: StakeDelegateCommand) {
+  const str = [
+    `  DELEGATE: ${command.stakeAccAddr}`,
+    `  TO: ${command.voteAccAddr}`,
+  ]
+    .filter(Boolean)
+    .join("\n");
+  return "\n" + str;
+}
+
+function formatStakeUndelegate(command: StakeUndelegateCommand) {
+  const str = [`  UNDELEGATE: ${command.stakeAccAddr}`]
+    .filter(Boolean)
+    .join("\n");
+  return "\n" + str;
+}
+
+function formatStakeWithdraw(
   mainAccount: Account,
   tx: Transaction,
-  command: TokenCreateATACommand
+  command: StakeWithdrawCommand
 ) {
-  const token = getTokenById(toTokenId(command.mint));
-  const str = [`  OPT IN TOKEN: ${token.ticker}`].filter(Boolean).join("\n");
+  const amount = lamportsToSOL(mainAccount, command.amount);
+  const str = [
+    `  WITHDRAW FROM: ${command.stakeAccAddr}`,
+    `  AMOUNT: ${amount}${tx.useAllAmount ? " (ALL)" : ""}`,
+    `  TO: ${command.toAccAddr}`,
+  ]
+    .filter(Boolean)
+    .join("\n");
+  return "\n" + str;
+}
+
+function formatStakeSplit(
+  mainAccount: Account,
+  tx: Transaction,
+  command: StakeSplitCommand
+) {
+  const amount = lamportsToSOL(mainAccount, command.amount);
+  const str = [
+    `  SPLIT: ${command.stakeAccAddr}`,
+    `  AMOUNT: ${amount}${tx.useAllAmount ? " (ALL)" : ""}`,
+    `  TO: ${command.splitStakeAccAddr}`,
+  ]
+    .filter(Boolean)
+    .join("\n");
   return "\n" + str;
 }
 

package/src/families/solana/types.ts

@@ -2,12 +2,7 @@ import type {
   TransactionCommon,
   TransactionCommonRaw,
 } from "../../types/transaction";
-
-// for legacy reasons export the types
-export type CoreStatics = Record<string, never>;
-export type CoreAccountSpecifics = Record<string, never>;
-export type CoreOperationSpecifics = Record<string, never>;
-export type CoreCurrencySpecifics = Record<string, never>;
+import { ValidatorsAppValidator } from "./validator-app";
 
 export type TransferCommand = {
   kind: "transfer";
@@ -24,6 +19,48 @@ export type TokenCreateATACommand = {
   associatedTokenAccountAddress: string;
 };
 
+export type StakeCreateAccountCommand = {
+  kind: "stake.createAccount";
+  fromAccAddress: string;
+  stakeAccAddress: string;
+  seed: string;
+  amount: number;
+  stakeAccRentExemptAmount: number;
+  delegate: {
+    voteAccAddress: string;
+  };
+};
+
+export type StakeDelegateCommand = {
+  kind: "stake.delegate";
+  authorizedAccAddr: string;
+  stakeAccAddr: string;
+  voteAccAddr: string;
+};
+
+export type StakeUndelegateCommand = {
+  kind: "stake.undelegate";
+  authorizedAccAddr: string;
+  stakeAccAddr: string;
+};
+
+export type StakeWithdrawCommand = {
+  kind: "stake.withdraw";
+  authorizedAccAddr: string;
+  stakeAccAddr: string;
+  toAccAddr: string;
+  amount: number;
+};
+
+export type StakeSplitCommand = {
+  kind: "stake.split";
+  authorizedAccAddr: string;
+  stakeAccAddr: string;
+  amount: number;
+  seed: string;
+  splitStakeAccAddr: string;
+};
+
 export type TokenRecipientDescriptor = {
   walletAddress: string;
   tokenAccAddress: string;
@@ -44,25 +81,20 @@ export type TokenTransferCommand = {
 export type Command =
   | TransferCommand
   | TokenTransferCommand
-  | TokenCreateATACommand;
-
-export type ValidCommandDescriptor = {
-  status: "valid";
+  | TokenCreateATACommand
+  | StakeCreateAccountCommand
+  | StakeDelegateCommand
+  | StakeUndelegateCommand
+  | StakeWithdrawCommand
+  | StakeSplitCommand;
+
+export type CommandDescriptor = {
   command: Command;
-  fees?: number;
-  warnings?: Record<string, Error>;
-};
-
-export type InvalidCommandDescriptor = {
-  status: "invalid";
+  fee: number;
+  warnings: Record<string, Error>;
   errors: Record<string, Error>;
-  warnings?: Record<string, Error>;
 };
 
-export type CommandDescriptor<> =
-  | ValidCommandDescriptor
-  | InvalidCommandDescriptor;
-
 export type TransferTransaction = {
   kind: "transfer";
   uiState: {
@@ -85,26 +117,125 @@ export type TokenCreateATATransaction = {
   };
 };
 
+export type StakeCreateAccountTransaction = {
+  kind: "stake.createAccount";
+  uiState: {
+    delegate: {
+      voteAccAddress: string;
+    };
+  };
+};
+
+export type StakeDelegateTransaction = {
+  kind: "stake.delegate";
+  uiState: {
+    stakeAccAddr: string;
+    voteAccAddr: string;
+  };
+};
+
+export type StakeUndelegateTransaction = {
+  kind: "stake.undelegate";
+  uiState: {
+    stakeAccAddr: string;
+  };
+};
+
+export type StakeWithdrawTransaction = {
+  kind: "stake.withdraw";
+  uiState: {
+    stakeAccAddr: string;
+  };
+};
+
+export type StakeSplitTransaction = {
+  kind: "stake.split";
+  uiState: {
+    stakeAccAddr: string;
+  };
+};
+
 export type TransactionModel = { commandDescriptor?: CommandDescriptor } & (
   | TransferTransaction
   | TokenTransferTransaction
   | TokenCreateATATransaction
+  | StakeCreateAccountTransaction
+  | StakeDelegateTransaction
+  | StakeUndelegateTransaction
+  | StakeWithdrawTransaction
+  | StakeSplitTransaction
 );
 
 export type Transaction = TransactionCommon & {
   family: "solana";
   model: TransactionModel;
-  feeCalculator?: {
-    lamportsPerSignature: number;
-  };
 };
 
 export type TransactionRaw = TransactionCommonRaw & {
   family: "solana";
   model: string;
-  feeCalculator?: {
-    lamportsPerSignature: number;
+};
+
+export type SolanaStake = {
+  stakeAccAddr: string;
+  hasStakeAuth: boolean;
+  hasWithdrawAuth: boolean;
+  delegation?: {
+    stake: number;
+    voteAccAddr: string;
+  };
+  stakeAccBalance: number;
+  rentExemptReserve: number;
+  withdrawable: number;
+  activation: {
+    state: "active" | "inactive" | "activating" | "deactivating";
+    active: number;
+    inactive: number;
   };
 };
 
-export const reflect = (_declare: unknown): void => {};
+export type SolanaStakeWithMeta = {
+  stake: SolanaStake;
+  meta: {
+    validator?: {
+      name?: string;
+      img?: string;
+      url?: string;
+    };
+  };
+};
+
+export type SolanaResources = {
+  stakes: SolanaStake[];
+};
+
+export type SolanaResourcesRaw = {
+  stakes: string;
+};
+
+export type SolanaValidator = {
+  voteAccAddr: string;
+  commission: number;
+  activatedStake: number;
+};
+
+export type SolanaPreloadDataV1 = {
+  version: "1";
+  validatorsWithMeta: SolanaValidatorWithMeta[];
+  validators: ValidatorsAppValidator[];
+};
+
+// exists for discriminated union to work
+export type SolanaPreloadDataV2 = {
+  version: "2";
+};
+
+export type SolanaPreloadData = SolanaPreloadDataV1 | SolanaPreloadDataV2;
+
+export type SolanaValidatorWithMeta = {
+  validator: SolanaValidator;
+  meta: {
+    name?: string;
+    img?: string;
+  };
+};

package/src/families/solana/utils.ts

@@ -1,6 +1,9 @@
-import { clusterApiUrl } from "@solana/web3.js";
+import { Cluster, clusterApiUrl } from "@solana/web3.js";
 import { getEnv } from "../../env";
 
+export const LEDGER_VALIDATOR_ADDRESS =
+  "26pV97Ce83ZQ6Kz9XT4td8tdoUFPTng8Fb8gPyc53dJx";
+
 export const assertUnreachable = (_: never): never => {
   throw new Error("unreachable assertion failed");
 };
@@ -17,6 +20,14 @@ export async function drainSeqAsyncGen<T>(
   return items;
 }
 
+export async function drainSeq<T>(jobs: (() => Promise<T>)[]) {
+  const items: T[] = [];
+  for (const job of jobs) {
+    items.push(await job());
+  }
+  return items;
+}
+
 export function endpointByCurrencyId(currencyId: string): string {
   const endpoints: Record<string, string> = {
     solana: getEnv("API_SOLANA_PROXY"),
@@ -33,6 +44,40 @@ export function endpointByCurrencyId(currencyId: string): string {
   );
 }
 
+export function clusterByCurrencyId(currencyId: string): Cluster {
+  const clusters: Record<string, Cluster> = {
+    solana: "mainnet-beta",
+    solana_devnet: "devnet",
+    solana_testnet: "testnet",
+  };
+
+  if (currencyId in clusters) {
+    return clusters[currencyId];
+  }
+
+  throw Error(
+    `unexpected currency id format <${currencyId}>, should be like solana[_(testnet | devnet)]`
+  );
+}
+
+export function defaultVoteAccAddrByCurrencyId(
+  currencyId: string
+): string | undefined {
+  const voteAccAddrs: Record<string, string | undefined> = {
+    solana: LEDGER_VALIDATOR_ADDRESS,
+    solana_devnet: undefined,
+    solana_testnet: undefined,
+  };
+
+  if (currencyId in voteAccAddrs) {
+    return voteAccAddrs[currencyId];
+  }
+
+  throw new Error(
+    `unexpected currency id format <${currencyId}>, should be like solana[_(testnet | devnet)]`
+  );
+}
+
 type AsyncQueueEntry<T> = {
   lazyPromise: () => Promise<T>;
   resolve: (value: T) => void;
@@ -79,3 +124,9 @@ export function asyncQueue(config: { delayBetweenRuns: number }): {
     submit,
   };
 }
+
+export function swap(arr: any[], i: number, j: number) {
+  const tmp = arr[i];
+  arr[i] = arr[j];
+  arr[j] = tmp;
+}