@ledgerhq/coin-solana 0.7.0-next.0

package/src/errors.ts

@@ -0,0 +1,61 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const SolanaAccountNotFunded = createCustomErrorClass("SolanaAccountNotFunded");
+
+export const SolanaRecipientAssociatedTokenAccountWillBeFunded = createCustomErrorClass(
+  "SolanaAssociatedTokenAccountWillBeFunded",
+);
+
+export const SolanaMemoIsTooLong = createCustomErrorClass("SolanaMemoIsTooLong");
+
+export const SolanaTokenAccountHoldsAnotherToken = createCustomErrorClass(
+  "SolanaTokenAccountHoldsAnotherToken",
+);
+
+export const SolanaTokenAccounNotInitialized = createCustomErrorClass(
+  "SolanaTokenAccounNotInitialized",
+);
+
+export const SolanaAddressOffEd25519 = createCustomErrorClass("SolanaAddressOfEd25519");
+
+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");
+
+export const SolanaUseAllAmountStakeWarning = createCustomErrorClass(
+  "SolanaUseAllAmountStakeWarning",
+);
+
+export const SolanaTxSimulationFailedWhilePendingOp = createCustomErrorClass(
+  "SolanaTxSimulationFailedWhilePendingOp",
+);
+
+export const SolanaTxConfirmationTimeout = createCustomErrorClass("SolanaTxConfirmationTimeout");

package/src/estimateMaxSpendable.ts

@@ -0,0 +1,72 @@
+import type { Account, AccountBridge } from "@ledgerhq/types-live";
+import type { Transaction } from "./types";
+import BigNumber from "bignumber.js";
+import { ChainAPI } from "./api";
+import { getStakeAccountMinimumBalanceForRentExemption } from "./api/chain/web3";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import { estimateTxFee } from "./tx-fees";
+
+export const estimateFeeAndSpendable = async (
+  api: ChainAPI,
+  account: Account,
+  transaction?: Transaction | undefined | null,
+): Promise<{ fee: number; spendable: BigNumber }> => {
+  const txKind = transaction?.model.kind ?? "transfer";
+  const txFee = await estimateTxFee(api, account.freshAddress, txKind);
+
+  const spendableBalance = BigNumber.max(account.spendableBalance.minus(txFee), 0);
+
+  switch (txKind) {
+    case "token.createATA": {
+      const assocAccRentExempt = await api.getAssocTokenAccMinNativeBalance();
+
+      return {
+        fee: txFee + assocAccRentExempt,
+        spendable: BigNumber.max(spendableBalance.minus(assocAccRentExempt), 0),
+      };
+    }
+    case "stake.createAccount": {
+      const stakeAccRentExempt = await getStakeAccountMinimumBalanceForRentExemption(api);
+      const unstakeReserve =
+        (await estimateTxFee(api, account.freshAddress, "stake.undelegate")) +
+        (await estimateTxFee(api, account.freshAddress, "stake.withdraw"));
+
+      return {
+        fee: txFee + stakeAccRentExempt,
+        spendable: BigNumber.max(
+          spendableBalance.minus(stakeAccRentExempt).minus(unstakeReserve),
+          0,
+        ),
+      };
+    }
+
+    default: {
+      return {
+        fee: txFee,
+        spendable: spendableBalance,
+      };
+    }
+  }
+};
+
+export const estimateMaxSpendableWithAPI = async (
+  {
+    account,
+    parentAccount,
+    transaction,
+  }: Parameters<AccountBridge<Transaction>["estimateMaxSpendable"]>[0],
+  api: ChainAPI,
+): Promise<BigNumber> => {
+  const mainAccount = getMainAccount(account, parentAccount);
+
+  switch (account.type) {
+    case "Account":
+      return (await estimateFeeAndSpendable(api, mainAccount, transaction)).spendable;
+    case "TokenAccount":
+      return account.spendableBalance;
+  }
+
+  throw new Error("not supported account type");
+};
+
+export default estimateMaxSpendableWithAPI;

package/src/getTransactionStatus.ts

@@ -0,0 +1,79 @@
+import { BigNumber } from "bignumber.js";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { assertUnreachable } from "./utils";
+import type {
+  Command,
+  CommandDescriptor,
+  SolanaAccount,
+  Transaction,
+  TransactionStatus,
+} from "./types";
+
+export const getTransactionStatus: AccountBridge<
+  Transaction,
+  SolanaAccount,
+  TransactionStatus
+>["getTransactionStatus"] = async (_account, tx) => {
+  const { commandDescriptor } = tx.model;
+
+  if (commandDescriptor === undefined) {
+    return {
+      amount: tx.amount,
+      estimatedFees: new BigNumber(0),
+      totalSpent: tx.amount,
+      errors: {},
+      warnings: {},
+    };
+  }
+
+  const { command, fee, errors, warnings } = commandDescriptor;
+
+  const amount = new BigNumber(getAmount(command));
+  const estimatedFees = new BigNumber(fee);
+  const totalSpent = new BigNumber(getTotalSpent(commandDescriptor));
+
+  return {
+    amount,
+    estimatedFees,
+    totalSpent,
+    warnings,
+    errors,
+  };
+};
+
+function getAmount(command: Command) {
+  switch (command.kind) {
+    case "transfer":
+    case "token.transfer":
+    case "stake.createAccount":
+    case "stake.withdraw":
+      return command.amount;
+    case "token.createATA":
+    case "stake.delegate":
+    case "stake.undelegate":
+    case "stake.split":
+      return 0;
+    default:
+      return assertUnreachable(command);
+  }
+}
+
+function getTotalSpent({ command, fee }: CommandDescriptor) {
+  switch (command.kind) {
+    case "transfer":
+    case "stake.createAccount":
+      return command.amount < 0 ? 0 : command.amount + fee;
+    case "token.transfer":
+      return Math.max(command.amount, 0);
+    case "token.createATA":
+    case "stake.delegate":
+    case "stake.undelegate":
+    case "stake.withdraw":
+    case "stake.split":
+      return fee;
+    default:
+      return assertUnreachable(command);
+  }
+}
+
+export default getTransactionStatus;

package/src/hw-getAddress.ts

@@ -0,0 +1,22 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { SolanaSigner } from "./signer";
+
+import bs58 from "bs58";
+
+const resolver = (signerContext: SignerContext<SolanaSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const { address } = await signerContext(deviceId, signer => signer.getAddress(path, verify));
+
+    const publicKey = bs58.encode(address);
+
+    return {
+      address: publicKey,
+      publicKey,
+      path,
+    };
+  };
+};
+
+export default resolver;

package/src/logic.ts

@@ -0,0 +1,123 @@
+import { findTokenById } from "@ledgerhq/cryptoassets";
+import { PublicKey } from "@solana/web3.js";
+import { TokenAccount } from "@ledgerhq/types-live";
+import { StakeMeta } from "./api/chain/account/stake";
+import { SolanaStake, StakeAction } from "./types";
+import { assertUnreachable } from "./utils";
+
+export type Awaited<T> = T extends PromiseLike<infer U> ? U : T;
+
+export const MAX_MEMO_LENGTH = 500;
+
+export const isValidBase58Address = (address: string): boolean => {
+  try {
+    return Boolean(new PublicKey(address));
+  } catch (_) {
+    return false;
+  }
+};
+
+export const isEd25519Address = (address: string): boolean => {
+  return PublicKey.isOnCurve(new PublicKey(address).toBytes());
+};
+
+export function encodeAccountIdWithTokenAccountAddress(accountId: string, address: string): string {
+  return `${accountId}+${address}`;
+}
+
+export function decodeAccountIdWithTokenAccountAddress(accountIdWithTokenAccountAddress: string): {
+  accountId: string;
+  address: string;
+} {
+  const lastColonIndex = accountIdWithTokenAccountAddress.lastIndexOf("+");
+  return {
+    accountId: accountIdWithTokenAccountAddress.slice(0, lastColonIndex),
+    address: accountIdWithTokenAccountAddress.slice(lastColonIndex + 1),
+  };
+}
+
+export function toTokenId(mint: string): string {
+  return `solana/spl/${mint}`;
+}
+
+export function toTokenMint(tokenId: string): string {
+  return tokenId.split("/")[2];
+}
+
+export function toSubAccMint(subAcc: TokenAccount): string {
+  return toTokenMint(subAcc.token.id);
+}
+
+export function tokenIsListedOnLedger(mint: string): boolean {
+  return findTokenById(toTokenId(mint))?.type === "TokenCurrency";
+}
+
+export function stakeActions(stake: SolanaStake): StakeAction[] {
+  const actions: StakeAction[] = [];
+
+  if (stake.withdrawable > 0) {
+    actions.push("withdraw");
+  }
+
+  switch (stake.activation.state) {
+    case "active":
+    case "activating":
+      actions.push("deactivate");
+      break;
+    case "deactivating":
+      actions.push("reactivate");
+      break;
+    case "inactive":
+      actions.push("activate");
+      break;
+    default:
+      return assertUnreachable(stake.activation.state);
+  }
+
+  return actions;
+}
+
+export function withdrawableFromStake({
+  stakeAccBalance,
+  activation,
+  rentExemptReserve,
+}: {
+  stakeAccBalance: number;
+  activation: SolanaStake["activation"];
+  rentExemptReserve: number;
+}) {
+  switch (activation.state) {
+    case "active":
+    case "activating":
+      return stakeAccBalance - rentExemptReserve - activation.active - activation.inactive;
+    case "deactivating":
+      return stakeAccBalance - rentExemptReserve - activation.active;
+    case "inactive":
+      return stakeAccBalance;
+    default:
+      return assertUnreachable(activation.state);
+  }
+}
+
+export function isStakeLockUpInForce({
+  lockup,
+  custodianAddress,
+  epoch,
+}: {
+  lockup: StakeMeta["lockup"];
+  custodianAddress: string;
+  epoch: number;
+}) {
+  if (custodianAddress === lockup.custodian.toBase58()) {
+    return false;
+  }
+  return lockup.unixTimestamp > Date.now() / 1000 || lockup.epoch > epoch;
+}
+
+export function stakeActivePercent(stake: SolanaStake) {
+  const amount = stake.delegation?.stake;
+  if (amount === undefined || amount === 0) {
+    return 0;
+  }
+  return (stake.activation.active / amount) * 100;
+}

package/src/preload-data.ts

@@ -0,0 +1,46 @@
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { BehaviorSubject, Observable } from "rxjs";
+import { SolanaPreloadDataV1 } from "./types";
+
+const initialData: SolanaPreloadDataV1 = {
+  version: "1",
+  validatorsWithMeta: [],
+  validators: [],
+};
+
+const dataByCurrency = new Map<string, SolanaPreloadDataV1>([
+  ["solana", initialData],
+  ["solana_testnet", initialData],
+  ["solana_devnet", initialData],
+]);
+
+const dataUpdatesByCurrency = new Map([
+  ["solana", new BehaviorSubject<SolanaPreloadDataV1>(initialData)],
+  ["solana_testnet", new BehaviorSubject<SolanaPreloadDataV1>(initialData)],
+  ["solana_devnet", new BehaviorSubject<SolanaPreloadDataV1>(initialData)],
+]);
+
+export function setSolanaPreloadData(data: SolanaPreloadDataV1, currency: CryptoCurrency): void {
+  dataByCurrency.set(currency.id, data);
+  const subject = dataUpdatesByCurrency.get(currency.id);
+  if (subject === undefined) {
+    throw new Error(`unsupported currency ${currency.id}`);
+  }
+  subject.next(data);
+}
+
+export function getSolanaPreloadData(currency: CryptoCurrency): Observable<SolanaPreloadDataV1> {
+  const subject = dataUpdatesByCurrency.get(currency.id);
+  if (subject === undefined) {
+    throw new Error(`unsupported currency ${currency.id}`);
+  }
+  return subject.asObservable();
+}
+
+export function getCurrentSolanaPreloadData(currency: CryptoCurrency): SolanaPreloadDataV1 {
+  const data = dataByCurrency.get(currency.id);
+  if (data === undefined) {
+    throw new Error(`unsupported currency ${currency.id}`);
+  }
+  return data;
+}

package/src/preload.test.ts

@@ -0,0 +1,14 @@
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { hydrate } from "./preload";
+import { SolanaPreloadData } from "./types";
+
+describe("hydrate", () => {
+  it.each([undefined, null, {}, { version: null }, { version: undefined }, {}])(
+    "should return undefined if data is corrupted (%p value)",
+    value => {
+      expect(hydrate(value as unknown as SolanaPreloadData, {} as CryptoCurrency)).toEqual(
+        undefined,
+      );
+    },
+  );
+});

package/src/preload.ts

@@ -0,0 +1,74 @@
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { flow } from "lodash/fp";
+import { ChainAPI } from "./api";
+import { setSolanaPreloadData as setPreloadData } from "./preload-data";
+import { SolanaPreloadData, SolanaPreloadDataV1 } from "./types";
+import {
+  assertUnreachable,
+  clusterByCurrencyId,
+  profitableValidators,
+  ledgerFirstValidators,
+} from "./utils";
+import { getValidators, ValidatorsAppValidator } from "./validator-app";
+
+export const PRELOAD_MAX_AGE = 15 * 60 * 1000; // 15min
+
+export async function preloadWithAPI(
+  currency: CryptoCurrency,
+  getAPI: () => Promise<ChainAPI>,
+): Promise<SolanaPreloadDataV1> {
+  const api = await getAPI();
+
+  const cluster = clusterByCurrencyId(currency.id);
+
+  const validators: ValidatorsAppValidator[] =
+    cluster === "devnet" ? await loadDevnetValidators(api) : await getValidators(cluster);
+
+  const data: SolanaPreloadData = {
+    version: "1",
+    validatorsWithMeta: [],
+    validators: cluster === "mainnet-beta" ? preprocessMainnetValidators(validators) : validators,
+  };
+
+  setPreloadData(data, currency);
+
+  return data;
+}
+
+function preprocessMainnetValidators(
+  validators: ValidatorsAppValidator[],
+): ValidatorsAppValidator[] {
+  return flow(() => validators, profitableValidators, ledgerFirstValidators)();
+}
+
+async function loadDevnetValidators(api: ChainAPI) {
+  const voteAccs = await api.getVoteAccounts();
+  const validators: ValidatorsAppValidator[] = voteAccs.current.map(acc => ({
+    activeStake: acc.activatedStake,
+    commission: acc.commission,
+    totalScore: 0,
+    voteAccount: acc.votePubkey,
+  }));
+  return validators;
+}
+
+export function hydrate(data: SolanaPreloadData | undefined, currency: CryptoCurrency): void {
+  // https://ledgerhq.atlassian.net/browse/LIVE-11568 covers unknown case where version is undefined
+  if (data == null || data.version == null) {
+    return;
+  }
+
+  switch (data.version) {
+    case "1":
+      hydrateV1(data, currency);
+      return;
+    case "2":
+      throw new Error("version 2 for now exists only to support discriminated union");
+    default:
+      return assertUnreachable(data);
+  }
+}
+
+function hydrateV1(data: SolanaPreloadDataV1, currency: CryptoCurrency) {
+  setPreloadData(data, currency);
+}