@ledgerhq/coin-solana 0.7.0-next.0

package/lib-es/validator-app/index.js

@@ -0,0 +1,55 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import network from "@ledgerhq/live-network/network";
+import { compact } from "lodash/fp";
+import { getEnv } from "@ledgerhq/live-env";
+const MAX_VALIDATORS_NB = 1000; // Max number of validators to fetch
+const URLS = {
+    validatorList: (cluster) => {
+        if (cluster === "testnet") {
+            const baseUrl = getEnv("SOLANA_TESTNET_VALIDATORS_APP_BASE_URL");
+            return `${baseUrl}/${cluster}.json?order=score&limit=${MAX_VALIDATORS_NB}`;
+        }
+        const baseUrl = getEnv("SOLANA_VALIDATORS_APP_BASE_URL");
+        return baseUrl;
+    },
+};
+export function getValidators(cluster) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield network({
+            method: "GET",
+            url: URLS.validatorList(cluster),
+        });
+        const allRawValidators = response.status === 200 ? response.data : [];
+        // validators app data is not clean: random properties can randomly contain
+        // data, null, undefined
+        const tryFromRawValidator = (validator) => {
+            var _a, _b, _c;
+            if (typeof validator.active_stake === "number" &&
+                typeof validator.commission === "number" &&
+                typeof validator.total_score === "number" &&
+                typeof validator.vote_account === "string" &&
+                validator.delinquent !== true) {
+                return {
+                    activeStake: validator.active_stake,
+                    commission: validator.commission,
+                    totalScore: validator.total_score,
+                    voteAccount: validator.vote_account,
+                    name: (_a = validator.name) !== null && _a !== void 0 ? _a : undefined,
+                    avatarUrl: (_b = validator.avatar_url) !== null && _b !== void 0 ? _b : undefined,
+                    wwwUrl: (_c = validator.www_url) !== null && _c !== void 0 ? _c : undefined,
+                };
+            }
+            return undefined;
+        };
+        return compact(allRawValidators.map(tryFromRawValidator));
+    });
+}
+//# sourceMappingURL=index.js.map

package/lib-es/validator-app/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/validator-app/index.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,OAAO,MAAM,gCAAgC,CAAC;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,MAAM,iBAAiB,GAAG,IAAI,CAAC,CAAC,oCAAoC;AAuBpE,MAAM,IAAI,GAAG;IACX,aAAa,EAAE,CAAC,OAAqD,EAAE,EAAE;QACvE,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,OAAO,GAAG,MAAM,CAAC,wCAAwC,CAAC,CAAC;YACjE,OAAO,GAAG,OAAO,IAAI,OAAO,2BAA2B,iBAAiB,EAAE,CAAC;QAC7E,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,CAAC,gCAAgC,CAAC,CAAC;QACzD,OAAO,OAAO,CAAC;IACjB,CAAC;CACF,CAAC;AAEF,MAAM,UAAgB,aAAa,CACjC,OAAqD;;QAErD,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC;YAC7B,MAAM,EAAE,KAAK;YACb,GAAG,EAAE,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;SACjC,CAAC,CAAC;QAEH,MAAM,gBAAgB,GACpB,QAAQ,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC,CAAE,QAAQ,CAAC,IAAoC,CAAC,CAAC,CAAC,EAAE,CAAC;QAEhF,2EAA2E;QAC3E,wBAAwB;QACxB,MAAM,mBAAmB,GAAG,CAC1B,SAAoC,EACA,EAAE;;YACtC,IACE,OAAO,SAAS,CAAC,YAAY,KAAK,QAAQ;gBAC1C,OAAO,SAAS,CAAC,UAAU,KAAK,QAAQ;gBACxC,OAAO,SAAS,CAAC,WAAW,KAAK,QAAQ;gBACzC,OAAO,SAAS,CAAC,YAAY,KAAK,QAAQ;gBAC1C,SAAS,CAAC,UAAU,KAAK,IAAI,EAC7B,CAAC;gBACD,OAAO;oBACL,WAAW,EAAE,SAAS,CAAC,YAAY;oBACnC,UAAU,EAAE,SAAS,CAAC,UAAU;oBAChC,UAAU,EAAE,SAAS,CAAC,WAAW;oBACjC,WAAW,EAAE,SAAS,CAAC,YAAY;oBACnC,IAAI,EAAE,MAAA,SAAS,CAAC,IAAI,mCAAI,SAAS;oBACjC,SAAS,EAAE,MAAA,SAAS,CAAC,UAAU,mCAAI,SAAS;oBAC5C,MAAM,EAAE,MAAA,SAAS,CAAC,OAAO,mCAAI,SAAS;iBACvC,CAAC;YACJ,CAAC;YAED,OAAO,SAAS,CAAC;QACnB,CAAC,CAAC;QAEF,OAAO,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC,CAAC;IAC5D,CAAC;CAAA"}

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@ledgerhq/coin-solana",
+  "version": "0.7.0-next.0",
+  "description": "Ledger Solana Coin integration",
+  "keywords": [
+    "Ledger",
+    "LedgerWallet",
+    "sol",
+    "Solana",
+    "Hardware Wallet"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LedgerHQ/ledger-live.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LedgerHQ/ledger-live/issues"
+  },
+  "homepage": "https://github.com/LedgerHQ/ledger-live/tree/develop/libs/coin-modules/coin-solana",
+  "publishConfig": {
+    "access": "public"
+  },
+  "typesVersions": {
+    "*": {
+      "lib/*": [
+        "lib/*"
+      ],
+      "lib-es/*": [
+        "lib-es/*"
+      ],
+      "*": [
+        "lib/*"
+      ]
+    }
+  },
+  "exports": {
+    "./lib/*": "./lib/*.js",
+    "./lib-es/*": "./lib-es/*.js",
+    "./*": {
+      "require": "./lib/*.js",
+      "default": "./lib-es/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@solana/spl-token": "^0.3.7",
+    "@solana/web3.js": "1.77.3",
+    "bignumber.js": "^9.1.2",
+    "bs58": "^4.0.1",
+    "expect": "^27.4.6",
+    "invariant": "^2.2.2",
+    "lodash": "^4.17.21",
+    "object-hash": "^2.2.0",
+    "rxjs": "^7.8.1",
+    "superstruct": "0.14.2",
+    "@ledgerhq/coin-framework": "^0.14.0-next.0",
+    "@ledgerhq/cryptoassets": "^13.1.0-next.0",
+    "@ledgerhq/devices": "^8.4.0-next.0",
+    "@ledgerhq/errors": "^6.17.0-next.0",
+    "@ledgerhq/live-env": "^2.1.0-next.0",
+    "@ledgerhq/live-network": "^1.3.0-next.0",
+    "@ledgerhq/logs": "^6.12.0",
+    "@ledgerhq/types-cryptoassets": "^7.13.0-next.0",
+    "@ledgerhq/types-live": "^6.48.0-next.0"
+  },
+  "devDependencies": {
+    "@types/bs58": "^4.0.1",
+    "@types/invariant": "^2.2.2",
+    "@types/jest": "^29.5.10",
+    "@types/lodash": "^4.14.191",
+    "@types/object-hash": "^2.1.0",
+    "@faker-js/faker": "^8.4.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1"
+  },
+  "scripts": {
+    "clean": "rimraf lib lib-es",
+    "build": "tsc && tsc -m ES6 --outDir lib-es",
+    "coverage": "jest --coverage --testPathIgnorePatterns='/bridge.integration.test.ts|node_modules|lib-es|lib/' --passWithNoTests && mv coverage/coverage-final.json coverage/coverage-solana.json",
+    "prewatch": "pnpm build",
+    "watch": "tsc --watch",
+    "doc": "documentation readme src/** --section=API --pe ts --re ts --re d.ts",
+    "lint": "eslint ./src --no-error-on-unmatched-pattern --ext .ts,.tsx --cache",
+    "lint:fix": "pnpm lint --fix",
+    "test": "jest",
+    "typecheck": "tsc --noEmit",
+    "unimported": "unimported"
+  }
+}

package/src/api/cached.ts

@@ -0,0 +1,79 @@
+import { makeLRUCache, minutes, seconds } from "@ledgerhq/live-network/cache";
+import hash from "object-hash";
+import { ChainAPI } from "./chain";
+
+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());
+
+const cacheKeyByArgs = (...args: any[]) => hash(args);
+
+export function cached(api: ChainAPI): ChainAPI {
+  return {
+    findAssocTokenAccAddress: makeLRUCache(
+      api.findAssocTokenAccAddress,
+      cacheKeyAssocTokenAccAddress,
+      minutes(1000),
+    ),
+
+    getAccountInfo: makeLRUCache(api.getAccountInfo, cacheKeyAddress, seconds(30)),
+
+    getAssocTokenAccMinNativeBalance: makeLRUCache(
+      api.getAssocTokenAccMinNativeBalance,
+      cacheKeyEmpty,
+      minutes(5),
+    ),
+
+    getBalance: makeLRUCache(api.getBalance, cacheKeyAddress, seconds(30)),
+
+    getBalanceAndContext: makeLRUCache(api.getBalanceAndContext, cacheKeyAddress, seconds(30)),
+
+    getParsedTransactions: makeLRUCache(
+      api.getParsedTransactions,
+      cacheKeyTransactions,
+      seconds(30),
+    ),
+
+    getParsedTokenAccountsByOwner: makeLRUCache(
+      api.getParsedTokenAccountsByOwner,
+      cacheKeyAddress,
+      minutes(1),
+    ),
+
+    // cached by default in api
+    getStakeAccountsByStakeAuth: api.getStakeAccountsByStakeAuth,
+    getStakeAccountsByWithdrawAuth: api.getStakeAccountsByWithdrawAuth,
+
+    getStakeActivation: makeLRUCache(api.getStakeActivation, cacheKeyAddress, minutes(1)),
+
+    getInflationReward: makeLRUCache(api.getInflationReward, cacheKeyByArgs, minutes(5)),
+
+    getVoteAccounts: makeLRUCache(api.getVoteAccounts, cacheKeyEmpty, minutes(1)),
+
+    getLatestBlockhash: makeLRUCache(api.getLatestBlockhash, cacheKeyEmpty, seconds(15)),
+
+    getFeeForMessage: makeLRUCache(
+      api.getFeeForMessage,
+      msg => msg.serialize().toString(),
+      minutes(1),
+    ),
+
+    getSignaturesForAddress: makeLRUCache(api.getSignaturesForAddress, cacheKeyByArgs, 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/api/chain/account/index.ts

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

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

@@ -0,0 +1,63 @@
+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);
+}
+
+export function tryParseAsTokenAccount(
+  data: ParsedAccountData,
+): TokenAccountInfo | undefined | Error {
+  const routine = () => {
+    const info = create(data.parsed, ParsedInfo);
+
+    if (data.program === "spl-token") {
+      const parsed = create(info, TokenAccount);
+      if (parsed.type === "account") {
+        return parseTokenAccountInfo(parsed.info);
+      }
+    }
+
+    return undefined;
+  };
+
+  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();
+  } catch (e) {
+    return e instanceof Error ? e : new Error(JSON.stringify(e));
+  }
+}

package/src/api/chain/account/stake.ts

@@ -0,0 +1,45 @@
+/* eslint-disable @typescript-eslint/no-redeclare */
+
+import { Infer, number, nullable, enums, type } from "superstruct";
+import { PublicKeyFromString } from "../validators/pubkey";
+import { BigNumFromString } from "../validators/bignum";
+
+export type StakeAccountType = Infer<typeof StakeAccountType>;
+export const StakeAccountType = enums(["uninitialized", "initialized", "delegated", "rewardsPool"]);
+
+export type StakeMeta = Infer<typeof StakeMeta>;
+export const StakeMeta = type({
+  rentExemptReserve: BigNumFromString,
+  authorized: type({
+    staker: PublicKeyFromString,
+    withdrawer: PublicKeyFromString,
+  }),
+  lockup: type({
+    unixTimestamp: number(),
+    epoch: number(),
+    custodian: PublicKeyFromString,
+  }),
+});
+
+export type StakeAccountInfo = Infer<typeof StakeAccountInfo>;
+export const StakeAccountInfo = type({
+  meta: StakeMeta,
+  stake: nullable(
+    type({
+      delegation: type({
+        voter: PublicKeyFromString,
+        stake: BigNumFromString,
+        activationEpoch: BigNumFromString,
+        deactivationEpoch: BigNumFromString,
+        warmupCooldownRate: number(),
+      }),
+      creditsObserved: number(),
+    }),
+  ),
+});
+
+export type StakeAccount = Infer<typeof StakeAccount>;
+export const StakeAccount = type({
+  type: StakeAccountType,
+  info: StakeAccountInfo,
+});

package/src/api/chain/account/token.ts

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/no-redeclare */
+
+import {
+  Infer,
+  number,
+  optional,
+  enums,
+  any,
+  boolean,
+  string,
+  array,
+  type,
+  nullable,
+} from "superstruct";
+import { PublicKeyFromString } from "../validators/pubkey";
+
+export type TokenAccountType = Infer<typeof TokenAccountType>;
+export const TokenAccountType = enums(["mint", "account", "multisig"]);
+
+export type TokenAccountState = Infer<typeof AccountState>;
+const AccountState = enums(["initialized", "uninitialized", "frozen"]);
+
+const TokenAmount = type({
+  decimals: number(),
+  uiAmountString: string(),
+  amount: string(),
+});
+
+export type TokenAccountInfo = Infer<typeof TokenAccountInfo>;
+export const TokenAccountInfo = type({
+  mint: PublicKeyFromString,
+  owner: PublicKeyFromString,
+  tokenAmount: TokenAmount,
+  delegate: optional(PublicKeyFromString),
+  state: AccountState,
+  isNative: boolean(),
+  rentExemptReserve: optional(TokenAmount),
+  delegatedAmount: optional(TokenAmount),
+  closeAuthority: optional(PublicKeyFromString),
+});
+
+export type MintAccountInfo = Infer<typeof MintAccountInfo>;
+export const MintAccountInfo = type({
+  mintAuthority: nullable(PublicKeyFromString),
+  supply: string(),
+  decimals: number(),
+  isInitialized: boolean(),
+  freezeAuthority: nullable(PublicKeyFromString),
+});
+
+export type MultisigAccountInfo = Infer<typeof MultisigAccountInfo>;
+export const MultisigAccountInfo = type({
+  numRequiredSigners: number(),
+  numValidSigners: number(),
+  isInitialized: boolean(),
+  signers: array(PublicKeyFromString),
+});
+
+export type TokenAccount = Infer<typeof TokenAccount>;
+export const TokenAccount = type({
+  type: TokenAccountType,
+  info: any(),
+});

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

@@ -0,0 +1,55 @@
+/* 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/api/chain/index.ts

@@ -0,0 +1,212 @@
+import {
+  TOKEN_PROGRAM_ID,
+  getAssociatedTokenAddress,
+  getMinimumBalanceForRentExemptAccount,
+} from "@solana/spl-token";
+import {
+  Connection,
+  FetchMiddleware,
+  VersionedMessage,
+  PublicKey,
+  sendAndConfirmRawTransaction,
+  SignaturesForAddressOptions,
+  StakeProgram,
+} from "@solana/web3.js";
+import { makeLRUCache, minutes } from "@ledgerhq/live-network/cache";
+import { getEnv } from "@ledgerhq/live-env";
+import { NetworkError } from "@ledgerhq/errors";
+import { Awaited } from "../../logic";
+
+export const LATEST_BLOCKHASH_MOCK = "EEbZs6DmDyDjucyYbo3LwVJU7pQYuVopYcYTSEZXskW3";
+
+export type Config = {
+  readonly endpoint: string;
+};
+
+export type ChainAPI = Readonly<{
+  getBalance: (address: string) => Promise<number>;
+
+  getLatestBlockhash: () => Promise<string>;
+
+  getFeeForMessage: (message: VersionedMessage) => Promise<number | null>;
+
+  getBalanceAndContext: (address: string) => ReturnType<Connection["getBalanceAndContext"]>;
+
+  getParsedTokenAccountsByOwner: (
+    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,
+  ) => ReturnType<Connection["getSignaturesForAddress"]>;
+
+  getParsedTransactions: (signatures: string[]) => ReturnType<Connection["getParsedTransactions"]>;
+
+  getAccountInfo: (
+    address: string,
+  ) => Promise<Awaited<ReturnType<Connection["getParsedAccountInfo"]>>["value"]>;
+
+  sendRawTransaction: (buffer: Buffer) => ReturnType<Connection["sendRawTransaction"]>;
+
+  findAssocTokenAccAddress: (owner: string, mint: string) => Promise<string>;
+
+  getAssocTokenAccMinNativeBalance: () => Promise<number>;
+
+  getMinimumBalanceForRentExemption: (dataLength: number) => Promise<number>;
+
+  getEpochInfo: () => ReturnType<Connection["getEpochInfo"]>;
+
+  config: Config;
+}>;
+
+// Naive mode, allow us to filter in sentry all this error comming from Sol RPC node
+const remapErrors = (e: Error) => {
+  throw new NetworkError(e?.message);
+};
+
+export function getChainAPI(
+  config: Config,
+  logger?: (url: string, options: any) => void,
+): ChainAPI {
+  const fetchMiddleware: FetchMiddleware | undefined =
+    logger === undefined
+      ? undefined
+      : (url, options, fetch) => {
+          logger(url, options);
+          fetch(url, options);
+        };
+
+  const connection = () => {
+    return new Connection(config.endpoint, {
+      ...(fetchMiddleware ? { fetchMiddleware } : {}),
+      commitment: "finalized",
+      confirmTransactionInitialTimeout: getEnv("SOLANA_TX_CONFIRMATION_TIMEOUT") || 0,
+    });
+  };
+
+  return {
+    getBalance: (address: string) =>
+      connection().getBalance(new PublicKey(address)).catch(remapErrors),
+
+    getLatestBlockhash: () =>
+      connection()
+        .getLatestBlockhash()
+        .then(r => r.blockhash)
+        .catch(remapErrors),
+
+    getFeeForMessage: (msg: VersionedMessage) =>
+      connection()
+        .getFeeForMessage(msg)
+        .then(r => r.value)
+        .catch(remapErrors),
+
+    getBalanceAndContext: (address: string) =>
+      connection().getBalanceAndContext(new PublicKey(address)).catch(remapErrors),
+
+    getParsedTokenAccountsByOwner: (address: string) =>
+      connection()
+        .getParsedTokenAccountsByOwner(new PublicKey(address), {
+          programId: TOKEN_PROGRAM_ID,
+        })
+        .catch(remapErrors),
+
+    getStakeAccountsByStakeAuth: makeLRUCache(
+      (authAddr: string) =>
+        connection()
+          .getParsedProgramAccounts(StakeProgram.programId, {
+            filters: [
+              {
+                memcmp: {
+                  offset: 12,
+                  bytes: authAddr,
+                },
+              },
+            ],
+          })
+          .catch(remapErrors),
+      (addr: string) => addr,
+      minutes(3),
+    ),
+
+    getStakeAccountsByWithdrawAuth: makeLRUCache(
+      (authAddr: string) =>
+        connection()
+          .getParsedProgramAccounts(StakeProgram.programId, {
+            filters: [
+              {
+                memcmp: {
+                  offset: 44,
+                  bytes: authAddr,
+                },
+              },
+            ],
+          })
+          .catch(remapErrors),
+      (addr: string) => addr,
+      minutes(3),
+    ),
+
+    getStakeActivation: (stakeAccAddr: string) =>
+      connection().getStakeActivation(new PublicKey(stakeAccAddr)).catch(remapErrors),
+
+    getInflationReward: (addresses: string[]) =>
+      connection()
+        .getInflationReward(addresses.map(addr => new PublicKey(addr)))
+        .catch(remapErrors),
+
+    getVoteAccounts: () => connection().getVoteAccounts().catch(remapErrors),
+
+    getSignaturesForAddress: (address: string, opts?: SignaturesForAddressOptions) =>
+      connection().getSignaturesForAddress(new PublicKey(address), opts).catch(remapErrors),
+
+    getParsedTransactions: (signatures: string[]) =>
+      connection()
+        .getParsedTransactions(signatures, {
+          maxSupportedTransactionVersion: 0,
+        })
+        .catch(remapErrors),
+
+    getAccountInfo: (address: string) =>
+      connection()
+        .getParsedAccountInfo(new PublicKey(address))
+        .then(r => r.value)
+        .catch(remapErrors),
+
+    sendRawTransaction: (buffer: Buffer) => {
+      return sendAndConfirmRawTransaction(connection(), buffer, {
+        commitment: "confirmed",
+      }).catch(remapErrors);
+    },
+
+    findAssocTokenAccAddress: (owner: string, mint: string) => {
+      return getAssociatedTokenAddress(new PublicKey(mint), new PublicKey(owner))
+        .then(r => r.toBase58())
+        .catch(remapErrors);
+    },
+
+    getAssocTokenAccMinNativeBalance: () =>
+      getMinimumBalanceForRentExemptAccount(connection()).catch(remapErrors),
+
+    getMinimumBalanceForRentExemption: (dataLength: number) =>
+      connection().getMinimumBalanceForRentExemption(dataLength).catch(remapErrors),
+
+    getEpochInfo: () => connection().getEpochInfo().catch(remapErrors),
+
+    config,
+  };
+}