@ledgerhq/live-common 21.20.0 → 21.21.0-rc.2

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

@@ -0,0 +1,122 @@
+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";
+
+type ParsedProgram =
+  | {
+      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 "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/families/solana/api/chain/validators/bignum.ts

@@ -0,0 +1,11 @@
+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/families/solana/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/families/solana/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)
+);

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

@@ -0,0 +1,258 @@
+import {
+  Connection,
+  PublicKey,
+  SystemProgram,
+  Transaction,
+  ConfirmedSignatureInfo,
+  ParsedConfirmedTransaction,
+  TransactionInstruction,
+} from "@solana/web3.js";
+import { chunk } from "lodash";
+import {
+  TokenCreateATACommand,
+  TokenTransferCommand,
+  TransferCommand,
+} from "../../types";
+import {
+  TOKEN_PROGRAM_ID,
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  Token,
+} from "@solana/spl-token";
+import { tryParseAsTokenAccount, parseTokenAccountInfo } from "./account";
+import { TokenAccountInfo } from "./account/token";
+import { drainSeqAsyncGen } from "../../utils";
+import { Awaited } from "../../logic";
+import { ChainAPI } from ".";
+
+const MEMO_PROGRAM_ID = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+
+type ParsedOnChainTokenAccount = Awaited<
+  ReturnType<Connection["getParsedTokenAccountsByOwner"]>
+>["value"][number];
+
+export type ParsedOnChainTokenAccountWithInfo = {
+  onChainAcc: ParsedOnChainTokenAccount;
+  info: TokenAccountInfo;
+};
+
+export function toTokenAccountWithInfo(
+  onChainAcc: ParsedOnChainTokenAccount
+): ParsedOnChainTokenAccountWithInfo {
+  const parsedInfo = onChainAcc.account.data.parsed.info;
+  const info = parseTokenAccountInfo(parsedInfo);
+  return { onChainAcc, info };
+}
+
+export type TransactionDescriptor = {
+  parsed: ParsedConfirmedTransaction;
+  info: ConfirmedSignatureInfo;
+};
+
+async function* getTransactionsBatched(
+  address: string,
+  untilTxSignature: string | undefined,
+  api: ChainAPI
+): AsyncGenerator<TransactionDescriptor[], void, unknown> {
+  // as per Ledger team - last 100 operations is a sane limit to begin with
+  const signatures = await api.getSignaturesForAddress(address, {
+    until: untilTxSignature,
+    limit: 100,
+  });
+
+  // max req payload is 50K, around 200 transactions atm
+  // requesting 100 at a time to give some space for payload to change in future
+  const batchSize = 100;
+
+  for (const signaturesInfoBatch of chunk(signatures, batchSize)) {
+    const transactions = await api.getParsedConfirmedTransactions(
+      signaturesInfoBatch.map((tx) => tx.signature)
+    );
+    const txsDetails = transactions.reduce((acc, tx, index) => {
+      if (tx && !tx.meta?.err && tx.blockTime) {
+        acc.push({
+          info: signaturesInfoBatch[index],
+          parsed: tx,
+        });
+      }
+      return acc;
+    }, [] as TransactionDescriptor[]);
+
+    yield txsDetails;
+  }
+}
+
+async function* getTransactionsGen(
+  address: string,
+  untilTxSignature: string | undefined,
+  api: ChainAPI
+): AsyncGenerator<TransactionDescriptor, void, undefined> {
+  for await (const txDetailsBatch of getTransactionsBatched(
+    address,
+    untilTxSignature,
+    api
+  )) {
+    yield* txDetailsBatch;
+  }
+}
+
+export function getTransactions(
+  address: string,
+  untilTxSignature: string | undefined,
+  api: ChainAPI
+): Promise<TransactionDescriptor[]> {
+  return drainSeqAsyncGen(getTransactionsGen(address, untilTxSignature, api));
+}
+
+export const buildTransferInstructions = ({
+  sender,
+  recipient,
+  amount,
+  memo,
+}: TransferCommand): TransactionInstruction[] => {
+  const fromPublicKey = new PublicKey(sender);
+  const toPublicKey = new PublicKey(recipient);
+
+  const instructions: TransactionInstruction[] = [
+    SystemProgram.transfer({
+      fromPubkey: fromPublicKey,
+      toPubkey: toPublicKey,
+      lamports: amount,
+    }),
+  ];
+
+  if (memo) {
+    const memoIx = new TransactionInstruction({
+      keys: [],
+      programId: new PublicKey(MEMO_PROGRAM_ID),
+      data: Buffer.from(memo),
+    });
+    instructions.push(memoIx);
+  }
+
+  return instructions;
+};
+
+export const buildTokenTransferInstructions = (
+  command: TokenTransferCommand
+): TransactionInstruction[] => {
+  const {
+    ownerAddress,
+    ownerAssociatedTokenAccountAddress,
+    amount,
+    recipientDescriptor,
+    mintAddress,
+    mintDecimals,
+    memo,
+  } = command;
+  const ownerPubkey = new PublicKey(ownerAddress);
+
+  const destinationPubkey = new PublicKey(recipientDescriptor.tokenAccAddress);
+
+  const instructions: TransactionInstruction[] = [];
+
+  const mintPubkey = new PublicKey(mintAddress);
+
+  if (recipientDescriptor.shouldCreateAsAssociatedTokenAccount) {
+    instructions.push(
+      Token.createAssociatedTokenAccountInstruction(
+        ASSOCIATED_TOKEN_PROGRAM_ID,
+        TOKEN_PROGRAM_ID,
+        mintPubkey,
+        destinationPubkey,
+        new PublicKey(recipientDescriptor.walletAddress),
+        ownerPubkey
+      )
+    );
+  }
+
+  instructions.push(
+    Token.createTransferCheckedInstruction(
+      TOKEN_PROGRAM_ID,
+      new PublicKey(ownerAssociatedTokenAccountAddress),
+      mintPubkey,
+      destinationPubkey,
+      ownerPubkey,
+      [],
+      amount,
+      mintDecimals
+    )
+  );
+
+  if (memo) {
+    instructions.push(
+      new TransactionInstruction({
+        keys: [],
+        programId: new PublicKey(MEMO_PROGRAM_ID),
+        data: Buffer.from(memo),
+      })
+    );
+  }
+
+  return instructions;
+};
+
+export const addSignatureToTransaction = ({
+  tx,
+  address,
+  signature,
+}: {
+  tx: Transaction;
+  address: string;
+  signature: Buffer;
+}): Transaction => {
+  tx.addSignature(new PublicKey(address), signature);
+
+  return tx;
+};
+
+export async function findAssociatedTokenAccountPubkey(
+  ownerAddress: string,
+  mintAddress: string
+): Promise<PublicKey> {
+  const ownerPubKey = new PublicKey(ownerAddress);
+  const mintPubkey = new PublicKey(mintAddress);
+
+  return Token.getAssociatedTokenAddress(
+    ASSOCIATED_TOKEN_PROGRAM_ID,
+    TOKEN_PROGRAM_ID,
+    mintPubkey,
+    ownerPubKey
+  );
+}
+
+export const getMaybeTokenAccount = async (
+  address: string,
+  api: ChainAPI
+): Promise<TokenAccountInfo | undefined | Error> => {
+  const accInfo = await api.getAccountInfo(address);
+
+  const tokenAccount =
+    accInfo !== null && "parsed" in accInfo.data
+      ? tryParseAsTokenAccount(accInfo.data)
+      : undefined;
+
+  return tokenAccount;
+};
+
+export function buildCreateAssociatedTokenAccountInstruction({
+  mint,
+  owner,
+  associatedTokenAccountAddress,
+}: TokenCreateATACommand): TransactionInstruction[] {
+  const ownerPubKey = new PublicKey(owner);
+  const mintPubkey = new PublicKey(mint);
+  const associatedTokenAccPubkey = new PublicKey(associatedTokenAccountAddress);
+
+  const instructions: TransactionInstruction[] = [
+    Token.createAssociatedTokenAccountInstruction(
+      ASSOCIATED_TOKEN_PROGRAM_ID,
+      TOKEN_PROGRAM_ID,
+      mintPubkey,
+      associatedTokenAccPubkey,
+      ownerPubKey,
+      ownerPubKey
+    ),
+  ];
+
+  return instructions;
+}

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

@@ -0,0 +1,4 @@
+export * from "./chain/index";
+export { cached } from "./cached";
+export { queued } from "./queued";
+export { logged } from "./logged";

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

@@ -0,0 +1,50 @@
+import { ChainAPI } from "./chain";
+
+//import fs from "fs";
+
+/* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+function write(file: string, str: string) {
+  // fs is not available on mobile
+  //fs.appendFileSync(file, str);
+}
+
+export function logged(api: ChainAPI, file: string): ChainAPI {
+  const proxy: ChainAPI = new Proxy(api, {
+    get(target, propKey, receiver) {
+      if (typeof propKey === "symbol") {
+        throw new Error("symbols not supported");
+      }
+      const targetValue = Reflect.get(target, propKey, receiver);
+      if (typeof targetValue === "function") {
+        return function (...args: unknown[]) {
+          const result = targetValue.apply(this, args);
+          const log = (answer: unknown) => {
+            const summary = {
+              method: propKey,
+              params: args,
+              answer,
+            };
+            const summaryJson = JSON.stringify(summary).replace(
+              /{"_bn":(".*?")}/g,
+              "new PublicKey(Buffer.from($1, 'hex'))"
+            );
+            write(file, summaryJson + ",\n");
+          };
+          if (result instanceof Promise) {
+            return result.then((answer) => {
+              log(answer);
+              return answer;
+            });
+          } else {
+            log(result);
+            return result;
+          }
+        };
+      } else {
+        return targetValue;
+      }
+    },
+  });
+
+  return proxy;
+}

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

@@ -0,0 +1,23 @@
+import { asyncQueue } from "../utils";
+import { ChainAPI } from "./chain";
+
+export function queued(api: ChainAPI, delayBetweenRuns = 100): ChainAPI {
+  const q = asyncQueue({
+    delayBetweenRuns,
+  });
+
+  const proxy: ChainAPI = new Proxy(api, {
+    get(target, propKey, receiver) {
+      const targetValue = Reflect.get(target, propKey, receiver);
+      if (typeof targetValue === "function") {
+        return function (...args: unknown[]) {
+          return q.submit(() => targetValue.apply(this, args));
+        };
+      } else {
+        return targetValue;
+      }
+    },
+  });
+
+  return proxy;
+}

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

@@ -0,0 +1,169 @@
+import {
+  GetAccountShape,
+  makeAccountBridgeReceive,
+  makeSync as makeSyncHelper,
+  makeScanAccounts as makeScanHelper,
+} from "../../../bridge/jsHelpers";
+import type {
+  Account,
+  AccountBridge,
+  AccountLike,
+  BroadcastFnSignature,
+  CurrencyBridge,
+  SignOperationFnSignature,
+} from "../../../types";
+import type { Transaction } from "../types";
+import { getAccountShapeWithAPI } from "../js-synchronization";
+import getTransactionStatus from "../js-getTransactionStatus";
+import estimateMaxSpendableWithAPI from "../js-estimateMaxSpendable";
+import createTransaction, { updateTransaction } from "../js-createTransaction";
+import { signOperationWithAPI } from "../js-signOperation";
+import { broadcastWithAPI } from "../js-broadcast";
+import { prepareTransaction as prepareTransactionWithAPI } from "../js-prepareTransaction";
+import { ChainAPI, Config } from "../api";
+import { makeLRUCache } from "../../../cache";
+import { clusterByCurrencyId } from "../utils";
+import { minutes, seconds } from "../api/cached";
+import hash from "object-hash";
+import BigNumber from "bignumber.js";
+
+function makePrepare(getChainAPI: (config: Config) => Promise<ChainAPI>) {
+  async function prepareTransaction(
+    mainAccount: Account,
+    transaction: Transaction
+  ) {
+    const config = {
+      cluster: clusterByCurrencyId(mainAccount.currency.id),
+    };
+
+    const chainAPI = await getChainAPI(config);
+    return prepareTransactionWithAPI(mainAccount, transaction, chainAPI);
+  }
+
+  const cacheKeyByAccTx = (account: Account, tx: Transaction) =>
+    hash({
+      account: {
+        id: account.id,
+        address: account.freshAddress,
+        syncDate: account.lastSyncDate.toISOString(),
+      },
+      tx: {
+        recipient: tx.recipient,
+        amount: tx.amount.toNumber(),
+        useAllAmount: tx.useAllAmount,
+        subAccountId: tx.subAccountId,
+        model: tx.model,
+      },
+    });
+
+  return makeLRUCache(prepareTransaction, cacheKeyByAccTx, seconds(30));
+}
+
+function makeSyncAndScan(getChainAPI: (config: Config) => Promise<ChainAPI>) {
+  const getAccountShape: GetAccountShape = async (info) => {
+    const config = {
+      cluster: clusterByCurrencyId(info.currency.id),
+    };
+
+    const chainAPI = await getChainAPI(config);
+    return getAccountShapeWithAPI(info, chainAPI);
+  };
+  return {
+    sync: makeSyncHelper(getAccountShape),
+    scan: makeScanHelper(getAccountShape),
+  };
+}
+
+function makeEstimateMaxSpendable(
+  getChainAPI: (config: Config) => Promise<ChainAPI>
+) {
+  async function estimateMaxSpendable(
+    arg: Parameters<AccountBridge<Transaction>["estimateMaxSpendable"]>[0]
+  ): Promise<BigNumber> {
+    const { account, parentAccount } = arg;
+
+    const currencyId =
+      account.type === "Account"
+        ? account.currency.id
+        : parentAccount?.currency.id;
+
+    if (currencyId === undefined) {
+      throw new Error("currency not found");
+    }
+
+    const config = {
+      cluster: clusterByCurrencyId(currencyId),
+    };
+
+    const api = await getChainAPI(config);
+
+    return estimateMaxSpendableWithAPI(arg, api);
+  }
+
+  const cacheKeyByAccBalance = ({ account }: { account: AccountLike }) =>
+    `${account.id}:${account.balance.toString()}`;
+
+  return makeLRUCache(estimateMaxSpendable, cacheKeyByAccBalance, minutes(5));
+}
+
+function makeBroadcast(
+  getChainAPI: (config: Config) => Promise<ChainAPI>
+): BroadcastFnSignature {
+  return async (info) => {
+    const config = {
+      cluster: clusterByCurrencyId(info.account.currency.id),
+    };
+    const api = await getChainAPI(config);
+    return broadcastWithAPI(info, api);
+  };
+}
+
+function makeSign(
+  getChainAPI: (config: Config) => Promise<ChainAPI>
+): SignOperationFnSignature<Transaction> {
+  return (info) => {
+    const config = {
+      cluster: clusterByCurrencyId(info.account.currency.id),
+    };
+    const api = () => getChainAPI(config);
+    return signOperationWithAPI(info, api);
+  };
+}
+
+export function makeBridges({
+  getAPI,
+  getQueuedAPI,
+  getQueuedAndCachedAPI,
+}: {
+  getAPI: (config: Config) => Promise<ChainAPI>;
+  getQueuedAPI: (config: Config) => Promise<ChainAPI>;
+  getQueuedAndCachedAPI: (config: Config) => Promise<ChainAPI>;
+}): {
+  currencyBridge: CurrencyBridge;
+  accountBridge: AccountBridge<Transaction>;
+} {
+  const { sync, scan } = makeSyncAndScan(getQueuedAPI);
+
+  const accountBridge: AccountBridge<Transaction> = {
+    createTransaction,
+    updateTransaction,
+    estimateMaxSpendable: makeEstimateMaxSpendable(getQueuedAndCachedAPI),
+    getTransactionStatus,
+    sync,
+    receive: makeAccountBridgeReceive(),
+    prepareTransaction: makePrepare(getQueuedAndCachedAPI),
+    broadcast: makeBroadcast(getAPI),
+    signOperation: makeSign(getAPI),
+  };
+
+  const currencyBridge: CurrencyBridge = {
+    preload: async (): Promise<any> => {},
+    hydrate: (): void => {},
+    scanAccounts: scan,
+  };
+
+  return {
+    currencyBridge,
+    accountBridge,
+  };
+}

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

@@ -0,0 +1,28 @@
+import { cached, Config, getChainAPI, queued } from "../api";
+import { makeLRUCache } from "../../../cache";
+import { makeBridges } from "./bridge";
+import { minutes } from "../api/cached";
+
+const getAPI = makeLRUCache(
+  (config: Config) => Promise.resolve(getChainAPI(config)),
+  (config) => config.cluster,
+  minutes(1000)
+);
+
+const getQueuedAPI = makeLRUCache(
+  (config: Config) => getAPI(config).then((api) => queued(api, 100)),
+  (config) => config.cluster,
+  minutes(1000)
+);
+
+const getQueuedAndCachedAPI = makeLRUCache(
+  (config: Config) => getQueuedAPI(config).then(cached),
+  (config) => config.cluster,
+  minutes(1000)
+);
+
+export default makeBridges({
+  getAPI,
+  getQueuedAPI,
+  getQueuedAndCachedAPI,
+});