@ledgerhq/coin-solana 0.7.0-nightly.0

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

@@ -0,0 +1,222 @@
+/* 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/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/api/chain/program/index.ts

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

package/src/api/chain/program/parser.ts

@@ -0,0 +1,120 @@
+import { ParsedInstruction, PartiallyDecodedInstruction } from "@solana/web3.js";
+import { parseSplTokenInstruction, TokenInstructionDescriptor } from "../instruction/token";
+import { PARSED_PROGRAMS } from "./constants";
+import {
+  AssociatedTokenAccountInstructionDescriptor,
+  parseAssociatedTokenAccountInstruction,
+} from "../instruction/associated-token-account";
+import { MemoInstructionDescriptor, parseSplMemoInstruction } from "../instruction/memo";
+import { parseStakeInstruction, StakeInstructionDescriptor } from "../instruction/stake";
+import { parseSystemInstruction, SystemInstructionDescriptor } from "../instruction/system";
+
+type ParsedProgram =
+  | {
+      program: "system";
+      title: string;
+      instruction: SystemInstructionDescriptor;
+    }
+  | {
+      program: "spl-associated-token-account";
+      title: string;
+      instruction: AssociatedTokenAccountInstructionDescriptor;
+    }
+  | {
+      program: "spl-memo";
+      title: string;
+      instruction: MemoInstructionDescriptor;
+    }
+  | {
+      program: "stake";
+      title: string;
+      instruction: StakeInstructionDescriptor;
+    }
+  | {
+      program: "spl-token";
+      title: string;
+      instruction: TokenInstructionDescriptor;
+    }
+  | {
+      program: "unknown";
+      title: "Unknown";
+      instruction: undefined;
+    };
+
+export const parse = (ix: ParsedInstruction | PartiallyDecodedInstruction): ParsedProgram => {
+  if ("parsed" in ix) {
+    const program: (typeof PARSED_PROGRAMS)[keyof typeof PARSED_PROGRAMS] = ix.program as any;
+
+    switch (program) {
+      case "system":
+        return {
+          program,
+          title: "System",
+          instruction: parseSystemInstruction({
+            ...ix,
+            program,
+          }),
+        };
+      case "spl-associated-token-account":
+        return {
+          program,
+          title: "Associated Token Account",
+          instruction: parseAssociatedTokenAccountInstruction({
+            ...ix,
+            program,
+          }),
+        };
+      case "spl-memo":
+        return {
+          program,
+          title: "Memo",
+          instruction: parseSplMemoInstruction({
+            ...ix,
+            program,
+          }),
+        };
+      case "stake":
+        return {
+          program,
+          title: "Stake",
+          instruction: parseStakeInstruction({
+            ...ix,
+            program,
+          }),
+        };
+      case "spl-token":
+        return {
+          program,
+          title: "Token",
+          instruction: parseSplTokenInstruction({
+            ...ix,
+            program,
+          }),
+        };
+      default:
+        return unknown();
+    }
+  }
+
+  return unknown();
+};
+
+export const parseQuiet = (ix: ParsedInstruction | PartiallyDecodedInstruction): ParsedProgram => {
+  try {
+    return parse(ix);
+  } catch (_) {
+    return unknown();
+  }
+};
+
+function unknown(): {
+  program: "unknown";
+  title: "Unknown";
+  instruction: undefined;
+} {
+  return {
+    program: "unknown",
+    title: "Unknown",
+    instruction: undefined,
+  } as const;
+}

package/src/api/chain/validators/bignum.ts

@@ -0,0 +1,7 @@
+import { coerce, instance, string } from "superstruct";
+import { BigNumber } from "bignumber.js";
+
+export const BigNumFromString = coerce(instance(BigNumber), string(), value => {
+  if (typeof value === "string") return new BigNumber(value, 10);
+  throw new Error("invalid big num");
+});

package/src/api/chain/validators/index.ts

@@ -0,0 +1,9 @@
+/* eslint-disable @typescript-eslint/no-redeclare */
+
+import { type, any, Infer, string } from "superstruct";
+
+export type ParsedInfo = Infer<typeof ParsedInfo>;
+export const ParsedInfo = type({
+  type: string(),
+  info: any(),
+});

package/src/api/chain/validators/pubkey.ts

@@ -0,0 +1,8 @@
+import { coerce, instance, string } from "superstruct";
+import { PublicKey } from "@solana/web3.js";
+
+export const PublicKeyFromString = coerce(
+  instance(PublicKey),
+  string(),
+  value => new PublicKey(value),
+);