@solana/web3.js 1.41.6 → 1.41.9

package/lib/index.esm.js

@@ -1,11 +1,11 @@
 import nacl from 'tweetnacl';
-import { Buffer as Buffer$1 } from 'buffer';
+import { Buffer } from 'buffer';
 import BN from 'bn.js';
 import bs58 from 'bs58';
 import { serialize, deserialize, deserializeUnchecked } from 'borsh';
 import * as BufferLayout from '@solana/buffer-layout';
-import { blob } from '@solana/buffer-layout';
-import fetch from 'cross-fetch';
+import { u64 } from '@solana/buffer-layout-utils';
+import crossFetch from 'cross-fetch';
 import { coerce, instance, string, tuple, literal, unknown, union, type, optional, any, number, array, nullable, create, boolean, record, assert as assert$7 } from 'superstruct';
 import { Client } from 'rpc-websockets';
 import RpcClient from 'jayson/lib/client/browser';
@@ -15,12 +15,12 @@ import secp256k1 from 'secp256k1';
 import sha3 from 'js-sha3';
 
 const toBuffer = arr => {
-  if (Buffer$1.isBuffer(arr)) {
+  if (Buffer.isBuffer(arr)) {
     return arr;
   } else if (arr instanceof Uint8Array) {
-    return Buffer$1.from(arr.buffer, arr.byteOffset, arr.byteLength);
+    return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength);
   } else {
-    return Buffer$1.from(arr);
+    return Buffer.from(arr);
   }
 };
 
@@ -1747,7 +1747,7 @@ class Struct {
   }
 
   encode() {
-    return Buffer$1.from(serialize(SOLANA_SCHEMA, this));
+    return Buffer.from(serialize(SOLANA_SCHEMA, this));
   }
 
   static decode(data) {
@@ -1864,13 +1864,13 @@ class PublicKey extends Struct {
 
 
   toBuffer() {
-    const b = this._bn.toArrayLike(Buffer$1);
+    const b = this._bn.toArrayLike(Buffer);
 
     if (b.length === 32) {
       return b;
     }
 
-    const zeroPad = Buffer$1.alloc(32);
+    const zeroPad = Buffer.alloc(32);
     b.copy(zeroPad, 32 - b.length);
     return zeroPad;
   }
@@ -1892,9 +1892,9 @@ class PublicKey extends Struct {
 
 
   static async createWithSeed(fromPublicKey, seed, programId) {
-    const buffer = Buffer$1.concat([fromPublicKey.toBuffer(), Buffer$1.from(seed), programId.toBuffer()]);
+    const buffer = Buffer.concat([fromPublicKey.toBuffer(), Buffer.from(seed), programId.toBuffer()]);
     const hash = sha256(new Uint8Array(buffer)).slice(2);
-    return new PublicKey(Buffer$1.from(hash, 'hex'));
+    return new PublicKey(Buffer.from(hash, 'hex'));
   }
   /**
    * Derive a program address from seeds and a program ID.
@@ -1904,15 +1904,15 @@ class PublicKey extends Struct {
 
 
   static createProgramAddressSync(seeds, programId) {
-    let buffer = Buffer$1.alloc(0);
+    let buffer = Buffer.alloc(0);
     seeds.forEach(function (seed) {
       if (seed.length > MAX_SEED_LENGTH) {
         throw new TypeError(`Max seed length exceeded`);
       }
 
-      buffer = Buffer$1.concat([buffer, toBuffer(seed)]);
+      buffer = Buffer.concat([buffer, toBuffer(seed)]);
     });
-    buffer = Buffer$1.concat([buffer, programId.toBuffer(), Buffer$1.from('ProgramDerivedAddress')]);
+    buffer = Buffer.concat([buffer, programId.toBuffer(), Buffer.from('ProgramDerivedAddress')]);
     let hash = sha256(new Uint8Array(buffer)).slice(2);
     let publicKeyBytes = new BN(hash, 16).toArray(undefined, 32);
 
@@ -1948,7 +1948,7 @@ class PublicKey extends Struct {
 
     while (nonce != 0) {
       try {
-        const seedsWithNonce = seeds.concat(Buffer$1.from([nonce]));
+        const seedsWithNonce = seeds.concat(Buffer.from([nonce]));
         address = this.createProgramAddressSync(seedsWithNonce, programId);
       } catch (err) {
         if (err instanceof TypeError) {
@@ -2124,13 +2124,13 @@ const rustString = (property = 'string') => {
 
   rslShim.encode = (str, b, offset) => {
     const data = {
-      chars: Buffer$1.from(str, 'utf8')
+      chars: Buffer.from(str, 'utf8')
     };
     return _encode(data, b, offset);
   };
 
   rslShim.alloc = str => {
-    return BufferLayout.u32().span + BufferLayout.u32().span + Buffer$1.from(str, 'utf8').length;
+    return BufferLayout.u32().span + BufferLayout.u32().span + Buffer.from(str, 'utf8').length;
   };
 
   return rslShim;
@@ -2260,16 +2260,16 @@ class Message {
       encodeLength(dataCount, data.length);
       return {
         programIdIndex,
-        keyIndicesCount: Buffer$1.from(keyIndicesCount),
+        keyIndicesCount: Buffer.from(keyIndicesCount),
         keyIndices: accounts,
-        dataLength: Buffer$1.from(dataCount),
+        dataLength: Buffer.from(dataCount),
         data
       };
     });
     let instructionCount = [];
     encodeLength(instructionCount, instructions.length);
-    let instructionBuffer = Buffer$1.alloc(PACKET_DATA_SIZE);
-    Buffer$1.from(instructionCount).copy(instructionBuffer);
+    let instructionBuffer = Buffer.alloc(PACKET_DATA_SIZE);
+    Buffer.from(instructionCount).copy(instructionBuffer);
     let instructionBufferLength = instructionCount.length;
     instructions.forEach(instruction => {
       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')]);
@@ -2279,14 +2279,14 @@ class Message {
     instructionBuffer = instructionBuffer.slice(0, instructionBufferLength);
     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$1.from([this.header.numRequiredSignatures]),
-      numReadonlySignedAccounts: Buffer$1.from([this.header.numReadonlySignedAccounts]),
-      numReadonlyUnsignedAccounts: Buffer$1.from([this.header.numReadonlyUnsignedAccounts]),
-      keyCount: Buffer$1.from(keyCount),
+      numRequiredSignatures: Buffer.from([this.header.numRequiredSignatures]),
+      numReadonlySignedAccounts: Buffer.from([this.header.numReadonlySignedAccounts]),
+      numReadonlyUnsignedAccounts: Buffer.from([this.header.numReadonlyUnsignedAccounts]),
+      keyCount: Buffer.from(keyCount),
       keys: this.accountKeys.map(key => toBuffer(key.toBytes())),
       recentBlockhash: bs58.decode(this.recentBlockhash)
     };
-    let signData = Buffer$1.alloc(2048);
+    let signData = Buffer.alloc(2048);
     const length = signDataLayout.encode(transaction, signData);
     instructionBuffer.copy(signData, length);
     return signData.slice(0, length + instructionBuffer.length);
@@ -2308,7 +2308,7 @@ class Message {
     for (let i = 0; i < accountCount; i++) {
       const account = byteArray.slice(0, PUBKEY_LENGTH);
       byteArray = byteArray.slice(PUBKEY_LENGTH);
-      accountKeys.push(bs58.encode(Buffer$1.from(account)));
+      accountKeys.push(bs58.encode(Buffer.from(account)));
     }
 
     const recentBlockhash = byteArray.slice(0, PUBKEY_LENGTH);
@@ -2323,7 +2323,7 @@ class Message {
       byteArray = byteArray.slice(accountCount);
       const dataLength = decodeLength(byteArray);
       const dataSlice = byteArray.slice(0, dataLength);
-      const data = bs58.encode(Buffer$1.from(dataSlice));
+      const data = bs58.encode(Buffer.from(dataSlice));
       byteArray = byteArray.slice(dataLength);
       instructions.push({
         programIdIndex,
@@ -2338,7 +2338,7 @@ class Message {
         numReadonlySignedAccounts,
         numReadonlyUnsignedAccounts
       },
-      recentBlockhash: bs58.encode(Buffer$1.from(recentBlockhash)),
+      recentBlockhash: bs58.encode(Buffer.from(recentBlockhash)),
       accountKeys,
       instructions
     };
@@ -2356,7 +2356,7 @@ function assert (condition, message) {
 /**
  * Default (empty) signature
  */
-const DEFAULT_SIGNATURE = Buffer$1.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
+const DEFAULT_SIGNATURE = Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
 /**
  * Account metadata used to define instructions
  */
@@ -2380,7 +2380,7 @@ class TransactionInstruction {
   constructor(opts) {
     this.keys = void 0;
     this.programId = void 0;
-    this.data = Buffer$1.alloc(0);
+    this.data = Buffer.alloc(0);
     this.programId = opts.programId;
     this.keys = opts.keys;
 
@@ -2859,7 +2859,7 @@ class Transaction {
       throw new Error(`unknown signer: ${pubkey.toString()}`);
     }
 
-    this.signatures[index].signature = Buffer$1.from(signature);
+    this.signatures[index].signature = Buffer.from(signature);
   }
   /**
    * Verify signatures of a complete, signed Transaction
@@ -2925,15 +2925,15 @@ class Transaction {
     const signatureCount = [];
     encodeLength(signatureCount, signatures.length);
     const transactionLength = signatureCount.length + signatures.length * 64 + signData.length;
-    const wireTransaction = Buffer$1.alloc(transactionLength);
+    const wireTransaction = Buffer.alloc(transactionLength);
     assert(signatures.length < 256);
-    Buffer$1.from(signatureCount).copy(wireTransaction, 0);
+    Buffer.from(signatureCount).copy(wireTransaction, 0);
     signatures.forEach(({
       signature
     }, index) => {
       if (signature !== null) {
         assert(signature.length === 64, `signature has invalid length`);
-        Buffer$1.from(signature).copy(wireTransaction, signatureCount.length + index * 64);
+        Buffer.from(signature).copy(wireTransaction, signatureCount.length + index * 64);
       }
     });
     signData.copy(wireTransaction, signatureCount.length + signatures.length * 64);
@@ -2984,7 +2984,7 @@ class Transaction {
     for (let i = 0; i < signatureCount; i++) {
       const signature = byteArray.slice(0, SIGNATURE_LENGTH_IN_BYTES);
       byteArray = byteArray.slice(SIGNATURE_LENGTH_IN_BYTES);
-      signatures.push(bs58.encode(Buffer$1.from(signature)));
+      signatures.push(bs58.encode(Buffer.from(signature)));
     }
 
     return Transaction.populate(Message.from(byteArray), signatures);
@@ -3073,113 +3073,13 @@ function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
-const encodeDecode = (layout) => {
-    const decode = layout.decode.bind(layout);
-    const encode = layout.encode.bind(layout);
-    return { decode, encode };
-};
-
-var node = {};
-
-Object.defineProperty(node, "__esModule", { value: true });
-let converter;
-{
-    try {
-        converter = require('bindings')('bigint_buffer');
-    }
-    catch (e) {
-        console.warn('bigint: Failed to load bindings, pure JS will be used (try npm run rebuild?)');
-    }
-}
-/**
- * Convert a little-endian buffer into a BigInt.
- * @param buf The little-endian buffer to convert
- * @returns A BigInt with the little-endian representation of buf.
- */
-function toBigIntLE(buf) {
-    if (converter === undefined) {
-        const reversed = Buffer.from(buf);
-        reversed.reverse();
-        const hex = reversed.toString('hex');
-        if (hex.length === 0) {
-            return BigInt(0);
-        }
-        return BigInt(`0x${hex}`);
-    }
-    return converter.toBigInt(buf, false);
-}
-var toBigIntLE_1 = node.toBigIntLE = toBigIntLE;
-/**
- * Convert a big-endian buffer into a BigInt
- * @param buf The big-endian buffer to convert.
- * @returns A BigInt with the big-endian representation of buf.
- */
-function toBigIntBE(buf) {
-    if (converter === undefined) {
-        const hex = buf.toString('hex');
-        if (hex.length === 0) {
-            return BigInt(0);
-        }
-        return BigInt(`0x${hex}`);
-    }
-    return converter.toBigInt(buf, true);
-}
-node.toBigIntBE = toBigIntBE;
-/**
- * Convert a BigInt to a little-endian buffer.
- * @param num   The BigInt to convert.
- * @param width The number of bytes that the resulting buffer should be.
- * @returns A little-endian buffer representation of num.
- */
-function toBufferLE(num, width) {
-    if (converter === undefined) {
-        const hex = num.toString(16);
-        const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-        buffer.reverse();
-        return buffer;
-    }
-    // Allocation is done here, since it is slower using napi in C
-    return converter.fromBigInt(num, Buffer.allocUnsafe(width), false);
-}
-var toBufferLE_1 = node.toBufferLE = toBufferLE;
-/**
- * Convert a BigInt to a big-endian buffer.
- * @param num   The BigInt to convert.
- * @param width The number of bytes that the resulting buffer should be.
- * @returns A big-endian buffer representation of num.
- */
-function toBufferBE(num, width) {
-    if (converter === undefined) {
-        const hex = num.toString(16);
-        return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-    }
-    return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);
-}
-node.toBufferBE = toBufferBE;
-
-const bigInt = (length) => (property) => {
-    const layout = blob(length, property);
-    const { encode, decode } = encodeDecode(layout);
-    const bigIntLayout = layout;
-    bigIntLayout.decode = (buffer, offset) => {
-        const src = decode(buffer, offset);
-        return toBigIntLE_1(Buffer.from(src));
-    };
-    bigIntLayout.encode = (bigInt, buffer, offset) => {
-        const src = toBufferLE_1(bigInt, length);
-        return encode(src, buffer, offset);
-    };
-    return bigIntLayout;
-};
-const u64 = bigInt(8);
-
 /**
  * Populate a buffer of instruction data using an InstructionType
  * @internal
  */
 function encodeData(type, fields) {
   const allocLength = type.layout.span >= 0 ? type.layout.span : getAlloc(type, fields);
-  const data = Buffer$1.alloc(allocLength);
+  const data = Buffer.alloc(allocLength);
   const layoutFields = Object.assign({
     instruction: type.index
   }, fields);
@@ -4079,7 +3979,7 @@ class Loader {
 
     while (array.length > 0) {
       const bytes = array.slice(0, chunkSize);
-      const data = Buffer$1.alloc(chunkSize + 16);
+      const data = Buffer.alloc(chunkSize + 16);
       dataLayout.encode({
         instruction: 0,
         // Load instruction
@@ -4114,7 +4014,7 @@ class Loader {
 
     {
       const dataLayout = BufferLayout.struct([BufferLayout.u32('instruction')]);
-      const data = Buffer$1.alloc(dataLayout.span);
+      const data = Buffer.alloc(dataLayout.span);
       dataLayout.encode({
         instruction: 1 // Finalize instruction
 
@@ -4590,7 +4490,7 @@ function makeWebsocketUrl(endpoint) {
 
 const PublicKeyFromString = coerce(instance(PublicKey), string(), value => new PublicKey(value));
 const RawAccountDataResult = tuple([string(), literal('base64')]);
-const BufferFromRawAccountData = coerce(instance(Buffer$1), RawAccountDataResult, value => Buffer$1.from(value[0], 'base64'));
+const BufferFromRawAccountData = coerce(instance(Buffer), RawAccountDataResult, value => Buffer.from(value[0], 'base64'));
 /**
  * Attempt to use a recent blockhash for up to 30 seconds
  * @internal
@@ -4773,7 +4673,7 @@ const BlockProductionResponseStruct = jsonRpcResultAndContext(type({
  */
 
 function createRpcClient(url, useHttps, httpHeaders, customFetch, fetchMiddleware, disableRetryOnRateLimit) {
-  const fetch$1 = customFetch ? customFetch : fetch;
+  const fetch = customFetch ? customFetch : crossFetch;
   let agentManager;
 
   {
@@ -4791,7 +4691,7 @@ function createRpcClient(url, useHttps, httpHeaders, customFetch, fetchMiddlewar
           reject(error);
         }
       });
-      return await fetch$1(...modifiedFetchArgs);
+      return await fetch(...modifiedFetchArgs);
     };
   }
 
@@ -4815,7 +4715,7 @@ function createRpcClient(url, useHttps, httpHeaders, customFetch, fetchMiddlewar
         if (fetchWithMiddleware) {
           res = await fetchWithMiddleware(url, options);
         } else {
-          res = await fetch$1(url, options);
+          res = await fetch(url, options);
         }
 
         if (res.status !== 429
@@ -5019,7 +4919,7 @@ const KeyedAccountInfoResult = type({
   pubkey: PublicKeyFromString,
   account: AccountInfoResult
 });
-const ParsedOrRawAccountData = coerce(union([instance(Buffer$1), ParsedAccountDataResult]), union([RawAccountDataResult, ParsedAccountDataResult]), value => {
+const ParsedOrRawAccountData = coerce(union([instance(Buffer), ParsedAccountDataResult]), union([RawAccountDataResult, ParsedAccountDataResult]), value => {
   if (Array.isArray(value)) {
     return create(value, BufferFromRawAccountData);
   } else {
@@ -7332,6 +7232,7 @@ class Connection {
 
 
   _wsOnError(err) {
+    this._rpcWebSocketConnected = false;
     console.error('ws error:', err.message);
   }
   /**
@@ -7340,6 +7241,7 @@ class Connection {
 
 
   _wsOnClose(code) {
+    this._rpcWebSocketConnected = false;
     this._rpcWebSocketGeneration++;
 
     if (this._rpcWebSocketHeartbeat) {
@@ -8177,7 +8079,7 @@ class Ed25519Program {
     const signatureOffset = publicKeyOffset + publicKey.length;
     const messageDataOffset = signatureOffset + signature.length;
     const numSignatures = 1;
-    const instructionData = Buffer$1.alloc(messageDataOffset + message.length);
+    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({
@@ -9048,7 +8950,7 @@ class Secp256k1Program {
     assert(publicKey.length === PUBLIC_KEY_BYTES, `Public key must be ${PUBLIC_KEY_BYTES} bytes but received ${publicKey.length} bytes`);
 
     try {
-      return Buffer$1.from(sha3.keccak_256.update(toBuffer(publicKey)).digest()).slice(-ETHEREUM_ADDRESS_BYTES);
+      return Buffer.from(sha3.keccak_256.update(toBuffer(publicKey)).digest()).slice(-ETHEREUM_ADDRESS_BYTES);
     } catch (error) {
       throw new Error(`Error constructing Ethereum address: ${error}`);
     }
@@ -9093,9 +8995,9 @@ class Secp256k1Program {
 
     if (typeof rawAddress === 'string') {
       if (rawAddress.startsWith('0x')) {
-        ethAddress = Buffer$1.from(rawAddress.substr(2), 'hex');
+        ethAddress = Buffer.from(rawAddress.substr(2), 'hex');
       } else {
-        ethAddress = Buffer$1.from(rawAddress, 'hex');
+        ethAddress = Buffer.from(rawAddress, 'hex');
       }
     } else {
       ethAddress = rawAddress;
@@ -9107,7 +9009,7 @@ class Secp256k1Program {
     const signatureOffset = dataStart + ethAddress.length;
     const messageDataOffset = signatureOffset + signature.length + 1;
     const numSignatures = 1;
-    const instructionData = Buffer$1.alloc(SECP256K1_INSTRUCTION_LAYOUT.span + message.length);
+    const instructionData = Buffer.alloc(SECP256K1_INSTRUCTION_LAYOUT.span + message.length);
     SECP256K1_INSTRUCTION_LAYOUT.encode({
       numSignatures,
       signatureOffset,
@@ -9146,7 +9048,7 @@ class Secp256k1Program {
       const privateKey = toBuffer(pkey);
       const publicKey = publicKeyCreate(privateKey, false).slice(1); // throw away leading byte
 
-      const messageHash = Buffer$1.from(sha3.keccak_256.update(toBuffer(message)).digest());
+      const messageHash = Buffer.from(sha3.keccak_256.update(toBuffer(message)).digest());
       const {
         signature,
         recid: recoveryId
@@ -9231,7 +9133,7 @@ class ValidatorInfo {
 
     if (configKeys[0].publicKey.equals(VALIDATOR_INFO_KEY)) {
       if (configKeys[1].isSigner) {
-        const rawInfo = rustString().decode(Buffer$1.from(byteArray));
+        const rawInfo = rustString().decode(Buffer.from(byteArray));
         const info = JSON.parse(rawInfo);
         assert$7(info, InfoString);
         return new ValidatorInfo(configKeys[1].publicKey, info);