@kamino-finance/klend-sdk 3.2.26 → 4.0.1

package/src/utils/oracle.ts

@@ -0,0 +1,337 @@
+import { parsePriceData } from '@pythnetwork/client';
+import { AccountInfo, Connection, PublicKey } from '@solana/web3.js';
+import Decimal from 'decimal.js';
+import { OraclePrices, Scope } from '@kamino-finance/scope-sdk';
+import { isNotNullPubkey, PubkeyHashMap, PublicKeySet } from './pubkey';
+import { parseTokenSymbol } from '../classes';
+import SwitchboardProgram from '@switchboard-xyz/sbv2-lite';
+import { Reserve } from '../lib';
+import { batchFetch } from '@kamino-finance/kliquidity-sdk';
+import BN from 'bn.js';
+
+const SWITCHBOARD_V2_PROGRAM_ID = new PublicKey('SW1TCH7qEPTdLsDHRgPuMQjbQxKdH2aBStViMFnt64f');
+
+// validate price confidence - confidence/price ratio should be less than 2%
+export const MAX_CONFIDENCE_PERCENTAGE: Decimal = new Decimal('2');
+
+/// Confidence factor is used to scale the confidence value to a value that can be compared to the price.
+export const CONFIDENCE_FACTOR: Decimal = new Decimal('100').div(MAX_CONFIDENCE_PERCENTAGE);
+
+const getScopeAddress = () => {
+  return 'HFn8GnPADiny6XqUoWE8uRPPxb29ikn4yTuPa9MF2fWJ';
+};
+
+export type TokenOracleData = {
+  mintAddress: PublicKey;
+  decimals: Decimal;
+  price: Decimal;
+  timestamp: bigint;
+  valid: boolean;
+};
+
+export type CandidatePrice = {
+  price: Decimal;
+  timestamp: bigint;
+  valid: boolean;
+};
+
+export type ScopeRefresh = {
+  includeScopeRefresh: boolean;
+  scopeFeed: string;
+};
+
+// TODO: Add freshness of the latest price to match sc logic
+export async function getTokenOracleData(
+  connection: Connection,
+  reserves: Reserve[]
+): Promise<Array<[Reserve, TokenOracleData | undefined]>> {
+  const allOracleAccounts = await getAllOracleAccounts(connection, reserves);
+  const tokenOracleDataForReserves: Array<[Reserve, TokenOracleData | undefined]> = [];
+  const pythCache = new PubkeyHashMap<PublicKey, PythPrices>();
+  const switchboardCache = new PubkeyHashMap<PublicKey, CandidatePrice>();
+  const scopeCache = new PubkeyHashMap<PublicKey, OraclePrices>();
+  let switchboardV2: SwitchboardProgram | undefined;
+  for (const reserve of reserves) {
+    let currentBest: CandidatePrice | undefined = undefined;
+    const oracle = {
+      pythAddress: reserve.config.tokenInfo.pythConfiguration.price,
+      switchboardFeedAddress: reserve.config.tokenInfo.switchboardConfiguration.priceAggregator,
+      switchboardTwapAddress: reserve.config.tokenInfo.switchboardConfiguration.twapAggregator,
+      scopeOracleAddress: reserve.config.tokenInfo.scopeConfiguration.priceFeed,
+    };
+    if (isNotNullPubkey(oracle.pythAddress)) {
+      const pythPrices = cacheOrGetPythPrices(oracle.pythAddress, pythCache, allOracleAccounts);
+      if (pythPrices && pythPrices.spot) {
+        currentBest = getBestPrice(currentBest, pythPrices.spot);
+      }
+    }
+    if (isNotNullPubkey(oracle.switchboardFeedAddress)) {
+      if (!switchboardV2) {
+        switchboardV2 = await SwitchboardProgram.loadMainnet(connection);
+      }
+      const switchboardPrice = cacheOrGetSwitchboardPrice(
+        oracle.switchboardFeedAddress,
+        switchboardCache,
+        allOracleAccounts,
+        switchboardV2
+      );
+      if (switchboardPrice) {
+        currentBest = getBestPrice(currentBest, switchboardPrice);
+      }
+    }
+
+    if (isNotNullPubkey(oracle.scopeOracleAddress)) {
+      const scopePrice = cacheOrGetScopePrice(
+        oracle.scopeOracleAddress,
+        scopeCache,
+        allOracleAccounts,
+        reserve.config.tokenInfo.scopeConfiguration.priceChain
+      );
+      if (scopePrice) {
+        currentBest = getBestPrice(currentBest, scopePrice);
+      }
+    }
+
+    if (!currentBest) {
+      console.error(`No price found for reserve: ${parseTokenSymbol(reserve.config.tokenInfo.name)}`);
+      tokenOracleDataForReserves.push([reserve, undefined]);
+      continue;
+    }
+    const tokenOracleData: TokenOracleData = {
+      mintAddress: reserve.liquidity.mintPubkey,
+      decimals: Decimal.pow(10, reserve.liquidity.mintDecimals.toString()),
+      price: new Decimal(currentBest.price),
+      timestamp: currentBest.timestamp,
+      valid: currentBest.valid,
+    };
+    tokenOracleDataForReserves.push([reserve, tokenOracleData]);
+  }
+  return tokenOracleDataForReserves;
+}
+
+export type AllOracleAccounts = PubkeyHashMap<PublicKey, AccountInfo<Buffer>>;
+
+export async function getAllOracleAccounts(connection: Connection, reserves: Reserve[]): Promise<AllOracleAccounts> {
+  const allAccounts: PublicKey[] = [];
+  reserves.forEach((reserve) => {
+    if (isNotNullPubkey(reserve.config.tokenInfo.pythConfiguration.price)) {
+      allAccounts.push(reserve.config.tokenInfo.pythConfiguration.price);
+    }
+    if (isNotNullPubkey(reserve.config.tokenInfo.switchboardConfiguration.priceAggregator)) {
+      allAccounts.push(reserve.config.tokenInfo.switchboardConfiguration.priceAggregator);
+    }
+    if (isNotNullPubkey(reserve.config.tokenInfo.switchboardConfiguration.twapAggregator)) {
+      allAccounts.push(reserve.config.tokenInfo.switchboardConfiguration.twapAggregator);
+    }
+    if (isNotNullPubkey(reserve.config.tokenInfo.scopeConfiguration.priceFeed)) {
+      allAccounts.push(reserve.config.tokenInfo.scopeConfiguration.priceFeed);
+    }
+  });
+  const allAccountsDeduped = dedupKeys(allAccounts);
+  const allAccs = await batchFetch(allAccountsDeduped, (chunk) => connection.getMultipleAccountsInfo(chunk));
+  const allAccsMap = new PubkeyHashMap<PublicKey, AccountInfo<Buffer>>();
+  allAccs.forEach((acc, i) => {
+    if (acc) {
+      allAccsMap.set(allAccountsDeduped[i], acc);
+    }
+  });
+  return allAccsMap;
+}
+
+function dedupKeys(keys: PublicKey[]): PublicKey[] {
+  return new PublicKeySet(keys).toArray();
+}
+
+export type PythPrices = {
+  spot?: CandidatePrice;
+  twap?: CandidatePrice;
+};
+
+/**
+ * Get pyth price from cache or fetch if not available
+ * @param oracle oracle address
+ * @param cache pyth cache
+ * @param oracleAccounts all oracle accounts
+ */
+export function cacheOrGetPythPrices(
+  oracle: PublicKey,
+  cache: Map<PublicKey, PythPrices>,
+  oracleAccounts: AllOracleAccounts
+): PythPrices | null {
+  const prices: PythPrices = {};
+  const cached = cache.get(oracle);
+  if (cached) {
+    return cached;
+  } else {
+    const result = oracleAccounts.get(oracle);
+    if (result) {
+      try {
+        const { price, timestamp, emaPrice, previousPrice, previousTimestamp, confidence } = parsePriceData(
+          result.data
+        );
+        if (price) {
+          const px = new Decimal(price);
+          prices.spot = {
+            price: px,
+            timestamp,
+            valid: validatePythPx(px, confidence),
+          };
+        } else {
+          prices.spot = {
+            price: new Decimal(previousPrice),
+            timestamp: previousTimestamp,
+            valid: false,
+          };
+        }
+        if (emaPrice !== undefined && emaPrice !== null) {
+          prices.twap = {
+            price: new Decimal(emaPrice.value),
+            timestamp,
+            valid: true,
+          };
+        }
+        if (prices.spot || prices.twap) {
+          cache.set(oracle, prices);
+        }
+      } catch (error) {
+        console.error(`Error parsing pyth price account ${oracle.toString()} data`, error);
+        return null;
+      }
+    } else {
+      return null;
+    }
+  }
+  return prices;
+}
+
+/**
+ * Get switchboard price from cache or fetch if not available
+ * @param oracle oracle address
+ * @param switchboardCache cache for oracle prices
+ * @param oracleAccounts all oracle accounts
+ * @param switchboardV2 loaded switchboard program
+ */
+export function cacheOrGetSwitchboardPrice(
+  oracle: PublicKey,
+  switchboardCache: Map<PublicKey, CandidatePrice>,
+  oracleAccounts: AllOracleAccounts,
+  switchboardV2: SwitchboardProgram
+): CandidatePrice | null {
+  const cached = switchboardCache.get(oracle);
+  if (cached) {
+    return cached;
+  } else {
+    const info = oracleAccounts.get(oracle);
+    if (info) {
+      if (info.owner.equals(SWITCHBOARD_V2_PROGRAM_ID)) {
+        const agg = switchboardV2.decodeAggregator(info!);
+        // @ts-ignore
+        const result: Big.Big | null = switchboardV2.getLatestAggregatorValue(agg);
+        if (result !== undefined && result !== null) {
+          const switchboardPx = new Decimal(result.toString());
+          const latestRoundTimestamp: BN = agg.latestConfirmedRound.roundOpenTimestamp;
+          const ts = BigInt(latestRoundTimestamp.toString());
+          const valid = validateSwitchboardV2Px(agg);
+          return {
+            price: switchboardPx,
+            timestamp: ts,
+            valid,
+          };
+        }
+      } else {
+        console.error('Unrecognized switchboard owner address: ', info.owner.toString());
+        return null;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Get scope price from cache or fetch if not available
+ * @param oracle oracle address
+ * @param scopeCache cache for oracle prices
+ * @param allOracleAccounts all oracle accounts
+ * @param chain scope chain
+ */
+export function cacheOrGetScopePrice(
+  oracle: PublicKey,
+  scopeCache: Map<PublicKey, OraclePrices>,
+  allOracleAccounts: AllOracleAccounts,
+  chain: number[]
+): CandidatePrice | null {
+  if (!isNotNullPubkey(oracle) || !chain || !Scope.isScopeChainValid(chain)) {
+    return null;
+  }
+
+  const scopePrices = scopeCache.get(oracle);
+  if (scopePrices) {
+    return scopeChainToCandidatePrice(chain, scopePrices);
+  }
+  const info = allOracleAccounts.get(oracle);
+  if (info) {
+    const owner = info.owner.toString();
+    if (owner === getScopeAddress()) {
+      const prices = OraclePrices.decode(info.data);
+      scopeCache.set(oracle, prices);
+      return scopeChainToCandidatePrice(chain, prices);
+    } else {
+      console.error('Unrecognized scope owner address: ', owner);
+    }
+  }
+
+  return null;
+}
+
+function getBestPrice(current: CandidatePrice | undefined, next: CandidatePrice): CandidatePrice | undefined {
+  if (isBetterPrice(current, next)) {
+    return next;
+  }
+  return current;
+}
+
+function isBetterPrice(current: CandidatePrice | undefined, next: CandidatePrice): boolean {
+  if (!current) {
+    return true;
+  }
+  if (current.valid && !next.valid) {
+    return false;
+  }
+  if (!current.valid && next.valid) {
+    return true;
+  }
+  return next.timestamp > current.timestamp;
+}
+
+function validatePythPx(price: Decimal, confidence: number | undefined): boolean {
+  const conf50x = new Decimal(confidence || 0).mul(CONFIDENCE_FACTOR);
+  return price.gt(conf50x);
+}
+
+function validateSwitchboardV2Px(agg: any): boolean {
+  const pxMantissa = new Decimal(agg.latestConfirmedRound.result.mantissa.toString());
+  const pxScale = new Decimal(agg.latestConfirmedRound.result.scale.toString());
+  const stDevMantissa = new Decimal(agg.latestConfirmedRound.stdDeviation.mantissa.toString());
+  const stDevScale = new Decimal(agg.latestConfirmedRound.stdDeviation.scale.toString());
+  let conf50xScaled: Decimal;
+  if (pxScale.gte(stDevScale)) {
+    const scalingFactor = pxScale.sub(stDevScale);
+    const conf50x = stDevMantissa.mul(CONFIDENCE_FACTOR);
+    conf50xScaled = conf50x.mul(scalingFactor);
+  } else {
+    const scalingFactor = stDevScale.sub(pxScale);
+    const conf50x = stDevMantissa.mul(CONFIDENCE_FACTOR);
+    conf50xScaled = conf50x.div(scalingFactor);
+  }
+  return conf50xScaled.gte(pxMantissa);
+}
+
+function scopeChainToCandidatePrice(chain: number[], prices: OraclePrices): CandidatePrice {
+  const scopePx = Scope.getPriceFromScopeChain(chain, prices);
+  const valid = scopePx.timestamp.gt('0'); // scope prices are pre-validated
+  return {
+    price: scopePx.price,
+    timestamp: BigInt(scopePx.timestamp.toString()),
+    valid,
+  };
+}

package/src/utils/pubkey.ts

@@ -0,0 +1,261 @@
+import { PublicKey } from '@solana/web3.js';
+import BN from 'bn.js';
+
+export const NULL_PUBKEY = new PublicKey('nu11111111111111111111111111111111111111111');
+export const COMPUTE_BUDGET_PROGRAM_ID = new PublicKey('ComputeBudget111111111111111111111111111111');
+
+/**
+ * Helper function to check if a configured pubkey is null or default.
+ * @param pubkey
+ * @returns {boolean}
+ */
+export function isNotNullPubkey(pubkey: PublicKey): boolean {
+  return pubkey && !pubkey.equals(NULL_PUBKEY) && !pubkey.equals(PublicKey.default);
+}
+
+/**
+ * Custom set implementation for PublicKey
+ * Calling toString() on a PublicKey is pretty slow and pubkeys do not support `SameValueZero` comparison, so we use a custom set implementation where keys are compared with `PublicKey.equals(PublicKey)`
+ */
+export class PublicKeySet<T extends PublicKey> {
+  private items: T[] = [];
+
+  constructor(items: Array<T>) {
+    items.forEach((item) => this.add(item));
+  }
+
+  add(item: T): void {
+    if (!this.contains(item)) {
+      this.items.push(item);
+    }
+  }
+
+  contains(item: T): boolean {
+    return this.items.some((existingItem) => this.equals(existingItem, item));
+  }
+
+  private equals(item1: T, item2: T): boolean {
+    return item1.equals(item2);
+  }
+
+  isEmpty(): boolean {
+    return this.items.length === 0;
+  }
+
+  toArray(): T[] {
+    return this.items.slice(); // Return a copy of the array to prevent external modifications
+  }
+}
+
+/**
+ * Custom map implementation for PublicKey, backed by a list for o(n) lookup speed
+ * Calling toString() on a PublicKey is pretty slow and pubkeys do not support `SameValueZero` comparison, so we use a custom map implementation where keys are compared with `PublicKey.equals(PublicKey)`
+ */
+export class PublicKeyMap<K extends PublicKey, V> {
+  private record: { key: K; value: V }[] = [];
+
+  set(key: K, value: V): void {
+    const index = this.findIndex(key);
+    if (index !== -1) {
+      // Update existing entry
+      this.record[index].value = value;
+    } else {
+      // Add new entry
+      this.record.push({ key, value });
+    }
+  }
+
+  get(key: K): V | undefined {
+    const index = this.findIndex(key);
+    return index !== -1 ? this.record[index].value : undefined;
+  }
+
+  has(key: K): boolean {
+    return this.findIndex(key) !== -1;
+  }
+
+  delete(key: K): void {
+    const index = this.findIndex(key);
+    if (index !== -1) {
+      this.record.splice(index, 1);
+    }
+  }
+
+  private findIndex(key: K): number {
+    return this.record.findIndex((entry) => entry.key.equals(key));
+  }
+
+  clear(): void {
+    this.record = [];
+  }
+
+  forEach(callback: (value: V, key: K) => void): void {
+    this.record.forEach((entry) => {
+      callback(entry.value, entry.key);
+    });
+  }
+
+  keys(): K[] {
+    return this.record.map((entry) => entry.key);
+  }
+
+  values(): V[] {
+    return this.record.map((entry) => entry.value);
+  }
+
+  entries(): [K, V][] {
+    return this.record.map((entry) => [entry.key, entry.value]);
+  }
+
+  isEmpty(): boolean {
+    return this.record.length === 0;
+  }
+}
+
+/**
+ * Custom map implementation for PublicKey, backed by a hashmap for o(1) lookup speed
+ * Calling toString() on a PublicKey is pretty slow and pubkeys do not support `SameValueZero` comparison, so we use a custom map implementation where keys are compared with `PublicKey.equals(PublicKey)`, and a hash is derived from the final 32 bits of the public key
+ */
+export class PubkeyHashMap<K extends PublicKey, V> implements Map<K, V> {
+  private buckets: Map<
+    number,
+    {
+      key: K;
+      value: V;
+    }[]
+  >;
+  size: number;
+
+  constructor(entries?: readonly (readonly [K, V])[] | null) {
+    this.buckets = new Map();
+    this.size = 0;
+    if (entries) {
+      for (const [key, value] of entries) {
+        this.set(key, value);
+      }
+    }
+  }
+
+  *[Symbol.iterator](): IterableIterator<[K, V]> {
+    for (const [, bucket] of this.buckets) {
+      for (const { key, value } of bucket) {
+        yield [key, value];
+      }
+    }
+  }
+
+  [Symbol.toStringTag]: string = 'PubkeyHashMap';
+
+  set(key: K, value: V): this {
+    const hash = new HashablePublicKey(key).hashCode();
+    const bucket = this.buckets.get(hash);
+    if (!bucket) {
+      this.buckets.set(hash, [{ key, value }]);
+      this.size++;
+    } else {
+      const entry = bucket.find((entry) => entry.key.equals(key));
+      if (entry) {
+        entry.value = value;
+      } else {
+        bucket.push({ key, value });
+        this.size++;
+      }
+    }
+    return this;
+  }
+
+  get(key: K): V | undefined {
+    const hash = new HashablePublicKey(key).hashCode();
+    const bucket = this.buckets.get(hash);
+    if (!bucket) {
+      return undefined;
+    }
+    const entry = bucket.find((entry) => entry.key.equals(key));
+    return entry ? entry.value : undefined;
+  }
+
+  has(key: K): boolean {
+    const hash = new HashablePublicKey(key).hashCode();
+    const bucket = this.buckets.get(hash);
+    if (!bucket) {
+      return false;
+    }
+    const entry = bucket.find((entry) => entry.key.equals(key));
+    return !!entry;
+  }
+
+  delete(key: K): boolean {
+    const hash = new HashablePublicKey(key).hashCode();
+    const bucket = this.buckets.get(hash);
+    if (!bucket) {
+      return false;
+    }
+    const index = bucket.findIndex((entry) => entry.key.equals(key));
+    if (index === -1) {
+      return false;
+    }
+    bucket.splice(index, 1);
+    if (bucket.length === 0) {
+      this.buckets.delete(hash);
+    }
+    this.size--;
+    return true;
+  }
+
+  clear(): void {
+    this.buckets = new Map();
+    this.size = 0;
+  }
+
+  isEmpty(): boolean {
+    return this.size === 0;
+  }
+
+  forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void {
+    this.buckets.forEach((bucket) => {
+      bucket.forEach((entry) => {
+        callbackfn(entry.value, entry.key, this);
+      }, thisArg);
+    }, thisArg);
+  }
+
+  *keys(): IterableIterator<K> {
+    for (const [key] of this) {
+      yield key;
+    }
+  }
+
+  *values(): IterableIterator<V> {
+    for (const [, value] of this) {
+      yield value;
+    }
+  }
+
+  entries(): IterableIterator<[K, V]> {
+    return this[Symbol.iterator]();
+  }
+}
+
+export class HashablePublicKey extends PublicKey implements IEquality<HashablePublicKey> {
+  // We only use the last 32 bits of the public key for hashing
+  static MASK = new BN(1).shln(32).subn(1);
+  constructor(value: PublicKey | string | Buffer | Uint8Array | Array<number>) {
+    super(value);
+  }
+
+  hashCode(): number {
+    let hash = 13;
+    hash = hash * 7 + this.getBN().clone().iuand(HashablePublicKey.MASK).toNumber();
+    return hash;
+  }
+
+  private getBN(): BN {
+    //@ts-ignore
+    return this._bn;
+  }
+}
+
+interface IEquality<T extends IEquality<T>> {
+  equals(other: T): boolean;
+  hashCode(): number;
+}

package/src/utils/rpc.ts

@@ -0,0 +1,108 @@
+import {
+  AccountInfo,
+  Commitment,
+  Connection,
+  GetProgramAccountsConfig,
+  GetProgramAccountsResponse,
+  PublicKey,
+  SolanaJSONRPCError,
+} from '@solana/web3.js';
+import { Buffer } from 'buffer';
+import axios from 'axios';
+import { init, decompress } from '@bokuweb/zstd-wasm';
+(async () => {
+  await init();
+})();
+
+/**
+ * Uses zstd compression when fetching all accounts owned by a program for a smaller response size
+ * Uses axios instead of node-fetch to work around a bug in node-fetch that causes subsequent requests with different encoding to fail
+ * @param connection
+ * @param programId
+ * @param configOrCommitment
+ */
+export async function getProgramAccounts(
+  connection: Connection,
+  programId: PublicKey,
+  configOrCommitment?: GetProgramAccountsConfig | Commitment
+): Promise<GetProgramAccountsResponse> {
+  const programIdStr = programId.toBase58();
+  const { commitment, config } = extractCommitmentFromConfig(configOrCommitment);
+  const { encoding: _encoding, ...configWithoutEncoding } = config || {};
+  // Use axios here to work around a bug in node fetch that causes subsequent requests with different encoding to fail
+  // https://github.com/node-fetch/node-fetch/issues/1767
+  const response = await axios.post(
+    connection.rpcEndpoint,
+    {
+      method: 'getProgramAccounts',
+      jsonrpc: '2.0',
+      params: [
+        programIdStr,
+        {
+          encoding: 'base64+zstd',
+          commitment,
+          ...configWithoutEncoding,
+        },
+      ],
+      id: crypto.randomUUID(),
+    },
+    {
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        'Accept-Encoding': 'gzip, deflate',
+        'Cache-Control': 'no-cache',
+      },
+    }
+  );
+
+  const unsafeRes = response.data;
+  if ('error' in unsafeRes) {
+    throw new SolanaJSONRPCError(unsafeRes.error, `Failed to get accounts owned by program: ${[programIdStr]}`);
+  }
+
+  const res = unsafeRes as RpcResult;
+  const deser = res.result.map(async (account) => ({
+    account: await deserializeAccountInfo(account.account),
+    pubkey: new PublicKey(account.pubkey),
+  }));
+  const x = await Promise.all(deser);
+  return x as GetProgramAccountsResponse;
+}
+
+async function deserializeAccountInfo(accountInfo: AccountInfo<string[]>): Promise<AccountInfo<Buffer>> {
+  const data = decompress(Buffer.from(accountInfo.data[0], 'base64'));
+  return {
+    owner: accountInfo.owner,
+    lamports: accountInfo.lamports,
+    executable: accountInfo.executable,
+    rentEpoch: accountInfo.rentEpoch,
+    data: Buffer.from(data),
+  };
+}
+
+function extractCommitmentFromConfig<TConfig>(
+  commitmentOrConfig?: Commitment | ({ commitment?: Commitment } & TConfig)
+) {
+  let commitment: Commitment | undefined;
+  let config: Omit<TConfig, 'commitment'> | undefined;
+  if (typeof commitmentOrConfig === 'string') {
+    commitment = commitmentOrConfig;
+  } else if (commitmentOrConfig) {
+    const { commitment: specifiedCommitment, ...specifiedConfig } = commitmentOrConfig;
+    commitment = specifiedCommitment;
+    config = specifiedConfig;
+  }
+  return { commitment, config };
+}
+
+interface RpcResult {
+  jsonrpc: string;
+  result: Result;
+}
+
+export type Result = readonly Readonly<{
+  account: AccountInfo<string[]>;
+  /** the account Pubkey as base-58 encoded string */
+  pubkey: string;
+}>[];