@ledgerhq/coin-solana 0.7.0-nightly.0

package/src/cli-transaction.ts

@@ -0,0 +1,246 @@
+import { findTokenById, findTokenByTicker } from "@ledgerhq/cryptoassets";
+import type { Account, AccountLike, AccountLikeArray } from "@ledgerhq/types-live";
+import invariant from "invariant";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import { Transaction } from "./types";
+import { assertUnreachable } from "./utils";
+
+const modes = [
+  "send",
+  "optIn",
+  "stake.createAccount",
+  "stake.delegate",
+  "stake.undelegate",
+  "stake.withdraw",
+  "stake.split",
+] as const;
+type Mode = (typeof modes)[number];
+
+// some options already specified for other blockchains like ethereum.
+// trying to reuse existing ones like <token>, <mode>, etc.
+const options = [
+  {
+    name: "solanaValidator",
+    type: String,
+    desc: "validator address to delegate to",
+  },
+  {
+    name: "solanaStakeAccount",
+    type: String,
+    desc: "stake account address to use in the transaction",
+  },
+];
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    mainAccount: Account;
+    transaction: Transaction;
+  }>,
+  opts: Partial<Record<string, string>>,
+): Transaction[] {
+  const mode = inferMode(opts.mode);
+
+  // reusing ethereum token option, comes as array
+  const tokens: string[] | undefined = opts.token as any;
+
+  if (tokens !== undefined && tokens.length !== 1) {
+    throw new Error("only 1 token at a time supported for solana transactions");
+  }
+
+  const token = tokens?.[0];
+
+  return transactions.map(({ account, transaction }) => {
+    if (transaction.family !== "solana") {
+      throw new Error(`Solana family transaction expected, got <${transaction.family}>`);
+    }
+    switch (mode) {
+      case "send":
+        if (account.type === "Account") {
+          const solanaTx: Transaction = {
+            ...transaction,
+            model: {
+              kind: "transfer",
+              uiState: {
+                memo: opts.memo,
+              },
+            },
+          };
+          return solanaTx;
+        } else {
+          if (account.type !== "TokenAccount") {
+            throw new Error("expected token account");
+          }
+          const subAccountId = account.id;
+          const solanaTx: Transaction = {
+            ...transaction,
+            subAccountId,
+            model: {
+              kind: "token.transfer",
+              uiState: {
+                memo: opts.memo,
+                subAccountId,
+              },
+            },
+          };
+          return solanaTx;
+        }
+      case "optIn": {
+        if (token === undefined) {
+          throw new Error("token required");
+        }
+
+        if (account.type !== "Account") {
+          throw new Error("expected main account");
+        }
+
+        const tokenCurrency = findTokenByTicker(token) ?? findTokenById(token);
+
+        if (!tokenCurrency) {
+          throw new Error(`token <${token}> not found`);
+        }
+
+        const solanaTx: Transaction = {
+          ...transaction,
+          model: {
+            kind: "token.createATA",
+            uiState: {
+              tokenId: tokenCurrency.id,
+            },
+          },
+        };
+        return solanaTx;
+      }
+      case "stake.createAccount": {
+        const validator = opts.solanaValidator;
+        return {
+          ...transaction,
+          model: {
+            kind: "stake.createAccount",
+            uiState: {
+              delegate: {
+                voteAccAddress: validator ?? "",
+              },
+            },
+          },
+        };
+      }
+      case "stake.delegate":
+        return {
+          ...transaction,
+          model: {
+            kind: "stake.delegate",
+            uiState: {
+              stakeAccAddr: opts.solanaStakeAccount ?? "",
+              voteAccAddr: opts.solanaValidator ?? "",
+            },
+          },
+        };
+      case "stake.undelegate":
+        return {
+          ...transaction,
+          model: {
+            kind: "stake.undelegate",
+            uiState: {
+              stakeAccAddr: opts.solanaStakeAccount ?? "",
+            },
+          },
+        };
+      case "stake.withdraw":
+        return {
+          ...transaction,
+          model: {
+            kind: "stake.withdraw",
+            uiState: {
+              stakeAccAddr: opts.solanaStakeAccount ?? "",
+            },
+          },
+        };
+      case "stake.split":
+        if (opts.solanaStakeAccount === undefined) {
+          throw new Error("stake account is required");
+        }
+
+        return {
+          ...transaction,
+          model: {
+            kind: "stake.split",
+            uiState: {
+              stakeAccAddr: opts.solanaStakeAccount,
+            },
+          },
+        };
+      default:
+        return assertUnreachable(mode);
+    }
+  });
+}
+
+function inferAccounts(mainAccount: Account, opts: Record<string, string>): AccountLikeArray {
+  invariant(mainAccount.currency.family === "solana", "solana family currency");
+
+  const mode = inferMode(opts.mode);
+
+  switch (mode) {
+    case "send": {
+      if (!opts.token) {
+        return [mainAccount];
+      }
+
+      // reusing ethereum token option, comes as array
+      const tokens: string[] = opts.token as any;
+
+      if (tokens.length !== 1) {
+        throw new Error("only 1 token at a time supported for solana");
+      }
+
+      const token = tokens[0];
+
+      const subAccount = mainAccount.subAccounts?.find(subAcc => {
+        const currency = getAccountCurrency(subAcc);
+        return token === currency.ticker || token === currency.id;
+      });
+
+      if (subAccount === undefined) {
+        throw new Error(
+          "token account '" +
+            opts.token +
+            "' not found. Available: " +
+            mainAccount.subAccounts?.map(subAcc => getAccountCurrency(subAcc).ticker).join(", "),
+        );
+      }
+      return [subAccount];
+    }
+    case "optIn":
+    case "stake.createAccount":
+    case "stake.delegate":
+    case "stake.undelegate":
+    case "stake.withdraw":
+    case "stake.split":
+      // TODO: infer stake account for stake ops
+      return [mainAccount];
+    default:
+      return assertUnreachable(mode);
+  }
+}
+
+function inferMode(input?: string): Mode {
+  const mode: Mode | undefined = input
+    ? modes.some(m => m === input)
+      ? (input as Mode)
+      : undefined
+    : "send";
+
+  if (mode === undefined) {
+    throw new Error(`Unexpected mode <${mode}>. Supported modes: ${modes.join(", ")}`);
+  }
+
+  return mode;
+}
+export default function makeCliTools() {
+  return {
+    options,
+    inferAccounts,
+    inferTransactions,
+  };
+}

package/src/datasets/solana.scanAccounts.1.ts

@@ -0,0 +1,9 @@
+export default {
+  name: "solana seed 1",
+  apdus: `
+      => e005000009028000002c800001f5
+      <= 8bc4d3e507c0550e3d02ffb5f6daf0772240af8a09e32d236615b4a2272437029000
+      => e00500000d038000002c800001f580000000
+      <= 56e75dba184e4a77652a1c79a329ffbc562c6bafc33036220c08c0d02ff047739000
+    `,
+};

package/src/deviceTransactionConfig.ts

@@ -0,0 +1,302 @@
+import BigNumber from "bignumber.js";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+import type { Account, AccountLike } from "@ledgerhq/types-live";
+import type {
+  CommandDescriptor,
+  StakeCreateAccountCommand,
+  StakeDelegateCommand,
+  StakeSplitCommand,
+  StakeUndelegateCommand,
+  StakeWithdrawCommand,
+  TokenCreateATACommand,
+  TokenTransferCommand,
+  Transaction,
+  TransferCommand,
+} from "./types";
+import { assertUnreachable } from "./utils";
+
+// do not show fields like 'To', 'Recipient', etc., as per Ledger policy
+
+function getDeviceTransactionConfig({
+  account,
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+}): Array<DeviceTransactionField> {
+  const { commandDescriptor } = transaction.model;
+  if (commandDescriptor === undefined) {
+    throw new Error("missing command descriptor");
+  }
+  if (Object.keys(commandDescriptor.errors).length > 0) {
+    throw new Error("unexpected invalid command");
+  }
+
+  return fieldsForCommand(commandDescriptor, account);
+}
+
+export default getDeviceTransactionConfig;
+
+function fieldsForCommand(
+  commandDescriptor: CommandDescriptor,
+  account: AccountLike,
+): DeviceTransactionField[] {
+  const { command } = commandDescriptor;
+  switch (command.kind) {
+    case "transfer":
+      return fieldsForTransfer(command);
+    case "token.transfer":
+      return fieldsForTokenTransfer(command);
+    case "token.createATA":
+      return fieldsForCreateATA(command);
+    case "stake.createAccount":
+      return fieldsForStakeCreateAccount(command, account);
+    case "stake.delegate":
+      return fieldsForStakeDelegate(command);
+    case "stake.undelegate":
+      return fieldsForStakeUndelegate(command);
+    case "stake.withdraw":
+      return fieldsForStakeWithdraw(command);
+    case "stake.split":
+      return fieldsForStakeSplit(command);
+    default:
+      return assertUnreachable(command);
+  }
+}
+
+function fieldsForTransfer(_command: TransferCommand): DeviceTransactionField[] {
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "amount",
+    label: "Transfer",
+  });
+
+  return fields;
+}
+function fieldsForTokenTransfer(command: TokenTransferCommand): DeviceTransactionField[] {
+  const fields: Array<DeviceTransactionField> = [];
+
+  if (command.recipientDescriptor.shouldCreateAsAssociatedTokenAccount) {
+    fields.push({
+      type: "address",
+      label: "Create token acct",
+      address: command.recipientDescriptor.tokenAccAddress,
+    });
+
+    fields.push({
+      type: "address",
+      label: "From mint",
+      address: command.mintAddress,
+    });
+    fields.push({
+      type: "address",
+      label: "Funded by",
+      address: command.ownerAddress,
+    });
+  }
+
+  fields.push({
+    type: "amount",
+    label: "Transfer tokens",
+  });
+
+  fields.push({
+    type: "address",
+    address: command.ownerAssociatedTokenAccountAddress,
+    label: "From",
+  });
+
+  fields.push({
+    type: "address",
+    address: command.ownerAddress,
+    label: "Owner",
+  });
+
+  fields.push({
+    type: "address",
+    address: command.ownerAddress,
+    label: "Fee payer",
+  });
+
+  return fields;
+}
+
+function fieldsForCreateATA(command: TokenCreateATACommand): DeviceTransactionField[] {
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "address",
+    label: "Create token acct",
+    address: command.associatedTokenAccountAddress,
+  });
+
+  fields.push({
+    type: "address",
+    label: "From mint",
+    address: command.mint,
+  });
+
+  fields.push({
+    type: "address",
+    label: "Owned by",
+    address: command.owner,
+  });
+
+  fields.push({
+    type: "address",
+    label: "Funded by",
+    address: command.owner,
+  });
+
+  fields.push({
+    type: "address",
+    label: "Fee payer",
+    address: command.owner,
+  });
+
+  return fields;
+}
+function fieldsForStakeCreateAccount(
+  command: StakeCreateAccountCommand,
+  account: AccountLike,
+): DeviceTransactionField[] {
+  if (account.type !== "Account") {
+    throw new Error("unsupported account type");
+  }
+
+  const unit = account.currency.units[0];
+
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "address",
+    label: "Delegate from",
+    address: command.stakeAccAddress,
+  });
+
+  // not using 'amount' field here because the field should
+  // show sum of amount and rent exempt amount
+  fields.push({
+    type: "text",
+    label: "Deposit",
+    value: formatCurrencyUnit(
+      unit,
+      new BigNumber(command.amount + command.stakeAccRentExemptAmount),
+      {
+        disableRounding: true,
+        showCode: true,
+      },
+    ),
+  });
+
+  fields.push({
+    type: "address",
+    label: "New authority",
+    address: command.fromAccAddress,
+  });
+
+  fields.push({
+    type: "address",
+    label: "Vote account",
+    address: command.delegate.voteAccAddress,
+  });
+
+  return fields;
+}
+
+function fieldsForStakeDelegate(command: StakeDelegateCommand): DeviceTransactionField[] {
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "address",
+    label: "Delegate from",
+    address: command.stakeAccAddr,
+  });
+
+  fields.push({
+    type: "address",
+    label: "Vote account",
+    address: command.voteAccAddr,
+  });
+
+  return fields;
+}
+
+function fieldsForStakeUndelegate(command: StakeUndelegateCommand): DeviceTransactionField[] {
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "address",
+    label: "Deactivate stake",
+    address: command.stakeAccAddr,
+  });
+
+  return fields;
+}
+
+function fieldsForStakeWithdraw(command: StakeWithdrawCommand): DeviceTransactionField[] {
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "amount",
+    label: "Stake withdraw",
+  });
+
+  fields.push({
+    type: "address",
+    label: "From",
+    address: command.stakeAccAddr,
+  });
+
+  return fields;
+}
+
+function fieldsForStakeSplit(command: StakeSplitCommand): DeviceTransactionField[] {
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "amount",
+    label: "Split stake",
+  });
+
+  fields.push({
+    type: "address",
+    label: "From",
+    address: command.stakeAccAddr,
+  });
+
+  fields.push({
+    type: "address",
+    label: "To",
+    address: command.splitStakeAccAddr,
+  });
+
+  fields.push({
+    type: "address",
+    label: "Base",
+    address: command.authorizedAccAddr,
+  });
+
+  fields.push({
+    type: "text",
+    label: "Seed",
+    value: command.seed,
+  });
+
+  fields.push({
+    type: "address",
+    label: "Authorized by",
+    address: command.authorizedAccAddr,
+  });
+
+  fields.push({
+    type: "address",
+    label: "Fee payer",
+    address: command.authorizedAccAddr,
+  });
+
+  return fields;
+}

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/hw-getAddress.ts

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

package/src/js-broadcast.ts

@@ -0,0 +1,38 @@
+import { log } from "@ledgerhq/logs";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import type { Account, Operation, SignedOperation } from "@ledgerhq/types-live";
+import { ChainAPI } from "./api";
+import { SolanaTxConfirmationTimeout, SolanaTxSimulationFailedWhilePendingOp } from "./errors";
+
+export const broadcastWithAPI = async (
+  {
+    account,
+    signedOperation,
+  }: {
+    account: Account;
+    signedOperation: SignedOperation;
+  },
+  api: ChainAPI,
+): Promise<Operation> => {
+  const { signature, operation } = signedOperation;
+
+  try {
+    const txSignature = await api.sendRawTransaction(Buffer.from(signature, "hex"));
+    return patchOperationWithHash(operation, txSignature);
+  } catch (e: any) {
+    // heuristics to make some errors more user friendly
+    if (e instanceof Error) {
+      log("broadcast-error", e.message);
+
+      if (e.message.includes("simulation failed") && account.pendingOperations.length > 0) {
+        throw new SolanaTxSimulationFailedWhilePendingOp();
+      }
+
+      if (e.message.includes("was not confirmed in")) {
+        throw new SolanaTxConfirmationTimeout();
+      }
+    }
+
+    throw e;
+  }
+};