@solana/web3.js 1.87.3 → 2.0.0-experimental.0099b2a

package/src/epoch-schedule.ts

@@ -1,102 +0,0 @@
-const MINIMUM_SLOT_PER_EPOCH = 32;
-
-// Returns the number of trailing zeros in the binary representation of self.
-function trailingZeros(n: number) {
-  let trailingZeros = 0;
-  while (n > 1) {
-    n /= 2;
-    trailingZeros++;
-  }
-  return trailingZeros;
-}
-
-// Returns the smallest power of two greater than or equal to n
-function nextPowerOfTwo(n: number) {
-  if (n === 0) return 1;
-  n--;
-  n |= n >> 1;
-  n |= n >> 2;
-  n |= n >> 4;
-  n |= n >> 8;
-  n |= n >> 16;
-  n |= n >> 32;
-  return n + 1;
-}
-
-/**
- * Epoch schedule
- * (see https://docs.solana.com/terminology#epoch)
- * Can be retrieved with the {@link Connection.getEpochSchedule} method
- */
-export class EpochSchedule {
-  /** The maximum number of slots in each epoch */
-  public slotsPerEpoch: number;
-  /** The number of slots before beginning of an epoch to calculate a leader schedule for that epoch */
-  public leaderScheduleSlotOffset: number;
-  /** Indicates whether epochs start short and grow */
-  public warmup: boolean;
-  /** The first epoch with `slotsPerEpoch` slots */
-  public firstNormalEpoch: number;
-  /** The first slot of `firstNormalEpoch` */
-  public firstNormalSlot: number;
-
-  constructor(
-    slotsPerEpoch: number,
-    leaderScheduleSlotOffset: number,
-    warmup: boolean,
-    firstNormalEpoch: number,
-    firstNormalSlot: number,
-  ) {
-    this.slotsPerEpoch = slotsPerEpoch;
-    this.leaderScheduleSlotOffset = leaderScheduleSlotOffset;
-    this.warmup = warmup;
-    this.firstNormalEpoch = firstNormalEpoch;
-    this.firstNormalSlot = firstNormalSlot;
-  }
-
-  getEpoch(slot: number): number {
-    return this.getEpochAndSlotIndex(slot)[0];
-  }
-
-  getEpochAndSlotIndex(slot: number): [number, number] {
-    if (slot < this.firstNormalSlot) {
-      const epoch =
-        trailingZeros(nextPowerOfTwo(slot + MINIMUM_SLOT_PER_EPOCH + 1)) -
-        trailingZeros(MINIMUM_SLOT_PER_EPOCH) -
-        1;
-
-      const epochLen = this.getSlotsInEpoch(epoch);
-      const slotIndex = slot - (epochLen - MINIMUM_SLOT_PER_EPOCH);
-      return [epoch, slotIndex];
-    } else {
-      const normalSlotIndex = slot - this.firstNormalSlot;
-      const normalEpochIndex = Math.floor(normalSlotIndex / this.slotsPerEpoch);
-      const epoch = this.firstNormalEpoch + normalEpochIndex;
-      const slotIndex = normalSlotIndex % this.slotsPerEpoch;
-      return [epoch, slotIndex];
-    }
-  }
-
-  getFirstSlotInEpoch(epoch: number): number {
-    if (epoch <= this.firstNormalEpoch) {
-      return (Math.pow(2, epoch) - 1) * MINIMUM_SLOT_PER_EPOCH;
-    } else {
-      return (
-        (epoch - this.firstNormalEpoch) * this.slotsPerEpoch +
-        this.firstNormalSlot
-      );
-    }
-  }
-
-  getLastSlotInEpoch(epoch: number): number {
-    return this.getFirstSlotInEpoch(epoch) + this.getSlotsInEpoch(epoch) - 1;
-  }
-
-  getSlotsInEpoch(epoch: number) {
-    if (epoch < this.firstNormalEpoch) {
-      return Math.pow(2, epoch + trailingZeros(MINIMUM_SLOT_PER_EPOCH));
-    } else {
-      return this.slotsPerEpoch;
-    }
-  }
-}

package/src/errors.ts

@@ -1,50 +0,0 @@
-export class SendTransactionError extends Error {
-  logs: string[] | undefined;
-
-  constructor(message: string, logs?: string[]) {
-    super(message);
-
-    this.logs = logs;
-  }
-}
-
-// Keep in sync with client/src/rpc_custom_errors.rs
-// Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
-export const SolanaJSONRPCErrorCode = {
-  JSON_RPC_SERVER_ERROR_BLOCK_CLEANED_UP: -32001,
-  JSON_RPC_SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE: -32002,
-  JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE: -32003,
-  JSON_RPC_SERVER_ERROR_BLOCK_NOT_AVAILABLE: -32004,
-  JSON_RPC_SERVER_ERROR_NODE_UNHEALTHY: -32005,
-  JSON_RPC_SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE: -32006,
-  JSON_RPC_SERVER_ERROR_SLOT_SKIPPED: -32007,
-  JSON_RPC_SERVER_ERROR_NO_SNAPSHOT: -32008,
-  JSON_RPC_SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED: -32009,
-  JSON_RPC_SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX: -32010,
-  JSON_RPC_SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE: -32011,
-  JSON_RPC_SCAN_ERROR: -32012,
-  JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH: -32013,
-  JSON_RPC_SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET: -32014,
-  JSON_RPC_SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION: -32015,
-  JSON_RPC_SERVER_ERROR_MIN_CONTEXT_SLOT_NOT_REACHED: -32016,
-} as const;
-export type SolanaJSONRPCErrorCodeEnum =
-  (typeof SolanaJSONRPCErrorCode)[keyof typeof SolanaJSONRPCErrorCode];
-
-export class SolanaJSONRPCError extends Error {
-  code: SolanaJSONRPCErrorCodeEnum | unknown;
-  data?: any;
-  constructor(
-    {
-      code,
-      message,
-      data,
-    }: Readonly<{code: unknown; message: string; data?: any}>,
-    customMessage?: string,
-  ) {
-    super(customMessage != null ? `${customMessage}: ${message}` : message);
-    this.code = code;
-    this.data = data;
-    this.name = 'SolanaJSONRPCError';
-  }
-}

package/src/fee-calculator.ts

@@ -1,18 +0,0 @@
-import * as BufferLayout from '@solana/buffer-layout';
-
-/**
- * https://github.com/solana-labs/solana/blob/90bedd7e067b5b8f3ddbb45da00a4e9cabb22c62/sdk/src/fee_calculator.rs#L7-L11
- *
- * @internal
- */
-export const FeeCalculatorLayout = BufferLayout.nu64('lamportsPerSignature');
-
-/**
- * Calculator for transaction fees.
- *
- * @deprecated Deprecated since Solana v1.8.0.
- */
-export interface FeeCalculator {
-  /** Cost in lamports to validate a signature. */
-  lamportsPerSignature: number;
-}

package/src/fetch-impl.ts

@@ -1,16 +0,0 @@
-import * as nodeFetch from 'node-fetch';
-
-export default (typeof globalThis.fetch === 'function'
-  ? // The Fetch API is supported experimentally in Node 17.5+ and natively in Node 18+.
-    globalThis.fetch
-  : // Otherwise use the polyfill.
-    async function (
-      input: nodeFetch.RequestInfo,
-      init?: nodeFetch.RequestInit,
-    ): Promise<nodeFetch.Response> {
-      const processedInput =
-        typeof input === 'string' && input.slice(0, 2) === '//'
-          ? 'https:' + input
-          : input;
-      return await nodeFetch.default(processedInput, init);
-    }) as typeof globalThis.fetch;

package/src/index.ts

@@ -1,24 +0,0 @@
-export * from './account';
-export * from './blockhash';
-export * from './bpf-loader-deprecated';
-export * from './bpf-loader';
-export * from './connection';
-export * from './epoch-schedule';
-export * from './errors';
-export * from './fee-calculator';
-export * from './keypair';
-export * from './loader';
-export * from './message';
-export * from './nonce-account';
-export * from './programs';
-export * from './publickey';
-export * from './transaction';
-export * from './validator-info';
-export * from './vote-account';
-export * from './sysvar';
-export * from './utils';
-
-/**
- * There are 1-billion lamports in one SOL
- */
-export const LAMPORTS_PER_SOL = 1000000000;

package/src/instruction.ts

@@ -1,58 +0,0 @@
-import {Buffer} from 'buffer';
-import * as BufferLayout from '@solana/buffer-layout';
-
-import * as Layout from './layout';
-
-export interface IInstructionInputData {
-  readonly instruction: number;
-}
-
-/**
- * @internal
- */
-export type InstructionType<TInputData extends IInstructionInputData> = {
-  /** The Instruction index (from solana upstream program) */
-  index: number;
-  /** The BufferLayout to use to build data */
-  layout: BufferLayout.Layout<TInputData>;
-};
-
-/**
- * Populate a buffer of instruction data using an InstructionType
- * @internal
- */
-export function encodeData<TInputData extends IInstructionInputData>(
-  type: InstructionType<TInputData>,
-  fields?: any,
-): Buffer {
-  const allocLength =
-    type.layout.span >= 0 ? type.layout.span : Layout.getAlloc(type, fields);
-  const data = Buffer.alloc(allocLength);
-  const layoutFields = Object.assign({instruction: type.index}, fields);
-  type.layout.encode(layoutFields, data);
-  return data;
-}
-
-/**
- * Decode instruction data buffer using an InstructionType
- * @internal
- */
-export function decodeData<TInputData extends IInstructionInputData>(
-  type: InstructionType<TInputData>,
-  buffer: Buffer,
-): TInputData {
-  let data: TInputData;
-  try {
-    data = type.layout.decode(buffer);
-  } catch (err) {
-    throw new Error('invalid instruction; ' + err);
-  }
-
-  if (data.instruction !== type.index) {
-    throw new Error(
-      `invalid instruction; instruction index mismatch ${data.instruction} != ${type.index}`,
-    );
-  }
-
-  return data;
-}

package/src/keypair.ts

@@ -1,102 +0,0 @@
-import {generateKeypair, getPublicKey, Ed25519Keypair} from './utils/ed25519';
-import {PublicKey} from './publickey';
-
-/**
- * Keypair signer interface
- */
-export interface Signer {
-  publicKey: PublicKey;
-  secretKey: Uint8Array;
-}
-
-/**
- * An account keypair used for signing transactions.
- */
-export class Keypair {
-  private _keypair: Ed25519Keypair;
-
-  /**
-   * Create a new keypair instance.
-   * Generate random keypair if no {@link Ed25519Keypair} is provided.
-   *
-   * @param {Ed25519Keypair} keypair ed25519 keypair
-   */
-  constructor(keypair?: Ed25519Keypair) {
-    this._keypair = keypair ?? generateKeypair();
-  }
-
-  /**
-   * Generate a new random keypair
-   *
-   * @returns {Keypair} Keypair
-   */
-  static generate(): Keypair {
-    return new Keypair(generateKeypair());
-  }
-
-  /**
-   * Create a keypair from a raw secret key byte array.
-   *
-   * This method should only be used to recreate a keypair from a previously
-   * generated secret key. Generating keypairs from a random seed should be done
-   * with the {@link Keypair.fromSeed} method.
-   *
-   * @throws error if the provided secret key is invalid and validation is not skipped.
-   *
-   * @param secretKey secret key byte array
-   * @param options skip secret key validation
-   *
-   * @returns {Keypair} Keypair
-   */
-  static fromSecretKey(
-    secretKey: Uint8Array,
-    options?: {skipValidation?: boolean},
-  ): Keypair {
-    if (secretKey.byteLength !== 64) {
-      throw new Error('bad secret key size');
-    }
-    const publicKey = secretKey.slice(32, 64);
-    if (!options || !options.skipValidation) {
-      const privateScalar = secretKey.slice(0, 32);
-      const computedPublicKey = getPublicKey(privateScalar);
-      for (let ii = 0; ii < 32; ii++) {
-        if (publicKey[ii] !== computedPublicKey[ii]) {
-          throw new Error('provided secretKey is invalid');
-        }
-      }
-    }
-    return new Keypair({publicKey, secretKey});
-  }
-
-  /**
-   * Generate a keypair from a 32 byte seed.
-   *
-   * @param seed seed byte array
-   *
-   * @returns {Keypair} Keypair
-   */
-  static fromSeed(seed: Uint8Array): Keypair {
-    const publicKey = getPublicKey(seed);
-    const secretKey = new Uint8Array(64);
-    secretKey.set(seed);
-    secretKey.set(publicKey, 32);
-    return new Keypair({publicKey, secretKey});
-  }
-
-  /**
-   * The public key for this keypair
-   *
-   * @returns {PublicKey} PublicKey
-   */
-  get publicKey(): PublicKey {
-    return new PublicKey(this._keypair.publicKey);
-  }
-
-  /**
-   * The raw secret key for this keypair
-   * @returns {Uint8Array} Secret key in an array of Uint8 bytes
-   */
-  get secretKey(): Uint8Array {
-    return new Uint8Array(this._keypair.secretKey);
-  }
-}

package/src/layout.ts

@@ -1,188 +0,0 @@
-import {Buffer} from 'buffer';
-import * as BufferLayout from '@solana/buffer-layout';
-
-import {VoteAuthorizeWithSeedArgs} from './programs/vote';
-
-/**
- * Layout for a public key
- */
-export const publicKey = (property: string = 'publicKey') => {
-  return BufferLayout.blob(32, property);
-};
-
-/**
- * Layout for a signature
- */
-export const signature = (property: string = 'signature') => {
-  return BufferLayout.blob(64, property);
-};
-
-/**
- * Layout for a 64bit unsigned value
- */
-export const uint64 = (property: string = 'uint64') => {
-  return BufferLayout.blob(8, property);
-};
-
-interface IRustStringShim
-  extends Omit<
-    BufferLayout.Structure<
-      Readonly<{
-        length: number;
-        lengthPadding: number;
-        chars: Uint8Array;
-      }>
-    >,
-    'decode' | 'encode' | 'replicate'
-  > {
-  alloc: (str: string) => number;
-  decode: (b: Uint8Array, offset?: number) => string;
-  encode: (str: string, b: Uint8Array, offset?: number) => number;
-  replicate: (property: string) => this;
-}
-
-/**
- * Layout for a Rust String type
- */
-export const rustString = (
-  property: string = 'string',
-): BufferLayout.Layout<string> => {
-  const rsl = BufferLayout.struct<
-    Readonly<{
-      length?: number;
-      lengthPadding?: number;
-      chars: Uint8Array;
-    }>
-  >(
-    [
-      BufferLayout.u32('length'),
-      BufferLayout.u32('lengthPadding'),
-      BufferLayout.blob(BufferLayout.offset(BufferLayout.u32(), -8), 'chars'),
-    ],
-    property,
-  );
-  const _decode = rsl.decode.bind(rsl);
-  const _encode = rsl.encode.bind(rsl);
-
-  const rslShim = rsl as unknown as IRustStringShim;
-
-  rslShim.decode = (b: Uint8Array, offset?: number) => {
-    const data = _decode(b, offset);
-    return data['chars'].toString();
-  };
-
-  rslShim.encode = (str: string, b: Uint8Array, offset?: number) => {
-    const data = {
-      chars: Buffer.from(str, 'utf8'),
-    };
-    return _encode(data, b, offset);
-  };
-
-  rslShim.alloc = (str: string) => {
-    return (
-      BufferLayout.u32().span +
-      BufferLayout.u32().span +
-      Buffer.from(str, 'utf8').length
-    );
-  };
-
-  return rslShim;
-};
-
-/**
- * Layout for an Authorized object
- */
-export const authorized = (property: string = 'authorized') => {
-  return BufferLayout.struct<
-    Readonly<{
-      staker: Uint8Array;
-      withdrawer: Uint8Array;
-    }>
-  >([publicKey('staker'), publicKey('withdrawer')], property);
-};
-
-/**
- * Layout for a Lockup object
- */
-export const lockup = (property: string = 'lockup') => {
-  return BufferLayout.struct<
-    Readonly<{
-      custodian: Uint8Array;
-      epoch: number;
-      unixTimestamp: number;
-    }>
-  >(
-    [
-      BufferLayout.ns64('unixTimestamp'),
-      BufferLayout.ns64('epoch'),
-      publicKey('custodian'),
-    ],
-    property,
-  );
-};
-
-/**
- *  Layout for a VoteInit object
- */
-export const voteInit = (property: string = 'voteInit') => {
-  return BufferLayout.struct<
-    Readonly<{
-      authorizedVoter: Uint8Array;
-      authorizedWithdrawer: Uint8Array;
-      commission: number;
-      nodePubkey: Uint8Array;
-    }>
-  >(
-    [
-      publicKey('nodePubkey'),
-      publicKey('authorizedVoter'),
-      publicKey('authorizedWithdrawer'),
-      BufferLayout.u8('commission'),
-    ],
-    property,
-  );
-};
-
-/**
- *  Layout for a VoteAuthorizeWithSeedArgs object
- */
-export const voteAuthorizeWithSeedArgs = (
-  property: string = 'voteAuthorizeWithSeedArgs',
-) => {
-  return BufferLayout.struct<VoteAuthorizeWithSeedArgs>(
-    [
-      BufferLayout.u32('voteAuthorizationType'),
-      publicKey('currentAuthorityDerivedKeyOwnerPubkey'),
-      rustString('currentAuthorityDerivedKeySeed'),
-      publicKey('newAuthorized'),
-    ],
-    property,
-  );
-};
-
-export function getAlloc(type: any, fields: any): number {
-  const getItemAlloc = (item: any): number => {
-    if (item.span >= 0) {
-      return item.span;
-    } else if (typeof item.alloc === 'function') {
-      return item.alloc(fields[item.property]);
-    } else if ('count' in item && 'elementLayout' in item) {
-      const field = fields[item.property];
-      if (Array.isArray(field)) {
-        return field.length * getItemAlloc(item.elementLayout);
-      }
-    } else if ('fields' in item) {
-      // This is a `Structure` whose size needs to be recursively measured.
-      return getAlloc({layout: item}, fields[item.property]);
-    }
-    // Couldn't determine allocated size of layout
-    return 0;
-  };
-
-  let alloc = 0;
-  type.layout.fields.forEach((item: any) => {
-    alloc += getItemAlloc(item);
-  });
-
-  return alloc;
-}