@ledgerhq/coin-solana 0.7.0-nightly.0

package/src/speculos-deviceActions.ts

@@ -0,0 +1,229 @@
+import type { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+import type { Transaction } from "./types";
+import {
+  deviceActionFlow,
+  formatDeviceAmount,
+  SpeculosButton,
+} from "@ledgerhq/coin-framework/bot/specs";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import BigNumber from "bignumber.js";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+function getMainCurrency(currency: CryptoCurrency) {
+  if (currency.isTestnetFor !== undefined) {
+    return getCryptoCurrencyById(currency.isTestnetFor);
+  }
+  return currency;
+}
+
+function ellipsis(str: string) {
+  return `${str.slice(0, 7)}..${str.slice(-7)}`;
+}
+
+function formatAmount(c: CryptoCurrency, amount: number) {
+  const currency = getMainCurrency(c);
+  return formatDeviceAmount(currency, new BigNumber(amount), {
+    postfixCode: true,
+  });
+}
+
+export const acceptTransferTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Transfer",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, transaction }) => {
+        const command = transaction.model.commandDescriptor?.command;
+        if (command?.kind === "transfer") {
+          return formatAmount(account.currency, command.amount);
+        }
+        throwUnexpectedTransaction();
+      },
+    },
+    {
+      title: "Recipient",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => {
+        const command = transaction.model.commandDescriptor?.command;
+        if (command?.kind === "transfer") {
+          return ellipsis(command.recipient);
+        }
+        throwUnexpectedTransaction();
+      },
+    },
+    {
+      title: "Approve",
+      button: SpeculosButton.BOTH,
+      final: true,
+    },
+  ],
+});
+
+export const acceptStakeCreateAccountTransaction: DeviceAction<Transaction, any> = deviceActionFlow(
+  {
+    steps: [
+      {
+        title: "Delegate from",
+        button: SpeculosButton.RIGHT,
+        expectedValue: ({ transaction }) => {
+          const command = transaction.model.commandDescriptor?.command;
+          if (command?.kind === "stake.createAccount") {
+            return ellipsis(command.stakeAccAddress);
+          }
+
+          throwUnexpectedTransaction();
+        },
+      },
+      {
+        title: "Deposit",
+        button: SpeculosButton.RIGHT,
+        expectedValue: ({ account, transaction }) => {
+          const command = transaction.model.commandDescriptor?.command;
+          if (command?.kind === "stake.createAccount") {
+            return formatAmount(
+              account.currency,
+              command.amount + command.stakeAccRentExemptAmount,
+            );
+          }
+
+          throwUnexpectedTransaction();
+        },
+      },
+      {
+        title: "New authority",
+        button: SpeculosButton.RIGHT,
+        expectedValue: ({ transaction }) => {
+          const command = transaction.model.commandDescriptor?.command;
+          if (command?.kind === "stake.createAccount") {
+            return ellipsis(command.fromAccAddress);
+          }
+
+          throwUnexpectedTransaction();
+        },
+      },
+      {
+        title: "Vote account",
+        button: SpeculosButton.RIGHT,
+        expectedValue: ({ transaction }) => {
+          const command = transaction.model.commandDescriptor?.command;
+          if (command?.kind === "stake.createAccount") {
+            return ellipsis(command.delegate.voteAccAddress);
+          }
+
+          throwUnexpectedTransaction();
+        },
+      },
+      {
+        title: "Approve",
+        button: SpeculosButton.BOTH,
+        final: true,
+      },
+    ],
+  },
+);
+
+export const acceptStakeDelegateTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Delegate from",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => {
+        const command = transaction.model.commandDescriptor?.command;
+        if (command?.kind === "stake.delegate") {
+          return ellipsis(command.stakeAccAddr);
+        }
+        throwUnexpectedTransaction();
+      },
+    },
+    {
+      title: "Vote account",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => {
+        const command = transaction.model.commandDescriptor?.command;
+        if (command?.kind === "stake.delegate") {
+          return ellipsis(command.voteAccAddr);
+        }
+        throwUnexpectedTransaction();
+      },
+    },
+    {
+      title: "Approve",
+      button: SpeculosButton.BOTH,
+      final: true,
+    },
+  ],
+});
+
+export const acceptStakeUndelegateTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Deactivate stake",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => {
+        const command = transaction.model.commandDescriptor?.command;
+        if (command?.kind === "stake.undelegate") {
+          return ellipsis(command.stakeAccAddr);
+        }
+        throwUnexpectedTransaction();
+      },
+    },
+    {
+      title: "Approve",
+      button: SpeculosButton.BOTH,
+      final: true,
+    },
+  ],
+});
+
+export const acceptStakeWithdrawTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Stake withdraw",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, transaction }) => {
+        const command = transaction.model.commandDescriptor?.command;
+
+        if (command?.kind === "stake.withdraw") {
+          return formatAmount(account.currency, command.amount);
+        }
+
+        throwUnexpectedTransaction();
+      },
+    },
+    {
+      title: "From",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => {
+        const command = transaction.model.commandDescriptor?.command;
+
+        if (command?.kind === "stake.withdraw") {
+          return ellipsis(command.stakeAccAddr);
+        }
+
+        throwUnexpectedTransaction();
+      },
+    },
+    {
+      title: "To",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => {
+        const command = transaction.model.commandDescriptor?.command;
+
+        if (command?.kind === "stake.withdraw") {
+          return ellipsis(command.toAccAddr);
+        }
+
+        throwUnexpectedTransaction();
+      },
+    },
+    {
+      title: "Approve",
+      button: SpeculosButton.BOTH,
+      final: true,
+    },
+  ],
+});
+
+function throwUnexpectedTransaction(): never {
+  throw new Error("unexpected or unprepared transaction");
+}

package/src/transaction.ts

@@ -0,0 +1,194 @@
+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 { findSubAccountById, getAccountUnit } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit, getTokenById } from "@ledgerhq/coin-framework/currencies/index";
+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(getAccountUnit(account), 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(getAccountUnit(subAccount), 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 "./js-buildTransaction";
+import createTransaction from "./js-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");
+}