@ledgerhq/coin-solana 0.7.0-nightly.0

package/src/js-buildTransaction.ts

@@ -0,0 +1,81 @@
+import type { Command, Transaction } from "./types";
+import {
+  buildTransferInstructions,
+  buildTokenTransferInstructions,
+  buildCreateAssociatedTokenAccountInstruction,
+  buildStakeCreateAccountInstructions,
+  buildStakeDelegateInstructions,
+  buildStakeUndelegateInstructions,
+  buildStakeWithdrawInstructions,
+  buildStakeSplitInstructions,
+} from "./api/chain/web3";
+import { assertUnreachable } from "./utils";
+import {
+  PublicKey,
+  VersionedTransaction as OnChainTransaction,
+  TransactionInstruction,
+  TransactionMessage,
+} from "@solana/web3.js";
+import { ChainAPI } from "./api";
+
+export const buildTransactionWithAPI = async (
+  address: string,
+  transaction: Transaction,
+  api: ChainAPI,
+): Promise<readonly [OnChainTransaction, (signature: Buffer) => OnChainTransaction]> => {
+  const instructions = buildInstructions(transaction);
+
+  const recentBlockhash = await api.getLatestBlockhash();
+
+  const feePayer = new PublicKey(address);
+
+  const tm = new TransactionMessage({
+    payerKey: feePayer,
+    recentBlockhash,
+    instructions,
+  });
+
+  const tx = new OnChainTransaction(tm.compileToLegacyMessage());
+
+  return [
+    tx,
+    (signature: Buffer) => {
+      tx.addSignature(new PublicKey(address), signature);
+      return tx;
+    },
+  ];
+};
+
+function buildInstructions(tx: Transaction): TransactionInstruction[] {
+  const { commandDescriptor } = tx.model;
+  if (commandDescriptor === undefined) {
+    throw new Error("missing command descriptor");
+  }
+  if (Object.keys(commandDescriptor.errors).length > 0) {
+    throw new Error("can not build invalid command");
+  }
+  return buildInstructionsForCommand(commandDescriptor.command);
+}
+
+function buildInstructionsForCommand(command: Command): TransactionInstruction[] {
+  switch (command.kind) {
+    case "transfer":
+      return buildTransferInstructions(command);
+    case "token.transfer":
+      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/js-createTransaction.ts

@@ -0,0 +1,20 @@
+import { BigNumber } from "bignumber.js";
+import type { Transaction /* TransactionMode */ } from "./types";
+import { Account } from "@ledgerhq/types-live";
+
+const createTransaction = (_: Account): Transaction => {
+  return {
+    family: "solana",
+    amount: new BigNumber(0),
+    useAllAmount: false,
+    recipient: "",
+    model: {
+      kind: "transfer",
+      uiState: {
+        memo: undefined,
+      },
+    },
+  };
+};
+
+export default createTransaction;

package/src/js-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,
+      };
+    }
+  }
+};
+
+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/js-getTransactionStatus.ts

@@ -0,0 +1,72 @@
+import { BigNumber } from "bignumber.js";
+import type { Account } from "@ledgerhq/types-live";
+import type { Command, CommandDescriptor, Transaction, TransactionStatus } from "./types";
+import { assertUnreachable } from "./utils";
+
+const getTransactionStatus = async (
+  _account: Account,
+  tx: Transaction,
+): Promise<TransactionStatus> => {
+  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/js-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/js-preload.test.ts

@@ -0,0 +1,14 @@
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { hydrate } from "./js-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/js-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 "./js-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);
+}