@ledgerhq/coin-solana 0.7.0-next.0

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

@@ -0,0 +1,33 @@
+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/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/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/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/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/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/api/chain/instruction/system/index.ts

@@ -0,0 +1,30 @@
+import { ParsedInstruction } from "@solana/web3.js";
+import { IX_STRUCTS, IX_TITLES, SystemInstructionType } from "./types";
+
+import { ParsedInfo } from "../../validators";
+import { create, Infer } from "superstruct";
+import { PARSED_PROGRAMS } from "../../program/constants";
+
+export function parseSystemInstruction(
+  ix: ParsedInstruction & { program: typeof PARSED_PROGRAMS.SYSTEM },
+): SystemInstructionDescriptor {
+  const parsed = create(ix.parsed, ParsedInfo);
+  const { type: rawType, info } = parsed;
+  const type = create(rawType, SystemInstructionType);
+  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 SystemInstructionDescriptor = {
+  [K in SystemInstructionType]: {
+    title: (typeof IX_TITLES)[K];
+    type: K;
+    info: Infer<(typeof IX_STRUCTS)[K]>;
+  };
+}[SystemInstructionType];

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

@@ -0,0 +1,141 @@
+import { enums, number, type, string, Infer } from "superstruct";
+import { PublicKeyFromString } from "../../validators/pubkey";
+
+export type CreateAccountInfo = Infer<typeof CreateAccountInfo>;
+export const CreateAccountInfo = type({
+  source: PublicKeyFromString,
+  newAccount: PublicKeyFromString,
+  lamports: number(),
+  space: number(),
+  owner: PublicKeyFromString,
+});
+
+export type AssignInfo = Infer<typeof AssignInfo>;
+export const AssignInfo = type({
+  account: PublicKeyFromString,
+  owner: PublicKeyFromString,
+});
+
+export type TransferInfo = Infer<typeof TransferInfo>;
+export const TransferInfo = type({
+  source: PublicKeyFromString,
+  destination: PublicKeyFromString,
+  lamports: number(),
+});
+
+export type CreateAccountWithSeedInfo = Infer<typeof CreateAccountWithSeedInfo>;
+export const CreateAccountWithSeedInfo = type({
+  source: PublicKeyFromString,
+  newAccount: PublicKeyFromString,
+  base: PublicKeyFromString,
+  seed: string(),
+  lamports: number(),
+  space: number(),
+  owner: PublicKeyFromString,
+});
+
+export type AdvanceNonceInfo = Infer<typeof AdvanceNonceInfo>;
+export const AdvanceNonceInfo = type({
+  nonceAccount: PublicKeyFromString,
+  nonceAuthority: PublicKeyFromString,
+});
+
+export type WithdrawNonceInfo = Infer<typeof WithdrawNonceInfo>;
+export const WithdrawNonceInfo = type({
+  nonceAccount: PublicKeyFromString,
+  destination: PublicKeyFromString,
+  nonceAuthority: PublicKeyFromString,
+  lamports: number(),
+});
+
+export type InitializeNonceInfo = Infer<typeof InitializeNonceInfo>;
+export const InitializeNonceInfo = type({
+  nonceAccount: PublicKeyFromString,
+  nonceAuthority: PublicKeyFromString,
+});
+
+export type AuthorizeNonceInfo = Infer<typeof AuthorizeNonceInfo>;
+export const AuthorizeNonceInfo = type({
+  nonceAccount: PublicKeyFromString,
+  nonceAuthority: PublicKeyFromString,
+  newAuthorized: PublicKeyFromString,
+});
+
+export type AllocateInfo = Infer<typeof AllocateInfo>;
+export const AllocateInfo = type({
+  account: PublicKeyFromString,
+  space: number(),
+});
+
+export type AllocateWithSeedInfo = Infer<typeof AllocateWithSeedInfo>;
+export const AllocateWithSeedInfo = type({
+  account: PublicKeyFromString,
+  base: PublicKeyFromString,
+  seed: string(),
+  space: number(),
+  owner: PublicKeyFromString,
+});
+
+export type AssignWithSeedInfo = Infer<typeof AssignWithSeedInfo>;
+export const AssignWithSeedInfo = type({
+  account: PublicKeyFromString,
+  base: PublicKeyFromString,
+  seed: string(),
+  owner: PublicKeyFromString,
+});
+
+export type TransferWithSeedInfo = Infer<typeof TransferWithSeedInfo>;
+export const TransferWithSeedInfo = type({
+  source: PublicKeyFromString,
+  sourceBase: PublicKeyFromString,
+  destination: PublicKeyFromString,
+  lamports: number(),
+  sourceSeed: string(),
+  sourceOwner: PublicKeyFromString,
+});
+
+export type SystemInstructionType = Infer<typeof SystemInstructionType>;
+export const SystemInstructionType = enums([
+  "createAccount",
+  "createAccountWithSeed",
+  "allocate",
+  "allocateWithSeed",
+  "assign",
+  "assignWithSeed",
+  "transfer",
+  "advanceNonce",
+  "withdrawNonce",
+  "authorizeNonce",
+  "initializeNonce",
+  "transferWithSeed",
+]);
+
+export const IX_STRUCTS = {
+  createAccount: CreateAccountInfo,
+  createAccountWithSeed: CreateAccountWithSeedInfo,
+  allocate: AllocateInfo,
+  allocateWithSeed: AllocateWithSeedInfo,
+  assign: AssignInfo,
+  assignWithSeed: AssignWithSeedInfo,
+  transfer: TransferInfo,
+  advanceNonce: AdvanceNonceInfo,
+  withdrawNonce: WithdrawNonceInfo,
+  authorizeNonce: AuthorizeNonceInfo,
+  initializeNonce: InitializeNonceInfo,
+  transferWithSeed: TransferWithSeedInfo,
+};
+
+export const IX_TITLES = {
+  createAccount: "Create Account",
+  createAccountWithSeed: "Create Account With Seed",
+  allocate: "Allocate",
+  allocateWithSeed: "Allocate With Seed",
+  assign: "Assign",
+  assignWithSeed: "Assign With Seed",
+  transfer: "Transfer",
+  advanceNonce: "Advance Nonce",
+  withdrawNonce: "Withdraw Nonce",
+  authorizeNonce: "Authorize Nonce",
+  initializeNonce: "Initialize Nonce",
+  transferWithSeed: "Transfer With Seed",
+};

package/src/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/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";