@solana/web3.js 1.35.0 → 1.37.0

package/src/loader.ts

@@ -9,6 +9,7 @@ import {sleep} from './util/sleep';
 import type {Connection} from './connection';
 import type {Signer} from './keypair';
 import {SystemProgram} from './system-program';
+import {IInstructionInputData} from './instruction';
 
 // Keep program chunks under PACKET_DATA_SIZE, leaving enough room for the
 // rest of the Transaction fields
@@ -137,7 +138,15 @@ export class Loader {
       }
     }
 
-    const dataLayout = BufferLayout.struct([
+    const dataLayout = BufferLayout.struct<
+      Readonly<{
+        bytes: number[];
+        bytesLength: number;
+        bytesLengthPadding: number;
+        instruction: number;
+        offset: number;
+      }>
+    >([
       BufferLayout.u32('instruction'),
       BufferLayout.u32('offset'),
       BufferLayout.u32('bytesLength'),
@@ -160,7 +169,9 @@ export class Loader {
         {
           instruction: 0, // Load instruction
           offset,
-          bytes,
+          bytes: bytes as number[],
+          bytesLength: 0,
+          bytesLengthPadding: 0,
         },
         data,
       );
@@ -189,7 +200,9 @@ export class Loader {
 
     // Finalize the account loaded with program data for execution
     {
-      const dataLayout = BufferLayout.struct([BufferLayout.u32('instruction')]);
+      const dataLayout = BufferLayout.struct<IInstructionInputData>([
+        BufferLayout.u32('instruction'),
+      ]);
 
       const data = Buffer.alloc(dataLayout.span);
       dataLayout.encode(

package/src/message.ts

@@ -118,7 +118,7 @@ export class Message {
 
     const instructions = this.instructions.map(instruction => {
       const {accounts, programIdIndex} = instruction;
-      const data = bs58.decode(instruction.data);
+      const data = Array.from(bs58.decode(instruction.data));
 
       let keyIndicesCount: number[] = [];
       shortvec.encodeLength(keyIndicesCount, accounts.length);
@@ -129,7 +129,7 @@ export class Message {
       return {
         programIdIndex,
         keyIndicesCount: Buffer.from(keyIndicesCount),
-        keyIndices: Buffer.from(accounts),
+        keyIndices: accounts,
         dataLength: Buffer.from(dataCount),
         data,
       };
@@ -142,7 +142,15 @@ export class Message {
     let instructionBufferLength = instructionCount.length;
 
     instructions.forEach(instruction => {
-      const instructionLayout = BufferLayout.struct([
+      const instructionLayout = BufferLayout.struct<
+        Readonly<{
+          data: number[];
+          dataLength: Uint8Array;
+          keyIndices: number[];
+          keyIndicesCount: Uint8Array;
+          programIdIndex: number;
+        }>
+      >([
         BufferLayout.u8('programIdIndex'),
 
         BufferLayout.blob(
@@ -170,7 +178,16 @@ export class Message {
     });
     instructionBuffer = instructionBuffer.slice(0, instructionBufferLength);
 
-    const signDataLayout = BufferLayout.struct([
+    const signDataLayout = BufferLayout.struct<
+      Readonly<{
+        keyCount: Uint8Array;
+        keys: Uint8Array[];
+        numReadonlySignedAccounts: Uint8Array;
+        numReadonlyUnsignedAccounts: Uint8Array;
+        numRequiredSignatures: Uint8Array;
+        recentBlockhash: Uint8Array;
+      }>
+    >([
       BufferLayout.blob(1, 'numRequiredSignatures'),
       BufferLayout.blob(1, 'numReadonlySignedAccounts'),
       BufferLayout.blob(1, 'numReadonlyUnsignedAccounts'),

package/src/nonce-account.ts

@@ -13,12 +13,25 @@ import {toBuffer} from './util/to-buffer';
  *
  * @internal
  */
-const NonceAccountLayout = BufferLayout.struct([
+const NonceAccountLayout = BufferLayout.struct<
+  Readonly<{
+    authorizedPubkey: Uint8Array;
+    feeCalculator: Readonly<{
+      lamportsPerSignature: number;
+    }>;
+    nonce: Uint8Array;
+    state: number;
+    version: number;
+  }>
+>([
   BufferLayout.u32('version'),
   BufferLayout.u32('state'),
   Layout.publicKey('authorizedPubkey'),
   Layout.publicKey('nonce'),
-  BufferLayout.struct([FeeCalculatorLayout], 'feeCalculator'),
+  BufferLayout.struct<Readonly<{lamportsPerSignature: number}>>(
+    [FeeCalculatorLayout],
+    'feeCalculator',
+  ),
 ]);
 
 export const NONCE_ACCOUNT_LENGTH = NonceAccountLayout.span;

package/src/secp256k1-program.ts

@@ -46,7 +46,21 @@ export type CreateSecp256k1InstructionWithPrivateKeyParams = {
   instructionIndex?: number;
 };
 
-const SECP256K1_INSTRUCTION_LAYOUT = BufferLayout.struct([
+const SECP256K1_INSTRUCTION_LAYOUT = BufferLayout.struct<
+  Readonly<{
+    ethAddress: Uint8Array;
+    ethAddressInstructionIndex: number;
+    ethAddressOffset: number;
+    messageDataOffset: number;
+    messageDataSize: number;
+    messageInstructionIndex: number;
+    numSignatures: number;
+    recoveryId: number;
+    signature: Uint8Array;
+    signatureInstructionIndex: number;
+    signatureOffset: number;
+  }>
+>([
   BufferLayout.u8('numSignatures'),
   BufferLayout.u16('signatureOffset'),
   BufferLayout.u8('signatureInstructionIndex'),

package/src/stake-program.ts

@@ -1,6 +1,11 @@
 import * as BufferLayout from '@solana/buffer-layout';
 
-import {encodeData, decodeData, InstructionType} from './instruction';
+import {
+  encodeData,
+  decodeData,
+  InstructionType,
+  IInstructionInputData,
+} from './instruction';
 import * as Layout from './layout';
 import {PublicKey} from './publickey';
 import {SystemProgram} from './system-program';
@@ -40,6 +45,11 @@ export class Authorized {
   }
 }
 
+type AuthorizedRaw = Readonly<{
+  staker: Uint8Array;
+  withdrawer: Uint8Array;
+}>;
+
 /**
  * Stake account lockup info
  */
@@ -66,6 +76,12 @@ export class Lockup {
   static default: Lockup = new Lockup(0, 0, PublicKey.default);
 }
 
+type LockupRaw = Readonly<{
+  custodian: Uint8Array;
+  epoch: number;
+  unixTimestamp: number;
+}>;
+
 /**
  * Create stake account transaction params
  */
@@ -429,25 +445,63 @@ export class StakeInstruction {
  * An enumeration of valid StakeInstructionType's
  */
 export type StakeInstructionType =
-  | 'AuthorizeWithSeed'
+  // FIXME
+  // It would be preferable for this type to be `keyof StakeInstructionInputData`
+  // but Typedoc does not transpile `keyof` expressions.
+  // See https://github.com/TypeStrong/typedoc/issues/1894
   | 'Authorize'
+  | 'AuthorizeWithSeed'
   | 'Deactivate'
   | 'Delegate'
   | 'Initialize'
+  | 'Merge'
   | 'Split'
-  | 'Withdraw'
-  | 'Merge';
+  | 'Withdraw';
+
+type StakeInstructionInputData = {
+  Authorize: IInstructionInputData &
+    Readonly<{
+      newAuthorized: Uint8Array;
+      stakeAuthorizationType: number;
+    }>;
+  AuthorizeWithSeed: IInstructionInputData &
+    Readonly<{
+      authorityOwner: Uint8Array;
+      authoritySeed: string;
+      instruction: number;
+      newAuthorized: Uint8Array;
+      stakeAuthorizationType: number;
+    }>;
+  Deactivate: IInstructionInputData;
+  Delegate: IInstructionInputData;
+  Initialize: IInstructionInputData &
+    Readonly<{
+      authorized: AuthorizedRaw;
+      lockup: LockupRaw;
+    }>;
+  Merge: IInstructionInputData;
+  Split: IInstructionInputData &
+    Readonly<{
+      lamports: number;
+    }>;
+  Withdraw: IInstructionInputData &
+    Readonly<{
+      lamports: number;
+    }>;
+};
 
 /**
  * An enumeration of valid stake InstructionType's
  * @internal
  */
-export const STAKE_INSTRUCTION_LAYOUTS: {
-  [type in StakeInstructionType]: InstructionType;
-} = Object.freeze({
+export const STAKE_INSTRUCTION_LAYOUTS = Object.freeze<{
+  [Instruction in StakeInstructionType]: InstructionType<
+    StakeInstructionInputData[Instruction]
+  >;
+}>({
   Initialize: {
     index: 0,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<StakeInstructionInputData['Initialize']>([
       BufferLayout.u32('instruction'),
       Layout.authorized(),
       Layout.lockup(),
@@ -455,7 +509,7 @@ export const STAKE_INSTRUCTION_LAYOUTS: {
   },
   Authorize: {
     index: 1,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<StakeInstructionInputData['Authorize']>([
       BufferLayout.u32('instruction'),
       Layout.publicKey('newAuthorized'),
       BufferLayout.u32('stakeAuthorizationType'),
@@ -463,39 +517,47 @@ export const STAKE_INSTRUCTION_LAYOUTS: {
   },
   Delegate: {
     index: 2,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction')]),
+    layout: BufferLayout.struct<StakeInstructionInputData['Delegate']>([
+      BufferLayout.u32('instruction'),
+    ]),
   },
   Split: {
     index: 3,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<StakeInstructionInputData['Split']>([
       BufferLayout.u32('instruction'),
       BufferLayout.ns64('lamports'),
     ]),
   },
   Withdraw: {
     index: 4,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<StakeInstructionInputData['Withdraw']>([
       BufferLayout.u32('instruction'),
       BufferLayout.ns64('lamports'),
     ]),
   },
   Deactivate: {
     index: 5,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction')]),
+    layout: BufferLayout.struct<StakeInstructionInputData['Deactivate']>([
+      BufferLayout.u32('instruction'),
+    ]),
   },
   Merge: {
     index: 7,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction')]),
+    layout: BufferLayout.struct<StakeInstructionInputData['Merge']>([
+      BufferLayout.u32('instruction'),
+    ]),
   },
   AuthorizeWithSeed: {
     index: 8,
-    layout: BufferLayout.struct([
-      BufferLayout.u32('instruction'),
-      Layout.publicKey('newAuthorized'),
-      BufferLayout.u32('stakeAuthorizationType'),
-      Layout.rustString('authoritySeed'),
-      Layout.publicKey('authorityOwner'),
-    ]),
+    layout: BufferLayout.struct<StakeInstructionInputData['AuthorizeWithSeed']>(
+      [
+        BufferLayout.u32('instruction'),
+        Layout.publicKey('newAuthorized'),
+        BufferLayout.u32('stakeAuthorizationType'),
+        Layout.rustString('authoritySeed'),
+        Layout.publicKey('authorityOwner'),
+      ],
+    ),
   },
 });
 

package/src/system-program.ts

@@ -1,6 +1,11 @@
 import * as BufferLayout from '@solana/buffer-layout';
 
-import {encodeData, decodeData, InstructionType} from './instruction';
+import {
+  encodeData,
+  decodeData,
+  InstructionType,
+  IInstructionInputData,
+} from './instruction';
 import * as Layout from './layout';
 import {NONCE_ACCOUNT_LENGTH} from './nonce-account';
 import {PublicKey} from './publickey';
@@ -517,6 +522,10 @@ export class SystemInstruction {
  * An enumeration of valid SystemInstructionType's
  */
 export type SystemInstructionType =
+  // FIXME
+  // It would be preferable for this type to be `keyof SystemInstructionInputData`
+  // but Typedoc does not transpile `keyof` expressions.
+  // See https://github.com/TypeStrong/typedoc/issues/1894
   | 'AdvanceNonceAccount'
   | 'Allocate'
   | 'AllocateWithSeed'
@@ -530,16 +539,68 @@ export type SystemInstructionType =
   | 'TransferWithSeed'
   | 'WithdrawNonceAccount';
 
+type SystemInstructionInputData = {
+  AdvanceNonceAccount: IInstructionInputData;
+  Allocate: IInstructionInputData & {
+    space: number;
+  };
+  AllocateWithSeed: IInstructionInputData & {
+    base: Uint8Array;
+    programId: Uint8Array;
+    seed: string;
+    space: number;
+  };
+  Assign: IInstructionInputData & {
+    programId: Uint8Array;
+  };
+  AssignWithSeed: IInstructionInputData & {
+    base: Uint8Array;
+    seed: string;
+    programId: Uint8Array;
+  };
+  AuthorizeNonceAccount: IInstructionInputData & {
+    authorized: Uint8Array;
+  };
+  Create: IInstructionInputData & {
+    lamports: number;
+    programId: Uint8Array;
+    space: number;
+  };
+  CreateWithSeed: IInstructionInputData & {
+    base: Uint8Array;
+    lamports: number;
+    programId: Uint8Array;
+    seed: string;
+    space: number;
+  };
+  InitializeNonceAccount: IInstructionInputData & {
+    authorized: Uint8Array;
+  };
+  Transfer: IInstructionInputData & {
+    lamports: number;
+  };
+  TransferWithSeed: IInstructionInputData & {
+    lamports: number;
+    programId: Uint8Array;
+    seed: string;
+  };
+  WithdrawNonceAccount: IInstructionInputData & {
+    lamports: number;
+  };
+};
+
 /**
  * An enumeration of valid system InstructionType's
  * @internal
  */
-export const SYSTEM_INSTRUCTION_LAYOUTS: {
-  [type in SystemInstructionType]: InstructionType;
-} = Object.freeze({
+export const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze<{
+  [Instruction in SystemInstructionType]: InstructionType<
+    SystemInstructionInputData[Instruction]
+  >;
+}>({
   Create: {
     index: 0,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<SystemInstructionInputData['Create']>([
       BufferLayout.u32('instruction'),
       BufferLayout.ns64('lamports'),
       BufferLayout.ns64('space'),
@@ -548,21 +609,21 @@ export const SYSTEM_INSTRUCTION_LAYOUTS: {
   },
   Assign: {
     index: 1,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<SystemInstructionInputData['Assign']>([
       BufferLayout.u32('instruction'),
       Layout.publicKey('programId'),
     ]),
   },
   Transfer: {
     index: 2,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<SystemInstructionInputData['Transfer']>([
       BufferLayout.u32('instruction'),
       BufferLayout.ns64('lamports'),
     ]),
   },
   CreateWithSeed: {
     index: 3,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<SystemInstructionInputData['CreateWithSeed']>([
       BufferLayout.u32('instruction'),
       Layout.publicKey('base'),
       Layout.rustString('seed'),
@@ -573,49 +634,50 @@ export const SYSTEM_INSTRUCTION_LAYOUTS: {
   },
   AdvanceNonceAccount: {
     index: 4,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction')]),
+    layout: BufferLayout.struct<
+      SystemInstructionInputData['AdvanceNonceAccount']
+    >([BufferLayout.u32('instruction')]),
   },
   WithdrawNonceAccount: {
     index: 5,
-    layout: BufferLayout.struct([
-      BufferLayout.u32('instruction'),
-      BufferLayout.ns64('lamports'),
-    ]),
+    layout: BufferLayout.struct<
+      SystemInstructionInputData['WithdrawNonceAccount']
+    >([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')]),
   },
   InitializeNonceAccount: {
     index: 6,
-    layout: BufferLayout.struct([
-      BufferLayout.u32('instruction'),
-      Layout.publicKey('authorized'),
-    ]),
+    layout: BufferLayout.struct<
+      SystemInstructionInputData['InitializeNonceAccount']
+    >([BufferLayout.u32('instruction'), Layout.publicKey('authorized')]),
   },
   AuthorizeNonceAccount: {
     index: 7,
-    layout: BufferLayout.struct([
-      BufferLayout.u32('instruction'),
-      Layout.publicKey('authorized'),
-    ]),
+    layout: BufferLayout.struct<
+      SystemInstructionInputData['AuthorizeNonceAccount']
+    >([BufferLayout.u32('instruction'), Layout.publicKey('authorized')]),
   },
   Allocate: {
     index: 8,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<SystemInstructionInputData['Allocate']>([
       BufferLayout.u32('instruction'),
       BufferLayout.ns64('space'),
     ]),
   },
   AllocateWithSeed: {
     index: 9,
-    layout: BufferLayout.struct([
-      BufferLayout.u32('instruction'),
-      Layout.publicKey('base'),
-      Layout.rustString('seed'),
-      BufferLayout.ns64('space'),
-      Layout.publicKey('programId'),
-    ]),
+    layout: BufferLayout.struct<SystemInstructionInputData['AllocateWithSeed']>(
+      [
+        BufferLayout.u32('instruction'),
+        Layout.publicKey('base'),
+        Layout.rustString('seed'),
+        BufferLayout.ns64('space'),
+        Layout.publicKey('programId'),
+      ],
+    ),
   },
   AssignWithSeed: {
     index: 10,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<SystemInstructionInputData['AssignWithSeed']>([
       BufferLayout.u32('instruction'),
       Layout.publicKey('base'),
       Layout.rustString('seed'),
@@ -624,12 +686,14 @@ export const SYSTEM_INSTRUCTION_LAYOUTS: {
   },
   TransferWithSeed: {
     index: 11,
-    layout: BufferLayout.struct([
-      BufferLayout.u32('instruction'),
-      BufferLayout.ns64('lamports'),
-      Layout.rustString('seed'),
-      Layout.publicKey('programId'),
-    ]),
+    layout: BufferLayout.struct<SystemInstructionInputData['TransferWithSeed']>(
+      [
+        BufferLayout.u32('instruction'),
+        BufferLayout.ns64('lamports'),
+        Layout.rustString('seed'),
+        Layout.publicKey('programId'),
+      ],
+    ),
   },
 });
 

package/src/transaction.ts

@@ -2,6 +2,7 @@ import nacl from 'tweetnacl';
 import bs58 from 'bs58';
 import {Buffer} from 'buffer';
 
+import {Connection} from './connection';
 import {Message} from './message';
 import {PublicKey} from './publickey';
 import * as shortvec from './util/shortvec-encoding';
@@ -405,6 +406,13 @@ export class Transaction {
     return this._compile().serialize();
   }
 
+  /**
+   * Get the estimated fee associated with a transaction
+   */
+  async getEstimatedFee(connection: Connection): Promise<number> {
+    return (await connection.getFeeForMessage(this.compileMessage())).value;
+  }
+
   /**
    * Specify the public keys which will be used to sign the Transaction.
    * The first signer will be used as the transaction fee payer account.