@solana/web3.js 0.0.0-next

package/src/ed25519-program.ts

@@ -0,0 +1,157 @@
+import {Buffer} from 'buffer';
+import * as BufferLayout from '@solana/buffer-layout';
+import nacl from 'tweetnacl';
+
+import {Keypair} from './keypair';
+import {PublicKey} from './publickey';
+import {TransactionInstruction} from './transaction';
+import assert from './util/assert';
+
+const PRIVATE_KEY_BYTES = 64;
+const PUBLIC_KEY_BYTES = 32;
+const SIGNATURE_BYTES = 64;
+
+/**
+ * Params for creating an ed25519 instruction using a public key
+ */
+export type CreateEd25519InstructionWithPublicKeyParams = {
+  publicKey: Uint8Array;
+  message: Uint8Array;
+  signature: Uint8Array;
+  instructionIndex?: number;
+};
+
+/**
+ * Params for creating an ed25519 instruction using a private key
+ */
+export type CreateEd25519InstructionWithPrivateKeyParams = {
+  privateKey: Uint8Array;
+  message: Uint8Array;
+  instructionIndex?: number;
+};
+
+const ED25519_INSTRUCTION_LAYOUT = BufferLayout.struct<
+  Readonly<{
+    messageDataOffset: number;
+    messageDataSize: number;
+    messageInstructionIndex: number;
+    numSignatures: number;
+    padding: number;
+    publicKeyInstructionIndex: number;
+    publicKeyOffset: number;
+    signatureInstructionIndex: number;
+    signatureOffset: number;
+  }>
+>([
+  BufferLayout.u8('numSignatures'),
+  BufferLayout.u8('padding'),
+  BufferLayout.u16('signatureOffset'),
+  BufferLayout.u16('signatureInstructionIndex'),
+  BufferLayout.u16('publicKeyOffset'),
+  BufferLayout.u16('publicKeyInstructionIndex'),
+  BufferLayout.u16('messageDataOffset'),
+  BufferLayout.u16('messageDataSize'),
+  BufferLayout.u16('messageInstructionIndex'),
+]);
+
+export class Ed25519Program {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  /**
+   * Public key that identifies the ed25519 program
+   */
+  static programId: PublicKey = new PublicKey(
+    'Ed25519SigVerify111111111111111111111111111',
+  );
+
+  /**
+   * Create an ed25519 instruction with a public key and signature. The
+   * public key must be a buffer that is 32 bytes long, and the signature
+   * must be a buffer of 64 bytes.
+   */
+  static createInstructionWithPublicKey(
+    params: CreateEd25519InstructionWithPublicKeyParams,
+  ): TransactionInstruction {
+    const {publicKey, message, signature, instructionIndex} = params;
+
+    assert(
+      publicKey.length === PUBLIC_KEY_BYTES,
+      `Public Key must be ${PUBLIC_KEY_BYTES} bytes but received ${publicKey.length} bytes`,
+    );
+
+    assert(
+      signature.length === SIGNATURE_BYTES,
+      `Signature must be ${SIGNATURE_BYTES} bytes but received ${signature.length} bytes`,
+    );
+
+    const publicKeyOffset = ED25519_INSTRUCTION_LAYOUT.span;
+    const signatureOffset = publicKeyOffset + publicKey.length;
+    const messageDataOffset = signatureOffset + signature.length;
+    const numSignatures = 1;
+
+    const instructionData = Buffer.alloc(messageDataOffset + message.length);
+
+    const index =
+      instructionIndex == null
+        ? 0xffff // An index of `u16::MAX` makes it default to the current instruction.
+        : instructionIndex;
+
+    ED25519_INSTRUCTION_LAYOUT.encode(
+      {
+        numSignatures,
+        padding: 0,
+        signatureOffset,
+        signatureInstructionIndex: index,
+        publicKeyOffset,
+        publicKeyInstructionIndex: index,
+        messageDataOffset,
+        messageDataSize: message.length,
+        messageInstructionIndex: index,
+      },
+      instructionData,
+    );
+
+    instructionData.fill(publicKey, publicKeyOffset);
+    instructionData.fill(signature, signatureOffset);
+    instructionData.fill(message, messageDataOffset);
+
+    return new TransactionInstruction({
+      keys: [],
+      programId: Ed25519Program.programId,
+      data: instructionData,
+    });
+  }
+
+  /**
+   * Create an ed25519 instruction with a private key. The private key
+   * must be a buffer that is 64 bytes long.
+   */
+  static createInstructionWithPrivateKey(
+    params: CreateEd25519InstructionWithPrivateKeyParams,
+  ): TransactionInstruction {
+    const {privateKey, message, instructionIndex} = params;
+
+    assert(
+      privateKey.length === PRIVATE_KEY_BYTES,
+      `Private key must be ${PRIVATE_KEY_BYTES} bytes but received ${privateKey.length} bytes`,
+    );
+
+    try {
+      const keypair = Keypair.fromSecretKey(privateKey);
+      const publicKey = keypair.publicKey.toBytes();
+      const signature = nacl.sign.detached(message, keypair.secretKey);
+
+      return this.createInstructionWithPublicKey({
+        publicKey,
+        message,
+        signature,
+        instructionIndex,
+      });
+    } catch (error) {
+      throw new Error(`Error creating instruction; ${error}`);
+    }
+  }
+}

package/src/epoch-schedule.ts

@@ -0,0 +1,102 @@
+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

@@ -0,0 +1,9 @@
+export class SendTransactionError extends Error {
+  logs: string[] | undefined;
+
+  constructor(message: string, logs?: string[]) {
+    super(message);
+
+    this.logs = logs;
+  }
+}

package/src/fee-calculator.ts

@@ -0,0 +1,16 @@
+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.
+ */
+export interface FeeCalculator {
+  /** Cost in lamports to validate a signature. */
+  lamportsPerSignature: number;
+}

package/src/index.ts

@@ -0,0 +1,31 @@
+export * from './account';
+export * from './blockhash';
+export * from './bpf-loader-deprecated';
+export * from './bpf-loader';
+export * from './connection';
+export * from './epoch-schedule';
+export * from './ed25519-program';
+export * from './fee-calculator';
+export * from './keypair';
+export * from './loader';
+export * from './message';
+export * from './nonce-account';
+export * from './publickey';
+export * from './stake-program';
+export * from './system-program';
+export * from './secp256k1-program';
+export * from './transaction';
+export * from './validator-info';
+export * from './vote-account';
+export * from './vote-program';
+export * from './sysvar';
+export * from './errors';
+export * from './util/borsh-schema';
+export * from './util/send-and-confirm-transaction';
+export * from './util/send-and-confirm-raw-transaction';
+export * from './util/cluster';
+
+/**
+ * There are 1-billion lamports in one SOL
+ */
+export const LAMPORTS_PER_SOL = 1000000000;

package/src/instruction.ts

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,98 @@
+import nacl from 'tweetnacl';
+
+import {PublicKey} from './publickey';
+
+/**
+ * Keypair signer interface
+ */
+export interface Signer {
+  publicKey: PublicKey;
+  secretKey: Uint8Array;
+}
+
+/**
+ * Ed25519 Keypair
+ */
+export interface Ed25519Keypair {
+  publicKey: Uint8Array;
+  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 keypair ed25519 keypair
+   */
+  constructor(keypair?: Ed25519Keypair) {
+    if (keypair) {
+      this._keypair = keypair;
+    } else {
+      this._keypair = nacl.sign.keyPair();
+    }
+  }
+
+  /**
+   * Generate a new random keypair
+   */
+  static generate(): Keypair {
+    return new Keypair(nacl.sign.keyPair());
+  }
+
+  /**
+   * 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
+   */
+  static fromSecretKey(
+    secretKey: Uint8Array,
+    options?: {skipValidation?: boolean},
+  ): Keypair {
+    const keypair = nacl.sign.keyPair.fromSecretKey(secretKey);
+    if (!options || !options.skipValidation) {
+      const encoder = new TextEncoder();
+      const signData = encoder.encode('@solana/web3.js-validation-v1');
+      const signature = nacl.sign.detached(signData, keypair.secretKey);
+      if (!nacl.sign.detached.verify(signData, signature, keypair.publicKey)) {
+        throw new Error('provided secretKey is invalid');
+      }
+    }
+    return new Keypair(keypair);
+  }
+
+  /**
+   * Generate a keypair from a 32 byte seed.
+   *
+   * @param seed seed byte array
+   */
+  static fromSeed(seed: Uint8Array): Keypair {
+    return new Keypair(nacl.sign.keyPair.fromSeed(seed));
+  }
+
+  /**
+   * The public key for this keypair
+   */
+  get publicKey(): PublicKey {
+    return new PublicKey(this._keypair.publicKey);
+  }
+
+  /**
+   * The raw secret key for this keypair
+   */
+  get secretKey(): Uint8Array {
+    return this._keypair.secretKey;
+  }
+}

package/src/layout.ts

@@ -0,0 +1,147 @@
+import {Buffer} from 'buffer';
+import * as BufferLayout from '@solana/buffer-layout';
+
+/**
+ * Layout for a public key
+ */
+export const publicKey = (property: string = 'publicKey') => {
+  return BufferLayout.blob(32, 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,
+  );
+};
+
+export function getAlloc(type: any, fields: any): number {
+  let alloc = 0;
+  type.layout.fields.forEach((item: any) => {
+    if (item.span >= 0) {
+      alloc += item.span;
+    } else if (typeof item.alloc === 'function') {
+      alloc += item.alloc(fields[item.property]);
+    }
+  });
+  return alloc;
+}