@solana/web3.js 1.41.3 → 1.41.4

package/lib/index.d.ts

@@ -2632,7 +2632,7 @@ declare module '@solana/web3.js' {
     /** Account that will receive transferred lamports */
     toPubkey: PublicKey;
     /** Amount of lamports to transfer */
-    lamports: number;
+    lamports: number | bigint;
   };
   /**
    * Assign system transaction params
@@ -2782,7 +2782,31 @@ declare module '@solana/web3.js' {
     /** Account that will receive transferred lamports */
     toPubkey: PublicKey;
     /** Amount of lamports to transfer */
-    lamports: number;
+    lamports: number | bigint;
+    /** Seed to use to derive the funding account address */
+    seed: string;
+    /** Program id to use to derive the funding account address */
+    programId: PublicKey;
+  };
+  /** Decoded transfer system transaction instruction */
+  export type DecodedTransferInstruction = {
+    /** Account that will transfer lamports */
+    fromPubkey: PublicKey;
+    /** Account that will receive transferred lamports */
+    toPubkey: PublicKey;
+    /** Amount of lamports to transfer */
+    lamports: bigint;
+  };
+  /** Decoded transferWithSeed system transaction instruction */
+  export type DecodedTransferWithSeedInstruction = {
+    /** Account that will transfer lamports */
+    fromPubkey: PublicKey;
+    /** Base public key to use to derive the funding account address */
+    basePubkey: PublicKey;
+    /** Account that will receive transferred lamports */
+    toPubkey: PublicKey;
+    /** Amount of lamports to transfer */
+    lamports: bigint;
     /** Seed to use to derive the funding account address */
     seed: string;
     /** Program id to use to derive the funding account address */
@@ -2807,13 +2831,15 @@ declare module '@solana/web3.js' {
     /**
      * Decode a transfer system instruction and retrieve the instruction params.
      */
-    static decodeTransfer(instruction: TransactionInstruction): TransferParams;
+    static decodeTransfer(
+      instruction: TransactionInstruction,
+    ): DecodedTransferInstruction;
     /**
      * Decode a transfer with seed system instruction and retrieve the instruction params.
      */
     static decodeTransferWithSeed(
       instruction: TransactionInstruction,
-    ): TransferWithSeedParams;
+    ): DecodedTransferWithSeedInstruction;
     /**
      * Decode an allocate system instruction and retrieve the instruction params.
      */

package/lib/index.esm.js

@@ -1,10 +1,11 @@
 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 crossFetch from 'cross-fetch';
+import { blob } from '@solana/buffer-layout';
+import fetch 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';
@@ -14,12 +15,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);
   }
 };
 
@@ -1746,7 +1747,7 @@ class Struct {
   }
 
   encode() {
-    return Buffer.from(serialize(SOLANA_SCHEMA, this));
+    return Buffer$1.from(serialize(SOLANA_SCHEMA, this));
   }
 
   static decode(data) {
@@ -1863,13 +1864,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;
   }
@@ -1891,9 +1892,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.
@@ -1903,15 +1904,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);
 
@@ -1947,7 +1948,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) {
@@ -2123,13 +2124,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;
@@ -2259,16 +2260,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')]);
@@ -2278,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.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);
@@ -2307,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.from(account)));
+      accountKeys.push(bs58.encode(Buffer$1.from(account)));
     }
 
     const recentBlockhash = byteArray.slice(0, PUBKEY_LENGTH);
@@ -2322,7 +2323,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,
@@ -2337,7 +2338,7 @@ class Message {
         numReadonlySignedAccounts,
         numReadonlyUnsignedAccounts
       },
-      recentBlockhash: bs58.encode(Buffer.from(recentBlockhash)),
+      recentBlockhash: bs58.encode(Buffer$1.from(recentBlockhash)),
       accountKeys,
       instructions
     };
@@ -2355,7 +2356,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
  */
@@ -2379,7 +2380,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;
 
@@ -2862,7 +2863,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
@@ -2928,15 +2929,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);
@@ -2987,7 +2988,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);
@@ -3076,13 +3077,113 @@ 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.alloc(allocLength);
+  const data = Buffer$1.alloc(allocLength);
   const layoutFields = Object.assign({
     instruction: type.index
   }, fields);
@@ -3465,7 +3566,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,
@@ -3501,7 +3602,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')])
   }
 });
 /**
@@ -3554,7 +3655,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())
       });
@@ -3574,7 +3675,7 @@ class SystemProgram {
     } else {
       const type = SYSTEM_INSTRUCTION_LAYOUTS.Transfer;
       data = encodeData(type, {
-        lamports: params.lamports
+        lamports: BigInt(params.lamports)
       });
       keys = [{
         pubkey: params.fromPubkey,
@@ -3982,7 +4083,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
@@ -4017,7 +4118,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
 
@@ -4493,7 +4594,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
@@ -4676,7 +4777,7 @@ const BlockProductionResponseStruct = jsonRpcResultAndContext(type({
  */
 
 function createRpcClient(url, useHttps, httpHeaders, customFetch, fetchMiddleware, disableRetryOnRateLimit) {
-  const fetch = customFetch ? customFetch : crossFetch;
+  const fetch$1 = customFetch ? customFetch : fetch;
   let agentManager;
 
   {
@@ -4694,7 +4795,7 @@ function createRpcClient(url, useHttps, httpHeaders, customFetch, fetchMiddlewar
           reject(error);
         }
       });
-      return await fetch(...modifiedFetchArgs);
+      return await fetch$1(...modifiedFetchArgs);
     };
   }
 
@@ -4718,7 +4819,7 @@ function createRpcClient(url, useHttps, httpHeaders, customFetch, fetchMiddlewar
         if (fetchWithMiddleware) {
           res = await fetchWithMiddleware(url, options);
         } else {
-          res = await fetch(url, options);
+          res = await fetch$1(url, options);
         }
 
         if (res.status !== 429
@@ -4922,7 +5023,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 {
@@ -8080,7 +8181,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({
@@ -8951,7 +9052,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}`);
     }
@@ -8996,9 +9097,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;
@@ -9010,7 +9111,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,
@@ -9049,7 +9150,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
@@ -9134,7 +9235,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);