@ledgerhq/live-common 21.20.0 → 21.21.0-rc.2

package/src/families/solana/api/chain/account/token.ts

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/no-redeclare */
+
+import {
+  Infer,
+  number,
+  optional,
+  enums,
+  any,
+  boolean,
+  string,
+  array,
+  type,
+  nullable,
+} from "superstruct";
+import { PublicKeyFromString } from "../validators/pubkey";
+
+export type TokenAccountType = Infer<typeof TokenAccountType>;
+export const TokenAccountType = enums(["mint", "account", "multisig"]);
+
+export type TokenAccountState = Infer<typeof AccountState>;
+const AccountState = enums(["initialized", "uninitialized", "frozen"]);
+
+const TokenAmount = type({
+  decimals: number(),
+  uiAmountString: string(),
+  amount: string(),
+});
+
+export type TokenAccountInfo = Infer<typeof TokenAccountInfo>;
+export const TokenAccountInfo = type({
+  mint: PublicKeyFromString,
+  owner: PublicKeyFromString,
+  tokenAmount: TokenAmount,
+  delegate: optional(PublicKeyFromString),
+  state: AccountState,
+  isNative: boolean(),
+  rentExemptReserve: optional(TokenAmount),
+  delegatedAmount: optional(TokenAmount),
+  closeAuthority: optional(PublicKeyFromString),
+});
+
+export type MintAccountInfo = Infer<typeof MintAccountInfo>;
+export const MintAccountInfo = type({
+  mintAuthority: nullable(PublicKeyFromString),
+  supply: string(),
+  decimals: number(),
+  isInitialized: boolean(),
+  freezeAuthority: nullable(PublicKeyFromString),
+});
+
+export type MultisigAccountInfo = Infer<typeof MultisigAccountInfo>;
+export const MultisigAccountInfo = type({
+  numRequiredSigners: number(),
+  numValidSigners: number(),
+  isInitialized: boolean(),
+  signers: array(PublicKeyFromString),
+});
+
+export type TokenAccount = Infer<typeof TokenAccount>;
+export const TokenAccount = type({
+  type: TokenAccountType,
+  info: any(),
+});

package/src/families/solana/api/chain/index.ts

@@ -0,0 +1,115 @@
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  Token,
+  TOKEN_PROGRAM_ID,
+} from "@solana/spl-token";
+import {
+  Cluster,
+  clusterApiUrl,
+  Connection,
+  FeeCalculator,
+  PublicKey,
+  SignaturesForAddressOptions,
+} from "@solana/web3.js";
+import { Awaited } from "../../logic";
+
+export type Config = {
+  readonly cluster: Cluster;
+};
+
+export type ChainAPI = Readonly<{
+  getBalance: (address: string) => Promise<number>;
+
+  getRecentBlockhash: () => Promise<string>;
+
+  getTxFeeCalculator: () => Promise<FeeCalculator>;
+
+  getBalanceAndContext: (
+    address: string
+  ) => ReturnType<Connection["getBalanceAndContext"]>;
+
+  getParsedTokenAccountsByOwner: (
+    address: string
+  ) => ReturnType<Connection["getParsedTokenAccountsByOwner"]>;
+
+  getSignaturesForAddress: (
+    address: string,
+    opts?: SignaturesForAddressOptions
+  ) => ReturnType<Connection["getSignaturesForAddress"]>;
+
+  getParsedConfirmedTransactions: (
+    signatures: string[]
+  ) => ReturnType<Connection["getParsedConfirmedTransactions"]>;
+
+  getAccountInfo: (
+    address: string
+  ) => Promise<
+    Awaited<ReturnType<Connection["getParsedAccountInfo"]>>["value"]
+  >;
+
+  sendRawTransaction: (
+    buffer: Buffer
+  ) => ReturnType<Connection["sendRawTransaction"]>;
+
+  findAssocTokenAccAddress: (owner: string, mint: string) => Promise<string>;
+
+  getAssocTokenAccMinNativeBalance: () => Promise<number>;
+
+  config: Config;
+}>;
+
+export function getChainAPI(config: Config): ChainAPI {
+  const connection = () =>
+    new Connection(clusterApiUrl(config.cluster), "finalized");
+
+  return {
+    getBalance: (address: string) =>
+      connection().getBalance(new PublicKey(address)),
+
+    getRecentBlockhash: () =>
+      connection()
+        .getRecentBlockhash()
+        .then((r) => r.blockhash),
+
+    getTxFeeCalculator: () =>
+      connection()
+        .getRecentBlockhash()
+        .then((r) => r.feeCalculator),
+
+    getBalanceAndContext: (address: string) =>
+      connection().getBalanceAndContext(new PublicKey(address)),
+
+    getParsedTokenAccountsByOwner: (address: string) =>
+      connection().getParsedTokenAccountsByOwner(new PublicKey(address), {
+        programId: TOKEN_PROGRAM_ID,
+      }),
+    getSignaturesForAddress: (
+      address: string,
+      opts?: SignaturesForAddressOptions
+    ) => connection().getSignaturesForAddress(new PublicKey(address), opts),
+
+    getParsedConfirmedTransactions: (signatures: string[]) =>
+      connection().getParsedConfirmedTransactions(signatures),
+
+    getAccountInfo: (address: string) =>
+      connection()
+        .getParsedAccountInfo(new PublicKey(address))
+        .then((r) => r.value),
+
+    sendRawTransaction: (buffer: Buffer) =>
+      connection().sendRawTransaction(buffer),
+
+    findAssocTokenAccAddress: (owner: string, mint: string) =>
+      Token.getAssociatedTokenAddress(
+        ASSOCIATED_TOKEN_PROGRAM_ID,
+        TOKEN_PROGRAM_ID,
+        new PublicKey(mint),
+        new PublicKey(owner)
+      ).then((r) => r.toBase58()),
+
+    getAssocTokenAccMinNativeBalance: () =>
+      Token.getMinBalanceRentForExemptAccount(connection()),
+
+    config,
+  };
+}

package/src/families/solana/api/chain/instruction/associated-token-account/index.ts

@@ -0,0 +1,37 @@
+import { ParsedInfo } from "../../validators";
+import { create, Infer } from "superstruct";
+import { ParsedInstruction } from "@solana/web3.js";
+import {
+  AssociatedTokenAccountInstructionType,
+  IX_STRUCTS,
+  IX_TITLES,
+} from "./types";
+
+import { PARSED_PROGRAMS } from "../../program/constants";
+
+export function parseAssociatedTokenAccountInstruction(
+  ix: ParsedInstruction & {
+    program: typeof PARSED_PROGRAMS.SPL_ASSOCIATED_TOKEN_ACCOUNT;
+  }
+): AssociatedTokenAccountInstructionDescriptor {
+  // TODO: check this
+  const parsed = create(ix.parsed, ParsedInfo);
+  //const { type: rawType, info } = parsed;
+  const type: AssociatedTokenAccountInstructionType = "associate";
+  const title = IX_TITLES[type];
+  const struct = IX_STRUCTS[type];
+
+  return {
+    type: "associate",
+    title: title,
+    info: create(parsed.info, struct as any) as any,
+  };
+}
+
+export type AssociatedTokenAccountInstructionDescriptor = {
+  [K in AssociatedTokenAccountInstructionType]: {
+    title: typeof IX_TITLES[K];
+    type: K;
+    info: Infer<typeof IX_STRUCTS[K]>;
+  };
+}[AssociatedTokenAccountInstructionType];

package/src/families/solana/api/chain/instruction/associated-token-account/types.ts

@@ -0,0 +1,23 @@
+import { enums, type, Infer } from "superstruct";
+import { PublicKeyFromString } from "../../validators/pubkey";
+
+type AssociateInfo = Infer<typeof AssociateInfo>;
+export const AssociateInfo = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  wallet: PublicKeyFromString,
+});
+
+export type AssociatedTokenAccountInstructionType = Infer<
+  typeof AssociatedTokenAccountInstructionType
+>;
+// not a real instruction type, added for structure
+export const AssociatedTokenAccountInstructionType = enums(["associate"]);
+
+export const IX_STRUCTS = {
+  associate: AssociateInfo,
+} as const;
+
+export const IX_TITLES = {
+  associate: "Associate",
+} as const;

package/src/families/solana/api/chain/instruction/memo/index.ts

@@ -0,0 +1,24 @@
+import { ParsedInstruction } from "@solana/web3.js";
+import { IX_STRUCTS, IX_TITLES, MemoInstructionType } from "./types";
+import { Infer } from "superstruct";
+import { PARSED_PROGRAMS } from "../../program/constants";
+
+export function parseSplMemoInstruction(
+  ix: ParsedInstruction & { program: typeof PARSED_PROGRAMS.SPL_MEMO }
+): MemoInstructionDescriptor {
+  return {
+    title: "Save",
+    type: "save",
+    info: {
+      data: ix.parsed,
+    },
+  };
+}
+
+export type MemoInstructionDescriptor = {
+  [K in MemoInstructionType]: {
+    title: typeof IX_TITLES[K];
+    type: K;
+    info: Infer<typeof IX_STRUCTS[K]>;
+  };
+}[MemoInstructionType];

package/src/families/solana/api/chain/instruction/memo/types.ts

@@ -0,0 +1,18 @@
+import { enums, type, string, Infer } from "superstruct";
+
+type SaveInfo = Infer<typeof SaveInfo>;
+export const SaveInfo = type({
+  data: string(),
+});
+
+export type MemoInstructionType = Infer<typeof MemoInstructionType>;
+// not a real instruction type, added for structure
+export const MemoInstructionType = enums(["save"]);
+
+export const IX_STRUCTS = {
+  save: SaveInfo,
+} as const;
+
+export const IX_TITLES = {
+  save: "Save",
+} as const;

package/src/families/solana/api/chain/instruction/stake/index.ts

@@ -0,0 +1,29 @@
+import { ParsedInfo } from "../../validators";
+import { create, Infer } from "superstruct";
+import { ParsedInstruction } from "@solana/web3.js";
+import { StakeInstructionType, IX_STRUCTS, IX_TITLES } from "./types";
+import { PARSED_PROGRAMS } from "../../program/constants";
+
+export function parseStakeInstruction(
+  ix: ParsedInstruction & { program: typeof PARSED_PROGRAMS.STAKE }
+): StakeInstructionDescriptor {
+  const parsed = create(ix.parsed, ParsedInfo);
+  const { type: rawType, info } = parsed;
+  const type = create(rawType, StakeInstructionType);
+  const title = IX_TITLES[type];
+  const struct = IX_STRUCTS[type];
+
+  return {
+    type,
+    title: title as any,
+    info: create(info, struct as any) as any,
+  };
+}
+
+export type StakeInstructionDescriptor = {
+  [K in StakeInstructionType]: {
+    title: typeof IX_TITLES[K];
+    type: K;
+    info: Infer<typeof IX_STRUCTS[K]>;
+  };
+}[StakeInstructionType];

package/src/families/solana/api/chain/instruction/stake/types.ts

@@ -0,0 +1,95 @@
+/* eslint-disable @typescript-eslint/no-redeclare */
+
+import { enums, number, type, string, Infer } from "superstruct";
+import { PublicKeyFromString } from "../../validators/pubkey";
+
+export type InitializeInfo = Infer<typeof InitializeInfo>;
+export const InitializeInfo = type({
+  stakeAccount: PublicKeyFromString,
+  authorized: type({
+    staker: PublicKeyFromString,
+    withdrawer: PublicKeyFromString,
+  }),
+  lockup: type({
+    unixTimestamp: number(),
+    epoch: number(),
+    custodian: PublicKeyFromString,
+  }),
+});
+
+export type DelegateInfo = Infer<typeof DelegateInfo>;
+export const DelegateInfo = type({
+  stakeAccount: PublicKeyFromString,
+  voteAccount: PublicKeyFromString,
+  stakeAuthority: PublicKeyFromString,
+});
+
+export type AuthorizeInfo = Infer<typeof AuthorizeInfo>;
+export const AuthorizeInfo = type({
+  authorityType: string(),
+  stakeAccount: PublicKeyFromString,
+  authority: PublicKeyFromString,
+  newAuthority: PublicKeyFromString,
+});
+
+export type SplitInfo = Infer<typeof SplitInfo>;
+export const SplitInfo = type({
+  stakeAccount: PublicKeyFromString,
+  stakeAuthority: PublicKeyFromString,
+  newSplitAccount: PublicKeyFromString,
+  lamports: number(),
+});
+
+export type WithdrawInfo = Infer<typeof WithdrawInfo>;
+export const WithdrawInfo = type({
+  stakeAccount: PublicKeyFromString,
+  withdrawAuthority: PublicKeyFromString,
+  destination: PublicKeyFromString,
+  lamports: number(),
+});
+
+export type DeactivateInfo = Infer<typeof DeactivateInfo>;
+export const DeactivateInfo = type({
+  stakeAccount: PublicKeyFromString,
+  stakeAuthority: PublicKeyFromString,
+});
+
+export type MergeInfo = Infer<typeof MergeInfo>;
+export const MergeInfo = type({
+  source: PublicKeyFromString,
+  destination: PublicKeyFromString,
+  stakeAuthority: PublicKeyFromString,
+  stakeHistorySysvar: PublicKeyFromString,
+  clockSysvar: PublicKeyFromString,
+});
+
+export type StakeInstructionType = Infer<typeof StakeInstructionType>;
+export const StakeInstructionType = enums([
+  "initialize",
+  "delegate",
+  "authorize",
+  "split",
+  "withdraw",
+  "deactivate",
+  "merge",
+]);
+
+export const IX_STRUCTS = {
+  initialize: InitializeInfo,
+  delegate: DelegateInfo,
+  authorize: AuthorizeInfo,
+  split: SplitInfo,
+  withdraw: WithdrawInfo,
+  deactivate: DeactivateInfo,
+  merge: MergeInfo,
+} as const;
+
+export const IX_TITLES = {
+  initialize: "Initialize",
+  delegate: "Delegate",
+  authorize: "Authorize",
+  split: "Split",
+  withdraw: "Withdraw",
+  deactivate: "Deactive",
+  merge: "Merge",
+} as const;

package/src/families/solana/api/chain/instruction/token/index.ts

@@ -0,0 +1,30 @@
+import { ParsedInstruction } from "@solana/web3.js";
+import { IX_STRUCTS, IX_TITLES, TokenInstructionType } from "./types";
+
+import { ParsedInfo } from "../../validators";
+import { create, Infer } from "superstruct";
+import { PARSED_PROGRAMS } from "../../program/constants";
+
+export function parseSplTokenInstruction(
+  ix: ParsedInstruction & { program: typeof PARSED_PROGRAMS.SPL_TOKEN }
+): TokenInstructionDescriptor {
+  const parsed = create(ix.parsed, ParsedInfo);
+  const { type: rawType, info } = parsed;
+  const type = create(rawType, TokenInstructionType);
+  const title = IX_TITLES[type];
+  const struct = IX_STRUCTS[type];
+
+  return {
+    type,
+    title: title as any,
+    info: create(info, struct as any) as any,
+  };
+}
+
+export type TokenInstructionDescriptor = {
+  [K in TokenInstructionType]: {
+    title: typeof IX_TITLES[K];
+    type: K;
+    info: Infer<typeof IX_STRUCTS[K]>;
+  };
+}[TokenInstructionType];

package/src/families/solana/api/chain/instruction/token/types.ts

@@ -0,0 +1,237 @@
+/* eslint-disable @typescript-eslint/no-redeclare */
+
+import {
+  enums,
+  type,
+  Infer,
+  number,
+  string,
+  optional,
+  array,
+  nullable,
+  union,
+} from "superstruct";
+import { PublicKeyFromString } from "../../validators/pubkey";
+
+export type TokenAmountUi = Infer<typeof TokenAmountUi>;
+export const TokenAmountUi = type({
+  amount: string(),
+  decimals: number(),
+  uiAmountString: string(),
+});
+
+const InitializeMint = type({
+  mint: PublicKeyFromString,
+  decimals: number(),
+  mintAuthority: PublicKeyFromString,
+  rentSysvar: PublicKeyFromString,
+  freezeAuthority: optional(PublicKeyFromString),
+});
+
+const InitializeAccount = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  owner: PublicKeyFromString,
+  rentSysvar: PublicKeyFromString,
+});
+
+const InitializeMultisig = type({
+  multisig: PublicKeyFromString,
+  rentSysvar: PublicKeyFromString,
+  signers: array(PublicKeyFromString),
+  m: number(),
+});
+
+export type Transfer = Infer<typeof Transfer>;
+export const Transfer = type({
+  source: PublicKeyFromString,
+  destination: PublicKeyFromString,
+  amount: union([string(), number()]),
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const Approve = type({
+  source: PublicKeyFromString,
+  delegate: PublicKeyFromString,
+  amount: union([string(), number()]),
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const Revoke = type({
+  source: PublicKeyFromString,
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const AuthorityType = enums([
+  "mintTokens",
+  "freezeAccount",
+  "accountOwner",
+  "closeAccount",
+]);
+
+const SetAuthority = type({
+  mint: optional(PublicKeyFromString),
+  account: optional(PublicKeyFromString),
+  authorityType: AuthorityType,
+  newAuthority: nullable(PublicKeyFromString),
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const MintTo = type({
+  mint: PublicKeyFromString,
+  account: PublicKeyFromString,
+  amount: union([string(), number()]),
+  mintAuthority: optional(PublicKeyFromString),
+  multisigMintAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const Burn = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  amount: union([string(), number()]),
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const CloseAccount = type({
+  account: PublicKeyFromString,
+  destination: PublicKeyFromString,
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const FreezeAccount = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  freezeAuthority: optional(PublicKeyFromString),
+  multisigFreezeAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const ThawAccount = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  freezeAuthority: optional(PublicKeyFromString),
+  multisigFreezeAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+export type TransferChecked = Infer<typeof TransferChecked>;
+export const TransferChecked = type({
+  source: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  destination: PublicKeyFromString,
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  tokenAmount: TokenAmountUi,
+});
+
+const ApproveChecked = type({
+  source: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  delegate: PublicKeyFromString,
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  tokenAmount: TokenAmountUi,
+});
+
+const MintToChecked = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  mintAuthority: optional(PublicKeyFromString),
+  multisigMintAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  tokenAmount: TokenAmountUi,
+});
+
+const BurnChecked = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  tokenAmount: TokenAmountUi,
+});
+
+export type TokenInstructionType = Infer<typeof TokenInstructionType>;
+export const TokenInstructionType = enums([
+  "initializeMint",
+  "initializeAccount",
+  "initializeMultisig",
+  "transfer",
+  "approve",
+  "revoke",
+  "setAuthority",
+  "mintTo",
+  "burn",
+  "closeAccount",
+  "freezeAccount",
+  "thawAccount",
+  "transfer2",
+  "approve2",
+  "mintTo2",
+  "burn2",
+  "transferChecked",
+  "approveChecked",
+  "mintToChecked",
+  "burnChecked",
+]);
+
+export const IX_STRUCTS = {
+  initializeMint: InitializeMint,
+  initializeAccount: InitializeAccount,
+  initializeMultisig: InitializeMultisig,
+  transfer: Transfer,
+  approve: Approve,
+  revoke: Revoke,
+  setAuthority: SetAuthority,
+  mintTo: MintTo,
+  burn: Burn,
+  closeAccount: CloseAccount,
+  freezeAccount: FreezeAccount,
+  thawAccount: ThawAccount,
+  transfer2: TransferChecked,
+  approve2: ApproveChecked,
+  mintTo2: MintToChecked,
+  burn2: BurnChecked,
+  transferChecked: TransferChecked,
+  approveChecked: ApproveChecked,
+  mintToChecked: MintToChecked,
+  burnChecked: BurnChecked,
+};
+
+export const IX_TITLES = {
+  initializeMint: "Initialize Mint",
+  initializeAccount: "Initialize Account",
+  initializeMultisig: "Initialize Multisig",
+  transfer: "Transfer",
+  approve: "Approve",
+  revoke: "Revoke",
+  setAuthority: "Set Authority",
+  mintTo: "Mint To",
+  burn: "Burn",
+  closeAccount: "Close Account",
+  freezeAccount: "Freeze Account",
+  thawAccount: "Thaw Account",
+  transfer2: "Transfer (Checked)",
+  approve2: "Approve (Checked)",
+  mintTo2: "Mint To (Checked)",
+  burn2: "Burn (Checked)",
+  transferChecked: "Transfer (Checked)",
+  approveChecked: "Approve (Checked)",
+  mintToChecked: "Mint To (Checked)",
+  burnChecked: "Burn (Checked)",
+};

package/src/families/solana/api/chain/program/constants.ts

@@ -0,0 +1,10 @@
+export const PARSED_PROGRAMS = {
+  SPL_ASSOCIATED_TOKEN_ACCOUNT: "spl-associated-token-account",
+  BPF_LOADER: "bpf-loader",
+  BPF_UPGRADEABLE_LOADER: "bpf-upgradeable-loader",
+  SPL_MEMO: "spl-memo",
+  STAKE: "stake",
+  SYSTEM: "system",
+  SPL_TOKEN: "spl-token",
+  VOTE: "vote",
+} as const;

package/src/families/solana/api/chain/program/index.ts

@@ -0,0 +1 @@
+export { parse, parseQuiet } from "./parser";