@solana/web3.js 1.41.3 → 1.41.6

package/lib/index.browser.esm.js

@@ -1,9 +1,10 @@
 import nacl from 'tweetnacl';
-import { Buffer } from 'buffer';
+import { Buffer as Buffer$1 } 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 { 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';
@@ -11,12 +12,12 @@ import secp256k1 from 'secp256k1';
 import sha3 from 'js-sha3';
 
 const toBuffer = arr => {
-  if (Buffer.isBuffer(arr)) {
+  if (Buffer$1.isBuffer(arr)) {
     return arr;
   } else if (arr instanceof Uint8Array) {
-    return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength);
+    return Buffer$1.from(arr.buffer, arr.byteOffset, arr.byteLength);
   } else {
-    return Buffer.from(arr);
+    return Buffer$1.from(arr);
   }
 };
 
@@ -1737,7 +1738,7 @@ class Struct {
   }
 
   encode() {
-    return Buffer.from(serialize(SOLANA_SCHEMA, this));
+    return Buffer$1.from(serialize(SOLANA_SCHEMA, this));
   }
 
   static decode(data) {
@@ -1854,13 +1855,13 @@ class PublicKey extends Struct {
 
 
   toBuffer() {
-    const b = this._bn.toArrayLike(Buffer);
+    const b = this._bn.toArrayLike(Buffer$1);
 
     if (b.length === 32) {
       return b;
     }
 
-    const zeroPad = Buffer.alloc(32);
+    const zeroPad = Buffer$1.alloc(32);
     b.copy(zeroPad, 32 - b.length);
     return zeroPad;
   }
@@ -1882,9 +1883,9 @@ class PublicKey extends Struct {
 
 
   static async createWithSeed(fromPublicKey, seed, programId) {
-    const buffer = Buffer.concat([fromPublicKey.toBuffer(), Buffer.from(seed), programId.toBuffer()]);
+    const buffer = Buffer$1.concat([fromPublicKey.toBuffer(), Buffer$1.from(seed), programId.toBuffer()]);
     const hash = sha256(new Uint8Array(buffer)).slice(2);
-    return new PublicKey(Buffer.from(hash, 'hex'));
+    return new PublicKey(Buffer$1.from(hash, 'hex'));
   }
   /**
    * Derive a program address from seeds and a program ID.
@@ -1894,15 +1895,15 @@ class PublicKey extends Struct {
 
 
   static createProgramAddressSync(seeds, programId) {
-    let buffer = Buffer.alloc(0);
+    let buffer = Buffer$1.alloc(0);
     seeds.forEach(function (seed) {
       if (seed.length > MAX_SEED_LENGTH) {
         throw new TypeError(`Max seed length exceeded`);
       }
 
-      buffer = Buffer.concat([buffer, toBuffer(seed)]);
+      buffer = Buffer$1.concat([buffer, toBuffer(seed)]);
     });
-    buffer = Buffer.concat([buffer, programId.toBuffer(), Buffer.from('ProgramDerivedAddress')]);
+    buffer = Buffer$1.concat([buffer, programId.toBuffer(), Buffer$1.from('ProgramDerivedAddress')]);
     let hash = sha256(new Uint8Array(buffer)).slice(2);
     let publicKeyBytes = new BN(hash, 16).toArray(undefined, 32);
 
@@ -1938,7 +1939,7 @@ class PublicKey extends Struct {
 
     while (nonce != 0) {
       try {
-        const seedsWithNonce = seeds.concat(Buffer.from([nonce]));
+        const seedsWithNonce = seeds.concat(Buffer$1.from([nonce]));
         address = this.createProgramAddressSync(seedsWithNonce, programId);
       } catch (err) {
         if (err instanceof TypeError) {
@@ -2114,13 +2115,13 @@ const rustString = (property = 'string') => {
 
   rslShim.encode = (str, b, offset) => {
     const data = {
-      chars: Buffer.from(str, 'utf8')
+      chars: Buffer$1.from(str, 'utf8')
     };
     return _encode(data, b, offset);
   };
 
   rslShim.alloc = str => {
-    return BufferLayout.u32().span + BufferLayout.u32().span + Buffer.from(str, 'utf8').length;
+    return BufferLayout.u32().span + BufferLayout.u32().span + Buffer$1.from(str, 'utf8').length;
   };
 
   return rslShim;
@@ -2250,16 +2251,16 @@ class Message {
       encodeLength(dataCount, data.length);
       return {
         programIdIndex,
-        keyIndicesCount: Buffer.from(keyIndicesCount),
+        keyIndicesCount: Buffer$1.from(keyIndicesCount),
         keyIndices: accounts,
-        dataLength: Buffer.from(dataCount),
+        dataLength: Buffer$1.from(dataCount),
         data
       };
     });
     let instructionCount = [];
     encodeLength(instructionCount, instructions.length);
-    let instructionBuffer = Buffer.alloc(PACKET_DATA_SIZE);
-    Buffer.from(instructionCount).copy(instructionBuffer);
+    let instructionBuffer = Buffer$1.alloc(PACKET_DATA_SIZE);
+    Buffer$1.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')]);
@@ -2269,14 +2270,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.from([this.header.numRequiredSignatures]),
-      numReadonlySignedAccounts: Buffer.from([this.header.numReadonlySignedAccounts]),
-      numReadonlyUnsignedAccounts: Buffer.from([this.header.numReadonlyUnsignedAccounts]),
-      keyCount: Buffer.from(keyCount),
+      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),
       keys: this.accountKeys.map(key => toBuffer(key.toBytes())),
       recentBlockhash: bs58.decode(this.recentBlockhash)
     };
-    let signData = Buffer.alloc(2048);
+    let signData = Buffer$1.alloc(2048);
     const length = signDataLayout.encode(transaction, signData);
     instructionBuffer.copy(signData, length);
     return signData.slice(0, length + instructionBuffer.length);
@@ -2298,7 +2299,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.from(account)));
+      accountKeys.push(bs58.encode(Buffer$1.from(account)));
     }
 
     const recentBlockhash = byteArray.slice(0, PUBKEY_LENGTH);
@@ -2313,7 +2314,7 @@ class Message {
       byteArray = byteArray.slice(accountCount);
       const dataLength = decodeLength(byteArray);
       const dataSlice = byteArray.slice(0, dataLength);
-      const data = bs58.encode(Buffer.from(dataSlice));
+      const data = bs58.encode(Buffer$1.from(dataSlice));
       byteArray = byteArray.slice(dataLength);
       instructions.push({
         programIdIndex,
@@ -2328,7 +2329,7 @@ class Message {
         numReadonlySignedAccounts,
         numReadonlyUnsignedAccounts
       },
-      recentBlockhash: bs58.encode(Buffer.from(recentBlockhash)),
+      recentBlockhash: bs58.encode(Buffer$1.from(recentBlockhash)),
       accountKeys,
       instructions
     };
@@ -2346,7 +2347,7 @@ function assert (condition, message) {
 /**
  * Default (empty) signature
  */
-const DEFAULT_SIGNATURE = Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
+const DEFAULT_SIGNATURE = Buffer$1.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
 /**
  * Account metadata used to define instructions
  */
@@ -2370,7 +2371,7 @@ class TransactionInstruction {
   constructor(opts) {
     this.keys = void 0;
     this.programId = void 0;
-    this.data = Buffer.alloc(0);
+    this.data = Buffer$1.alloc(0);
     this.programId = opts.programId;
     this.keys = opts.keys;
 
@@ -2489,11 +2490,7 @@ class Transaction {
 
 
   compileMessage() {
-    if (this._message) {
-      if (JSON.stringify(this.toJSON()) !== JSON.stringify(this._json)) {
-        throw new Error('Transaction message mutated after being populated from Message');
-      }
-
+    if (this._message && JSON.stringify(this.toJSON()) === JSON.stringify(this._json)) {
       return this._message;
     }
 
@@ -2853,7 +2850,7 @@ class Transaction {
       throw new Error(`unknown signer: ${pubkey.toString()}`);
     }
 
-    this.signatures[index].signature = Buffer.from(signature);
+    this.signatures[index].signature = Buffer$1.from(signature);
   }
   /**
    * Verify signatures of a complete, signed Transaction
@@ -2919,15 +2916,15 @@ class Transaction {
     const signatureCount = [];
     encodeLength(signatureCount, signatures.length);
     const transactionLength = signatureCount.length + signatures.length * 64 + signData.length;
-    const wireTransaction = Buffer.alloc(transactionLength);
+    const wireTransaction = Buffer$1.alloc(transactionLength);
     assert(signatures.length < 256);
-    Buffer.from(signatureCount).copy(wireTransaction, 0);
+    Buffer$1.from(signatureCount).copy(wireTransaction, 0);
     signatures.forEach(({
       signature
     }, index) => {
       if (signature !== null) {
         assert(signature.length === 64, `signature has invalid length`);
-        Buffer.from(signature).copy(wireTransaction, signatureCount.length + index * 64);
+        Buffer$1.from(signature).copy(wireTransaction, signatureCount.length + index * 64);
       }
     });
     signData.copy(wireTransaction, signatureCount.length + signatures.length * 64);
@@ -2978,7 +2975,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.from(signature)));
+      signatures.push(bs58.encode(Buffer$1.from(signature)));
     }
 
     return Transaction.populate(Message.from(byteArray), signatures);
@@ -3067,13 +3064,99 @@ 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 browser = {};
+
+Object.defineProperty(browser, "__esModule", { value: true });
+/**
+ * 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) {
+    {
+        const reversed = Buffer.from(buf);
+        reversed.reverse();
+        const hex = reversed.toString('hex');
+        if (hex.length === 0) {
+            return BigInt(0);
+        }
+        return BigInt(`0x${hex}`);
+    }
+}
+var toBigIntLE_1 = browser.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) {
+    {
+        const hex = buf.toString('hex');
+        if (hex.length === 0) {
+            return BigInt(0);
+        }
+        return BigInt(`0x${hex}`);
+    }
+}
+browser.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) {
+    {
+        const hex = num.toString(16);
+        const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+        buffer.reverse();
+        return buffer;
+    }
+}
+var toBufferLE_1 = browser.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) {
+    {
+        const hex = num.toString(16);
+        return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+    }
+}
+browser.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.alloc(allocLength);
+  const data = Buffer$1.alloc(allocLength);
   const layoutFields = Object.assign({
     instruction: type.index
   }, fields);
@@ -3456,7 +3539,7 @@ const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze({
   },
   Transfer: {
     index: 2,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), u64('lamports')])
   },
   CreateWithSeed: {
     index: 3,
@@ -3492,7 +3575,7 @@ const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze({
   },
   TransferWithSeed: {
     index: 11,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports'), rustString('seed'), publicKey('programId')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), u64('lamports'), rustString('seed'), publicKey('programId')])
   }
 });
 /**
@@ -3545,7 +3628,7 @@ class SystemProgram {
     if ('basePubkey' in params) {
       const type = SYSTEM_INSTRUCTION_LAYOUTS.TransferWithSeed;
       data = encodeData(type, {
-        lamports: params.lamports,
+        lamports: BigInt(params.lamports),
         seed: params.seed,
         programId: toBuffer(params.programId.toBuffer())
       });
@@ -3565,7 +3648,7 @@ class SystemProgram {
     } else {
       const type = SYSTEM_INSTRUCTION_LAYOUTS.Transfer;
       data = encodeData(type, {
-        lamports: params.lamports
+        lamports: BigInt(params.lamports)
       });
       keys = [{
         pubkey: params.fromPubkey,
@@ -3973,7 +4056,7 @@ class Loader {
 
     while (array.length > 0) {
       const bytes = array.slice(0, chunkSize);
-      const data = Buffer.alloc(chunkSize + 16);
+      const data = Buffer$1.alloc(chunkSize + 16);
       dataLayout.encode({
         instruction: 0,
         // Load instruction
@@ -4008,7 +4091,7 @@ class Loader {
 
     {
       const dataLayout = BufferLayout.struct([BufferLayout.u32('instruction')]);
-      const data = Buffer.alloc(dataLayout.span);
+      const data = Buffer$1.alloc(dataLayout.span);
       dataLayout.encode({
         instruction: 1 // Finalize instruction
 
@@ -4996,7 +5079,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), RawAccountDataResult, value => Buffer.from(value[0], 'base64'));
+const BufferFromRawAccountData = coerce(instance(Buffer$1), RawAccountDataResult, value => Buffer$1.from(value[0], 'base64'));
 /**
  * Attempt to use a recent blockhash for up to 30 seconds
  * @internal
@@ -5419,7 +5502,7 @@ const KeyedAccountInfoResult = type({
   pubkey: PublicKeyFromString,
   account: AccountInfoResult
 });
-const ParsedOrRawAccountData = coerce(union([instance(Buffer), ParsedAccountDataResult]), union([RawAccountDataResult, ParsedAccountDataResult]), value => {
+const ParsedOrRawAccountData = coerce(union([instance(Buffer$1), ParsedAccountDataResult]), union([RawAccountDataResult, ParsedAccountDataResult]), value => {
   if (Array.isArray(value)) {
     return create(value, BufferFromRawAccountData);
   } else {
@@ -8348,7 +8431,7 @@ class Connection {
 
           try {
             this.removeSignatureListener(clientSubscriptionId); // eslint-disable-next-line no-empty
-          } catch {// Already removed.
+          } catch (_err) {// Already removed.
           }
         }
       },
@@ -8390,7 +8473,7 @@ class Connection {
 
         try {
           this.removeSignatureListener(clientSubscriptionId); // eslint-disable-next-line no-empty
-        } catch {// Already removed.
+        } catch (_err) {// Already removed.
         }
       },
       method: 'signatureSubscribe',
@@ -8577,7 +8660,7 @@ class Ed25519Program {
     const signatureOffset = publicKeyOffset + publicKey.length;
     const messageDataOffset = signatureOffset + signature.length;
     const numSignatures = 1;
-    const instructionData = Buffer.alloc(messageDataOffset + message.length);
+    const instructionData = Buffer$1.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({
@@ -9448,7 +9531,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.from(sha3.keccak_256.update(toBuffer(publicKey)).digest()).slice(-ETHEREUM_ADDRESS_BYTES);
+      return Buffer$1.from(sha3.keccak_256.update(toBuffer(publicKey)).digest()).slice(-ETHEREUM_ADDRESS_BYTES);
     } catch (error) {
       throw new Error(`Error constructing Ethereum address: ${error}`);
     }
@@ -9493,9 +9576,9 @@ class Secp256k1Program {
 
     if (typeof rawAddress === 'string') {
       if (rawAddress.startsWith('0x')) {
-        ethAddress = Buffer.from(rawAddress.substr(2), 'hex');
+        ethAddress = Buffer$1.from(rawAddress.substr(2), 'hex');
       } else {
-        ethAddress = Buffer.from(rawAddress, 'hex');
+        ethAddress = Buffer$1.from(rawAddress, 'hex');
       }
     } else {
       ethAddress = rawAddress;
@@ -9507,7 +9590,7 @@ class Secp256k1Program {
     const signatureOffset = dataStart + ethAddress.length;
     const messageDataOffset = signatureOffset + signature.length + 1;
     const numSignatures = 1;
-    const instructionData = Buffer.alloc(SECP256K1_INSTRUCTION_LAYOUT.span + message.length);
+    const instructionData = Buffer$1.alloc(SECP256K1_INSTRUCTION_LAYOUT.span + message.length);
     SECP256K1_INSTRUCTION_LAYOUT.encode({
       numSignatures,
       signatureOffset,
@@ -9546,7 +9629,7 @@ class Secp256k1Program {
       const privateKey = toBuffer(pkey);
       const publicKey = publicKeyCreate(privateKey, false).slice(1); // throw away leading byte
 
-      const messageHash = Buffer.from(sha3.keccak_256.update(toBuffer(message)).digest());
+      const messageHash = Buffer$1.from(sha3.keccak_256.update(toBuffer(message)).digest());
       const {
         signature,
         recid: recoveryId
@@ -9631,7 +9714,7 @@ class ValidatorInfo {
 
     if (configKeys[0].publicKey.equals(VALIDATOR_INFO_KEY)) {
       if (configKeys[1].isSigner) {
-        const rawInfo = rustString().decode(Buffer.from(byteArray));
+        const rawInfo = rustString().decode(Buffer$1.from(byteArray));
         const info = JSON.parse(rawInfo);
         assert$7(info, InfoString);
         return new ValidatorInfo(configKeys[1].publicKey, info);