@ledgerhq/coin-solana 0.7.0-next.0

package/src/transaction.ts

@@ -0,0 +1,199 @@
+import { BigNumber } from "bignumber.js";
+import type {
+  Command,
+  StakeCreateAccountCommand,
+  StakeDelegateCommand,
+  StakeSplitCommand,
+  StakeUndelegateCommand,
+  StakeWithdrawCommand,
+  TokenCreateATACommand,
+  TokenTransferCommand,
+  Transaction,
+  TransactionRaw,
+  TransferCommand,
+} from "./types";
+import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/serialization";
+import type { Account } from "@ledgerhq/types-live";
+import { getTokenById } from "@ledgerhq/cryptoassets/index";
+import { findSubAccountById, getAccountCurrency } from "@ledgerhq/coin-framework/account";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import { assertUnreachable } from "./utils";
+import { toTokenId } from "./logic";
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  const { family, model } = tr;
+  return {
+    ...common,
+    family,
+    model: JSON.parse(model),
+  };
+};
+
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  const { family, model } = t;
+  return {
+    ...common,
+    family,
+    model: JSON.stringify(model),
+  };
+};
+
+const lamportsToSOL = (account: Account, amount: number) => {
+  return formatCurrencyUnit(getAccountCurrency(account).units[0], new BigNumber(amount), {
+    showCode: true,
+    disableRounding: true,
+  });
+};
+
+export const formatTransaction = (tx: Transaction, mainAccount: Account): string => {
+  if (tx.model.commandDescriptor === undefined) {
+    throw new Error("can not format unprepared transaction");
+  }
+  const { commandDescriptor } = tx.model;
+
+  if (Object.keys(commandDescriptor.errors).length > 0) {
+    throw new Error("can not format invalid transaction");
+  }
+  return formatCommand(mainAccount, tx, commandDescriptor.command);
+};
+
+function formatCommand(mainAccount: Account, tx: Transaction, command: Command) {
+  switch (command.kind) {
+    case "transfer":
+      return formatTransfer(mainAccount, tx, command);
+    case "token.transfer":
+      return formatTokenTransfer(mainAccount, tx, command);
+    case "token.createATA":
+      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, command: TransferCommand) {
+  const amount = lamportsToSOL(mainAccount, command.amount);
+  const str = [
+    `  SEND: ${amount}${tx.useAllAmount ? " (ALL)" : ""}`,
+    `  TO: ${command.recipient}`,
+    command.memo ? `  MEMO: ${command.memo}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+
+  return "\n" + str;
+}
+
+function formatTokenTransfer(mainAccount: Account, tx: Transaction, command: TokenTransferCommand) {
+  if (!tx.subAccountId) {
+    throw new Error("expected subaccountId on transaction");
+  }
+  const subAccount = findSubAccountById(mainAccount, tx.subAccountId);
+  if (!subAccount || subAccount.type !== "TokenAccount") {
+    throw new Error("token subaccount expected");
+  }
+  const amount = formatCurrencyUnit(
+    getAccountCurrency(subAccount).units[0],
+    new BigNumber(command.amount),
+    {
+      showCode: true,
+      disableRounding: true,
+    },
+  );
+  const recipient = command.recipientDescriptor.walletAddress;
+  const str = [
+    `  SEND: ${amount}${tx.useAllAmount ? " (ALL)" : ""}`,
+    `  TO: ${recipient}`,
+    command.memo ? `  MEMO: ${command.memo}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+  return "\n" + str;
+}
+
+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: StakeWithdrawCommand) {
+  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;
+}
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};

package/src/tx-fees.ts

@@ -0,0 +1,206 @@
+import { ChainAPI } from "./api";
+import { buildTransactionWithAPI } from "./buildTransaction";
+import createTransaction from "./createTransaction";
+import { Transaction, TransactionModel } from "./types";
+import { assertUnreachable } from "./utils";
+import { VersionedTransaction as OnChainTransaction } from "@solana/web3.js";
+import { log } from "@ledgerhq/logs";
+
+const DEFAULT_TX_FEE = 5000;
+
+export async function estimateTxFee(
+  api: ChainAPI,
+  address: string,
+  kind: TransactionModel["kind"],
+) {
+  const tx = createDummyTx(address, kind);
+  const [onChainTx] = await buildTransactionWithAPI(address, tx, api);
+
+  let fee = await api.getFeeForMessage(onChainTx.message);
+
+  if (typeof fee !== "number") {
+    // Sometimes getFeeForMessage doesn't return valid fees, because onChainTx.message.recentBlockhash
+    // is outdated --> retrying with a next blockhash
+    log("debug", `Solana api.getFeeForMessage returned invalid fee: <${fee}>`);
+    fee = await retryWithNewBlockhash(api, onChainTx);
+  }
+
+  if (typeof fee !== "number") {
+    log(
+      "error",
+      `Solana unexpected fee: <${fee}>, after retry with a new blockhash. Fallback to the default.`,
+    );
+    // If still failing, fallback to a default fees value
+    fee = DEFAULT_TX_FEE;
+  }
+  return fee;
+}
+
+const createDummyTx = (address: string, kind: TransactionModel["kind"]) => {
+  switch (kind) {
+    case "transfer":
+      return createDummyTransferTx(address);
+    case "stake.createAccount":
+      return createDummyStakeCreateAccountTx(address);
+    case "stake.delegate":
+      return createDummyStakeDelegateTx(address);
+    case "stake.undelegate":
+      return createDummyStakeUndelegateTx(address);
+    case "stake.withdraw":
+      return createDummyStakeWithdrawTx(address);
+    case "stake.split":
+    case "token.createATA":
+    case "token.transfer":
+      throw new Error(`not implemented for <${kind}>`);
+    default:
+      return assertUnreachable(kind);
+  }
+};
+
+const createDummyTransferTx = (address: string): Transaction => {
+  return {
+    ...createTransaction({} as any),
+    model: {
+      kind: "transfer",
+      uiState: {},
+      commandDescriptor: {
+        command: {
+          kind: "transfer",
+          amount: 0,
+          recipient: address,
+          sender: address,
+        },
+        ...commandDescriptorCommons,
+      },
+    },
+  };
+};
+
+const createDummyStakeCreateAccountTx = (address: string): Transaction => {
+  return {
+    ...createTransaction({} as any),
+    model: {
+      kind: "stake.createAccount",
+      uiState: {} as any,
+      commandDescriptor: {
+        command: {
+          kind: "stake.createAccount",
+          amount: 0,
+          delegate: {
+            voteAccAddress: randomAddresses[0],
+          },
+          fromAccAddress: address,
+          seed: "",
+          stakeAccAddress: randomAddresses[1],
+          stakeAccRentExemptAmount: 0,
+        },
+        ...commandDescriptorCommons,
+      },
+    },
+  };
+};
+
+const createDummyStakeDelegateTx = (address: string): Transaction => {
+  return {
+    ...createTransaction({} as any),
+    model: {
+      kind: "stake.delegate",
+      uiState: {} as any,
+      commandDescriptor: {
+        command: {
+          kind: "stake.delegate",
+          authorizedAccAddr: address,
+          stakeAccAddr: randomAddresses[0],
+          voteAccAddr: randomAddresses[1],
+        },
+        ...commandDescriptorCommons,
+      },
+    },
+  };
+};
+
+const createDummyStakeUndelegateTx = (address: string): Transaction => {
+  return {
+    ...createTransaction({} as any),
+    model: {
+      kind: "stake.undelegate",
+      uiState: {} as any,
+      commandDescriptor: {
+        command: {
+          kind: "stake.undelegate",
+          authorizedAccAddr: address,
+          stakeAccAddr: randomAddresses[0],
+        },
+        ...commandDescriptorCommons,
+      },
+    },
+  };
+};
+
+const createDummyStakeWithdrawTx = (address: string): Transaction => {
+  return {
+    ...createTransaction({} as any),
+    model: {
+      kind: "stake.withdraw",
+      uiState: {} as any,
+      commandDescriptor: {
+        command: {
+          kind: "stake.withdraw",
+          amount: 0,
+          authorizedAccAddr: address,
+          stakeAccAddr: randomAddresses[0],
+          toAccAddr: randomAddresses[1],
+        },
+        ...commandDescriptorCommons,
+      },
+    },
+  };
+};
+
+const commandDescriptorCommons = {
+  errors: {},
+  fee: 0,
+  warnings: {},
+};
+
+// pregenerate for better caching
+const randomAddresses = [
+  "HxCvgjSbF8HMt3fj8P3j49jmajNCMwKAqBu79HUDPtkM",
+  "AjmMiagw33Ad4WdPR3y2QWsDXaLxmsiSZEpMfpT1Q9uZ",
+  "AVHhsobqNw3b3XD43fz7Crq3d3UxFYZfHAByh7ogZoeN",
+  "FvbvvXMY4Rf1AtGG7UHJUesjt8FFgPnPy6o83Dna9mXK",
+  "AEtRo9MKfLqGtjvxdz8H93R7SQxXLEkibVSJbs9XKnD1",
+];
+
+async function retryWithNewBlockhash(api: ChainAPI, onChainTx: OnChainTransaction) {
+  if (onChainTx.message.recentBlockhash === undefined) {
+    throw new Error("expected recentBlockhash");
+  }
+
+  onChainTx.message.recentBlockhash = await waitNextBlockhash(
+    api,
+    onChainTx.message.recentBlockhash,
+  );
+
+  return api.getFeeForMessage(onChainTx.message);
+}
+
+function sleep(durationMS: number): Promise<void> {
+  return new Promise(res => setTimeout(res, durationMS));
+}
+
+async function waitNextBlockhash(api: ChainAPI, currentBlockhash: string) {
+  const sleepTimeMS = 5000;
+  for (let i = 0; i < 5; i++) {
+    log("info", `sleeping for ${sleepTimeMS} ms, waiting for a new blockhash`);
+    await sleep(sleepTimeMS);
+    const blockhash = await api.getLatestBlockhash();
+    if (blockhash !== currentBlockhash) {
+      log("info", "got a new blockhash");
+      return blockhash;
+    }
+    log("info", "got same blockhash");
+  }
+
+  throw new Error("next blockhash timeout");
+}

package/src/types.ts

@@ -0,0 +1,291 @@
+import BigNumber from "bignumber.js";
+import {
+  Account,
+  AccountRaw,
+  Operation,
+  TransactionCommon,
+  TransactionCommonRaw,
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+import { ValidatorsAppValidator } from "./validator-app";
+
+export type TransferCommand = {
+  kind: "transfer";
+  sender: string;
+  recipient: string;
+  amount: number;
+  memo?: string | undefined;
+};
+
+export type TokenCreateATACommand = {
+  kind: "token.createATA";
+  owner: string;
+  mint: string;
+  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;
+  shouldCreateAsAssociatedTokenAccount: boolean;
+};
+
+export type TokenTransferCommand = {
+  kind: "token.transfer";
+  ownerAddress: string;
+  ownerAssociatedTokenAccountAddress: string;
+  recipientDescriptor: TokenRecipientDescriptor;
+  amount: number;
+  mintAddress: string;
+  mintDecimals: number;
+  memo?: string | undefined;
+};
+
+export type Command =
+  | TransferCommand
+  | TokenTransferCommand
+  | TokenCreateATACommand
+  | StakeCreateAccountCommand
+  | StakeDelegateCommand
+  | StakeUndelegateCommand
+  | StakeWithdrawCommand
+  | StakeSplitCommand;
+
+export type CommandDescriptor = {
+  command: Command;
+  fee: number;
+  warnings: Record<string, Error>;
+  errors: Record<string, Error>;
+};
+
+export type TransferTransaction = {
+  kind: "transfer";
+  uiState: {
+    memo?: string | undefined;
+  };
+};
+
+export type TokenTransferTransaction = {
+  kind: "token.transfer";
+  uiState: {
+    subAccountId: string;
+    memo?: string | undefined;
+  };
+};
+
+export type TokenCreateATATransaction = {
+  kind: "token.createATA";
+  uiState: {
+    tokenId: string;
+  };
+};
+
+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;
+};
+
+export type TransactionRaw = TransactionCommonRaw & {
+  family: "solana";
+  model: string;
+};
+
+export type SolanaStake = {
+  stakeAccAddr: string;
+  hasStakeAuth: boolean;
+  hasWithdrawAuth: boolean;
+  delegation:
+    | {
+        stake: number;
+        voteAccAddr: string;
+      }
+    | undefined;
+  stakeAccBalance: number;
+  rentExemptReserve: number;
+  withdrawable: number;
+  activation: {
+    state: "active" | "inactive" | "activating" | "deactivating";
+    active: number;
+    inactive: number;
+  };
+  reward?:
+    | {
+        amount: number;
+      }
+    | undefined;
+};
+
+export type SolanaStakeWithMeta = {
+  stake: SolanaStake;
+  meta: {
+    validator?: {
+      name?: string;
+      img?: string;
+      url?: string;
+    };
+  };
+};
+
+export type SolanaResources = {
+  stakes: SolanaStake[];
+  unstakeReserve: BigNumber;
+};
+
+export type SolanaResourcesRaw = {
+  stakes: string;
+  unstakeReserve: 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;
+  };
+};
+
+export type StakeAction = "deactivate" | "activate" | "withdraw" | "reactivate";
+
+export type SolanaAccount = Account & { solanaResources: SolanaResources };
+
+export type SolanaAccountRaw = AccountRaw & {
+  solanaResources: SolanaResourcesRaw;
+};
+
+export type TransactionStatus = TransactionStatusCommon;
+
+export type TransactionStatusRaw = TransactionStatusCommonRaw;
+
+export type SolanaOperation = Operation<SolanaOperationExtra>;
+export type SolanaOperationRaw = Operation<SolanaOperationExtraRaw>;
+
+export type ExtraStakeInfo = {
+  address: string;
+  amount: BigNumber;
+};
+
+export type ExtraStakeInfoRaw = {
+  address: string;
+  amount: string;
+};
+
+export type SolanaOperationExtra = {
+  memo?: string | undefined;
+  stake?: ExtraStakeInfo;
+};
+
+export type SolanaOperationExtraRaw = {
+  memo?: string | undefined;
+  stake?: ExtraStakeInfoRaw;
+};