@ledgerhq/live-common 21.36.3 → 22.0.2

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

@@ -6,9 +6,15 @@ import {
   ConfirmedSignatureInfo,
   ParsedConfirmedTransaction,
   TransactionInstruction,
+  StakeProgram,
 } from "@solana/web3.js";
 import { chunk } from "lodash";
 import {
+  StakeCreateAccountCommand,
+  StakeDelegateCommand,
+  StakeSplitCommand,
+  StakeUndelegateCommand,
+  StakeWithdrawCommand,
   TokenCreateATACommand,
   TokenTransferCommand,
   TransferCommand,
@@ -18,11 +24,18 @@ import {
   ASSOCIATED_TOKEN_PROGRAM_ID,
   Token,
 } from "@solana/spl-token";
-import { tryParseAsTokenAccount, parseTokenAccountInfo } from "./account";
+import {
+  tryParseAsTokenAccount,
+  parseTokenAccountInfo,
+  tryParseAsVoteAccount,
+} from "./account";
 import { TokenAccountInfo } from "./account/token";
 import { drainSeqAsyncGen } from "../../utils";
 import { Awaited } from "../../logic";
 import { ChainAPI } from ".";
+import { VoteAccountInfo } from "./account/vote";
+import { parseStakeAccountInfo } from "./account/parser";
+import { StakeAccountInfo } from "./account/stake";
 
 const MEMO_PROGRAM_ID = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
 
@@ -30,11 +43,20 @@ type ParsedOnChainTokenAccount = Awaited<
   ReturnType<Connection["getParsedTokenAccountsByOwner"]>
 >["value"][number];
 
+type ParsedOnChainStakeAccount = Awaited<
+  ReturnType<Connection["getParsedProgramAccounts"]>
+>[number];
+
 export type ParsedOnChainTokenAccountWithInfo = {
   onChainAcc: ParsedOnChainTokenAccount;
   info: TokenAccountInfo;
 };
 
+export type ParsedOnChainStakeAccountWithInfo = {
+  onChainAcc: ParsedOnChainStakeAccount;
+  info: StakeAccountInfo;
+};
+
 export function toTokenAccountWithInfo(
   onChainAcc: ParsedOnChainTokenAccount
 ): ParsedOnChainTokenAccountWithInfo {
@@ -43,6 +65,17 @@ export function toTokenAccountWithInfo(
   return { onChainAcc, info };
 }
 
+export function toStakeAccountWithInfo(
+  onChainAcc: ParsedOnChainStakeAccount
+): ParsedOnChainStakeAccountWithInfo | undefined {
+  if ("parsed" in onChainAcc.account.data) {
+    const parsedInfo = onChainAcc.account.data.parsed.info;
+    const info = parseStakeAccountInfo(parsedInfo);
+    return { onChainAcc, info };
+  }
+  return undefined;
+}
+
 export type TransactionDescriptor = {
   parsed: ParsedConfirmedTransaction;
   info: ConfirmedSignatureInfo;
@@ -234,6 +267,39 @@ export const getMaybeTokenAccount = async (
   return tokenAccount;
 };
 
+export async function getMaybeVoteAccount(
+  address: string,
+  api: ChainAPI
+): Promise<VoteAccountInfo | undefined | Error> {
+  const accInfo = await api.getAccountInfo(address);
+  const voteAccount =
+    accInfo !== null && "parsed" in accInfo.data
+      ? tryParseAsVoteAccount(accInfo.data)
+      : undefined;
+
+  return voteAccount;
+}
+
+export function getStakeAccountMinimumBalanceForRentExemption(api: ChainAPI) {
+  return api.getMinimumBalanceForRentExemption(StakeProgram.space);
+}
+
+export async function getStakeAccountAddressWithSeed({
+  fromAddress,
+  seed,
+}: {
+  fromAddress: string;
+  seed: string;
+}) {
+  const pubkey = await PublicKey.createWithSeed(
+    new PublicKey(fromAddress),
+    seed,
+    StakeProgram.programId
+  );
+
+  return pubkey.toBase58();
+}
+
 export function buildCreateAssociatedTokenAccountInstruction({
   mint,
   owner,
@@ -256,3 +322,109 @@ export function buildCreateAssociatedTokenAccountInstruction({
 
   return instructions;
 }
+
+export function buildStakeDelegateInstructions({
+  authorizedAccAddr,
+  stakeAccAddr,
+  voteAccAddr,
+}: StakeDelegateCommand): TransactionInstruction[] {
+  const tx = StakeProgram.delegate({
+    authorizedPubkey: new PublicKey(authorizedAccAddr),
+    stakePubkey: new PublicKey(stakeAccAddr),
+    votePubkey: new PublicKey(voteAccAddr),
+  });
+
+  return tx.instructions;
+}
+
+export function buildStakeUndelegateInstructions({
+  authorizedAccAddr,
+  stakeAccAddr,
+}: StakeUndelegateCommand): TransactionInstruction[] {
+  const tx = StakeProgram.deactivate({
+    authorizedPubkey: new PublicKey(authorizedAccAddr),
+    stakePubkey: new PublicKey(stakeAccAddr),
+  });
+
+  return tx.instructions;
+}
+
+export function buildStakeWithdrawInstructions({
+  authorizedAccAddr,
+  stakeAccAddr,
+  amount,
+  toAccAddr,
+}: StakeWithdrawCommand): TransactionInstruction[] {
+  const tx = StakeProgram.withdraw({
+    authorizedPubkey: new PublicKey(authorizedAccAddr),
+    stakePubkey: new PublicKey(stakeAccAddr),
+    lamports: amount,
+    toPubkey: new PublicKey(toAccAddr),
+  });
+
+  return tx.instructions;
+}
+
+export function buildStakeSplitInstructions({
+  authorizedAccAddr,
+  stakeAccAddr,
+  seed,
+  amount,
+  splitStakeAccAddr,
+}: StakeSplitCommand): TransactionInstruction[] {
+  // HACK: switch to split_with_seed when supported by @solana/web3.js
+  const splitIx = StakeProgram.split({
+    authorizedPubkey: new PublicKey(authorizedAccAddr),
+    lamports: amount,
+    stakePubkey: new PublicKey(stakeAccAddr),
+    splitStakePubkey: new PublicKey(splitStakeAccAddr),
+  }).instructions[1];
+
+  if (splitIx === undefined) {
+    throw new Error("expected split instruction");
+  }
+
+  const allocateIx = SystemProgram.allocate({
+    accountPubkey: new PublicKey(splitStakeAccAddr),
+    basePubkey: new PublicKey(authorizedAccAddr),
+    programId: StakeProgram.programId,
+    seed,
+    space: StakeProgram.space,
+  });
+
+  return [allocateIx, splitIx];
+}
+
+export function buildStakeCreateAccountInstructions({
+  fromAccAddress,
+  stakeAccAddress,
+  seed,
+  amount,
+  stakeAccRentExemptAmount,
+  delegate,
+}: StakeCreateAccountCommand): TransactionInstruction[] {
+  const fromPubkey = new PublicKey(fromAccAddress);
+  const stakePubkey = new PublicKey(stakeAccAddress);
+
+  const tx = StakeProgram.createAccountWithSeed({
+    fromPubkey,
+    stakePubkey,
+    basePubkey: fromPubkey,
+    seed,
+    lamports: amount + stakeAccRentExemptAmount,
+    authorized: {
+      staker: fromPubkey,
+      withdrawer: fromPubkey,
+    },
+  });
+
+  tx.add(
+    StakeProgram.delegate({
+      authorizedPubkey: fromPubkey,
+      stakePubkey,
+      votePubkey: new PublicKey(delegate.voteAccAddress),
+    })
+  );
+
+  return tx.instructions;
+}

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

@@ -1,6 +1,7 @@
 import { ChainAPI } from "./chain";
 
 //import fs from "fs";
+import { PublicKey } from "@solana/web3.js";
 
 /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
 function write(file: string, str: string) {
@@ -24,10 +25,14 @@ export function logged(api: ChainAPI, file: string): ChainAPI {
               params: args,
               answer,
             };
+            const publicKeytoJSON = PublicKey.prototype.toJSON;
+            // @ts-expect-error hack to temporary remove toJSON so it doesn't affect JSON.stringify
+            delete PublicKey.prototype.toJSON;
             const summaryJson = JSON.stringify(summary).replace(
               /{"_bn":(".*?")}/g,
               "new PublicKey(Buffer.from($1, 'hex'))"
             );
+            PublicKey.prototype.toJSON = publicKeytoJSON;
             write(file, summaryJson + ",\n");
           };
           if (result instanceof Promise) {

package/src/families/solana/bridge/bridge.ts

@@ -9,6 +9,7 @@ import type {
   AccountBridge,
   AccountLike,
   BroadcastFnSignature,
+  CryptoCurrency,
   CurrencyBridge,
   SignOperationFnSignature,
 } from "../../../types";
@@ -20,6 +21,7 @@ import createTransaction, { updateTransaction } from "../js-createTransaction";
 import { signOperationWithAPI } from "../js-signOperation";
 import { broadcastWithAPI } from "../js-broadcast";
 import { prepareTransaction as prepareTransactionWithAPI } from "../js-prepareTransaction";
+import { hydrate, preloadWithAPI } from "../js-preload";
 import { ChainAPI, Config } from "../api";
 import { makeLRUCache } from "../../../cache";
 import { endpointByCurrencyId } from "../utils";
@@ -100,8 +102,16 @@ function makeEstimateMaxSpendable(
     return estimateMaxSpendableWithAPI(arg, api);
   }
 
-  const cacheKeyByAccBalance = ({ account }: { account: AccountLike }) =>
-    `${account.id}:${account.balance.toString()}`;
+  const cacheKeyByAccBalance = ({
+    account,
+    transaction,
+  }: {
+    account: AccountLike;
+    transaction?: Transaction | null;
+  }) =>
+    `${account.id}:${account.balance.toString()}:tx:${
+      transaction?.model.kind ?? "<no transaction>"
+    }`;
 
   return makeLRUCache(estimateMaxSpendable, cacheKeyByAccBalance, minutes(5));
 }
@@ -130,6 +140,19 @@ function makeSign(
   };
 }
 
+function makePreload(
+  getChainAPI: (config: Config) => Promise<ChainAPI>
+): CurrencyBridge["preload"] {
+  const preload = (currency: CryptoCurrency): Promise<Record<string, any>> => {
+    const config: Config = {
+      endpoint: endpointByCurrencyId(currency.id),
+    };
+    const api = () => getChainAPI(config);
+    return preloadWithAPI(currency, api);
+  };
+  return preload;
+}
+
 export function makeBridges({
   getAPI,
   getQueuedAPI,
@@ -157,8 +180,8 @@ export function makeBridges({
   };
 
   const currencyBridge: CurrencyBridge = {
-    preload: async (): Promise<any> => {},
-    hydrate: (): void => {},
+    preload: makePreload(getQueuedAndCachedAPI),
+    hydrate,
     scanAccounts: scan,
   };