@ledgerhq/live-common 21.36.3 → 22.0.2

package/src/families/solana/__snapshots__/bridge.test.ts.snap

@@ -0,0 +1,116 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`solana currency bridge scanAccounts solana seed 1 1`] = `
+Array [
+  Object {
+    "balance": "83389840",
+    "currencyId": "solana",
+    "derivationMode": "solanaMain",
+    "freshAddress": "AQbkEagmPgmsdAfS4X8V8UyJnXXjVPMvjeD15etqQ3Jh",
+    "freshAddressPath": "44'/501'",
+    "freshAddresses": Array [
+      Object {
+        "address": "AQbkEagmPgmsdAfS4X8V8UyJnXXjVPMvjeD15etqQ3Jh",
+        "derivationPath": "44'/501'",
+      },
+    ],
+    "id": "js:2:solana:AQbkEagmPgmsdAfS4X8V8UyJnXXjVPMvjeD15etqQ3Jh:solanaMain",
+    "index": 0,
+    "name": "Solana 1",
+    "nfts": undefined,
+    "operationsCount": 2,
+    "pendingOperations": Array [],
+    "seedIdentifier": "AQbkEagmPgmsdAfS4X8V8UyJnXXjVPMvjeD15etqQ3Jh",
+    "solanaResources": Object {
+      "stakes": "[]",
+    },
+    "spendableBalance": "83389840",
+    "starred": false,
+    "swapHistory": Array [],
+    "syncHash": undefined,
+    "unitMagnitude": 9,
+    "used": true,
+  },
+  Object {
+    "balance": "0",
+    "currencyId": "solana",
+    "derivationMode": "solanaSub",
+    "freshAddress": "6rEgdtB3sgjKJnRE172YEr9z6qUyr4nFW28vJokuD36A",
+    "freshAddressPath": "44'/501'/0'",
+    "freshAddresses": Array [
+      Object {
+        "address": "6rEgdtB3sgjKJnRE172YEr9z6qUyr4nFW28vJokuD36A",
+        "derivationPath": "44'/501'/0'",
+      },
+    ],
+    "id": "js:2:solana:6rEgdtB3sgjKJnRE172YEr9z6qUyr4nFW28vJokuD36A:solanaSub",
+    "index": 0,
+    "name": "Solana 1",
+    "nfts": undefined,
+    "operationsCount": 0,
+    "pendingOperations": Array [],
+    "seedIdentifier": "AQbkEagmPgmsdAfS4X8V8UyJnXXjVPMvjeD15etqQ3Jh",
+    "solanaResources": Object {
+      "stakes": "[]",
+    },
+    "spendableBalance": "0",
+    "starred": false,
+    "swapHistory": Array [],
+    "syncHash": undefined,
+    "unitMagnitude": 9,
+    "used": false,
+  },
+]
+`;
+
+exports[`solana currency bridge scanAccounts solana seed 1 2`] = `
+Array [
+  Array [
+    Object {
+      "accountId": "js:2:solana:AQbkEagmPgmsdAfS4X8V8UyJnXXjVPMvjeD15etqQ3Jh:solanaMain",
+      "blockHash": "4NSL4VrfWd2eUccMD95dLQsdy5UGz8yhokpfH1et1R2c",
+      "blockHeight": 108520722,
+      "contract": undefined,
+      "extra": Object {},
+      "fee": "0",
+      "hasFailed": false,
+      "hash": "25KWBvKtVgKR3yoRmozTY6wmiW8atwrnzAnTXdsms8jqg5aR8GnCDxdJzWXtzMZPvbsE6SUuBkGFXudy2mrcTYna",
+      "id": "js:2:solana:AQbkEagmPgmsdAfS4X8V8UyJnXXjVPMvjeD15etqQ3Jh:solanaMain-25KWBvKtVgKR3yoRmozTY6wmiW8atwrnzAnTXdsms8jqg5aR8GnCDxdJzWXtzMZPvbsE6SUuBkGFXudy2mrcTYna-IN",
+      "operator": undefined,
+      "recipients": Array [
+        "AQbkEagmPgmsdAfS4X8V8UyJnXXjVPMvjeD15etqQ3Jh",
+      ],
+      "senders": Array [
+        "7CZgkK494jMdoY8xpXY3ViLjpDGMbNikCzMtAT5cAjKk",
+      ],
+      "standard": undefined,
+      "tokenId": undefined,
+      "type": "IN",
+      "value": "93394840",
+    },
+    Object {
+      "accountId": "js:2:solana:AQbkEagmPgmsdAfS4X8V8UyJnXXjVPMvjeD15etqQ3Jh:solanaMain",
+      "blockHash": "9tPbgLaETEenufCt5SzXMuWijgFJj549W9j5cJLbaogn",
+      "blockHeight": 108521109,
+      "contract": undefined,
+      "extra": Object {},
+      "fee": "5000",
+      "hasFailed": false,
+      "hash": "A29zPnK1jPr2tGziTnaAvSnadYR2kLCv9sPywj9FJsaEFjtpwmUonspN3WJgz4u6XWmjtVpoFsDrygEnvW51cgk",
+      "id": "js:2:solana:AQbkEagmPgmsdAfS4X8V8UyJnXXjVPMvjeD15etqQ3Jh:solanaMain-A29zPnK1jPr2tGziTnaAvSnadYR2kLCv9sPywj9FJsaEFjtpwmUonspN3WJgz4u6XWmjtVpoFsDrygEnvW51cgk-OUT",
+      "operator": undefined,
+      "recipients": Array [
+        "8RtwWeqdFz4EFuZU3MAadfYMWSdRMamjFrfq6BXkHuNN",
+      ],
+      "senders": Array [
+        "AQbkEagmPgmsdAfS4X8V8UyJnXXjVPMvjeD15etqQ3Jh",
+      ],
+      "standard": undefined,
+      "tokenId": undefined,
+      "type": "OUT",
+      "value": "10005000",
+    },
+  ],
+  Array [],
+]
+`;

package/src/families/solana/api/cached.ts

@@ -17,6 +17,8 @@ const cacheKeyAddress = (address: string) => address;
 const cacheKeyEmpty = () => "" as const;
 const cacheKeyAssocTokenAccAddress = (owner: string, mint: string) =>
   `${owner}:${mint}`;
+const cacheKeyMinimumBalanceForRentExemption = (dataLengt: number) =>
+  dataLengt.toString();
 
 const cacheKeyTransactions = (signatures: string[]) =>
   hash([...signatures].sort());
@@ -63,6 +65,36 @@ export function cached(api: ChainAPI): ChainAPI {
       minutes(1)
     ),
 
+    getStakeAccountsByStakeAuth: makeLRUCache(
+      api.getStakeAccountsByStakeAuth,
+      cacheKeyAddress,
+      minutes(1)
+    ),
+
+    getStakeAccountsByWithdrawAuth: makeLRUCache(
+      api.getStakeAccountsByWithdrawAuth,
+      cacheKeyAddress,
+      minutes(1)
+    ),
+
+    getStakeActivation: makeLRUCache(
+      api.getStakeActivation,
+      cacheKeyAddress,
+      minutes(1)
+    ),
+
+    getInflationReward: makeLRUCache(
+      api.getInflationReward,
+      cacheKeyByArgs,
+      minutes(5)
+    ),
+
+    getVoteAccounts: makeLRUCache(
+      api.getVoteAccounts,
+      cacheKeyEmpty,
+      minutes(1)
+    ),
+
     getRecentBlockhash: makeLRUCache(
       api.getRecentBlockhash,
       cacheKeyEmpty,
@@ -81,9 +113,17 @@ export function cached(api: ChainAPI): ChainAPI {
       seconds(30)
     ),
 
+    getMinimumBalanceForRentExemption: makeLRUCache(
+      api.getMinimumBalanceForRentExemption,
+      cacheKeyMinimumBalanceForRentExemption,
+      minutes(5)
+    ),
+
     // do not cache
     sendRawTransaction: api.sendRawTransaction,
 
+    getEpochInfo: makeLRUCache(api.getEpochInfo, cacheKeyEmpty, minutes(1)),
+
     config: api.config,
   };
 }

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

@@ -1 +1,5 @@
-export { tryParseAsTokenAccount, parseTokenAccountInfo } from "./parser";
+export {
+  tryParseAsTokenAccount,
+  parseTokenAccountInfo,
+  tryParseAsVoteAccount,
+} from "./parser";

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

@@ -1,7 +1,10 @@
 import { ParsedAccountData } from "@solana/web3.js";
 import { create } from "superstruct";
+import { PARSED_PROGRAMS } from "../program/constants";
 import { ParsedInfo } from "../validators";
+import { StakeAccountInfo } from "./stake";
 import { TokenAccount, TokenAccountInfo } from "./token";
+import { VoteAccount, VoteAccountInfo } from "./vote";
 
 export function parseTokenAccountInfo(info: unknown): TokenAccountInfo {
   return create(info, TokenAccountInfo);
@@ -26,6 +29,31 @@ export function tryParseAsTokenAccount(
   return onThrowReturnError(routine);
 }
 
+export function parseVoteAccountInfo(info: unknown): VoteAccountInfo {
+  return create(info, VoteAccountInfo);
+}
+
+export function tryParseAsVoteAccount(
+  data: ParsedAccountData
+): VoteAccountInfo | undefined | Error {
+  const routine = () => {
+    const info = create(data.parsed, ParsedInfo);
+
+    if (data.program === PARSED_PROGRAMS.VOTE) {
+      const parsed = create(info, VoteAccount);
+      return parseVoteAccountInfo(parsed.info);
+    }
+
+    return undefined;
+  };
+
+  return onThrowReturnError(routine);
+}
+
+export function parseStakeAccountInfo(info: unknown): StakeAccountInfo {
+  return create(info, StakeAccountInfo);
+}
+
 function onThrowReturnError<R>(fn: () => R) {
   try {
     return fn();

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

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/no-redeclare */
+
+import {
+  Infer,
+  enums,
+  number,
+  array,
+  type,
+  nullable,
+  string,
+} from "superstruct";
+import { PublicKeyFromString } from "../validators/pubkey";
+
+export type VoteAccountType = Infer<typeof VoteAccountType>;
+export const VoteAccountType = enums(["vote"]);
+
+export type AuthorizedVoter = Infer<typeof AuthorizedVoter>;
+export const AuthorizedVoter = type({
+  authorizedVoter: PublicKeyFromString,
+  epoch: number(),
+});
+
+export type PriorVoter = Infer<typeof PriorVoter>;
+export const PriorVoter = type({
+  authorizedPubkey: PublicKeyFromString,
+  epochOfLastAuthorizedSwitch: number(),
+  targetEpoch: number(),
+});
+
+export type EpochCredits = Infer<typeof EpochCredits>;
+export const EpochCredits = type({
+  epoch: number(),
+  credits: string(),
+  previousCredits: string(),
+});
+
+export type Vote = Infer<typeof Vote>;
+export const Vote = type({
+  slot: number(),
+  confirmationCount: number(),
+});
+
+export type VoteAccountInfo = Infer<typeof VoteAccountInfo>;
+export const VoteAccountInfo = type({
+  authorizedVoters: array(AuthorizedVoter),
+  authorizedWithdrawer: PublicKeyFromString,
+  commission: number(),
+  epochCredits: array(EpochCredits),
+  lastTimestamp: type({
+    slot: number(),
+    timestamp: number(),
+  }),
+  nodePubkey: PublicKeyFromString,
+  priorVoters: array(PriorVoter),
+  rootSlot: nullable(number()),
+  votes: array(Vote),
+});
+
+export type VoteAccount = Infer<typeof VoteAccount>;
+export const VoteAccount = type({
+  type: VoteAccountType,
+  info: VoteAccountInfo,
+});

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

@@ -10,6 +10,7 @@ import {
   PublicKey,
   sendAndConfirmRawTransaction,
   SignaturesForAddressOptions,
+  StakeProgram,
 } from "@solana/web3.js";
 import { Awaited } from "../../logic";
 
@@ -32,6 +33,24 @@ export type ChainAPI = Readonly<{
     address: string
   ) => ReturnType<Connection["getParsedTokenAccountsByOwner"]>;
 
+  getStakeAccountsByStakeAuth: (
+    authAddr: string
+  ) => ReturnType<Connection["getParsedProgramAccounts"]>;
+
+  getStakeAccountsByWithdrawAuth: (
+    authAddr: string
+  ) => ReturnType<Connection["getParsedProgramAccounts"]>;
+
+  getStakeActivation: (
+    stakeAccAddr: string
+  ) => ReturnType<Connection["getStakeActivation"]>;
+
+  getInflationReward: (
+    addresses: string[]
+  ) => ReturnType<Connection["getInflationReward"]>;
+
+  getVoteAccounts: () => ReturnType<Connection["getVoteAccounts"]>;
+
   getSignaturesForAddress: (
     address: string,
     opts?: SignaturesForAddressOptions
@@ -55,6 +74,10 @@ export type ChainAPI = Readonly<{
 
   getAssocTokenAccMinNativeBalance: () => Promise<number>;
 
+  getMinimumBalanceForRentExemption: (dataLength: number) => Promise<number>;
+
+  getEpochInfo: () => ReturnType<Connection["getEpochInfo"]>;
+
   config: Config;
 }>;
 
@@ -98,6 +121,41 @@ export function getChainAPI(
       connection().getParsedTokenAccountsByOwner(new PublicKey(address), {
         programId: TOKEN_PROGRAM_ID,
       }),
+
+    getStakeAccountsByStakeAuth: (authAddr: string) =>
+      connection().getParsedProgramAccounts(StakeProgram.programId, {
+        filters: [
+          {
+            memcmp: {
+              offset: 12,
+              bytes: authAddr,
+            },
+          },
+        ],
+      }),
+
+    getStakeAccountsByWithdrawAuth: (authAddr: string) =>
+      connection().getParsedProgramAccounts(StakeProgram.programId, {
+        filters: [
+          {
+            memcmp: {
+              offset: 44,
+              bytes: authAddr,
+            },
+          },
+        ],
+      }),
+
+    getStakeActivation: (stakeAccAddr: string) =>
+      connection().getStakeActivation(new PublicKey(stakeAccAddr)),
+
+    getInflationReward: (addresses: string[]) =>
+      connection().getInflationReward(
+        addresses.map((addr) => new PublicKey(addr))
+      ),
+
+    getVoteAccounts: () => connection().getVoteAccounts(),
+
     getSignaturesForAddress: (
       address: string,
       opts?: SignaturesForAddressOptions
@@ -128,6 +186,11 @@ export function getChainAPI(
     getAssocTokenAccMinNativeBalance: () =>
       Token.getMinBalanceRentForExemptAccount(connection()),
 
+    getMinimumBalanceForRentExemption: (dataLength: number) =>
+      connection().getMinimumBalanceForRentExemption(dataLength),
+
+    getEpochInfo: () => connection().getEpochInfo(),
+
     config,
   };
 }

package/src/families/solana/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/families/solana/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/families/solana/api/chain/program/parser.ts

@@ -19,8 +19,17 @@ 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;
@@ -55,6 +64,15 @@ export const parse = (
       ix.program as any;
 
     switch (program) {
+      case "system":
+        return {
+          program,
+          title: "System",
+          instruction: parseSystemInstruction({
+            ...ix,
+            program,
+          }),
+        };
       case "spl-associated-token-account":
         return {
           program,