@ledgerhq/live-common 21.36.2 → 22.0.0

package/src/families/ripple/types.ts

@@ -4,65 +4,7 @@ import type {
   TransactionCommon,
   TransactionCommonRaw,
 } from "../../types/transaction";
-import type { CoreAmount, CoreBigInt, Spec } from "../../libcore/types";
 
-declare class CoreRippleLikeAddress {
-  toBase58(): Promise<string>;
-}
-
-declare class CoreRippleLikeTransaction {
-  getHash(): Promise<string>;
-  getFees(): Promise<CoreAmount>;
-  getReceiver(): Promise<CoreRippleLikeAddress>;
-  getSender(): Promise<CoreRippleLikeAddress>;
-  serialize(): Promise<string>;
-  setSignature(arg0: string, arg1: string): Promise<void>;
-  setDERSignature(arg0: string): Promise<void>;
-  getDestinationTag(): Promise<number | null | undefined>;
-  getSequence(): Promise<CoreBigInt>;
-}
-
-declare class CoreRippleLikeOperation {
-  getTransaction(): Promise<CoreRippleLikeTransaction>;
-}
-
-declare class CoreRippleLikeTransactionBuilder {
-  wipeToAddress(address: string): Promise<void>;
-  sendToAddress(amount: CoreAmount, recipient: string): Promise<void>;
-  setDestinationTag(tag: number): Promise<void>;
-  setFees(fees: CoreAmount): Promise<void>;
-  build(): Promise<CoreRippleLikeTransaction>;
-}
-
-declare class CoreRippleLikeAccount {
-  buildTransaction(): Promise<CoreRippleLikeTransactionBuilder>;
-  broadcastRawTransaction(signed: string): Promise<string>;
-  getFees(): Promise<CoreAmount>;
-  getBaseReserve(): Promise<CoreAmount>;
-  isAddressActivated(address: string): Promise<boolean>;
-}
-
-export type CoreStatics = {
-  RippleLikeOperation: CoreRippleLikeOperation;
-  RippleLikeAddress: CoreRippleLikeAddress;
-  RippleLikeTransaction: CoreRippleLikeTransaction;
-  RippleLikeAccount: CoreRippleLikeAccount;
-  RippleLikeTransactionBuilder: CoreRippleLikeTransactionBuilder;
-};
-export type {
-  CoreRippleLikeAccount,
-  CoreRippleLikeAddress,
-  CoreRippleLikeOperation,
-  CoreRippleLikeTransaction,
-  CoreRippleLikeTransactionBuilder,
-};
-export type CoreAccountSpecifics = {
-  asRippleLikeAccount(): Promise<CoreRippleLikeAccount>;
-};
-export type CoreOperationSpecifics = {
-  asRippleLikeOperation(): Promise<CoreRippleLikeOperation>;
-};
-export type CoreCurrencySpecifics = Record<string, never>;
 export type NetworkInfo = {
   family: "ripple";
   serverFee: BigNumber;
@@ -87,88 +29,3 @@ export type TransactionRaw = TransactionCommonRaw & {
   tag: number | null | undefined;
   feeCustomUnit: Unit | null | undefined;
 };
-export const reflect = (declare: (arg0: string, arg1: Spec) => void) => {
-  declare("RippleLikeAddress", {
-    methods: {
-      toBase58: {},
-    },
-  });
-  declare("RippleLikeOperation", {
-    methods: {
-      getTransaction: {
-        returns: "RippleLikeTransaction",
-      },
-    },
-  });
-  declare("RippleLikeTransaction", {
-    methods: {
-      getHash: {},
-      getDestinationTag: {},
-      getSequence: {
-        returns: "BigInt",
-      },
-      getFees: {
-        returns: "Amount",
-      },
-      getReceiver: {
-        returns: "RippleLikeAddress",
-      },
-      getSender: {
-        returns: "RippleLikeAddress",
-      },
-      serialize: {
-        returns: "hex",
-      },
-      setSignature: {
-        params: ["hex", "hex"],
-      },
-      setDERSignature: {
-        params: ["hex"],
-      },
-    },
-  });
-  declare("RippleLikeTransactionBuilder", {
-    methods: {
-      wipeToAddress: {},
-      sendToAddress: {
-        params: ["Amount"],
-      },
-      setFees: {
-        params: ["Amount"],
-      },
-      setDestinationTag: {},
-      build: {
-        returns: "RippleLikeTransaction",
-      },
-    },
-  });
-  declare("RippleLikeAccount", {
-    methods: {
-      buildTransaction: {
-        returns: "RippleLikeTransactionBuilder",
-      },
-      broadcastRawTransaction: {
-        params: ["hex"],
-      },
-      getFees: {
-        returns: "Amount",
-      },
-      getBaseReserve: {
-        returns: "Amount",
-      },
-      isAddressActivated: {},
-    },
-  });
-  return {
-    OperationMethods: {
-      asRippleLikeOperation: {
-        returns: "RippleLikeOperation",
-      },
-    },
-    AccountMethods: {
-      asRippleLikeAccount: {
-        returns: "RippleLikeAccount",
-      },
-    },
-  };
-};

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];