@solana/web3.js 0.98.0 → 1.0.1

package/lib/index.esm.js

@@ -1,10 +1,11 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import nacl, { sign } from 'tweetnacl';
+import * as nacl from 'tweetnacl';
+import nacl__default from 'tweetnacl';
 import { Buffer } from 'buffer';
 import BN from 'bn.js';
 import bs58 from 'bs58';
 import { sha256 } from 'crypto-hash';
-import { blob, struct, ns64, u32, offset, u8, seq, nu64, u16 } from 'buffer-layout';
+import * as BufferLayout from 'buffer-layout';
 import invariant from 'assert';
 import { parse, format } from 'url';
 import fetch from 'node-fetch';
@@ -166,7 +167,7 @@ class PublicKey {
 
 } // @ts-ignore
 
-let naclLowLevel = nacl.lowlevel; // Check that a pubkey is on the curve.
+let naclLowLevel = nacl__default.lowlevel; // Check that a pubkey is on the curve.
 // This function and its dependents were sourced from:
 // https://github.com/dchest/tweetnacl-js/blob/f1ec050ceae0861f34280e62498b1d3ed9c350c6/nacl.js#L792
 
@@ -234,9 +235,9 @@ class Account {
     _defineProperty(this, "_keypair", void 0);
 
     if (secretKey) {
-      this._keypair = sign.keyPair.fromSecretKey(toBuffer(secretKey));
+      this._keypair = nacl.sign.keyPair.fromSecretKey(toBuffer(secretKey));
     } else {
-      this._keypair = sign.keyPair();
+      this._keypair = nacl.sign.keyPair();
     }
   }
   /**
@@ -265,14 +266,14 @@ const BPF_LOADER_DEPRECATED_PROGRAM_ID = new PublicKey('BPFLoader111111111111111
  */
 
 const publicKey = (property = 'publicKey') => {
-  return blob(32, property);
+  return BufferLayout.blob(32, property);
 };
 /**
  * Layout for a Rust String type
  */
 
 const rustString = (property = 'string') => {
-  const rsl = struct([u32('length'), u32('lengthPadding'), blob(offset(u32(), -8), 'chars')], property);
+  const rsl = BufferLayout.struct([BufferLayout.u32('length'), BufferLayout.u32('lengthPadding'), BufferLayout.blob(BufferLayout.offset(BufferLayout.u32(), -8), 'chars')], property);
 
   const _decode = rsl.decode.bind(rsl);
 
@@ -292,7 +293,7 @@ const rustString = (property = 'string') => {
   };
 
   rsl.alloc = str => {
-    return u32().span + u32().span + Buffer.from(str, 'utf8').length;
+    return BufferLayout.u32().span + BufferLayout.u32().span + Buffer.from(str, 'utf8').length;
   };
 
   return rsl;
@@ -302,14 +303,14 @@ const rustString = (property = 'string') => {
  */
 
 const authorized = (property = 'authorized') => {
-  return struct([publicKey('staker'), publicKey('withdrawer')], property);
+  return BufferLayout.struct([publicKey('staker'), publicKey('withdrawer')], property);
 };
 /**
  * Layout for a Lockup object
  */
 
 const lockup = (property = 'lockup') => {
-  return struct([ns64('unixTimestamp'), ns64('epoch'), publicKey('custodian')], property);
+  return BufferLayout.struct([BufferLayout.ns64('unixTimestamp'), BufferLayout.ns64('epoch'), publicKey('custodian')], property);
 };
 function getAlloc(type, fields) {
   let alloc = 0;
@@ -356,6 +357,36 @@ function encodeLength(bytes, len) {
   }
 }
 
+const END_OF_BUFFER_ERROR_MESSAGE = 'Reached end of buffer unexpectedly';
+/**
+ * Delegates to `Array#shift`, but throws if the array is zero-length.
+ */
+
+function guardedShift(byteArray) {
+  if (byteArray.length === 0) {
+    throw new Error(END_OF_BUFFER_ERROR_MESSAGE);
+  }
+
+  return byteArray.shift();
+}
+/**
+ * Delegates to `Array#splice`, but throws if the section being spliced out extends past the end of
+ * the array.
+ */
+
+function guardedSplice(byteArray, ...args) {
+  var _args$;
+
+  const [start] = args;
+
+  if (args.length === 2 // Implies that `deleteCount` was supplied
+  ? start + ((_args$ = args[1]) !== null && _args$ !== void 0 ? _args$ : 0) > byteArray.length : start >= byteArray.length) {
+    throw new Error(END_OF_BUFFER_ERROR_MESSAGE);
+  }
+
+  return byteArray.splice(...args);
+}
+
 /**
  * The message header, identifying signed and read-only account
  *
@@ -419,12 +450,12 @@ class Message {
     Buffer.from(instructionCount).copy(instructionBuffer);
     let instructionBufferLength = instructionCount.length;
     instructions.forEach(instruction => {
-      const instructionLayout = struct([u8('programIdIndex'), blob(instruction.keyIndicesCount.length, 'keyIndicesCount'), seq(u8('keyIndex'), instruction.keyIndices.length, 'keyIndices'), blob(instruction.dataLength.length, 'dataLength'), seq(u8('userdatum'), instruction.data.length, 'data')]);
+      const instructionLayout = BufferLayout.struct([BufferLayout.u8('programIdIndex'), BufferLayout.blob(instruction.keyIndicesCount.length, 'keyIndicesCount'), BufferLayout.seq(BufferLayout.u8('keyIndex'), instruction.keyIndices.length, 'keyIndices'), BufferLayout.blob(instruction.dataLength.length, 'dataLength'), BufferLayout.seq(BufferLayout.u8('userdatum'), instruction.data.length, 'data')]);
       const length = instructionLayout.encode(instruction, instructionBuffer, instructionBufferLength);
       instructionBufferLength += length;
     });
     instructionBuffer = instructionBuffer.slice(0, instructionBufferLength);
-    const signDataLayout = struct([blob(1, 'numRequiredSignatures'), blob(1, 'numReadonlySignedAccounts'), blob(1, 'numReadonlyUnsignedAccounts'), blob(keyCount.length, 'keyCount'), seq(publicKey('key'), numKeys, 'keys'), publicKey('recentBlockhash')]);
+    const signDataLayout = BufferLayout.struct([BufferLayout.blob(1, 'numRequiredSignatures'), BufferLayout.blob(1, 'numReadonlySignedAccounts'), BufferLayout.blob(1, 'numReadonlyUnsignedAccounts'), BufferLayout.blob(keyCount.length, 'keyCount'), BufferLayout.seq(publicKey('key'), numKeys, 'keys'), publicKey('recentBlockhash')]);
     const transaction = {
       numRequiredSignatures: Buffer.from([this.header.numRequiredSignatures]),
       numReadonlySignedAccounts: Buffer.from([this.header.numReadonlySignedAccounts]),
@@ -446,32 +477,28 @@ class Message {
   static from(buffer) {
     // Slice up wire data
     let byteArray = [...buffer];
-    const numRequiredSignatures = byteArray.shift();
-    const numReadonlySignedAccounts = byteArray.shift();
-    const numReadonlyUnsignedAccounts = byteArray.shift();
+    const numRequiredSignatures = guardedShift(byteArray);
+    const numReadonlySignedAccounts = guardedShift(byteArray);
+    const numReadonlyUnsignedAccounts = guardedShift(byteArray);
     const accountCount = decodeLength(byteArray);
     let accountKeys = [];
 
     for (let i = 0; i < accountCount; i++) {
-      const account = byteArray.slice(0, PUBKEY_LENGTH);
-      byteArray = byteArray.slice(PUBKEY_LENGTH);
+      const account = guardedSplice(byteArray, 0, PUBKEY_LENGTH);
       accountKeys.push(bs58.encode(Buffer.from(account)));
     }
 
-    const recentBlockhash = byteArray.slice(0, PUBKEY_LENGTH);
-    byteArray = byteArray.slice(PUBKEY_LENGTH);
+    const recentBlockhash = guardedSplice(byteArray, 0, PUBKEY_LENGTH);
     const instructionCount = decodeLength(byteArray);
     let instructions = [];
 
     for (let i = 0; i < instructionCount; i++) {
-      const programIdIndex = byteArray.shift();
+      const programIdIndex = guardedShift(byteArray);
       const accountCount = decodeLength(byteArray);
-      const accounts = byteArray.slice(0, accountCount);
-      byteArray = byteArray.slice(accountCount);
+      const accounts = guardedSplice(byteArray, 0, accountCount);
       const dataLength = decodeLength(byteArray);
-      const dataSlice = byteArray.slice(0, dataLength);
+      const dataSlice = guardedSplice(byteArray, 0, dataLength);
       const data = bs58.encode(Buffer.from(dataSlice));
-      byteArray = byteArray.slice(dataLength);
       instructions.push({
         programIdIndex,
         accounts,
@@ -942,7 +969,7 @@ class Transaction {
   _partialSign(message, ...signers) {
     const signData = message.serialize();
     signers.forEach(signer => {
-      const signature = nacl.sign.detached(signData, signer.secretKey);
+      const signature = nacl__default.sign.detached(signData, signer.secretKey);
 
       this._addSignature(signer.publicKey, toBuffer(signature));
     });
@@ -998,7 +1025,7 @@ class Transaction {
           return false;
         }
       } else {
-        if (!nacl.sign.detached.verify(signData, signature, publicKey.toBuffer())) {
+        if (!nacl__default.sign.detached.verify(signData, signature, publicKey.toBuffer())) {
           return false;
         }
       }
@@ -1096,8 +1123,7 @@ class Transaction {
     let signatures = [];
 
     for (let i = 0; i < signatureCount; i++) {
-      const signature = byteArray.slice(0, SIGNATURE_LENGTH);
-      byteArray = byteArray.slice(SIGNATURE_LENGTH);
+      const signature = guardedSplice(byteArray, 0, SIGNATURE_LENGTH);
       signatures.push(bs58.encode(Buffer.from(signature)));
     }
 
@@ -1229,7 +1255,7 @@ function decodeData(type, buffer) {
  * @internal
  */
 
-const FeeCalculatorLayout = nu64('lamportsPerSignature');
+const FeeCalculatorLayout = BufferLayout.nu64('lamportsPerSignature');
 /**
  * Calculator for transaction fees.
  */
@@ -1240,7 +1266,7 @@ const FeeCalculatorLayout = nu64('lamportsPerSignature');
  * @internal
  */
 
-const NonceAccountLayout = struct([u32('version'), u32('state'), publicKey('authorizedPubkey'), publicKey('nonce'), struct([FeeCalculatorLayout], 'feeCalculator')]);
+const NonceAccountLayout = BufferLayout.struct([BufferLayout.u32('version'), BufferLayout.u32('state'), publicKey('authorizedPubkey'), publicKey('nonce'), BufferLayout.struct([FeeCalculatorLayout], 'feeCalculator')]);
 const NONCE_ACCOUNT_LENGTH = NonceAccountLayout.span;
 
 /**
@@ -1305,7 +1331,7 @@ class SystemInstruction {
 
   static decodeInstructionType(instruction) {
     this.checkProgramId(instruction.programId);
-    const instructionTypeLayout = u32('instruction');
+    const instructionTypeLayout = BufferLayout.u32('instruction');
     const typeIndex = instructionTypeLayout.decode(instruction.data);
     let type;
 
@@ -1578,51 +1604,51 @@ class SystemInstruction {
 const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze({
   Create: {
     index: 0,
-    layout: struct([u32('instruction'), ns64('lamports'), ns64('space'), publicKey('programId')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports'), BufferLayout.ns64('space'), publicKey('programId')])
   },
   Assign: {
     index: 1,
-    layout: struct([u32('instruction'), publicKey('programId')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), publicKey('programId')])
   },
   Transfer: {
     index: 2,
-    layout: struct([u32('instruction'), ns64('lamports')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')])
   },
   CreateWithSeed: {
     index: 3,
-    layout: struct([u32('instruction'), publicKey('base'), rustString('seed'), ns64('lamports'), ns64('space'), publicKey('programId')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), publicKey('base'), rustString('seed'), BufferLayout.ns64('lamports'), BufferLayout.ns64('space'), publicKey('programId')])
   },
   AdvanceNonceAccount: {
     index: 4,
-    layout: struct([u32('instruction')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction')])
   },
   WithdrawNonceAccount: {
     index: 5,
-    layout: struct([u32('instruction'), ns64('lamports')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')])
   },
   InitializeNonceAccount: {
     index: 6,
-    layout: struct([u32('instruction'), publicKey('authorized')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), publicKey('authorized')])
   },
   AuthorizeNonceAccount: {
     index: 7,
-    layout: struct([u32('instruction'), publicKey('authorized')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), publicKey('authorized')])
   },
   Allocate: {
     index: 8,
-    layout: struct([u32('instruction'), ns64('space')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('space')])
   },
   AllocateWithSeed: {
     index: 9,
-    layout: struct([u32('instruction'), publicKey('base'), rustString('seed'), ns64('space'), publicKey('programId')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), publicKey('base'), rustString('seed'), BufferLayout.ns64('space'), publicKey('programId')])
   },
   AssignWithSeed: {
     index: 10,
-    layout: struct([u32('instruction'), publicKey('base'), rustString('seed'), publicKey('programId')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), publicKey('base'), rustString('seed'), publicKey('programId')])
   },
   TransferWithSeed: {
     index: 11,
-    layout: struct([u32('instruction'), ns64('lamports'), rustString('seed'), publicKey('programId')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports'), rustString('seed'), publicKey('programId')])
   }
 });
 /**
@@ -2103,9 +2129,9 @@ class Loader {
         });
       }
     }
-    const dataLayout = struct([u32('instruction'), u32('offset'), u32('bytesLength'), u32('bytesLengthPadding'), seq(u8('byte'), offset(u32(), -8), 'bytes')]);
+    const dataLayout = BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.u32('offset'), BufferLayout.u32('bytesLength'), BufferLayout.u32('bytesLengthPadding'), BufferLayout.seq(BufferLayout.u8('byte'), BufferLayout.offset(BufferLayout.u32(), -8), 'bytes')]);
     const chunkSize = Loader.chunkSize;
-    let offset$1 = 0;
+    let offset = 0;
     let array = data;
     let transactions = [];
 
@@ -2115,7 +2141,7 @@ class Loader {
       dataLayout.encode({
         instruction: 0,
         // Load instruction
-        offset: offset$1,
+        offset,
         bytes
       }, data);
       const transaction = new Transaction().add({
@@ -2136,14 +2162,14 @@ class Loader {
         await sleep(1000 / REQUESTS_PER_SECOND);
       }
 
-      offset$1 += chunkSize;
+      offset += chunkSize;
       array = array.slice(chunkSize);
     }
 
     await Promise.all(transactions); // Finalize the account loaded with program data for execution
 
     {
-      const dataLayout = struct([u32('instruction')]);
+      const dataLayout = BufferLayout.struct([BufferLayout.u32('instruction')]);
       const data = Buffer.alloc(dataLayout.span);
       dataLayout.encode({
         instruction: 1 // Finalize instruction
@@ -4820,7 +4846,7 @@ class StakeInstruction {
 
   static decodeInstructionType(instruction) {
     this.checkProgramId(instruction.programId);
-    const instructionTypeLayout = u32('instruction');
+    const instructionTypeLayout = BufferLayout.u32('instruction');
     const typeIndex = instructionTypeLayout.decode(instruction.data);
     let type;
 
@@ -5016,31 +5042,31 @@ class StakeInstruction {
 const STAKE_INSTRUCTION_LAYOUTS = Object.freeze({
   Initialize: {
     index: 0,
-    layout: struct([u32('instruction'), authorized(), lockup()])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), authorized(), lockup()])
   },
   Authorize: {
     index: 1,
-    layout: struct([u32('instruction'), publicKey('newAuthorized'), u32('stakeAuthorizationType')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), publicKey('newAuthorized'), BufferLayout.u32('stakeAuthorizationType')])
   },
   Delegate: {
     index: 2,
-    layout: struct([u32('instruction')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction')])
   },
   Split: {
     index: 3,
-    layout: struct([u32('instruction'), ns64('lamports')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')])
   },
   Withdraw: {
     index: 4,
-    layout: struct([u32('instruction'), ns64('lamports')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')])
   },
   Deactivate: {
     index: 5,
-    layout: struct([u32('instruction')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction')])
   },
   AuthorizeWithSeed: {
     index: 8,
-    layout: struct([u32('instruction'), publicKey('newAuthorized'), u32('stakeAuthorizationType'), rustString('authoritySeed'), publicKey('authorityOwner')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), publicKey('newAuthorized'), BufferLayout.u32('stakeAuthorizationType'), rustString('authoritySeed'), publicKey('authorityOwner')])
   }
 });
 /**
@@ -5467,7 +5493,7 @@ const SIGNATURE_OFFSETS_SERIALIZED_SIZE = 11;
  * @property {number} recoveryId
  */
 
-const SECP256K1_INSTRUCTION_LAYOUT = struct([u8('numSignatures'), u16('signatureOffset'), u8('signatureInstructionIndex'), u16('ethAddressOffset'), u8('ethAddressInstructionIndex'), u16('messageDataOffset'), u16('messageDataSize'), u8('messageInstructionIndex'), blob(20, 'ethAddress'), blob(64, 'signature'), u8('recoveryId')]);
+const SECP256K1_INSTRUCTION_LAYOUT = BufferLayout.struct([BufferLayout.u8('numSignatures'), BufferLayout.u16('signatureOffset'), BufferLayout.u8('signatureInstructionIndex'), BufferLayout.u16('ethAddressOffset'), BufferLayout.u8('ethAddressInstructionIndex'), BufferLayout.u16('messageDataOffset'), BufferLayout.u16('messageDataSize'), BufferLayout.u8('messageInstructionIndex'), BufferLayout.blob(20, 'ethAddress'), BufferLayout.blob(64, 'signature'), BufferLayout.u8('recoveryId')]);
 class Secp256k1Program {
   /**
    * @internal
@@ -5664,10 +5690,8 @@ class ValidatorInfo {
     const configKeys = [];
 
     for (let i = 0; i < 2; i++) {
-      const publicKey = new PublicKey(byteArray.slice(0, PUBKEY_LENGTH));
-      byteArray = byteArray.slice(PUBKEY_LENGTH);
-      const isSigner = byteArray.slice(0, 1)[0] === 1;
-      byteArray = byteArray.slice(1);
+      const publicKey = new PublicKey(guardedSplice(byteArray, 0, PUBKEY_LENGTH));
+      const isSigner = guardedShift(byteArray) === 1;
       configKeys.push({
         publicKey,
         isSigner
@@ -5695,9 +5719,9 @@ const VOTE_PROGRAM_ID = new PublicKey('Vote1111111111111111111111111111111111111
  *
  * @internal
  */
-const VoteAccountLayout = struct([publicKey('nodePubkey'), publicKey('authorizedVoterPubkey'), publicKey('authorizedWithdrawerPubkey'), u8('commission'), nu64(), // votes.length
-seq(struct([nu64('slot'), u32('confirmationCount')]), offset(u32(), -8), 'votes'), u8('rootSlotValid'), nu64('rootSlot'), nu64('epoch'), nu64('credits'), nu64('lastEpochCredits'), nu64(), // epochCredits.length
-seq(struct([nu64('epoch'), nu64('credits'), nu64('prevCredits')]), offset(u32(), -8), 'epochCredits')]);
+const VoteAccountLayout = BufferLayout.struct([publicKey('nodePubkey'), publicKey('authorizedVoterPubkey'), publicKey('authorizedWithdrawerPubkey'), BufferLayout.u8('commission'), BufferLayout.nu64(), // votes.length
+BufferLayout.seq(BufferLayout.struct([BufferLayout.nu64('slot'), BufferLayout.u32('confirmationCount')]), BufferLayout.offset(BufferLayout.u32(), -8), 'votes'), BufferLayout.u8('rootSlotValid'), BufferLayout.nu64('rootSlot'), BufferLayout.nu64('epoch'), BufferLayout.nu64('credits'), BufferLayout.nu64('lastEpochCredits'), BufferLayout.nu64(), // epochCredits.length
+BufferLayout.seq(BufferLayout.struct([BufferLayout.nu64('epoch'), BufferLayout.nu64('credits'), BufferLayout.nu64('prevCredits')]), BufferLayout.offset(BufferLayout.u32(), -8), 'epochCredits')]);
 
 /**
  * VoteAccount class