@solana/web3.js 0.0.0-development → 0.0.0-pr-29130

package/src/epoch-schedule.ts

@@ -26,7 +26,7 @@ function nextPowerOfTwo(n: number) {
 /**
  * Epoch schedule
  * (see https://docs.solana.com/terminology#epoch)
- * Can be retrieved with the {@link connection.getEpochSchedule} method
+ * Can be retrieved with the {@link Connection.getEpochSchedule} method
  */
 export class EpochSchedule {
   /** The maximum number of slots in each epoch */

package/src/keypair.ts

@@ -1,5 +1,4 @@
-import nacl from 'tweetnacl';
-
+import {generateKeypair, getPublicKey, Ed25519Keypair} from './utils/ed25519';
 import {PublicKey} from './publickey';
 
 /**
@@ -10,14 +9,6 @@ export interface Signer {
   secretKey: Uint8Array;
 }
 
-/**
- * Ed25519 Keypair
- */
-export interface Ed25519Keypair {
-  publicKey: Uint8Array;
-  secretKey: Uint8Array;
-}
-
 /**
  * An account keypair used for signing transactions.
  */
@@ -31,18 +22,14 @@ export class Keypair {
    * @param keypair ed25519 keypair
    */
   constructor(keypair?: Ed25519Keypair) {
-    if (keypair) {
-      this._keypair = keypair;
-    } else {
-      this._keypair = nacl.sign.keyPair();
-    }
+    this._keypair = keypair ?? generateKeypair();
   }
 
   /**
    * Generate a new random keypair
    */
   static generate(): Keypair {
-    return new Keypair(nacl.sign.keyPair());
+    return new Keypair(generateKeypair());
   }
 
   /**
@@ -61,16 +48,20 @@ export class Keypair {
     secretKey: Uint8Array,
     options?: {skipValidation?: boolean},
   ): Keypair {
-    const keypair = nacl.sign.keyPair.fromSecretKey(secretKey);
+    if (secretKey.byteLength !== 64) {
+      throw new Error('bad secret key size');
+    }
+    const publicKey = secretKey.slice(32, 64);
     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');
+      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(keypair);
+    return new Keypair({publicKey, secretKey});
   }
 
   /**
@@ -79,7 +70,11 @@ export class Keypair {
    * @param seed seed byte array
    */
   static fromSeed(seed: Uint8Array): Keypair {
-    return new Keypair(nacl.sign.keyPair.fromSeed(seed));
+    const publicKey = getPublicKey(seed);
+    const secretKey = new Uint8Array(64);
+    secretKey.set(seed);
+    secretKey.set(publicKey, 32);
+    return new Keypair({publicKey, secretKey});
   }
 
   /**
@@ -93,6 +88,6 @@ export class Keypair {
    * The raw secret key for this keypair
    */
   get secretKey(): Uint8Array {
-    return this._keypair.secretKey;
+    return new Uint8Array(this._keypair.secretKey);
   }
 }

package/src/layout.ts

@@ -1,6 +1,8 @@
 import {Buffer} from 'buffer';
 import * as BufferLayout from '@solana/buffer-layout';
 
+import {VoteAuthorizeWithSeedArgs} from './programs/vote';
+
 /**
  * Layout for a public key
  */
@@ -8,6 +10,13 @@ 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
  */
@@ -134,6 +143,23 @@ export const voteInit = (property: string = 'voteInit') => {
   );
 };
 
+/**
+ *  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) {
@@ -145,6 +171,9 @@ export function getAlloc(type: any, fields: any): number {
       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;

package/src/message/account-keys.ts

@@ -0,0 +1,79 @@
+import {LoadedAddresses} from '../connection';
+import {PublicKey} from '../publickey';
+import {TransactionInstruction} from '../transaction';
+import {MessageCompiledInstruction} from './index';
+
+export type AccountKeysFromLookups = LoadedAddresses;
+
+export class MessageAccountKeys {
+  staticAccountKeys: Array<PublicKey>;
+  accountKeysFromLookups?: AccountKeysFromLookups;
+
+  constructor(
+    staticAccountKeys: Array<PublicKey>,
+    accountKeysFromLookups?: AccountKeysFromLookups,
+  ) {
+    this.staticAccountKeys = staticAccountKeys;
+    this.accountKeysFromLookups = accountKeysFromLookups;
+  }
+
+  keySegments(): Array<Array<PublicKey>> {
+    const keySegments = [this.staticAccountKeys];
+    if (this.accountKeysFromLookups) {
+      keySegments.push(this.accountKeysFromLookups.writable);
+      keySegments.push(this.accountKeysFromLookups.readonly);
+    }
+    return keySegments;
+  }
+
+  get(index: number): PublicKey | undefined {
+    for (const keySegment of this.keySegments()) {
+      if (index < keySegment.length) {
+        return keySegment[index];
+      } else {
+        index -= keySegment.length;
+      }
+    }
+    return;
+  }
+
+  get length(): number {
+    return this.keySegments().flat().length;
+  }
+
+  compileInstructions(
+    instructions: Array<TransactionInstruction>,
+  ): Array<MessageCompiledInstruction> {
+    // Bail early if any account indexes would overflow a u8
+    const U8_MAX = 255;
+    if (this.length > U8_MAX + 1) {
+      throw new Error('Account index overflow encountered during compilation');
+    }
+
+    const keyIndexMap = new Map();
+    this.keySegments()
+      .flat()
+      .forEach((key, index) => {
+        keyIndexMap.set(key.toBase58(), index);
+      });
+
+    const findKeyIndex = (key: PublicKey) => {
+      const keyIndex = keyIndexMap.get(key.toBase58());
+      if (keyIndex === undefined)
+        throw new Error(
+          'Encountered an unknown instruction account key during compilation',
+        );
+      return keyIndex;
+    };
+
+    return instructions.map((instruction): MessageCompiledInstruction => {
+      return {
+        programIdIndex: findKeyIndex(instruction.programId),
+        accountKeyIndexes: instruction.keys.map(meta =>
+          findKeyIndex(meta.pubkey),
+        ),
+        data: instruction.data,
+      };
+    });
+  }
+}

package/src/message/compiled-keys.ts

@@ -0,0 +1,165 @@
+import {MessageHeader, MessageAddressTableLookup} from './index';
+import {AccountKeysFromLookups} from './account-keys';
+import {AddressLookupTableAccount} from '../programs';
+import {TransactionInstruction} from '../transaction';
+import assert from '../utils/assert';
+import {PublicKey} from '../publickey';
+
+export type CompiledKeyMeta = {
+  isSigner: boolean;
+  isWritable: boolean;
+  isInvoked: boolean;
+};
+
+type KeyMetaMap = Map<string, CompiledKeyMeta>;
+
+export class CompiledKeys {
+  payer: PublicKey;
+  keyMetaMap: KeyMetaMap;
+
+  constructor(payer: PublicKey, keyMetaMap: KeyMetaMap) {
+    this.payer = payer;
+    this.keyMetaMap = keyMetaMap;
+  }
+
+  static compile(
+    instructions: Array<TransactionInstruction>,
+    payer: PublicKey,
+  ): CompiledKeys {
+    const keyMetaMap: KeyMetaMap = new Map();
+    const getOrInsertDefault = (pubkey: PublicKey): CompiledKeyMeta => {
+      const address = pubkey.toBase58();
+      let keyMeta = keyMetaMap.get(address);
+      if (keyMeta === undefined) {
+        keyMeta = {
+          isSigner: false,
+          isWritable: false,
+          isInvoked: false,
+        };
+        keyMetaMap.set(address, keyMeta);
+      }
+      return keyMeta;
+    };
+
+    const payerKeyMeta = getOrInsertDefault(payer);
+    payerKeyMeta.isSigner = true;
+    payerKeyMeta.isWritable = true;
+
+    for (const ix of instructions) {
+      getOrInsertDefault(ix.programId).isInvoked = true;
+      for (const accountMeta of ix.keys) {
+        const keyMeta = getOrInsertDefault(accountMeta.pubkey);
+        keyMeta.isSigner ||= accountMeta.isSigner;
+        keyMeta.isWritable ||= accountMeta.isWritable;
+      }
+    }
+
+    return new CompiledKeys(payer, keyMetaMap);
+  }
+
+  getMessageComponents(): [MessageHeader, Array<PublicKey>] {
+    const mapEntries = [...this.keyMetaMap.entries()];
+    assert(mapEntries.length <= 256, 'Max static account keys length exceeded');
+
+    const writableSigners = mapEntries.filter(
+      ([, meta]) => meta.isSigner && meta.isWritable,
+    );
+    const readonlySigners = mapEntries.filter(
+      ([, meta]) => meta.isSigner && !meta.isWritable,
+    );
+    const writableNonSigners = mapEntries.filter(
+      ([, meta]) => !meta.isSigner && meta.isWritable,
+    );
+    const readonlyNonSigners = mapEntries.filter(
+      ([, meta]) => !meta.isSigner && !meta.isWritable,
+    );
+
+    const header: MessageHeader = {
+      numRequiredSignatures: writableSigners.length + readonlySigners.length,
+      numReadonlySignedAccounts: readonlySigners.length,
+      numReadonlyUnsignedAccounts: readonlyNonSigners.length,
+    };
+
+    // sanity checks
+    {
+      assert(
+        writableSigners.length > 0,
+        'Expected at least one writable signer key',
+      );
+      const [payerAddress] = writableSigners[0];
+      assert(
+        payerAddress === this.payer.toBase58(),
+        'Expected first writable signer key to be the fee payer',
+      );
+    }
+
+    const staticAccountKeys = [
+      ...writableSigners.map(([address]) => new PublicKey(address)),
+      ...readonlySigners.map(([address]) => new PublicKey(address)),
+      ...writableNonSigners.map(([address]) => new PublicKey(address)),
+      ...readonlyNonSigners.map(([address]) => new PublicKey(address)),
+    ];
+
+    return [header, staticAccountKeys];
+  }
+
+  extractTableLookup(
+    lookupTable: AddressLookupTableAccount,
+  ): [MessageAddressTableLookup, AccountKeysFromLookups] | undefined {
+    const [writableIndexes, drainedWritableKeys] =
+      this.drainKeysFoundInLookupTable(
+        lookupTable.state.addresses,
+        keyMeta =>
+          !keyMeta.isSigner && !keyMeta.isInvoked && keyMeta.isWritable,
+      );
+    const [readonlyIndexes, drainedReadonlyKeys] =
+      this.drainKeysFoundInLookupTable(
+        lookupTable.state.addresses,
+        keyMeta =>
+          !keyMeta.isSigner && !keyMeta.isInvoked && !keyMeta.isWritable,
+      );
+
+    // Don't extract lookup if no keys were found
+    if (writableIndexes.length === 0 && readonlyIndexes.length === 0) {
+      return;
+    }
+
+    return [
+      {
+        accountKey: lookupTable.key,
+        writableIndexes,
+        readonlyIndexes,
+      },
+      {
+        writable: drainedWritableKeys,
+        readonly: drainedReadonlyKeys,
+      },
+    ];
+  }
+
+  /** @internal */
+  private drainKeysFoundInLookupTable(
+    lookupTableEntries: Array<PublicKey>,
+    keyMetaFilter: (keyMeta: CompiledKeyMeta) => boolean,
+  ): [Array<number>, Array<PublicKey>] {
+    const lookupTableIndexes = new Array();
+    const drainedKeys = new Array();
+
+    for (const [address, keyMeta] of this.keyMetaMap.entries()) {
+      if (keyMetaFilter(keyMeta)) {
+        const key = new PublicKey(address);
+        const lookupTableIndex = lookupTableEntries.findIndex(entry =>
+          entry.equals(key),
+        );
+        if (lookupTableIndex >= 0) {
+          assert(lookupTableIndex < 256, 'Max lookup table index exceeded');
+          lookupTableIndexes.push(lookupTableIndex);
+          drainedKeys.push(key);
+          this.keyMetaMap.delete(address);
+        }
+      }
+    }
+
+    return [lookupTableIndexes, drainedKeys];
+  }
+}

package/src/message/index.ts

@@ -1,4 +1,10 @@
+import {PublicKey} from '../publickey';
+
+export * from './account-keys';
+// note: compiled-keys is internal and doesn't need to be exported
 export * from './legacy';
+export * from './versioned';
+export * from './v0';
 
 /**
  * The message header, identifying signed and read-only account
@@ -15,18 +21,27 @@ export type MessageHeader = {
   numReadonlyUnsignedAccounts: number;
 };
 
+/**
+ * An address table lookup used to load additional accounts
+ */
+export type MessageAddressTableLookup = {
+  accountKey: PublicKey;
+  writableIndexes: Array<number>;
+  readonlyIndexes: Array<number>;
+};
+
 /**
  * An instruction to execute by a program
  *
  * @property {number} programIdIndex
- * @property {number[]} accounts
- * @property {string} data
+ * @property {number[]} accountKeyIndexes
+ * @property {Uint8Array} data
  */
-export type CompiledInstruction = {
+export type MessageCompiledInstruction = {
   /** Index into the transaction keys array indicating the program account that executes this instruction */
   programIdIndex: number;
   /** Ordered indices into the transaction keys array indicating which accounts to pass to the program */
-  accounts: number[];
-  /** The program input data encoded as base 58 */
-  data: string;
+  accountKeyIndexes: number[];
+  /** The program input data */
+  data: Uint8Array;
 };

package/src/message/legacy.ts

@@ -5,10 +5,33 @@ import * as BufferLayout from '@solana/buffer-layout';
 import {PublicKey, PUBLIC_KEY_LENGTH} from '../publickey';
 import type {Blockhash} from '../blockhash';
 import * as Layout from '../layout';
-import {PACKET_DATA_SIZE} from '../transaction/constants';
+import {PACKET_DATA_SIZE, VERSION_PREFIX_MASK} from '../transaction/constants';
 import * as shortvec from '../utils/shortvec-encoding';
 import {toBuffer} from '../utils/to-buffer';
-import {CompiledInstruction, MessageHeader} from './index';
+import {
+  MessageHeader,
+  MessageAddressTableLookup,
+  MessageCompiledInstruction,
+} from './index';
+import {TransactionInstruction} from '../transaction';
+import {CompiledKeys} from './compiled-keys';
+import {MessageAccountKeys} from './account-keys';
+
+/**
+ * An instruction to execute by a program
+ *
+ * @property {number} programIdIndex
+ * @property {number[]} accounts
+ * @property {string} data
+ */
+export type CompiledInstruction = {
+  /** Index into the transaction keys array indicating the program account that executes this instruction */
+  programIdIndex: number;
+  /** Ordered indices into the transaction keys array indicating which accounts to pass to the program */
+  accounts: number[];
+  /** The program input data encoded as base 58 */
+  data: string;
+};
 
 /**
  * Message constructor arguments
@@ -17,13 +40,19 @@ export type MessageArgs = {
   /** The message header, identifying signed and read-only `accountKeys` */
   header: MessageHeader;
   /** All the account keys used by this transaction */
-  accountKeys: string[];
+  accountKeys: string[] | PublicKey[];
   /** The hash of a recent ledger block */
   recentBlockhash: Blockhash;
   /** Instructions that will be executed in sequence and committed in one atomic transaction if all succeed. */
   instructions: CompiledInstruction[];
 };
 
+export type CompileLegacyArgs = {
+  payerKey: PublicKey;
+  instructions: Array<TransactionInstruction>;
+  recentBlockhash: Blockhash;
+};
+
 /**
  * List of instructions to be processed atomically
  */
@@ -51,19 +80,68 @@ export class Message {
     );
   }
 
+  get version(): 'legacy' {
+    return 'legacy';
+  }
+
+  get staticAccountKeys(): Array<PublicKey> {
+    return this.accountKeys;
+  }
+
+  get compiledInstructions(): Array<MessageCompiledInstruction> {
+    return this.instructions.map(
+      (ix): MessageCompiledInstruction => ({
+        programIdIndex: ix.programIdIndex,
+        accountKeyIndexes: ix.accounts,
+        data: bs58.decode(ix.data),
+      }),
+    );
+  }
+
+  get addressTableLookups(): Array<MessageAddressTableLookup> {
+    return [];
+  }
+
+  getAccountKeys(): MessageAccountKeys {
+    return new MessageAccountKeys(this.staticAccountKeys);
+  }
+
+  static compile(args: CompileLegacyArgs): Message {
+    const compiledKeys = CompiledKeys.compile(args.instructions, args.payerKey);
+    const [header, staticAccountKeys] = compiledKeys.getMessageComponents();
+    const accountKeys = new MessageAccountKeys(staticAccountKeys);
+    const instructions = accountKeys.compileInstructions(args.instructions).map(
+      (ix: MessageCompiledInstruction): CompiledInstruction => ({
+        programIdIndex: ix.programIdIndex,
+        accounts: ix.accountKeyIndexes,
+        data: bs58.encode(ix.data),
+      }),
+    );
+    return new Message({
+      header,
+      accountKeys: staticAccountKeys,
+      recentBlockhash: args.recentBlockhash,
+      instructions,
+    });
+  }
+
   isAccountSigner(index: number): boolean {
     return index < this.header.numRequiredSignatures;
   }
 
   isAccountWritable(index: number): boolean {
-    return (
-      index <
-        this.header.numRequiredSignatures -
-          this.header.numReadonlySignedAccounts ||
-      (index >= this.header.numRequiredSignatures &&
-        index <
-          this.accountKeys.length - this.header.numReadonlyUnsignedAccounts)
-    );
+    const numSignedAccounts = this.header.numRequiredSignatures;
+    if (index >= this.header.numRequiredSignatures) {
+      const unsignedAccountIndex = index - numSignedAccounts;
+      const numUnsignedAccounts = this.accountKeys.length - numSignedAccounts;
+      const numWritableUnsignedAccounts =
+        numUnsignedAccounts - this.header.numReadonlyUnsignedAccounts;
+      return unsignedAccountIndex < numWritableUnsignedAccounts;
+    } else {
+      const numWritableSignedAccounts =
+        numSignedAccounts - this.header.numReadonlySignedAccounts;
+      return index < numWritableSignedAccounts;
+    }
   }
 
   isProgramId(index: number): boolean {
@@ -190,16 +268,25 @@ export class Message {
     // Slice up wire data
     let byteArray = [...buffer];
 
-    const numRequiredSignatures = byteArray.shift() as number;
-    const numReadonlySignedAccounts = byteArray.shift() as number;
-    const numReadonlyUnsignedAccounts = byteArray.shift() as number;
+    const numRequiredSignatures = byteArray.shift()!;
+    if (
+      numRequiredSignatures !==
+      (numRequiredSignatures & VERSION_PREFIX_MASK)
+    ) {
+      throw new Error(
+        'Versioned messages must be deserialized with VersionedMessage.deserialize()',
+      );
+    }
+
+    const numReadonlySignedAccounts = byteArray.shift()!;
+    const numReadonlyUnsignedAccounts = byteArray.shift()!;
 
     const accountCount = shortvec.decodeLength(byteArray);
     let accountKeys = [];
     for (let i = 0; i < accountCount; i++) {
       const account = byteArray.slice(0, PUBLIC_KEY_LENGTH);
       byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);
-      accountKeys.push(bs58.encode(Buffer.from(account)));
+      accountKeys.push(new PublicKey(Buffer.from(account)));
     }
 
     const recentBlockhash = byteArray.slice(0, PUBLIC_KEY_LENGTH);
@@ -208,7 +295,7 @@ export class Message {
     const instructionCount = shortvec.decodeLength(byteArray);
     let instructions: CompiledInstruction[] = [];
     for (let i = 0; i < instructionCount; i++) {
-      const programIdIndex = byteArray.shift() as number;
+      const programIdIndex = byteArray.shift()!;
       const accountCount = shortvec.decodeLength(byteArray);
       const accounts = byteArray.slice(0, accountCount);
       byteArray = byteArray.slice(accountCount);